do_sqlite3 0.2.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (9) hide show
  1. data/LICENSE +20 -0
  2. data/README +4 -0
  3. data/Rakefile +51 -0
  4. data/TODO +5 -0
  5. data/ext/extconf.rb +9 -0
  6. data/ext/sqlite3_c.c +4725 -0
  7. data/ext/sqlite_c.i +168 -0
  8. data/lib/do_sqlite3.rb +165 -0
  9. metadata +63 -0
data/LICENSE ADDED
@@ -0,0 +1,20 @@
1
+ Copyright (c) 2007 Yehuda Katz
2
+
3
+ Permission is hereby granted, free of charge, to any person obtaining
4
+ a copy of this software and associated documentation files (the
5
+ "Software"), to deal in the Software without restriction, including
6
+ without limitation the rights to use, copy, modify, merge, publish,
7
+ distribute, sublicense, and/or sell copies of the Software, and to
8
+ permit persons to whom the Software is furnished to do so, subject to
9
+ the following conditions:
10
+
11
+ The above copyright notice and this permission notice shall be
12
+ included in all copies or substantial portions of the Software.
13
+
14
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
15
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
16
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
17
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
18
+ LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
19
+ OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
20
+ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
data/README ADDED
@@ -0,0 +1,4 @@
1
+ do_sqlite3
2
+ =================
3
+
4
+ A plugin for the Merb framework that provides ....
@@ -0,0 +1,51 @@
1
+ require 'rubygems'
2
+ require 'rake/gempackagetask'
3
+
4
+ PLUGIN = "do_sqlite3"
5
+ NAME = "do_sqlite3"
6
+ VERSION = "0.2.0"
7
+ AUTHOR = "Yehuda Katz"
8
+ EMAIL = "wycats@gmail.com"
9
+ HOMEPAGE = "http://dataobjects.devjavu.com"
10
+ SUMMARY = "A DataObject.rb driver for sqlite3"
11
+
12
+ spec = Gem::Specification.new do |s|
13
+ s.name = NAME
14
+ s.version = VERSION
15
+ s.platform = Gem::Platform::RUBY
16
+ s.has_rdoc = true
17
+ s.extra_rdoc_files = ["README", "LICENSE", 'TODO']
18
+ s.summary = SUMMARY
19
+ s.description = s.summary
20
+ s.author = AUTHOR
21
+ s.email = EMAIL
22
+ s.homepage = HOMEPAGE
23
+ s.add_dependency('data_objects')
24
+ s.require_path = 'lib'
25
+ s.autorequire = PLUGIN
26
+ s.files = %w(LICENSE README Rakefile TODO) + Dir.glob("{lib,specs,ext}/**/*")
27
+ end
28
+
29
+ Rake::GemPackageTask.new(spec) do |pkg|
30
+ pkg.gem_spec = spec
31
+ end
32
+
33
+ task :install => [:package] do
34
+ STDERR.puts
35
+ STDERR.puts "* Installing native extensions"
36
+ old_stdout, old_stderr = STDOUT.dup, STDERR.dup
37
+
38
+ STDOUT.reopen("/dev/null")
39
+ STDERR.reopen("/dev/null")
40
+
41
+ sh %{ruby ext/extconf.rb}
42
+ sh %{make clean}
43
+ sh %{make}
44
+ sh %{sudo make install}
45
+ sh %{sudo gem install pkg/#{NAME}-#{VERSION}}
46
+
47
+ STDOUT.reopen(old_stdout)
48
+ STDERR.reopen(old_stderr)
49
+
50
+ puts "* Successfully installed native extensions"
51
+ end
data/TODO ADDED
@@ -0,0 +1,5 @@
1
+ TODO:
2
+ Fix LICENSE with your name
3
+ Fix Rakefile with your name and contact info
4
+ Add your code to lib/do_sqlite3.rb
5
+ Add your Merb rake tasks to lib/do_sqlite3/merbtasks.rb
@@ -0,0 +1,9 @@
1
+ require 'mkmf'
2
+
3
+ SWIG_WRAP = "sqlite3_api_wrap.c"
4
+
5
+ dir_config( "sqlite3", "/usr/local" )
6
+
7
+ if have_header( "sqlite3.h" ) && have_library( "sqlite3", "sqlite3_open" )
8
+ create_makefile( "sqlite3_c" )
9
+ end
@@ -0,0 +1,4725 @@
1
+ /* ----------------------------------------------------------------------------
2
+ * This file was automatically generated by SWIG (http://www.swig.org).
3
+ * Version 1.3.31
4
+ *
5
+ * This file is not intended to be easily readable and contains a number of
6
+ * coding conventions designed to improve portability and efficiency. Do not make
7
+ * changes to this file unless you know what you are doing--modify the SWIG
8
+ * interface file instead.
9
+ * ----------------------------------------------------------------------------- */
10
+
11
+ #define SWIGRUBY
12
+ /* -----------------------------------------------------------------------------
13
+ * This section contains generic SWIG labels for method/variable
14
+ * declarations/attributes, and other compiler dependent labels.
15
+ * ----------------------------------------------------------------------------- */
16
+
17
+ /* template workaround for compilers that cannot correctly implement the C++ standard */
18
+ #ifndef SWIGTEMPLATEDISAMBIGUATOR
19
+ # if defined(__SUNPRO_CC)
20
+ # if (__SUNPRO_CC <= 0x560)
21
+ # define SWIGTEMPLATEDISAMBIGUATOR template
22
+ # else
23
+ # define SWIGTEMPLATEDISAMBIGUATOR
24
+ # endif
25
+ # else
26
+ # define SWIGTEMPLATEDISAMBIGUATOR
27
+ # endif
28
+ #endif
29
+
30
+ /* inline attribute */
31
+ #ifndef SWIGINLINE
32
+ # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
33
+ # define SWIGINLINE inline
34
+ # else
35
+ # define SWIGINLINE
36
+ # endif
37
+ #endif
38
+
39
+ /* attribute recognised by some compilers to avoid 'unused' warnings */
40
+ #ifndef SWIGUNUSED
41
+ # if defined(__GNUC__)
42
+ # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
43
+ # define SWIGUNUSED __attribute__ ((__unused__))
44
+ # else
45
+ # define SWIGUNUSED
46
+ # endif
47
+ # elif defined(__ICC)
48
+ # define SWIGUNUSED __attribute__ ((__unused__))
49
+ # else
50
+ # define SWIGUNUSED
51
+ # endif
52
+ #endif
53
+
54
+ #ifndef SWIGUNUSEDPARM
55
+ # ifdef __cplusplus
56
+ # define SWIGUNUSEDPARM(p)
57
+ # else
58
+ # define SWIGUNUSEDPARM(p) p SWIGUNUSED
59
+ # endif
60
+ #endif
61
+
62
+ /* internal SWIG method */
63
+ #ifndef SWIGINTERN
64
+ # define SWIGINTERN static SWIGUNUSED
65
+ #endif
66
+
67
+ /* internal inline SWIG method */
68
+ #ifndef SWIGINTERNINLINE
69
+ # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
70
+ #endif
71
+
72
+ /* exporting methods */
73
+ #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
74
+ # ifndef GCC_HASCLASSVISIBILITY
75
+ # define GCC_HASCLASSVISIBILITY
76
+ # endif
77
+ #endif
78
+
79
+ #ifndef SWIGEXPORT
80
+ # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
81
+ # if defined(STATIC_LINKED)
82
+ # define SWIGEXPORT
83
+ # else
84
+ # define SWIGEXPORT __declspec(dllexport)
85
+ # endif
86
+ # else
87
+ # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
88
+ # define SWIGEXPORT __attribute__ ((visibility("default")))
89
+ # else
90
+ # define SWIGEXPORT
91
+ # endif
92
+ # endif
93
+ #endif
94
+
95
+ /* calling conventions for Windows */
96
+ #ifndef SWIGSTDCALL
97
+ # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
98
+ # define SWIGSTDCALL __stdcall
99
+ # else
100
+ # define SWIGSTDCALL
101
+ # endif
102
+ #endif
103
+
104
+ /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
105
+ #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
106
+ # define _CRT_SECURE_NO_DEPRECATE
107
+ #endif
108
+
109
+ /* -----------------------------------------------------------------------------
110
+ * This section contains generic SWIG labels for method/variable
111
+ * declarations/attributes, and other compiler dependent labels.
112
+ * ----------------------------------------------------------------------------- */
113
+
114
+ /* template workaround for compilers that cannot correctly implement the C++ standard */
115
+ #ifndef SWIGTEMPLATEDISAMBIGUATOR
116
+ # if defined(__SUNPRO_CC)
117
+ # if (__SUNPRO_CC <= 0x560)
118
+ # define SWIGTEMPLATEDISAMBIGUATOR template
119
+ # else
120
+ # define SWIGTEMPLATEDISAMBIGUATOR
121
+ # endif
122
+ # else
123
+ # define SWIGTEMPLATEDISAMBIGUATOR
124
+ # endif
125
+ #endif
126
+
127
+ /* inline attribute */
128
+ #ifndef SWIGINLINE
129
+ # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
130
+ # define SWIGINLINE inline
131
+ # else
132
+ # define SWIGINLINE
133
+ # endif
134
+ #endif
135
+
136
+ /* attribute recognised by some compilers to avoid 'unused' warnings */
137
+ #ifndef SWIGUNUSED
138
+ # if defined(__GNUC__)
139
+ # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
140
+ # define SWIGUNUSED __attribute__ ((__unused__))
141
+ # else
142
+ # define SWIGUNUSED
143
+ # endif
144
+ # elif defined(__ICC)
145
+ # define SWIGUNUSED __attribute__ ((__unused__))
146
+ # else
147
+ # define SWIGUNUSED
148
+ # endif
149
+ #endif
150
+
151
+ #ifndef SWIGUNUSEDPARM
152
+ # ifdef __cplusplus
153
+ # define SWIGUNUSEDPARM(p)
154
+ # else
155
+ # define SWIGUNUSEDPARM(p) p SWIGUNUSED
156
+ # endif
157
+ #endif
158
+
159
+ /* internal SWIG method */
160
+ #ifndef SWIGINTERN
161
+ # define SWIGINTERN static SWIGUNUSED
162
+ #endif
163
+
164
+ /* internal inline SWIG method */
165
+ #ifndef SWIGINTERNINLINE
166
+ # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
167
+ #endif
168
+
169
+ /* exporting methods */
170
+ #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
171
+ # ifndef GCC_HASCLASSVISIBILITY
172
+ # define GCC_HASCLASSVISIBILITY
173
+ # endif
174
+ #endif
175
+
176
+ #ifndef SWIGEXPORT
177
+ # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
178
+ # if defined(STATIC_LINKED)
179
+ # define SWIGEXPORT
180
+ # else
181
+ # define SWIGEXPORT __declspec(dllexport)
182
+ # endif
183
+ # else
184
+ # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
185
+ # define SWIGEXPORT __attribute__ ((visibility("default")))
186
+ # else
187
+ # define SWIGEXPORT
188
+ # endif
189
+ # endif
190
+ #endif
191
+
192
+ /* calling conventions for Windows */
193
+ #ifndef SWIGSTDCALL
194
+ # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
195
+ # define SWIGSTDCALL __stdcall
196
+ # else
197
+ # define SWIGSTDCALL
198
+ # endif
199
+ #endif
200
+
201
+ /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
202
+ #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
203
+ # define _CRT_SECURE_NO_DEPRECATE
204
+ #endif
205
+
206
+ /* -----------------------------------------------------------------------------
207
+ * swigrun.swg
208
+ *
209
+ * This file contains generic CAPI SWIG runtime support for pointer
210
+ * type checking.
211
+ * ----------------------------------------------------------------------------- */
212
+
213
+ /* This should only be incremented when either the layout of swig_type_info changes,
214
+ or for whatever reason, the runtime changes incompatibly */
215
+ #define SWIG_RUNTIME_VERSION "3"
216
+
217
+ /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
218
+ #ifdef SWIG_TYPE_TABLE
219
+ # define SWIG_QUOTE_STRING(x) #x
220
+ # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
221
+ # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
222
+ #else
223
+ # define SWIG_TYPE_TABLE_NAME
224
+ #endif
225
+
226
+ /*
227
+ You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
228
+ creating a static or dynamic library from the swig runtime code.
229
+ In 99.9% of the cases, swig just needs to declare them as 'static'.
230
+
231
+ But only do this if is strictly necessary, ie, if you have problems
232
+ with your compiler or so.
233
+ */
234
+
235
+ #ifndef SWIGRUNTIME
236
+ # define SWIGRUNTIME SWIGINTERN
237
+ #endif
238
+
239
+ #ifndef SWIGRUNTIMEINLINE
240
+ # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
241
+ #endif
242
+
243
+ /* Generic buffer size */
244
+ #ifndef SWIG_BUFFER_SIZE
245
+ # define SWIG_BUFFER_SIZE 1024
246
+ #endif
247
+
248
+ /* Flags for pointer conversions */
249
+ #define SWIG_POINTER_DISOWN 0x1
250
+
251
+ /* Flags for new pointer objects */
252
+ #define SWIG_POINTER_OWN 0x1
253
+
254
+
255
+ /*
256
+ Flags/methods for returning states.
257
+
258
+ The swig conversion methods, as ConvertPtr, return and integer
259
+ that tells if the conversion was successful or not. And if not,
260
+ an error code can be returned (see swigerrors.swg for the codes).
261
+
262
+ Use the following macros/flags to set or process the returning
263
+ states.
264
+
265
+ In old swig versions, you usually write code as:
266
+
267
+ if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
268
+ // success code
269
+ } else {
270
+ //fail code
271
+ }
272
+
273
+ Now you can be more explicit as:
274
+
275
+ int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
276
+ if (SWIG_IsOK(res)) {
277
+ // success code
278
+ } else {
279
+ // fail code
280
+ }
281
+
282
+ that seems to be the same, but now you can also do
283
+
284
+ Type *ptr;
285
+ int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
286
+ if (SWIG_IsOK(res)) {
287
+ // success code
288
+ if (SWIG_IsNewObj(res) {
289
+ ...
290
+ delete *ptr;
291
+ } else {
292
+ ...
293
+ }
294
+ } else {
295
+ // fail code
296
+ }
297
+
298
+ I.e., now SWIG_ConvertPtr can return new objects and you can
299
+ identify the case and take care of the deallocation. Of course that
300
+ requires also to SWIG_ConvertPtr to return new result values, as
301
+
302
+ int SWIG_ConvertPtr(obj, ptr,...) {
303
+ if (<obj is ok>) {
304
+ if (<need new object>) {
305
+ *ptr = <ptr to new allocated object>;
306
+ return SWIG_NEWOBJ;
307
+ } else {
308
+ *ptr = <ptr to old object>;
309
+ return SWIG_OLDOBJ;
310
+ }
311
+ } else {
312
+ return SWIG_BADOBJ;
313
+ }
314
+ }
315
+
316
+ Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
317
+ more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
318
+ swig errors code.
319
+
320
+ Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
321
+ allows to return the 'cast rank', for example, if you have this
322
+
323
+ int food(double)
324
+ int fooi(int);
325
+
326
+ and you call
327
+
328
+ food(1) // cast rank '1' (1 -> 1.0)
329
+ fooi(1) // cast rank '0'
330
+
331
+ just use the SWIG_AddCast()/SWIG_CheckState()
332
+
333
+
334
+ */
335
+ #define SWIG_OK (0)
336
+ #define SWIG_ERROR (-1)
337
+ #define SWIG_IsOK(r) (r >= 0)
338
+ #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
339
+
340
+ /* The CastRankLimit says how many bits are used for the cast rank */
341
+ #define SWIG_CASTRANKLIMIT (1 << 8)
342
+ /* The NewMask denotes the object was created (using new/malloc) */
343
+ #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
344
+ /* The TmpMask is for in/out typemaps that use temporal objects */
345
+ #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
346
+ /* Simple returning values */
347
+ #define SWIG_BADOBJ (SWIG_ERROR)
348
+ #define SWIG_OLDOBJ (SWIG_OK)
349
+ #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
350
+ #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
351
+ /* Check, add and del mask methods */
352
+ #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
353
+ #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
354
+ #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
355
+ #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
356
+ #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
357
+ #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
358
+
359
+
360
+ /* Cast-Rank Mode */
361
+ #if defined(SWIG_CASTRANK_MODE)
362
+ # ifndef SWIG_TypeRank
363
+ # define SWIG_TypeRank unsigned long
364
+ # endif
365
+ # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
366
+ # define SWIG_MAXCASTRANK (2)
367
+ # endif
368
+ # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
369
+ # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
370
+ SWIGINTERNINLINE int SWIG_AddCast(int r) {
371
+ return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
372
+ }
373
+ SWIGINTERNINLINE int SWIG_CheckState(int r) {
374
+ return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
375
+ }
376
+ #else /* no cast-rank mode */
377
+ # define SWIG_AddCast
378
+ # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
379
+ #endif
380
+
381
+
382
+
383
+
384
+ #include <string.h>
385
+
386
+ #ifdef __cplusplus
387
+ extern "C" {
388
+ #endif
389
+
390
+ typedef void *(*swig_converter_func)(void *);
391
+ typedef struct swig_type_info *(*swig_dycast_func)(void **);
392
+
393
+ /* Structure to store inforomation on one type */
394
+ typedef struct swig_type_info {
395
+ const char *name; /* mangled name of this type */
396
+ const char *str; /* human readable name of this type */
397
+ swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
398
+ struct swig_cast_info *cast; /* linked list of types that can cast into this type */
399
+ void *clientdata; /* language specific type data */
400
+ int owndata; /* flag if the structure owns the clientdata */
401
+ } swig_type_info;
402
+
403
+ /* Structure to store a type and conversion function used for casting */
404
+ typedef struct swig_cast_info {
405
+ swig_type_info *type; /* pointer to type that is equivalent to this type */
406
+ swig_converter_func converter; /* function to cast the void pointers */
407
+ struct swig_cast_info *next; /* pointer to next cast in linked list */
408
+ struct swig_cast_info *prev; /* pointer to the previous cast */
409
+ } swig_cast_info;
410
+
411
+ /* Structure used to store module information
412
+ * Each module generates one structure like this, and the runtime collects
413
+ * all of these structures and stores them in a circularly linked list.*/
414
+ typedef struct swig_module_info {
415
+ swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
416
+ size_t size; /* Number of types in this module */
417
+ struct swig_module_info *next; /* Pointer to next element in circularly linked list */
418
+ swig_type_info **type_initial; /* Array of initially generated type structures */
419
+ swig_cast_info **cast_initial; /* Array of initially generated casting structures */
420
+ void *clientdata; /* Language specific module data */
421
+ } swig_module_info;
422
+
423
+ /*
424
+ Compare two type names skipping the space characters, therefore
425
+ "char*" == "char *" and "Class<int>" == "Class<int >", etc.
426
+
427
+ Return 0 when the two name types are equivalent, as in
428
+ strncmp, but skipping ' '.
429
+ */
430
+ SWIGRUNTIME int
431
+ SWIG_TypeNameComp(const char *f1, const char *l1,
432
+ const char *f2, const char *l2) {
433
+ for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
434
+ while ((*f1 == ' ') && (f1 != l1)) ++f1;
435
+ while ((*f2 == ' ') && (f2 != l2)) ++f2;
436
+ if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
437
+ }
438
+ return (l1 - f1) - (l2 - f2);
439
+ }
440
+
441
+ /*
442
+ Check type equivalence in a name list like <name1>|<name2>|...
443
+ Return 0 if not equal, 1 if equal
444
+ */
445
+ SWIGRUNTIME int
446
+ SWIG_TypeEquiv(const char *nb, const char *tb) {
447
+ int equiv = 0;
448
+ const char* te = tb + strlen(tb);
449
+ const char* ne = nb;
450
+ while (!equiv && *ne) {
451
+ for (nb = ne; *ne; ++ne) {
452
+ if (*ne == '|') break;
453
+ }
454
+ equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
455
+ if (*ne) ++ne;
456
+ }
457
+ return equiv;
458
+ }
459
+
460
+ /*
461
+ Check type equivalence in a name list like <name1>|<name2>|...
462
+ Return 0 if equal, -1 if nb < tb, 1 if nb > tb
463
+ */
464
+ SWIGRUNTIME int
465
+ SWIG_TypeCompare(const char *nb, const char *tb) {
466
+ int equiv = 0;
467
+ const char* te = tb + strlen(tb);
468
+ const char* ne = nb;
469
+ while (!equiv && *ne) {
470
+ for (nb = ne; *ne; ++ne) {
471
+ if (*ne == '|') break;
472
+ }
473
+ equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
474
+ if (*ne) ++ne;
475
+ }
476
+ return equiv;
477
+ }
478
+
479
+
480
+ /* think of this as a c++ template<> or a scheme macro */
481
+ #define SWIG_TypeCheck_Template(comparison, ty) \
482
+ if (ty) { \
483
+ swig_cast_info *iter = ty->cast; \
484
+ while (iter) { \
485
+ if (comparison) { \
486
+ if (iter == ty->cast) return iter; \
487
+ /* Move iter to the top of the linked list */ \
488
+ iter->prev->next = iter->next; \
489
+ if (iter->next) \
490
+ iter->next->prev = iter->prev; \
491
+ iter->next = ty->cast; \
492
+ iter->prev = 0; \
493
+ if (ty->cast) ty->cast->prev = iter; \
494
+ ty->cast = iter; \
495
+ return iter; \
496
+ } \
497
+ iter = iter->next; \
498
+ } \
499
+ } \
500
+ return 0
501
+
502
+ /*
503
+ Check the typename
504
+ */
505
+ SWIGRUNTIME swig_cast_info *
506
+ SWIG_TypeCheck(const char *c, swig_type_info *ty) {
507
+ SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
508
+ }
509
+
510
+ /* Same as previous function, except strcmp is replaced with a pointer comparison */
511
+ SWIGRUNTIME swig_cast_info *
512
+ SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
513
+ SWIG_TypeCheck_Template(iter->type == from, into);
514
+ }
515
+
516
+ /*
517
+ Cast a pointer up an inheritance hierarchy
518
+ */
519
+ SWIGRUNTIMEINLINE void *
520
+ SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
521
+ return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
522
+ }
523
+
524
+ /*
525
+ Dynamic pointer casting. Down an inheritance hierarchy
526
+ */
527
+ SWIGRUNTIME swig_type_info *
528
+ SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
529
+ swig_type_info *lastty = ty;
530
+ if (!ty || !ty->dcast) return ty;
531
+ while (ty && (ty->dcast)) {
532
+ ty = (*ty->dcast)(ptr);
533
+ if (ty) lastty = ty;
534
+ }
535
+ return lastty;
536
+ }
537
+
538
+ /*
539
+ Return the name associated with this type
540
+ */
541
+ SWIGRUNTIMEINLINE const char *
542
+ SWIG_TypeName(const swig_type_info *ty) {
543
+ return ty->name;
544
+ }
545
+
546
+ /*
547
+ Return the pretty name associated with this type,
548
+ that is an unmangled type name in a form presentable to the user.
549
+ */
550
+ SWIGRUNTIME const char *
551
+ SWIG_TypePrettyName(const swig_type_info *type) {
552
+ /* The "str" field contains the equivalent pretty names of the
553
+ type, separated by vertical-bar characters. We choose
554
+ to print the last name, as it is often (?) the most
555
+ specific. */
556
+ if (!type) return NULL;
557
+ if (type->str != NULL) {
558
+ const char *last_name = type->str;
559
+ const char *s;
560
+ for (s = type->str; *s; s++)
561
+ if (*s == '|') last_name = s+1;
562
+ return last_name;
563
+ }
564
+ else
565
+ return type->name;
566
+ }
567
+
568
+ /*
569
+ Set the clientdata field for a type
570
+ */
571
+ SWIGRUNTIME void
572
+ SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
573
+ swig_cast_info *cast = ti->cast;
574
+ /* if (ti->clientdata == clientdata) return; */
575
+ ti->clientdata = clientdata;
576
+
577
+ while (cast) {
578
+ if (!cast->converter) {
579
+ swig_type_info *tc = cast->type;
580
+ if (!tc->clientdata) {
581
+ SWIG_TypeClientData(tc, clientdata);
582
+ }
583
+ }
584
+ cast = cast->next;
585
+ }
586
+ }
587
+ SWIGRUNTIME void
588
+ SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
589
+ SWIG_TypeClientData(ti, clientdata);
590
+ ti->owndata = 1;
591
+ }
592
+
593
+ /*
594
+ Search for a swig_type_info structure only by mangled name
595
+ Search is a O(log #types)
596
+
597
+ We start searching at module start, and finish searching when start == end.
598
+ Note: if start == end at the beginning of the function, we go all the way around
599
+ the circular list.
600
+ */
601
+ SWIGRUNTIME swig_type_info *
602
+ SWIG_MangledTypeQueryModule(swig_module_info *start,
603
+ swig_module_info *end,
604
+ const char *name) {
605
+ swig_module_info *iter = start;
606
+ do {
607
+ if (iter->size) {
608
+ register size_t l = 0;
609
+ register size_t r = iter->size - 1;
610
+ do {
611
+ /* since l+r >= 0, we can (>> 1) instead (/ 2) */
612
+ register size_t i = (l + r) >> 1;
613
+ const char *iname = iter->types[i]->name;
614
+ if (iname) {
615
+ register int compare = strcmp(name, iname);
616
+ if (compare == 0) {
617
+ return iter->types[i];
618
+ } else if (compare < 0) {
619
+ if (i) {
620
+ r = i - 1;
621
+ } else {
622
+ break;
623
+ }
624
+ } else if (compare > 0) {
625
+ l = i + 1;
626
+ }
627
+ } else {
628
+ break; /* should never happen */
629
+ }
630
+ } while (l <= r);
631
+ }
632
+ iter = iter->next;
633
+ } while (iter != end);
634
+ return 0;
635
+ }
636
+
637
+ /*
638
+ Search for a swig_type_info structure for either a mangled name or a human readable name.
639
+ It first searches the mangled names of the types, which is a O(log #types)
640
+ If a type is not found it then searches the human readable names, which is O(#types).
641
+
642
+ We start searching at module start, and finish searching when start == end.
643
+ Note: if start == end at the beginning of the function, we go all the way around
644
+ the circular list.
645
+ */
646
+ SWIGRUNTIME swig_type_info *
647
+ SWIG_TypeQueryModule(swig_module_info *start,
648
+ swig_module_info *end,
649
+ const char *name) {
650
+ /* STEP 1: Search the name field using binary search */
651
+ swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
652
+ if (ret) {
653
+ return ret;
654
+ } else {
655
+ /* STEP 2: If the type hasn't been found, do a complete search
656
+ of the str field (the human readable name) */
657
+ swig_module_info *iter = start;
658
+ do {
659
+ register size_t i = 0;
660
+ for (; i < iter->size; ++i) {
661
+ if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
662
+ return iter->types[i];
663
+ }
664
+ iter = iter->next;
665
+ } while (iter != end);
666
+ }
667
+
668
+ /* neither found a match */
669
+ return 0;
670
+ }
671
+
672
+ /*
673
+ Pack binary data into a string
674
+ */
675
+ SWIGRUNTIME char *
676
+ SWIG_PackData(char *c, void *ptr, size_t sz) {
677
+ static const char hex[17] = "0123456789abcdef";
678
+ register const unsigned char *u = (unsigned char *) ptr;
679
+ register const unsigned char *eu = u + sz;
680
+ for (; u != eu; ++u) {
681
+ register unsigned char uu = *u;
682
+ *(c++) = hex[(uu & 0xf0) >> 4];
683
+ *(c++) = hex[uu & 0xf];
684
+ }
685
+ return c;
686
+ }
687
+
688
+ /*
689
+ Unpack binary data from a string
690
+ */
691
+ SWIGRUNTIME const char *
692
+ SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
693
+ register unsigned char *u = (unsigned char *) ptr;
694
+ register const unsigned char *eu = u + sz;
695
+ for (; u != eu; ++u) {
696
+ register char d = *(c++);
697
+ register unsigned char uu;
698
+ if ((d >= '0') && (d <= '9'))
699
+ uu = ((d - '0') << 4);
700
+ else if ((d >= 'a') && (d <= 'f'))
701
+ uu = ((d - ('a'-10)) << 4);
702
+ else
703
+ return (char *) 0;
704
+ d = *(c++);
705
+ if ((d >= '0') && (d <= '9'))
706
+ uu |= (d - '0');
707
+ else if ((d >= 'a') && (d <= 'f'))
708
+ uu |= (d - ('a'-10));
709
+ else
710
+ return (char *) 0;
711
+ *u = uu;
712
+ }
713
+ return c;
714
+ }
715
+
716
+ /*
717
+ Pack 'void *' into a string buffer.
718
+ */
719
+ SWIGRUNTIME char *
720
+ SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
721
+ char *r = buff;
722
+ if ((2*sizeof(void *) + 2) > bsz) return 0;
723
+ *(r++) = '_';
724
+ r = SWIG_PackData(r,&ptr,sizeof(void *));
725
+ if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
726
+ strcpy(r,name);
727
+ return buff;
728
+ }
729
+
730
+ SWIGRUNTIME const char *
731
+ SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
732
+ if (*c != '_') {
733
+ if (strcmp(c,"NULL") == 0) {
734
+ *ptr = (void *) 0;
735
+ return name;
736
+ } else {
737
+ return 0;
738
+ }
739
+ }
740
+ return SWIG_UnpackData(++c,ptr,sizeof(void *));
741
+ }
742
+
743
+ SWIGRUNTIME char *
744
+ SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
745
+ char *r = buff;
746
+ size_t lname = (name ? strlen(name) : 0);
747
+ if ((2*sz + 2 + lname) > bsz) return 0;
748
+ *(r++) = '_';
749
+ r = SWIG_PackData(r,ptr,sz);
750
+ if (lname) {
751
+ strncpy(r,name,lname+1);
752
+ } else {
753
+ *r = 0;
754
+ }
755
+ return buff;
756
+ }
757
+
758
+ SWIGRUNTIME const char *
759
+ SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
760
+ if (*c != '_') {
761
+ if (strcmp(c,"NULL") == 0) {
762
+ memset(ptr,0,sz);
763
+ return name;
764
+ } else {
765
+ return 0;
766
+ }
767
+ }
768
+ return SWIG_UnpackData(++c,ptr,sz);
769
+ }
770
+
771
+ #ifdef __cplusplus
772
+ }
773
+ #endif
774
+
775
+ /* Errors in SWIG */
776
+ #define SWIG_UnknownError -1
777
+ #define SWIG_IOError -2
778
+ #define SWIG_RuntimeError -3
779
+ #define SWIG_IndexError -4
780
+ #define SWIG_TypeError -5
781
+ #define SWIG_DivisionByZero -6
782
+ #define SWIG_OverflowError -7
783
+ #define SWIG_SyntaxError -8
784
+ #define SWIG_ValueError -9
785
+ #define SWIG_SystemError -10
786
+ #define SWIG_AttributeError -11
787
+ #define SWIG_MemoryError -12
788
+ #define SWIG_NullReferenceError -13
789
+
790
+
791
+
792
+ #include <ruby.h>
793
+
794
+ /* Ruby 1.7 defines NUM2LL(), LL2NUM() and ULL2NUM() macros */
795
+ #ifndef NUM2LL
796
+ #define NUM2LL(x) NUM2LONG((x))
797
+ #endif
798
+ #ifndef LL2NUM
799
+ #define LL2NUM(x) INT2NUM((long) (x))
800
+ #endif
801
+ #ifndef ULL2NUM
802
+ #define ULL2NUM(x) UINT2NUM((unsigned long) (x))
803
+ #endif
804
+
805
+ /* Ruby 1.7 doesn't (yet) define NUM2ULL() */
806
+ #ifndef NUM2ULL
807
+ #ifdef HAVE_LONG_LONG
808
+ #define NUM2ULL(x) rb_num2ull((x))
809
+ #else
810
+ #define NUM2ULL(x) NUM2ULONG(x)
811
+ #endif
812
+ #endif
813
+
814
+ /* RSTRING_LEN, etc are new in Ruby 1.9, but ->ptr and ->len no longer work */
815
+ /* Define these for older versions so we can just write code the new way */
816
+ #ifndef RSTRING_LEN
817
+ # define RSTRING_LEN(x) RSTRING(x)->len
818
+ #endif
819
+ #ifndef RSTRING_PTR
820
+ # define RSTRING_PTR(x) RSTRING(x)->ptr
821
+ #endif
822
+ #ifndef RARRAY_LEN
823
+ # define RARRAY_LEN(x) RARRAY(x)->len
824
+ #endif
825
+ #ifndef RARRAY_PTR
826
+ # define RARRAY_PTR(x) RARRAY(x)->ptr
827
+ #endif
828
+
829
+ /*
830
+ * Need to be very careful about how these macros are defined, especially
831
+ * when compiling C++ code or C code with an ANSI C compiler.
832
+ *
833
+ * VALUEFUNC(f) is a macro used to typecast a C function that implements
834
+ * a Ruby method so that it can be passed as an argument to API functions
835
+ * like rb_define_method() and rb_define_singleton_method().
836
+ *
837
+ * VOIDFUNC(f) is a macro used to typecast a C function that implements
838
+ * either the "mark" or "free" stuff for a Ruby Data object, so that it
839
+ * can be passed as an argument to API functions like Data_Wrap_Struct()
840
+ * and Data_Make_Struct().
841
+ */
842
+
843
+ #ifdef __cplusplus
844
+ # ifndef RUBY_METHOD_FUNC /* These definitions should work for Ruby 1.4.6 */
845
+ # define PROTECTFUNC(f) ((VALUE (*)()) f)
846
+ # define VALUEFUNC(f) ((VALUE (*)()) f)
847
+ # define VOIDFUNC(f) ((void (*)()) f)
848
+ # else
849
+ # ifndef ANYARGS /* These definitions should work for Ruby 1.6 */
850
+ # define PROTECTFUNC(f) ((VALUE (*)()) f)
851
+ # define VALUEFUNC(f) ((VALUE (*)()) f)
852
+ # define VOIDFUNC(f) ((RUBY_DATA_FUNC) f)
853
+ # else /* These definitions should work for Ruby 1.7+ */
854
+ # define PROTECTFUNC(f) ((VALUE (*)(VALUE)) f)
855
+ # define VALUEFUNC(f) ((VALUE (*)(ANYARGS)) f)
856
+ # define VOIDFUNC(f) ((RUBY_DATA_FUNC) f)
857
+ # endif
858
+ # endif
859
+ #else
860
+ # define VALUEFUNC(f) (f)
861
+ # define VOIDFUNC(f) (f)
862
+ #endif
863
+
864
+ /* Don't use for expressions have side effect */
865
+ #ifndef RB_STRING_VALUE
866
+ #define RB_STRING_VALUE(s) (TYPE(s) == T_STRING ? (s) : (*(volatile VALUE *)&(s) = rb_str_to_str(s)))
867
+ #endif
868
+ #ifndef StringValue
869
+ #define StringValue(s) RB_STRING_VALUE(s)
870
+ #endif
871
+ #ifndef StringValuePtr
872
+ #define StringValuePtr(s) RSTRING_PTR(RB_STRING_VALUE(s))
873
+ #endif
874
+ #ifndef StringValueLen
875
+ #define StringValueLen(s) RSTRING_LEN(RB_STRING_VALUE(s))
876
+ #endif
877
+ #ifndef SafeStringValue
878
+ #define SafeStringValue(v) do {\
879
+ StringValue(v);\
880
+ rb_check_safe_str(v);\
881
+ } while (0)
882
+ #endif
883
+
884
+ #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
885
+ #define rb_define_alloc_func(klass, func) rb_define_singleton_method((klass), "new", VALUEFUNC((func)), -1)
886
+ #define rb_undef_alloc_func(klass) rb_undef_method(CLASS_OF((klass)), "new")
887
+ #endif
888
+
889
+
890
+ /* -----------------------------------------------------------------------------
891
+ * error manipulation
892
+ * ----------------------------------------------------------------------------- */
893
+
894
+
895
+ /* Define some additional error types */
896
+ #define SWIG_ObjectPreviouslyDeletedError -100
897
+
898
+
899
+ /* Define custom exceptions for errors that do not map to existing Ruby
900
+ exceptions. Note this only works for C++ since a global cannot be
901
+ initialized by a funtion in C. For C, fallback to rb_eRuntimeError.*/
902
+
903
+ SWIGINTERN VALUE
904
+ getNullReferenceError(void) {
905
+ static int init = 0;
906
+ static VALUE rb_eNullReferenceError ;
907
+ if (!init) {
908
+ init = 1;
909
+ rb_eNullReferenceError = rb_define_class("NullReferenceError", rb_eRuntimeError);
910
+ }
911
+ return rb_eNullReferenceError;
912
+ }
913
+
914
+ SWIGINTERN VALUE
915
+ getObjectPreviouslyDeletedError(void) {
916
+ static int init = 0;
917
+ static VALUE rb_eObjectPreviouslyDeleted ;
918
+ if (!init) {
919
+ init = 1;
920
+ rb_eObjectPreviouslyDeleted = rb_define_class("ObjectPreviouslyDeleted", rb_eRuntimeError);
921
+ }
922
+ return rb_eObjectPreviouslyDeleted;
923
+ }
924
+
925
+
926
+ SWIGINTERN VALUE
927
+ SWIG_Ruby_ErrorType(int SWIG_code) {
928
+ VALUE type;
929
+ switch (SWIG_code) {
930
+ case SWIG_MemoryError:
931
+ type = rb_eNoMemError;
932
+ break;
933
+ case SWIG_IOError:
934
+ type = rb_eIOError;
935
+ break;
936
+ case SWIG_RuntimeError:
937
+ type = rb_eRuntimeError;
938
+ break;
939
+ case SWIG_IndexError:
940
+ type = rb_eIndexError;
941
+ break;
942
+ case SWIG_TypeError:
943
+ type = rb_eTypeError;
944
+ break;
945
+ case SWIG_DivisionByZero:
946
+ type = rb_eZeroDivError;
947
+ break;
948
+ case SWIG_OverflowError:
949
+ type = rb_eRangeError;
950
+ break;
951
+ case SWIG_SyntaxError:
952
+ type = rb_eSyntaxError;
953
+ break;
954
+ case SWIG_ValueError:
955
+ type = rb_eArgError;
956
+ break;
957
+ case SWIG_SystemError:
958
+ type = rb_eFatal;
959
+ break;
960
+ case SWIG_AttributeError:
961
+ type = rb_eRuntimeError;
962
+ break;
963
+ case SWIG_NullReferenceError:
964
+ type = getNullReferenceError();
965
+ break;
966
+ case SWIG_ObjectPreviouslyDeletedError:
967
+ type = getObjectPreviouslyDeletedError();
968
+ break;
969
+ case SWIG_UnknownError:
970
+ type = rb_eRuntimeError;
971
+ break;
972
+ default:
973
+ type = rb_eRuntimeError;
974
+ }
975
+ return type;
976
+ }
977
+
978
+
979
+
980
+
981
+ /* -----------------------------------------------------------------------------
982
+ * See the LICENSE file for information on copyright, usage and redistribution
983
+ * of SWIG, and the README file for authors - http://www.swig.org/release.html.
984
+ *
985
+ * rubytracking.swg
986
+ *
987
+ * This file contains support for tracking mappings from
988
+ * Ruby objects to C++ objects. This functionality is needed
989
+ * to implement mark functions for Ruby's mark and sweep
990
+ * garbage collector.
991
+ * ----------------------------------------------------------------------------- */
992
+
993
+ #ifdef __cplusplus
994
+ extern "C" {
995
+ #endif
996
+
997
+
998
+ /* Global Ruby hash table to store Trackings from C/C++
999
+ structs to Ruby Objects. */
1000
+ static VALUE swig_ruby_trackings;
1001
+
1002
+ /* Global variable that stores a reference to the ruby
1003
+ hash table delete function. */
1004
+ static ID swig_ruby_hash_delete = 0;
1005
+
1006
+ /* Setup a Ruby hash table to store Trackings */
1007
+ SWIGRUNTIME void SWIG_RubyInitializeTrackings(void) {
1008
+ /* Create a ruby hash table to store Trackings from C++
1009
+ objects to Ruby objects. Also make sure to tell
1010
+ the garabage collector about the hash table. */
1011
+ swig_ruby_trackings = rb_hash_new();
1012
+ rb_gc_register_address(&swig_ruby_trackings);
1013
+
1014
+ /* Now store a reference to the hash table delete function
1015
+ so that we only have to look it up once.*/
1016
+ swig_ruby_hash_delete = rb_intern("delete");
1017
+ }
1018
+
1019
+ /* Get a Ruby number to reference a pointer */
1020
+ SWIGRUNTIME VALUE SWIG_RubyPtrToReference(void* ptr) {
1021
+ /* We cast the pointer to an unsigned long
1022
+ and then store a reference to it using
1023
+ a Ruby number object. */
1024
+
1025
+ /* Convert the pointer to a Ruby number */
1026
+ unsigned long value = (unsigned long) ptr;
1027
+ return LONG2NUM(value);
1028
+ }
1029
+
1030
+ /* Get a Ruby number to reference an object */
1031
+ SWIGRUNTIME VALUE SWIG_RubyObjectToReference(VALUE object) {
1032
+ /* We cast the object to an unsigned long
1033
+ and then store a reference to it using
1034
+ a Ruby number object. */
1035
+
1036
+ /* Convert the Object to a Ruby number */
1037
+ unsigned long value = (unsigned long) object;
1038
+ return LONG2NUM(value);
1039
+ }
1040
+
1041
+ /* Get a Ruby object from a previously stored reference */
1042
+ SWIGRUNTIME VALUE SWIG_RubyReferenceToObject(VALUE reference) {
1043
+ /* The provided Ruby number object is a reference
1044
+ to the Ruby object we want.*/
1045
+
1046
+ /* First convert the Ruby number to a C number */
1047
+ unsigned long value = NUM2LONG(reference);
1048
+ return (VALUE) value;
1049
+ }
1050
+
1051
+ /* Add a Tracking from a C/C++ struct to a Ruby object */
1052
+ SWIGRUNTIME void SWIG_RubyAddTracking(void* ptr, VALUE object) {
1053
+ /* In a Ruby hash table we store the pointer and
1054
+ the associated Ruby object. The trick here is
1055
+ that we cannot store the Ruby object directly - if
1056
+ we do then it cannot be garbage collected. So
1057
+ instead we typecast it as a unsigned long and
1058
+ convert it to a Ruby number object.*/
1059
+
1060
+ /* Get a reference to the pointer as a Ruby number */
1061
+ VALUE key = SWIG_RubyPtrToReference(ptr);
1062
+
1063
+ /* Get a reference to the Ruby object as a Ruby number */
1064
+ VALUE value = SWIG_RubyObjectToReference(object);
1065
+
1066
+ /* Store the mapping to the global hash table. */
1067
+ rb_hash_aset(swig_ruby_trackings, key, value);
1068
+ }
1069
+
1070
+ /* Get the Ruby object that owns the specified C/C++ struct */
1071
+ SWIGRUNTIME VALUE SWIG_RubyInstanceFor(void* ptr) {
1072
+ /* Get a reference to the pointer as a Ruby number */
1073
+ VALUE key = SWIG_RubyPtrToReference(ptr);
1074
+
1075
+ /* Now lookup the value stored in the global hash table */
1076
+ VALUE value = rb_hash_aref(swig_ruby_trackings, key);
1077
+
1078
+ if (value == Qnil) {
1079
+ /* No object exists - return nil. */
1080
+ return Qnil;
1081
+ }
1082
+ else {
1083
+ /* Convert this value to Ruby object */
1084
+ return SWIG_RubyReferenceToObject(value);
1085
+ }
1086
+ }
1087
+
1088
+ /* Remove a Tracking from a C/C++ struct to a Ruby object. It
1089
+ is very important to remove objects once they are destroyed
1090
+ since the same memory address may be reused later to create
1091
+ a new object. */
1092
+ SWIGRUNTIME void SWIG_RubyRemoveTracking(void* ptr) {
1093
+ /* Get a reference to the pointer as a Ruby number */
1094
+ VALUE key = SWIG_RubyPtrToReference(ptr);
1095
+
1096
+ /* Delete the object from the hash table by calling Ruby's
1097
+ do this we need to call the Hash.delete method.*/
1098
+ rb_funcall(swig_ruby_trackings, swig_ruby_hash_delete, 1, key);
1099
+ }
1100
+
1101
+ /* This is a helper method that unlinks a Ruby object from its
1102
+ underlying C++ object. This is needed if the lifetime of the
1103
+ Ruby object is longer than the C++ object */
1104
+ SWIGRUNTIME void SWIG_RubyUnlinkObjects(void* ptr) {
1105
+ VALUE object = SWIG_RubyInstanceFor(ptr);
1106
+
1107
+ if (object != Qnil) {
1108
+ DATA_PTR(object) = 0;
1109
+ }
1110
+ }
1111
+
1112
+
1113
+ #ifdef __cplusplus
1114
+ }
1115
+ #endif
1116
+
1117
+ /* -----------------------------------------------------------------------------
1118
+ * Ruby API portion that goes into the runtime
1119
+ * ----------------------------------------------------------------------------- */
1120
+
1121
+ #ifdef __cplusplus
1122
+ extern "C" {
1123
+ #endif
1124
+
1125
+ SWIGINTERN VALUE
1126
+ SWIG_Ruby_AppendOutput(VALUE target, VALUE o) {
1127
+ if (NIL_P(target)) {
1128
+ target = o;
1129
+ } else {
1130
+ if (TYPE(target) != T_ARRAY) {
1131
+ VALUE o2 = target;
1132
+ target = rb_ary_new();
1133
+ rb_ary_push(target, o2);
1134
+ }
1135
+ rb_ary_push(target, o);
1136
+ }
1137
+ return target;
1138
+ }
1139
+
1140
+ #ifdef __cplusplus
1141
+ }
1142
+ #endif
1143
+
1144
+
1145
+ /* -----------------------------------------------------------------------------
1146
+ * See the LICENSE file for information on copyright, usage and redistribution
1147
+ * of SWIG, and the README file for authors - http://www.swig.org/release.html.
1148
+ *
1149
+ * rubyrun.swg
1150
+ *
1151
+ * This file contains the runtime support for Ruby modules
1152
+ * and includes code for managing global variables and pointer
1153
+ * type checking.
1154
+ * ----------------------------------------------------------------------------- */
1155
+
1156
+ /* For backward compatibility only */
1157
+ #define SWIG_POINTER_EXCEPTION 0
1158
+
1159
+ /* for raw pointers */
1160
+ #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1161
+ #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1162
+ #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Ruby_NewPointerObj(ptr, type, flags)
1163
+ #define SWIG_AcquirePtr(ptr, own) SWIG_Ruby_AcquirePtr(ptr, own)
1164
+ #define swig_owntype ruby_owntype
1165
+
1166
+ /* for raw packed data */
1167
+ #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty, flags)
1168
+ #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Ruby_NewPackedObj(ptr, sz, type)
1169
+
1170
+ /* for class or struct pointers */
1171
+ #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1172
+ #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1173
+
1174
+ /* for C or C++ function pointers */
1175
+ #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_ConvertPtr(obj, pptr, type, 0)
1176
+ #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_NewPointerObj(ptr, type, 0)
1177
+
1178
+ /* for C++ member pointers, ie, member methods */
1179
+ #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty)
1180
+ #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Ruby_NewPackedObj(ptr, sz, type)
1181
+
1182
+
1183
+ /* Runtime API */
1184
+
1185
+ #define SWIG_GetModule(clientdata) SWIG_Ruby_GetModule()
1186
+ #define SWIG_SetModule(clientdata, pointer) SWIG_Ruby_SetModule(pointer)
1187
+
1188
+
1189
+ /* Error manipulation */
1190
+
1191
+ #define SWIG_ErrorType(code) SWIG_Ruby_ErrorType(code)
1192
+ #define SWIG_Error(code, msg) rb_raise(SWIG_Ruby_ErrorType(code), msg)
1193
+ #define SWIG_fail goto fail
1194
+
1195
+
1196
+ /* Ruby-specific SWIG API */
1197
+
1198
+ #define SWIG_InitRuntime() SWIG_Ruby_InitRuntime()
1199
+ #define SWIG_define_class(ty) SWIG_Ruby_define_class(ty)
1200
+ #define SWIG_NewClassInstance(value, ty) SWIG_Ruby_NewClassInstance(value, ty)
1201
+ #define SWIG_MangleStr(value) SWIG_Ruby_MangleStr(value)
1202
+ #define SWIG_CheckConvert(value, ty) SWIG_Ruby_CheckConvert(value, ty)
1203
+
1204
+
1205
+ /* -----------------------------------------------------------------------------
1206
+ * pointers/data manipulation
1207
+ * ----------------------------------------------------------------------------- */
1208
+
1209
+ #ifdef __cplusplus
1210
+ extern "C" {
1211
+ #if 0
1212
+ } /* cc-mode */
1213
+ #endif
1214
+ #endif
1215
+
1216
+ typedef struct {
1217
+ VALUE klass;
1218
+ VALUE mImpl;
1219
+ void (*mark)(void *);
1220
+ void (*destroy)(void *);
1221
+ int trackObjects;
1222
+ } swig_class;
1223
+
1224
+
1225
+ static VALUE _mSWIG = Qnil;
1226
+ static VALUE _cSWIG_Pointer = Qnil;
1227
+ static VALUE swig_runtime_data_type_pointer = Qnil;
1228
+
1229
+ SWIGRUNTIME VALUE
1230
+ getExceptionClass(void) {
1231
+ static int init = 0;
1232
+ static VALUE rubyExceptionClass ;
1233
+ if (!init) {
1234
+ init = 1;
1235
+ rubyExceptionClass = rb_const_get(_mSWIG, rb_intern("Exception"));
1236
+ }
1237
+ return rubyExceptionClass;
1238
+ }
1239
+
1240
+ /* This code checks to see if the Ruby object being raised as part
1241
+ of an exception inherits from the Ruby class Exception. If so,
1242
+ the object is simply returned. If not, then a new Ruby exception
1243
+ object is created and that will be returned to Ruby.*/
1244
+ SWIGRUNTIME VALUE
1245
+ SWIG_Ruby_ExceptionType(swig_type_info *desc, VALUE obj) {
1246
+ VALUE exceptionClass = getExceptionClass();
1247
+ if (rb_obj_is_kind_of(obj, exceptionClass)) {
1248
+ return obj;
1249
+ } else {
1250
+ return rb_exc_new3(rb_eRuntimeError, rb_obj_as_string(obj));
1251
+ }
1252
+ }
1253
+
1254
+ /* Initialize Ruby runtime support */
1255
+ SWIGRUNTIME void
1256
+ SWIG_Ruby_InitRuntime(void)
1257
+ {
1258
+ if (_mSWIG == Qnil) {
1259
+ _mSWIG = rb_define_module("SWIG");
1260
+ }
1261
+ }
1262
+
1263
+ /* Define Ruby class for C type */
1264
+ SWIGRUNTIME void
1265
+ SWIG_Ruby_define_class(swig_type_info *type)
1266
+ {
1267
+ VALUE klass;
1268
+ char *klass_name = (char *) malloc(4 + strlen(type->name) + 1);
1269
+ sprintf(klass_name, "TYPE%s", type->name);
1270
+ if (NIL_P(_cSWIG_Pointer)) {
1271
+ _cSWIG_Pointer = rb_define_class_under(_mSWIG, "Pointer", rb_cObject);
1272
+ rb_undef_method(CLASS_OF(_cSWIG_Pointer), "new");
1273
+ }
1274
+ klass = rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer);
1275
+ free((void *) klass_name);
1276
+ }
1277
+
1278
+ /* Create a new pointer object */
1279
+ SWIGRUNTIME VALUE
1280
+ SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
1281
+ {
1282
+ int own = flags & SWIG_POINTER_OWN;
1283
+
1284
+ char *klass_name;
1285
+ swig_class *sklass;
1286
+ VALUE klass;
1287
+ VALUE obj;
1288
+
1289
+ if (!ptr)
1290
+ return Qnil;
1291
+
1292
+ if (type->clientdata) {
1293
+ sklass = (swig_class *) type->clientdata;
1294
+
1295
+ /* Are we tracking this class and have we already returned this Ruby object? */
1296
+ if (sklass->trackObjects) {
1297
+ obj = SWIG_RubyInstanceFor(ptr);
1298
+
1299
+ /* Check the object's type and make sure it has the correct type.
1300
+ It might not in cases where methods do things like
1301
+ downcast methods. */
1302
+ if (obj != Qnil) {
1303
+ VALUE value = rb_iv_get(obj, "__swigtype__");
1304
+ char* type_name = RSTRING_PTR(value);
1305
+
1306
+ if (strcmp(type->name, type_name) == 0) {
1307
+ return obj;
1308
+ }
1309
+ }
1310
+ }
1311
+
1312
+ /* Create a new Ruby object */
1313
+ obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark), (own ? VOIDFUNC(sklass->destroy) : 0), ptr);
1314
+
1315
+ /* If tracking is on for this class then track this object. */
1316
+ if (sklass->trackObjects) {
1317
+ SWIG_RubyAddTracking(ptr, obj);
1318
+ }
1319
+ } else {
1320
+ klass_name = (char *) malloc(4 + strlen(type->name) + 1);
1321
+ sprintf(klass_name, "TYPE%s", type->name);
1322
+ klass = rb_const_get(_mSWIG, rb_intern(klass_name));
1323
+ free((void *) klass_name);
1324
+ obj = Data_Wrap_Struct(klass, 0, 0, ptr);
1325
+ }
1326
+ rb_iv_set(obj, "__swigtype__", rb_str_new2(type->name));
1327
+
1328
+ return obj;
1329
+ }
1330
+
1331
+ /* Create a new class instance (always owned) */
1332
+ SWIGRUNTIME VALUE
1333
+ SWIG_Ruby_NewClassInstance(VALUE klass, swig_type_info *type)
1334
+ {
1335
+ VALUE obj;
1336
+ swig_class *sklass = (swig_class *) type->clientdata;
1337
+ obj = Data_Wrap_Struct(klass, VOIDFUNC(sklass->mark), VOIDFUNC(sklass->destroy), 0);
1338
+ rb_iv_set(obj, "__swigtype__", rb_str_new2(type->name));
1339
+ return obj;
1340
+ }
1341
+
1342
+ /* Get type mangle from class name */
1343
+ SWIGRUNTIMEINLINE char *
1344
+ SWIG_Ruby_MangleStr(VALUE obj)
1345
+ {
1346
+ VALUE stype = rb_iv_get(obj, "__swigtype__");
1347
+ return StringValuePtr(stype);
1348
+ }
1349
+
1350
+ /* Acquire a pointer value */
1351
+ typedef void (*ruby_owntype)(void*);
1352
+
1353
+ SWIGRUNTIME ruby_owntype
1354
+ SWIG_Ruby_AcquirePtr(VALUE obj, ruby_owntype own) {
1355
+ if (obj) {
1356
+ ruby_owntype oldown = RDATA(obj)->dfree;
1357
+ RDATA(obj)->dfree = own;
1358
+ return oldown;
1359
+ } else {
1360
+ return 0;
1361
+ }
1362
+ }
1363
+
1364
+ /* Convert a pointer value */
1365
+ SWIGRUNTIME int
1366
+ SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags, ruby_owntype *own)
1367
+ {
1368
+ char *c;
1369
+ swig_cast_info *tc;
1370
+ void *vptr = 0;
1371
+
1372
+ /* Grab the pointer */
1373
+ if (NIL_P(obj)) {
1374
+ *ptr = 0;
1375
+ return SWIG_OK;
1376
+ } else {
1377
+ if (TYPE(obj) != T_DATA) {
1378
+ return SWIG_ERROR;
1379
+ }
1380
+ Data_Get_Struct(obj, void, vptr);
1381
+ }
1382
+
1383
+ if (own) *own = RDATA(obj)->dfree;
1384
+
1385
+ /* Check to see if the input object is giving up ownership
1386
+ of the underlying C struct or C++ object. If so then we
1387
+ need to reset the destructor since the Ruby object no
1388
+ longer owns the underlying C++ object.*/
1389
+ if (flags & SWIG_POINTER_DISOWN) {
1390
+ /* Is tracking on for this class? */
1391
+ int track = 0;
1392
+ if (ty && ty->clientdata) {
1393
+ swig_class *sklass = (swig_class *) ty->clientdata;
1394
+ track = sklass->trackObjects;
1395
+ }
1396
+
1397
+ if (track) {
1398
+ /* We are tracking objects for this class. Thus we change the destructor
1399
+ * to SWIG_RubyRemoveTracking. This allows us to
1400
+ * remove the mapping from the C++ to Ruby object
1401
+ * when the Ruby object is garbage collected. If we don't
1402
+ * do this, then it is possible we will return a reference
1403
+ * to a Ruby object that no longer exists thereby crashing Ruby. */
1404
+ RDATA(obj)->dfree = SWIG_RubyRemoveTracking;
1405
+ } else {
1406
+ RDATA(obj)->dfree = 0;
1407
+ }
1408
+ }
1409
+
1410
+ /* Do type-checking if type info was provided */
1411
+ if (ty) {
1412
+ if (ty->clientdata) {
1413
+ if (rb_obj_is_kind_of(obj, ((swig_class *) (ty->clientdata))->klass)) {
1414
+ if (vptr == 0) {
1415
+ /* The object has already been deleted */
1416
+ return SWIG_ObjectPreviouslyDeletedError;
1417
+ }
1418
+ *ptr = vptr;
1419
+ return SWIG_OK;
1420
+ }
1421
+ }
1422
+ if ((c = SWIG_MangleStr(obj)) == NULL) {
1423
+ return SWIG_ERROR;
1424
+ }
1425
+ tc = SWIG_TypeCheck(c, ty);
1426
+ if (!tc) {
1427
+ return SWIG_ERROR;
1428
+ }
1429
+ *ptr = SWIG_TypeCast(tc, vptr);
1430
+ } else {
1431
+ *ptr = vptr;
1432
+ }
1433
+
1434
+ return SWIG_OK;
1435
+ }
1436
+
1437
+ /* Check convert */
1438
+ SWIGRUNTIMEINLINE int
1439
+ SWIG_Ruby_CheckConvert(VALUE obj, swig_type_info *ty)
1440
+ {
1441
+ char *c = SWIG_MangleStr(obj);
1442
+ if (!c) return 0;
1443
+ return SWIG_TypeCheck(c,ty) != 0;
1444
+ }
1445
+
1446
+ SWIGRUNTIME VALUE
1447
+ SWIG_Ruby_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
1448
+ char result[1024];
1449
+ char *r = result;
1450
+ if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
1451
+ *(r++) = '_';
1452
+ r = SWIG_PackData(r, ptr, sz);
1453
+ strcpy(r, type->name);
1454
+ return rb_str_new2(result);
1455
+ }
1456
+
1457
+ /* Convert a packed value value */
1458
+ SWIGRUNTIME int
1459
+ SWIG_Ruby_ConvertPacked(VALUE obj, void *ptr, int sz, swig_type_info *ty) {
1460
+ swig_cast_info *tc;
1461
+ const char *c;
1462
+
1463
+ if (TYPE(obj) != T_STRING) goto type_error;
1464
+ c = StringValuePtr(obj);
1465
+ /* Pointer values must start with leading underscore */
1466
+ if (*c != '_') goto type_error;
1467
+ c++;
1468
+ c = SWIG_UnpackData(c, ptr, sz);
1469
+ if (ty) {
1470
+ tc = SWIG_TypeCheck(c, ty);
1471
+ if (!tc) goto type_error;
1472
+ }
1473
+ return SWIG_OK;
1474
+
1475
+ type_error:
1476
+ return SWIG_ERROR;
1477
+ }
1478
+
1479
+ SWIGRUNTIME swig_module_info *
1480
+ SWIG_Ruby_GetModule(void)
1481
+ {
1482
+ VALUE pointer;
1483
+ swig_module_info *ret = 0;
1484
+ VALUE verbose = rb_gv_get("VERBOSE");
1485
+
1486
+ /* temporarily disable warnings, since the pointer check causes warnings with 'ruby -w' */
1487
+ rb_gv_set("VERBOSE", Qfalse);
1488
+
1489
+ /* first check if pointer already created */
1490
+ pointer = rb_gv_get("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
1491
+ if (pointer != Qnil) {
1492
+ Data_Get_Struct(pointer, swig_module_info, ret);
1493
+ }
1494
+
1495
+ /* reinstate warnings */
1496
+ rb_gv_set("VERBOSE", verbose);
1497
+ return ret;
1498
+ }
1499
+
1500
+ SWIGRUNTIME void
1501
+ SWIG_Ruby_SetModule(swig_module_info *pointer)
1502
+ {
1503
+ /* register a new class */
1504
+ VALUE cl = rb_define_class("swig_runtime_data", rb_cObject);
1505
+ /* create and store the structure pointer to a global variable */
1506
+ swig_runtime_data_type_pointer = Data_Wrap_Struct(cl, 0, 0, pointer);
1507
+ rb_define_readonly_variable("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, &swig_runtime_data_type_pointer);
1508
+ }
1509
+
1510
+ #ifdef __cplusplus
1511
+ #if 0
1512
+ { /* cc-mode */
1513
+ #endif
1514
+ }
1515
+ #endif
1516
+
1517
+
1518
+
1519
+ #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
1520
+
1521
+ #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
1522
+
1523
+
1524
+
1525
+ /* -------- TYPES TABLE (BEGIN) -------- */
1526
+
1527
+ #define SWIGTYPE_p_BLOB swig_types[0]
1528
+ #define SWIGTYPE_p_VALBLOB swig_types[1]
1529
+ #define SWIGTYPE_p_char swig_types[2]
1530
+ #define SWIGTYPE_p_f_p_sqlite3_context__void swig_types[3]
1531
+ #define SWIGTYPE_p_f_p_sqlite3_context_int_p_p_sqlite3_value__void swig_types[4]
1532
+ #define SWIGTYPE_p_f_p_void__void swig_types[5]
1533
+ #define SWIGTYPE_p_f_p_void_int__int swig_types[6]
1534
+ #define SWIGTYPE_p_f_p_void_int_p_q_const__char_p_q_const__char_p_q_const__char_p_q_const__char__int swig_types[7]
1535
+ #define SWIGTYPE_p_f_p_void_p_q_const__char__void swig_types[8]
1536
+ #define SWIGTYPE_p_p_char swig_types[9]
1537
+ #define SWIGTYPE_p_p_sqlite3 swig_types[10]
1538
+ #define SWIGTYPE_p_p_sqlite3_stmt swig_types[11]
1539
+ #define SWIGTYPE_p_p_void swig_types[12]
1540
+ #define SWIGTYPE_p_sqlite3 swig_types[13]
1541
+ #define SWIGTYPE_p_sqlite3_context swig_types[14]
1542
+ #define SWIGTYPE_p_sqlite3_stmt swig_types[15]
1543
+ #define SWIGTYPE_p_sqlite3_value swig_types[16]
1544
+ #define SWIGTYPE_p_sqlite_int64 swig_types[17]
1545
+ #define SWIGTYPE_p_void swig_types[18]
1546
+ static swig_type_info *swig_types[20];
1547
+ static swig_module_info swig_module = {swig_types, 19, 0, 0, 0, 0};
1548
+ #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1549
+ #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1550
+
1551
+ /* -------- TYPES TABLE (END) -------- */
1552
+
1553
+ #define SWIG_init Init_sqlite3_c
1554
+ #define SWIG_name "Sqlite3_c"
1555
+
1556
+ static VALUE mSqlite3_c;
1557
+
1558
+ #define SWIGVERSION 0x010331
1559
+ #define SWIG_VERSION SWIGVERSION
1560
+
1561
+
1562
+ #define SWIG_as_voidptr(a) (void *)((const void *)(a))
1563
+ #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
1564
+
1565
+
1566
+ #ifdef __cplusplus
1567
+ extern "C" {
1568
+ #endif
1569
+ #include "rubyio.h"
1570
+ #ifdef __cplusplus
1571
+ }
1572
+ #endif
1573
+
1574
+
1575
+ #ifdef __cplusplus
1576
+ extern "C" {
1577
+ #endif
1578
+ #ifdef HAVE_SYS_TIME_H
1579
+ # include <sys/time.h>
1580
+ struct timeval rb_time_timeval(VALUE);
1581
+ #endif
1582
+ #ifdef __cplusplus
1583
+ }
1584
+ #endif
1585
+
1586
+
1587
+ #include <sqlite3.h>
1588
+ typedef void BLOB;
1589
+ typedef void VALBLOB;
1590
+
1591
+
1592
+ SWIGINTERN swig_type_info*
1593
+ SWIG_pchar_descriptor(void)
1594
+ {
1595
+ static int init = 0;
1596
+ static swig_type_info* info = 0;
1597
+ if (!init) {
1598
+ info = SWIG_TypeQuery("_p_char");
1599
+ init = 1;
1600
+ }
1601
+ return info;
1602
+ }
1603
+
1604
+
1605
+ SWIGINTERNINLINE VALUE
1606
+ SWIG_FromCharPtrAndSize(const char* carray, size_t size)
1607
+ {
1608
+ if (carray) {
1609
+ if (size > LONG_MAX) {
1610
+ swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
1611
+ return pchar_descriptor ?
1612
+ SWIG_NewPointerObj((char *)(carray), pchar_descriptor, 0) : Qnil;
1613
+ } else {
1614
+ return rb_str_new(carray, (long)(size));
1615
+ }
1616
+ } else {
1617
+ return Qnil;
1618
+ }
1619
+ }
1620
+
1621
+
1622
+ SWIGINTERNINLINE VALUE
1623
+ SWIG_FromCharPtr(const char *cptr)
1624
+ {
1625
+ return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
1626
+ }
1627
+
1628
+
1629
+ #include <limits.h>
1630
+ #ifndef LLONG_MIN
1631
+ # define LLONG_MIN LONG_LONG_MIN
1632
+ #endif
1633
+ #ifndef LLONG_MAX
1634
+ # define LLONG_MAX LONG_LONG_MAX
1635
+ #endif
1636
+ #ifndef ULLONG_MAX
1637
+ # define ULLONG_MAX ULONG_LONG_MAX
1638
+ #endif
1639
+
1640
+
1641
+ #define SWIG_From_long LONG2NUM
1642
+
1643
+
1644
+ SWIGINTERNINLINE VALUE
1645
+ SWIG_From_int (int value)
1646
+ {
1647
+ return SWIG_From_long (value);
1648
+ }
1649
+
1650
+
1651
+ SWIGINTERN int
1652
+ SWIG_AsCharPtrAndSize(VALUE obj, char** cptr, size_t* psize, int *alloc)
1653
+ {
1654
+ if (TYPE(obj) == T_STRING) {
1655
+
1656
+
1657
+
1658
+ char *cstr = STR2CSTR(obj);
1659
+
1660
+ size_t size = RSTRING_LEN(obj) + 1;
1661
+ if (cptr) {
1662
+ if (alloc) {
1663
+ if (*alloc == SWIG_NEWOBJ) {
1664
+ *cptr = (char *)memcpy((char *)malloc((size)*sizeof(char)), cstr, sizeof(char)*(size));
1665
+ } else {
1666
+ *cptr = cstr;
1667
+ *alloc = SWIG_OLDOBJ;
1668
+ }
1669
+ }
1670
+ }
1671
+ if (psize) *psize = size;
1672
+ return SWIG_OK;
1673
+ } else {
1674
+ swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
1675
+ if (pchar_descriptor) {
1676
+ void* vptr = 0;
1677
+ if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
1678
+ if (cptr) *cptr = (char *)vptr;
1679
+ if (psize) *psize = vptr ? (strlen((char*)vptr) + 1) : 0;
1680
+ if (alloc) *alloc = SWIG_OLDOBJ;
1681
+ return SWIG_OK;
1682
+ }
1683
+ }
1684
+ }
1685
+ return SWIG_TypeError;
1686
+ }
1687
+
1688
+
1689
+
1690
+
1691
+
1692
+ SWIGINTERN VALUE
1693
+ SWIG_ruby_failed(void)
1694
+ {
1695
+ return Qnil;
1696
+ }
1697
+
1698
+
1699
+ /*@SWIG:%ruby_aux_method@*/
1700
+ SWIGINTERN VALUE SWIG_AUX_NUM2LONG(VALUE *args)
1701
+ {
1702
+ VALUE obj = args[0];
1703
+ VALUE type = TYPE(obj);
1704
+ long *res = (long *)(args[1]);
1705
+ *res = type == T_FIXNUM ? NUM2LONG(obj) : rb_big2long(obj);
1706
+ return obj;
1707
+ }
1708
+ /*@SWIG@*/
1709
+
1710
+ SWIGINTERN int
1711
+ SWIG_AsVal_long (VALUE obj, long* val)
1712
+ {
1713
+ VALUE type = TYPE(obj);
1714
+ if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
1715
+ long v;
1716
+ VALUE a[2];
1717
+ a[0] = obj;
1718
+ a[1] = (VALUE)(&v);
1719
+ if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2LONG), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
1720
+ if (val) *val = v;
1721
+ return SWIG_OK;
1722
+ }
1723
+ }
1724
+ return SWIG_TypeError;
1725
+ }
1726
+
1727
+
1728
+ SWIGINTERN int
1729
+ SWIG_AsVal_int (VALUE obj, int *val)
1730
+ {
1731
+ long v;
1732
+ int res = SWIG_AsVal_long (obj, &v);
1733
+ if (SWIG_IsOK(res)) {
1734
+ if ((v < INT_MIN || v > INT_MAX)) {
1735
+ return SWIG_OverflowError;
1736
+ } else {
1737
+ if (val) *val = (int)(v);
1738
+ }
1739
+ }
1740
+ return res;
1741
+ }
1742
+
1743
+
1744
+ #define output_helper SWIG_Ruby_AppendOutput
1745
+
1746
+
1747
+ /*@SWIG:%ruby_aux_method@*/
1748
+ SWIGINTERN VALUE SWIG_AUX_NUM2DBL(VALUE *args)
1749
+ {
1750
+ VALUE obj = args[0];
1751
+ VALUE type = TYPE(obj);
1752
+ double *res = (double *)(args[1]);
1753
+ *res = (type == T_FLOAT ? NUM2DBL(obj) : (type == T_FIXNUM ? (double) FIX2INT(obj) : rb_big2dbl(obj)));
1754
+ return obj;
1755
+ }
1756
+ /*@SWIG@*/
1757
+
1758
+ SWIGINTERN int
1759
+ SWIG_AsVal_double (VALUE obj, double *val)
1760
+ {
1761
+ VALUE type = TYPE(obj);
1762
+ if ((type == T_FLOAT) || (type == T_FIXNUM) || (type == T_BIGNUM)) {
1763
+ double v;
1764
+ VALUE a[2];
1765
+ a[0] = obj;
1766
+ a[1] = (VALUE)(&v);
1767
+ if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2DBL), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
1768
+ if (val) *val = v;
1769
+ return SWIG_OK;
1770
+ }
1771
+ }
1772
+ return SWIG_TypeError;
1773
+ }
1774
+
1775
+
1776
+ #define SWIG_From_double rb_float_new
1777
+
1778
+ SWIGINTERN VALUE
1779
+ _wrap_sqlite3_libversion(int argc, VALUE *argv, VALUE self) {
1780
+ char *result = 0 ;
1781
+ VALUE vresult = Qnil;
1782
+
1783
+ if ((argc < 0) || (argc > 0)) {
1784
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
1785
+ }
1786
+ result = (char *)sqlite3_libversion();
1787
+ vresult = SWIG_FromCharPtr((const char *)result);
1788
+ return vresult;
1789
+ fail:
1790
+ return Qnil;
1791
+ }
1792
+
1793
+
1794
+ SWIGINTERN VALUE
1795
+ _wrap_sqlite3_close(int argc, VALUE *argv, VALUE self) {
1796
+ sqlite3 *arg1 = (sqlite3 *) 0 ;
1797
+ int result;
1798
+ void *argp1 = 0 ;
1799
+ int res1 = 0 ;
1800
+ VALUE vresult = Qnil;
1801
+
1802
+ if ((argc < 1) || (argc > 1)) {
1803
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
1804
+ }
1805
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3, 0 | 0 );
1806
+ if (!SWIG_IsOK(res1)) {
1807
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_close" "', argument " "1"" of type '" "sqlite3 *""'");
1808
+ }
1809
+ arg1 = (sqlite3 *)(argp1);
1810
+ result = (int)sqlite3_close(arg1);
1811
+ vresult = SWIG_From_int((int)(result));
1812
+ return vresult;
1813
+ fail:
1814
+ return Qnil;
1815
+ }
1816
+
1817
+
1818
+ SWIGINTERN VALUE
1819
+ _wrap_sqlite3_last_insert_rowid(int argc, VALUE *argv, VALUE self) {
1820
+ sqlite3 *arg1 = (sqlite3 *) 0 ;
1821
+ sqlite_int64 result;
1822
+ void *argp1 = 0 ;
1823
+ int res1 = 0 ;
1824
+ VALUE vresult = Qnil;
1825
+
1826
+ if ((argc < 1) || (argc > 1)) {
1827
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
1828
+ }
1829
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3, 0 | 0 );
1830
+ if (!SWIG_IsOK(res1)) {
1831
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_last_insert_rowid" "', argument " "1"" of type '" "sqlite3 *""'");
1832
+ }
1833
+ arg1 = (sqlite3 *)(argp1);
1834
+ result = sqlite3_last_insert_rowid(arg1);
1835
+ {
1836
+ vresult = LONG2NUM(result);
1837
+ }
1838
+ return vresult;
1839
+ fail:
1840
+ return Qnil;
1841
+ }
1842
+
1843
+
1844
+ SWIGINTERN VALUE
1845
+ _wrap_sqlite3_changes(int argc, VALUE *argv, VALUE self) {
1846
+ sqlite3 *arg1 = (sqlite3 *) 0 ;
1847
+ int result;
1848
+ void *argp1 = 0 ;
1849
+ int res1 = 0 ;
1850
+ VALUE vresult = Qnil;
1851
+
1852
+ if ((argc < 1) || (argc > 1)) {
1853
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
1854
+ }
1855
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3, 0 | 0 );
1856
+ if (!SWIG_IsOK(res1)) {
1857
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_changes" "', argument " "1"" of type '" "sqlite3 *""'");
1858
+ }
1859
+ arg1 = (sqlite3 *)(argp1);
1860
+ result = (int)sqlite3_changes(arg1);
1861
+ vresult = SWIG_From_int((int)(result));
1862
+ return vresult;
1863
+ fail:
1864
+ return Qnil;
1865
+ }
1866
+
1867
+
1868
+ SWIGINTERN VALUE
1869
+ _wrap_sqlite3_total_changes(int argc, VALUE *argv, VALUE self) {
1870
+ sqlite3 *arg1 = (sqlite3 *) 0 ;
1871
+ int result;
1872
+ void *argp1 = 0 ;
1873
+ int res1 = 0 ;
1874
+ VALUE vresult = Qnil;
1875
+
1876
+ if ((argc < 1) || (argc > 1)) {
1877
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
1878
+ }
1879
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3, 0 | 0 );
1880
+ if (!SWIG_IsOK(res1)) {
1881
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_total_changes" "', argument " "1"" of type '" "sqlite3 *""'");
1882
+ }
1883
+ arg1 = (sqlite3 *)(argp1);
1884
+ result = (int)sqlite3_total_changes(arg1);
1885
+ vresult = SWIG_From_int((int)(result));
1886
+ return vresult;
1887
+ fail:
1888
+ return Qnil;
1889
+ }
1890
+
1891
+
1892
+ SWIGINTERN VALUE
1893
+ _wrap_sqlite3_interrupt(int argc, VALUE *argv, VALUE self) {
1894
+ sqlite3 *arg1 = (sqlite3 *) 0 ;
1895
+ void *argp1 = 0 ;
1896
+ int res1 = 0 ;
1897
+
1898
+ if ((argc < 1) || (argc > 1)) {
1899
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
1900
+ }
1901
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3, 0 | 0 );
1902
+ if (!SWIG_IsOK(res1)) {
1903
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_interrupt" "', argument " "1"" of type '" "sqlite3 *""'");
1904
+ }
1905
+ arg1 = (sqlite3 *)(argp1);
1906
+ sqlite3_interrupt(arg1);
1907
+ return Qnil;
1908
+ fail:
1909
+ return Qnil;
1910
+ }
1911
+
1912
+
1913
+ SWIGINTERN VALUE
1914
+ _wrap_sqlite3_complete(int argc, VALUE *argv, VALUE self) {
1915
+ char *arg1 = (char *) 0 ;
1916
+ int result;
1917
+ int res1 ;
1918
+ char *buf1 = 0 ;
1919
+ int alloc1 = 0 ;
1920
+ VALUE vresult = Qnil;
1921
+
1922
+ if ((argc < 1) || (argc > 1)) {
1923
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
1924
+ }
1925
+ res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
1926
+ if (!SWIG_IsOK(res1)) {
1927
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_complete" "', argument " "1"" of type '" "char const *""'");
1928
+ }
1929
+ arg1 = (char *)(buf1);
1930
+ result = (int)sqlite3_complete((char const *)arg1);
1931
+ vresult = SWIG_From_int((int)(result));
1932
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
1933
+ return vresult;
1934
+ fail:
1935
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
1936
+ return Qnil;
1937
+ }
1938
+
1939
+
1940
+ SWIGINTERN VALUE
1941
+ _wrap_sqlite3_complete16(int argc, VALUE *argv, VALUE self) {
1942
+ void *arg1 = (void *) 0 ;
1943
+ int result;
1944
+ int res1 ;
1945
+ VALUE vresult = Qnil;
1946
+
1947
+ if ((argc < 1) || (argc > 1)) {
1948
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
1949
+ }
1950
+ res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
1951
+ if (!SWIG_IsOK(res1)) {
1952
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_complete16" "', argument " "1"" of type '" "void const *""'");
1953
+ }
1954
+ result = (int)sqlite3_complete16((void const *)arg1);
1955
+ vresult = SWIG_From_int((int)(result));
1956
+ return vresult;
1957
+ fail:
1958
+ return Qnil;
1959
+ }
1960
+
1961
+
1962
+ SWIGINTERN VALUE
1963
+ _wrap_sqlite3_busy_handler(int argc, VALUE *argv, VALUE self) {
1964
+ sqlite3 *arg1 = (sqlite3 *) 0 ;
1965
+ int (*arg2)(void *,int) = (int (*)(void *,int)) 0 ;
1966
+ void *arg3 = (void *) 0 ;
1967
+ int result;
1968
+ void *argp1 = 0 ;
1969
+ int res1 = 0 ;
1970
+ int res3 ;
1971
+ VALUE vresult = Qnil;
1972
+
1973
+ if ((argc < 3) || (argc > 3)) {
1974
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
1975
+ }
1976
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3, 0 | 0 );
1977
+ if (!SWIG_IsOK(res1)) {
1978
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_busy_handler" "', argument " "1"" of type '" "sqlite3 *""'");
1979
+ }
1980
+ arg1 = (sqlite3 *)(argp1);
1981
+ {
1982
+ int res = SWIG_ConvertFunctionPtr(argv[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_int__int);
1983
+ if (!SWIG_IsOK(res)) {
1984
+ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "sqlite3_busy_handler" "', argument " "2"" of type '" "int (*)(void *,int)""'");
1985
+ }
1986
+ }
1987
+ res3 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg3), 0, 0);
1988
+ if (!SWIG_IsOK(res3)) {
1989
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "sqlite3_busy_handler" "', argument " "3"" of type '" "void *""'");
1990
+ }
1991
+ result = (int)sqlite3_busy_handler(arg1,arg2,arg3);
1992
+ vresult = SWIG_From_int((int)(result));
1993
+ return vresult;
1994
+ fail:
1995
+ return Qnil;
1996
+ }
1997
+
1998
+
1999
+ SWIGINTERN VALUE
2000
+ _wrap_sqlite3_busy_timeout(int argc, VALUE *argv, VALUE self) {
2001
+ sqlite3 *arg1 = (sqlite3 *) 0 ;
2002
+ int arg2 ;
2003
+ int result;
2004
+ void *argp1 = 0 ;
2005
+ int res1 = 0 ;
2006
+ int val2 ;
2007
+ int ecode2 = 0 ;
2008
+ VALUE vresult = Qnil;
2009
+
2010
+ if ((argc < 2) || (argc > 2)) {
2011
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
2012
+ }
2013
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3, 0 | 0 );
2014
+ if (!SWIG_IsOK(res1)) {
2015
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_busy_timeout" "', argument " "1"" of type '" "sqlite3 *""'");
2016
+ }
2017
+ arg1 = (sqlite3 *)(argp1);
2018
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
2019
+ if (!SWIG_IsOK(ecode2)) {
2020
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sqlite3_busy_timeout" "', argument " "2"" of type '" "int""'");
2021
+ }
2022
+ arg2 = (int)(val2);
2023
+ result = (int)sqlite3_busy_timeout(arg1,arg2);
2024
+ vresult = SWIG_From_int((int)(result));
2025
+ return vresult;
2026
+ fail:
2027
+ return Qnil;
2028
+ }
2029
+
2030
+
2031
+ SWIGINTERN VALUE
2032
+ _wrap_sqlite3_set_authorizer(int argc, VALUE *argv, VALUE self) {
2033
+ sqlite3 *arg1 = (sqlite3 *) 0 ;
2034
+ int (*arg2)(void *,int,char const *,char const *,char const *,char const *) = (int (*)(void *,int,char const *,char const *,char const *,char const *)) 0 ;
2035
+ void *arg3 = (void *) 0 ;
2036
+ int result;
2037
+ void *argp1 = 0 ;
2038
+ int res1 = 0 ;
2039
+ int res3 ;
2040
+ VALUE vresult = Qnil;
2041
+
2042
+ if ((argc < 3) || (argc > 3)) {
2043
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
2044
+ }
2045
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3, 0 | 0 );
2046
+ if (!SWIG_IsOK(res1)) {
2047
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_set_authorizer" "', argument " "1"" of type '" "sqlite3 *""'");
2048
+ }
2049
+ arg1 = (sqlite3 *)(argp1);
2050
+ {
2051
+ int res = SWIG_ConvertFunctionPtr(argv[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_int_p_q_const__char_p_q_const__char_p_q_const__char_p_q_const__char__int);
2052
+ if (!SWIG_IsOK(res)) {
2053
+ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "sqlite3_set_authorizer" "', argument " "2"" of type '" "int (*)(void *,int,char const *,char const *,char const *,char const *)""'");
2054
+ }
2055
+ }
2056
+ res3 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg3), 0, 0);
2057
+ if (!SWIG_IsOK(res3)) {
2058
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "sqlite3_set_authorizer" "', argument " "3"" of type '" "void *""'");
2059
+ }
2060
+ result = (int)sqlite3_set_authorizer(arg1,arg2,arg3);
2061
+ vresult = SWIG_From_int((int)(result));
2062
+ return vresult;
2063
+ fail:
2064
+ return Qnil;
2065
+ }
2066
+
2067
+
2068
+ SWIGINTERN VALUE
2069
+ _wrap_sqlite3_trace(int argc, VALUE *argv, VALUE self) {
2070
+ sqlite3 *arg1 = (sqlite3 *) 0 ;
2071
+ void (*arg2)(void *,char const *) = (void (*)(void *,char const *)) 0 ;
2072
+ void *arg3 = (void *) 0 ;
2073
+ int result;
2074
+ void *argp1 = 0 ;
2075
+ int res1 = 0 ;
2076
+ int res3 ;
2077
+ VALUE vresult = Qnil;
2078
+
2079
+ if ((argc < 3) || (argc > 3)) {
2080
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
2081
+ }
2082
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3, 0 | 0 );
2083
+ if (!SWIG_IsOK(res1)) {
2084
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_trace" "', argument " "1"" of type '" "sqlite3 *""'");
2085
+ }
2086
+ arg1 = (sqlite3 *)(argp1);
2087
+ {
2088
+ int res = SWIG_ConvertFunctionPtr(argv[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__char__void);
2089
+ if (!SWIG_IsOK(res)) {
2090
+ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "sqlite3_trace" "', argument " "2"" of type '" "void (*)(void *,char const *)""'");
2091
+ }
2092
+ }
2093
+ res3 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg3), 0, 0);
2094
+ if (!SWIG_IsOK(res3)) {
2095
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "sqlite3_trace" "', argument " "3"" of type '" "void *""'");
2096
+ }
2097
+ result = (int)sqlite3_trace(arg1,arg2,arg3);
2098
+ vresult = SWIG_From_int((int)(result));
2099
+ return vresult;
2100
+ fail:
2101
+ return Qnil;
2102
+ }
2103
+
2104
+
2105
+ SWIGINTERN VALUE
2106
+ _wrap_sqlite3_open(int argc, VALUE *argv, VALUE self) {
2107
+ char *arg1 = (char *) 0 ;
2108
+ sqlite3 **arg2 = (sqlite3 **) 0 ;
2109
+ int result;
2110
+ int res1 ;
2111
+ char *buf1 = 0 ;
2112
+ int alloc1 = 0 ;
2113
+ VALUE vresult = Qnil;
2114
+
2115
+ {
2116
+ arg2 = (sqlite3**)malloc( sizeof( sqlite3* ) );
2117
+ }
2118
+ if ((argc < 1) || (argc > 1)) {
2119
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
2120
+ }
2121
+ res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
2122
+ if (!SWIG_IsOK(res1)) {
2123
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_open" "', argument " "1"" of type '" "char const *""'");
2124
+ }
2125
+ arg1 = (char *)(buf1);
2126
+ result = (int)sqlite3_open((char const *)arg1,arg2);
2127
+ vresult = SWIG_From_int((int)(result));
2128
+ {
2129
+ vresult = output_helper(vresult, SWIG_NewPointerObj( *arg2, SWIGTYPE_p_sqlite3, 0 ));
2130
+ }
2131
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2132
+ {
2133
+ free((sqlite3 *)arg2);
2134
+ }
2135
+ return vresult;
2136
+ fail:
2137
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2138
+ {
2139
+ free((sqlite3 *)arg2);
2140
+ }
2141
+ return Qnil;
2142
+ }
2143
+
2144
+
2145
+ SWIGINTERN VALUE
2146
+ _wrap_sqlite3_open16(int argc, VALUE *argv, VALUE self) {
2147
+ void *arg1 = (void *) 0 ;
2148
+ sqlite3 **arg2 = (sqlite3 **) 0 ;
2149
+ int result;
2150
+ int res1 ;
2151
+ void *argp2 = 0 ;
2152
+ int res2 = 0 ;
2153
+ VALUE vresult = Qnil;
2154
+
2155
+ if ((argc < 2) || (argc > 2)) {
2156
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
2157
+ }
2158
+ res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
2159
+ if (!SWIG_IsOK(res1)) {
2160
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_open16" "', argument " "1"" of type '" "void const *""'");
2161
+ }
2162
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_p_sqlite3, 0 | 0 );
2163
+ if (!SWIG_IsOK(res2)) {
2164
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sqlite3_open16" "', argument " "2"" of type '" "sqlite3 **""'");
2165
+ }
2166
+ arg2 = (sqlite3 **)(argp2);
2167
+ result = (int)sqlite3_open16((void const *)arg1,arg2);
2168
+ vresult = SWIG_From_int((int)(result));
2169
+ {
2170
+ free((sqlite3 *)arg2);
2171
+ }
2172
+ return vresult;
2173
+ fail:
2174
+ {
2175
+ free((sqlite3 *)arg2);
2176
+ }
2177
+ return Qnil;
2178
+ }
2179
+
2180
+
2181
+ SWIGINTERN VALUE
2182
+ _wrap_sqlite3_errcode(int argc, VALUE *argv, VALUE self) {
2183
+ sqlite3 *arg1 = (sqlite3 *) 0 ;
2184
+ int result;
2185
+ void *argp1 = 0 ;
2186
+ int res1 = 0 ;
2187
+ VALUE vresult = Qnil;
2188
+
2189
+ if ((argc < 1) || (argc > 1)) {
2190
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
2191
+ }
2192
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3, 0 | 0 );
2193
+ if (!SWIG_IsOK(res1)) {
2194
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_errcode" "', argument " "1"" of type '" "sqlite3 *""'");
2195
+ }
2196
+ arg1 = (sqlite3 *)(argp1);
2197
+ result = (int)sqlite3_errcode(arg1);
2198
+ vresult = SWIG_From_int((int)(result));
2199
+ return vresult;
2200
+ fail:
2201
+ return Qnil;
2202
+ }
2203
+
2204
+
2205
+ SWIGINTERN VALUE
2206
+ _wrap_sqlite3_errmsg(int argc, VALUE *argv, VALUE self) {
2207
+ sqlite3 *arg1 = (sqlite3 *) 0 ;
2208
+ char *result = 0 ;
2209
+ void *argp1 = 0 ;
2210
+ int res1 = 0 ;
2211
+ VALUE vresult = Qnil;
2212
+
2213
+ if ((argc < 1) || (argc > 1)) {
2214
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
2215
+ }
2216
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3, 0 | 0 );
2217
+ if (!SWIG_IsOK(res1)) {
2218
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_errmsg" "', argument " "1"" of type '" "sqlite3 *""'");
2219
+ }
2220
+ arg1 = (sqlite3 *)(argp1);
2221
+ result = (char *)sqlite3_errmsg(arg1);
2222
+ vresult = SWIG_FromCharPtr((const char *)result);
2223
+ return vresult;
2224
+ fail:
2225
+ return Qnil;
2226
+ }
2227
+
2228
+
2229
+ SWIGINTERN VALUE
2230
+ _wrap_sqlite3_errmsg16(int argc, VALUE *argv, VALUE self) {
2231
+ sqlite3 *arg1 = (sqlite3 *) 0 ;
2232
+ void *result = 0 ;
2233
+ void *argp1 = 0 ;
2234
+ int res1 = 0 ;
2235
+ VALUE vresult = Qnil;
2236
+
2237
+ if ((argc < 1) || (argc > 1)) {
2238
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
2239
+ }
2240
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3, 0 | 0 );
2241
+ if (!SWIG_IsOK(res1)) {
2242
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_errmsg16" "', argument " "1"" of type '" "sqlite3 *""'");
2243
+ }
2244
+ arg1 = (sqlite3 *)(argp1);
2245
+ result = (void *)sqlite3_errmsg16(arg1);
2246
+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
2247
+ return vresult;
2248
+ fail:
2249
+ return Qnil;
2250
+ }
2251
+
2252
+
2253
+ SWIGINTERN VALUE
2254
+ _wrap_sqlite3_prepare(int argc, VALUE *argv, VALUE self) {
2255
+ sqlite3 *arg1 = (sqlite3 *) 0 ;
2256
+ char *arg2 = (char *) 0 ;
2257
+ int arg3 ;
2258
+ sqlite3_stmt **arg4 = (sqlite3_stmt **) 0 ;
2259
+ char **arg5 = (char **) 0 ;
2260
+ int result;
2261
+ void *argp1 = 0 ;
2262
+ int res1 = 0 ;
2263
+ int res2 ;
2264
+ char *buf2 = 0 ;
2265
+ int alloc2 = 0 ;
2266
+ int val3 ;
2267
+ int ecode3 = 0 ;
2268
+ VALUE vresult = Qnil;
2269
+
2270
+ {
2271
+ arg4 = (sqlite3_stmt**)malloc( sizeof( sqlite3_stmt* ) );
2272
+ }
2273
+ {
2274
+ arg5 = (char**)malloc( sizeof( char* ) );
2275
+ }
2276
+ if ((argc < 3) || (argc > 3)) {
2277
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
2278
+ }
2279
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3, 0 | 0 );
2280
+ if (!SWIG_IsOK(res1)) {
2281
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_prepare" "', argument " "1"" of type '" "sqlite3 *""'");
2282
+ }
2283
+ arg1 = (sqlite3 *)(argp1);
2284
+ res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
2285
+ if (!SWIG_IsOK(res2)) {
2286
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sqlite3_prepare" "', argument " "2"" of type '" "char const *""'");
2287
+ }
2288
+ arg2 = (char *)(buf2);
2289
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
2290
+ if (!SWIG_IsOK(ecode3)) {
2291
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "sqlite3_prepare" "', argument " "3"" of type '" "int""'");
2292
+ }
2293
+ arg3 = (int)(val3);
2294
+ result = (int)sqlite3_prepare(arg1,(char const *)arg2,arg3,arg4,(char const **)arg5);
2295
+ vresult = SWIG_From_int((int)(result));
2296
+ {
2297
+ vresult = output_helper(vresult, SWIG_NewPointerObj( *arg4, SWIGTYPE_p_sqlite3_stmt, 0 ));
2298
+ }
2299
+ {
2300
+ vresult = output_helper(vresult, rb_str_new2(*arg5));
2301
+ }
2302
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2303
+ {
2304
+ free((sqlite3_stmt *)arg4);
2305
+ }
2306
+ {
2307
+ free((char *)arg5);
2308
+ }
2309
+ return vresult;
2310
+ fail:
2311
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2312
+ {
2313
+ free((sqlite3_stmt *)arg4);
2314
+ }
2315
+ {
2316
+ free((char *)arg5);
2317
+ }
2318
+ return Qnil;
2319
+ }
2320
+
2321
+
2322
+ SWIGINTERN VALUE
2323
+ _wrap_sqlite3_prepare_v2(int argc, VALUE *argv, VALUE self) {
2324
+ sqlite3 *arg1 = (sqlite3 *) 0 ;
2325
+ char *arg2 = (char *) 0 ;
2326
+ int arg3 ;
2327
+ sqlite3_stmt **arg4 = (sqlite3_stmt **) 0 ;
2328
+ char **arg5 = (char **) 0 ;
2329
+ int result;
2330
+ void *argp1 = 0 ;
2331
+ int res1 = 0 ;
2332
+ int res2 ;
2333
+ char *buf2 = 0 ;
2334
+ int alloc2 = 0 ;
2335
+ int val3 ;
2336
+ int ecode3 = 0 ;
2337
+ VALUE vresult = Qnil;
2338
+
2339
+ {
2340
+ arg4 = (sqlite3_stmt**)malloc( sizeof( sqlite3_stmt* ) );
2341
+ }
2342
+ {
2343
+ arg5 = (char**)malloc( sizeof( char* ) );
2344
+ }
2345
+ if ((argc < 3) || (argc > 3)) {
2346
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
2347
+ }
2348
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3, 0 | 0 );
2349
+ if (!SWIG_IsOK(res1)) {
2350
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_prepare_v2" "', argument " "1"" of type '" "sqlite3 *""'");
2351
+ }
2352
+ arg1 = (sqlite3 *)(argp1);
2353
+ res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
2354
+ if (!SWIG_IsOK(res2)) {
2355
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sqlite3_prepare_v2" "', argument " "2"" of type '" "char const *""'");
2356
+ }
2357
+ arg2 = (char *)(buf2);
2358
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
2359
+ if (!SWIG_IsOK(ecode3)) {
2360
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "sqlite3_prepare_v2" "', argument " "3"" of type '" "int""'");
2361
+ }
2362
+ arg3 = (int)(val3);
2363
+ result = (int)sqlite3_prepare_v2(arg1,(char const *)arg2,arg3,arg4,(char const **)arg5);
2364
+ vresult = SWIG_From_int((int)(result));
2365
+ {
2366
+ vresult = output_helper(vresult, SWIG_NewPointerObj( *arg4, SWIGTYPE_p_sqlite3_stmt, 0 ));
2367
+ }
2368
+ {
2369
+ vresult = output_helper(vresult, rb_str_new2(*arg5));
2370
+ }
2371
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2372
+ {
2373
+ free((sqlite3_stmt *)arg4);
2374
+ }
2375
+ {
2376
+ free((char *)arg5);
2377
+ }
2378
+ return vresult;
2379
+ fail:
2380
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2381
+ {
2382
+ free((sqlite3_stmt *)arg4);
2383
+ }
2384
+ {
2385
+ free((char *)arg5);
2386
+ }
2387
+ return Qnil;
2388
+ }
2389
+
2390
+
2391
+ SWIGINTERN VALUE
2392
+ _wrap_sqlite3_prepare16(int argc, VALUE *argv, VALUE self) {
2393
+ sqlite3 *arg1 = (sqlite3 *) 0 ;
2394
+ void *arg2 = (void *) 0 ;
2395
+ int arg3 ;
2396
+ sqlite3_stmt **arg4 = (sqlite3_stmt **) 0 ;
2397
+ void **arg5 = (void **) 0 ;
2398
+ int result;
2399
+ void *argp1 = 0 ;
2400
+ int res1 = 0 ;
2401
+ int res2 ;
2402
+ int val3 ;
2403
+ int ecode3 = 0 ;
2404
+ void *argp4 = 0 ;
2405
+ int res4 = 0 ;
2406
+ void *argp5 = 0 ;
2407
+ int res5 = 0 ;
2408
+ VALUE vresult = Qnil;
2409
+
2410
+ if ((argc < 5) || (argc > 5)) {
2411
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
2412
+ }
2413
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3, 0 | 0 );
2414
+ if (!SWIG_IsOK(res1)) {
2415
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_prepare16" "', argument " "1"" of type '" "sqlite3 *""'");
2416
+ }
2417
+ arg1 = (sqlite3 *)(argp1);
2418
+ res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
2419
+ if (!SWIG_IsOK(res2)) {
2420
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sqlite3_prepare16" "', argument " "2"" of type '" "void const *""'");
2421
+ }
2422
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
2423
+ if (!SWIG_IsOK(ecode3)) {
2424
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "sqlite3_prepare16" "', argument " "3"" of type '" "int""'");
2425
+ }
2426
+ arg3 = (int)(val3);
2427
+ res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_p_sqlite3_stmt, 0 | 0 );
2428
+ if (!SWIG_IsOK(res4)) {
2429
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "sqlite3_prepare16" "', argument " "4"" of type '" "sqlite3_stmt **""'");
2430
+ }
2431
+ arg4 = (sqlite3_stmt **)(argp4);
2432
+ res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_p_void, 0 | 0 );
2433
+ if (!SWIG_IsOK(res5)) {
2434
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "sqlite3_prepare16" "', argument " "5"" of type '" "void const **""'");
2435
+ }
2436
+ arg5 = (void **)(argp5);
2437
+ result = (int)sqlite3_prepare16(arg1,(void const *)arg2,arg3,arg4,(void const **)arg5);
2438
+ vresult = SWIG_From_int((int)(result));
2439
+ {
2440
+ free((sqlite3_stmt *)arg4);
2441
+ }
2442
+ return vresult;
2443
+ fail:
2444
+ {
2445
+ free((sqlite3_stmt *)arg4);
2446
+ }
2447
+ return Qnil;
2448
+ }
2449
+
2450
+
2451
+ SWIGINTERN VALUE
2452
+ _wrap_sqlite3_bind_blob(int argc, VALUE *argv, VALUE self) {
2453
+ sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ;
2454
+ int arg2 ;
2455
+ void *arg3 = (void *) 0 ;
2456
+ int arg4 ;
2457
+ void (*arg5)(void *) = (void (*)(void *)) 0 ;
2458
+ int result;
2459
+ void *argp1 = 0 ;
2460
+ int res1 = 0 ;
2461
+ int val2 ;
2462
+ int ecode2 = 0 ;
2463
+ int res3 ;
2464
+ int val4 ;
2465
+ int ecode4 = 0 ;
2466
+ VALUE vresult = Qnil;
2467
+
2468
+ if ((argc < 5) || (argc > 5)) {
2469
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
2470
+ }
2471
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 );
2472
+ if (!SWIG_IsOK(res1)) {
2473
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_bind_blob" "', argument " "1"" of type '" "sqlite3_stmt *""'");
2474
+ }
2475
+ arg1 = (sqlite3_stmt *)(argp1);
2476
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
2477
+ if (!SWIG_IsOK(ecode2)) {
2478
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sqlite3_bind_blob" "', argument " "2"" of type '" "int""'");
2479
+ }
2480
+ arg2 = (int)(val2);
2481
+ res3 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg3), 0, 0);
2482
+ if (!SWIG_IsOK(res3)) {
2483
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "sqlite3_bind_blob" "', argument " "3"" of type '" "void const *""'");
2484
+ }
2485
+ ecode4 = SWIG_AsVal_int(argv[3], &val4);
2486
+ if (!SWIG_IsOK(ecode4)) {
2487
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "sqlite3_bind_blob" "', argument " "4"" of type '" "int""'");
2488
+ }
2489
+ arg4 = (int)(val4);
2490
+ {
2491
+ int res = SWIG_ConvertFunctionPtr(argv[4], (void**)(&arg5), SWIGTYPE_p_f_p_void__void);
2492
+ if (!SWIG_IsOK(res)) {
2493
+ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "sqlite3_bind_blob" "', argument " "5"" of type '" "void (*)(void *)""'");
2494
+ }
2495
+ }
2496
+ result = (int)sqlite3_bind_blob(arg1,arg2,(void const *)arg3,arg4,arg5);
2497
+ vresult = SWIG_From_int((int)(result));
2498
+ return vresult;
2499
+ fail:
2500
+ return Qnil;
2501
+ }
2502
+
2503
+
2504
+ SWIGINTERN VALUE
2505
+ _wrap_sqlite3_bind_double(int argc, VALUE *argv, VALUE self) {
2506
+ sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ;
2507
+ int arg2 ;
2508
+ double arg3 ;
2509
+ int result;
2510
+ void *argp1 = 0 ;
2511
+ int res1 = 0 ;
2512
+ int val2 ;
2513
+ int ecode2 = 0 ;
2514
+ double val3 ;
2515
+ int ecode3 = 0 ;
2516
+ VALUE vresult = Qnil;
2517
+
2518
+ if ((argc < 3) || (argc > 3)) {
2519
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
2520
+ }
2521
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 );
2522
+ if (!SWIG_IsOK(res1)) {
2523
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_bind_double" "', argument " "1"" of type '" "sqlite3_stmt *""'");
2524
+ }
2525
+ arg1 = (sqlite3_stmt *)(argp1);
2526
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
2527
+ if (!SWIG_IsOK(ecode2)) {
2528
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sqlite3_bind_double" "', argument " "2"" of type '" "int""'");
2529
+ }
2530
+ arg2 = (int)(val2);
2531
+ ecode3 = SWIG_AsVal_double(argv[2], &val3);
2532
+ if (!SWIG_IsOK(ecode3)) {
2533
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "sqlite3_bind_double" "', argument " "3"" of type '" "double""'");
2534
+ }
2535
+ arg3 = (double)(val3);
2536
+ result = (int)sqlite3_bind_double(arg1,arg2,arg3);
2537
+ vresult = SWIG_From_int((int)(result));
2538
+ return vresult;
2539
+ fail:
2540
+ return Qnil;
2541
+ }
2542
+
2543
+
2544
+ SWIGINTERN VALUE
2545
+ _wrap_sqlite3_bind_int(int argc, VALUE *argv, VALUE self) {
2546
+ sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ;
2547
+ int arg2 ;
2548
+ int arg3 ;
2549
+ int result;
2550
+ void *argp1 = 0 ;
2551
+ int res1 = 0 ;
2552
+ int val2 ;
2553
+ int ecode2 = 0 ;
2554
+ int val3 ;
2555
+ int ecode3 = 0 ;
2556
+ VALUE vresult = Qnil;
2557
+
2558
+ if ((argc < 3) || (argc > 3)) {
2559
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
2560
+ }
2561
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 );
2562
+ if (!SWIG_IsOK(res1)) {
2563
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_bind_int" "', argument " "1"" of type '" "sqlite3_stmt *""'");
2564
+ }
2565
+ arg1 = (sqlite3_stmt *)(argp1);
2566
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
2567
+ if (!SWIG_IsOK(ecode2)) {
2568
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sqlite3_bind_int" "', argument " "2"" of type '" "int""'");
2569
+ }
2570
+ arg2 = (int)(val2);
2571
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
2572
+ if (!SWIG_IsOK(ecode3)) {
2573
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "sqlite3_bind_int" "', argument " "3"" of type '" "int""'");
2574
+ }
2575
+ arg3 = (int)(val3);
2576
+ result = (int)sqlite3_bind_int(arg1,arg2,arg3);
2577
+ vresult = SWIG_From_int((int)(result));
2578
+ return vresult;
2579
+ fail:
2580
+ return Qnil;
2581
+ }
2582
+
2583
+
2584
+ SWIGINTERN VALUE
2585
+ _wrap_sqlite3_bind_int64(int argc, VALUE *argv, VALUE self) {
2586
+ sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ;
2587
+ int arg2 ;
2588
+ sqlite_int64 arg3 ;
2589
+ int result;
2590
+ void *argp1 = 0 ;
2591
+ int res1 = 0 ;
2592
+ int val2 ;
2593
+ int ecode2 = 0 ;
2594
+ void *argp3 ;
2595
+ int res3 = 0 ;
2596
+ VALUE vresult = Qnil;
2597
+
2598
+ if ((argc < 3) || (argc > 3)) {
2599
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
2600
+ }
2601
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 );
2602
+ if (!SWIG_IsOK(res1)) {
2603
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_bind_int64" "', argument " "1"" of type '" "sqlite3_stmt *""'");
2604
+ }
2605
+ arg1 = (sqlite3_stmt *)(argp1);
2606
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
2607
+ if (!SWIG_IsOK(ecode2)) {
2608
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sqlite3_bind_int64" "', argument " "2"" of type '" "int""'");
2609
+ }
2610
+ arg2 = (int)(val2);
2611
+ {
2612
+ res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_sqlite_int64, 0 );
2613
+ if (!SWIG_IsOK(res3)) {
2614
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "sqlite3_bind_int64" "', argument " "3"" of type '" "sqlite_int64""'");
2615
+ }
2616
+ if (!argp3) {
2617
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sqlite3_bind_int64" "', argument " "3"" of type '" "sqlite_int64""'");
2618
+ } else {
2619
+ arg3 = *((sqlite_int64 *)(argp3));
2620
+ }
2621
+ }
2622
+ result = (int)sqlite3_bind_int64(arg1,arg2,arg3);
2623
+ vresult = SWIG_From_int((int)(result));
2624
+ return vresult;
2625
+ fail:
2626
+ return Qnil;
2627
+ }
2628
+
2629
+
2630
+ SWIGINTERN VALUE
2631
+ _wrap_sqlite3_bind_null(int argc, VALUE *argv, VALUE self) {
2632
+ sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ;
2633
+ int arg2 ;
2634
+ int result;
2635
+ void *argp1 = 0 ;
2636
+ int res1 = 0 ;
2637
+ int val2 ;
2638
+ int ecode2 = 0 ;
2639
+ VALUE vresult = Qnil;
2640
+
2641
+ if ((argc < 2) || (argc > 2)) {
2642
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
2643
+ }
2644
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 );
2645
+ if (!SWIG_IsOK(res1)) {
2646
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_bind_null" "', argument " "1"" of type '" "sqlite3_stmt *""'");
2647
+ }
2648
+ arg1 = (sqlite3_stmt *)(argp1);
2649
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
2650
+ if (!SWIG_IsOK(ecode2)) {
2651
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sqlite3_bind_null" "', argument " "2"" of type '" "int""'");
2652
+ }
2653
+ arg2 = (int)(val2);
2654
+ result = (int)sqlite3_bind_null(arg1,arg2);
2655
+ vresult = SWIG_From_int((int)(result));
2656
+ return vresult;
2657
+ fail:
2658
+ return Qnil;
2659
+ }
2660
+
2661
+
2662
+ SWIGINTERN VALUE
2663
+ _wrap_sqlite3_bind_text(int argc, VALUE *argv, VALUE self) {
2664
+ sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ;
2665
+ int arg2 ;
2666
+ char *arg3 = (char *) 0 ;
2667
+ int arg4 ;
2668
+ void (*arg5)(void *) = (void (*)(void *)) 0 ;
2669
+ int result;
2670
+ void *argp1 = 0 ;
2671
+ int res1 = 0 ;
2672
+ int val2 ;
2673
+ int ecode2 = 0 ;
2674
+ int res3 ;
2675
+ char *buf3 = 0 ;
2676
+ int alloc3 = 0 ;
2677
+ int val4 ;
2678
+ int ecode4 = 0 ;
2679
+ VALUE vresult = Qnil;
2680
+
2681
+ if ((argc < 5) || (argc > 5)) {
2682
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
2683
+ }
2684
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 );
2685
+ if (!SWIG_IsOK(res1)) {
2686
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_bind_text" "', argument " "1"" of type '" "sqlite3_stmt *""'");
2687
+ }
2688
+ arg1 = (sqlite3_stmt *)(argp1);
2689
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
2690
+ if (!SWIG_IsOK(ecode2)) {
2691
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sqlite3_bind_text" "', argument " "2"" of type '" "int""'");
2692
+ }
2693
+ arg2 = (int)(val2);
2694
+ res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
2695
+ if (!SWIG_IsOK(res3)) {
2696
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "sqlite3_bind_text" "', argument " "3"" of type '" "char const *""'");
2697
+ }
2698
+ arg3 = (char *)(buf3);
2699
+ ecode4 = SWIG_AsVal_int(argv[3], &val4);
2700
+ if (!SWIG_IsOK(ecode4)) {
2701
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "sqlite3_bind_text" "', argument " "4"" of type '" "int""'");
2702
+ }
2703
+ arg4 = (int)(val4);
2704
+ {
2705
+ int res = SWIG_ConvertFunctionPtr(argv[4], (void**)(&arg5), SWIGTYPE_p_f_p_void__void);
2706
+ if (!SWIG_IsOK(res)) {
2707
+ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "sqlite3_bind_text" "', argument " "5"" of type '" "void (*)(void *)""'");
2708
+ }
2709
+ }
2710
+ result = (int)sqlite3_bind_text(arg1,arg2,(char const *)arg3,arg4,arg5);
2711
+ vresult = SWIG_From_int((int)(result));
2712
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
2713
+ return vresult;
2714
+ fail:
2715
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
2716
+ return Qnil;
2717
+ }
2718
+
2719
+
2720
+ SWIGINTERN VALUE
2721
+ _wrap_sqlite3_bind_text16(int argc, VALUE *argv, VALUE self) {
2722
+ sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ;
2723
+ int arg2 ;
2724
+ void *arg3 = (void *) 0 ;
2725
+ int arg4 ;
2726
+ void (*arg5)(void *) = (void (*)(void *)) 0 ;
2727
+ int result;
2728
+ void *argp1 = 0 ;
2729
+ int res1 = 0 ;
2730
+ int val2 ;
2731
+ int ecode2 = 0 ;
2732
+ int res3 ;
2733
+ int val4 ;
2734
+ int ecode4 = 0 ;
2735
+ VALUE vresult = Qnil;
2736
+
2737
+ if ((argc < 5) || (argc > 5)) {
2738
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
2739
+ }
2740
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 );
2741
+ if (!SWIG_IsOK(res1)) {
2742
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_bind_text16" "', argument " "1"" of type '" "sqlite3_stmt *""'");
2743
+ }
2744
+ arg1 = (sqlite3_stmt *)(argp1);
2745
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
2746
+ if (!SWIG_IsOK(ecode2)) {
2747
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sqlite3_bind_text16" "', argument " "2"" of type '" "int""'");
2748
+ }
2749
+ arg2 = (int)(val2);
2750
+ res3 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg3), 0, 0);
2751
+ if (!SWIG_IsOK(res3)) {
2752
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "sqlite3_bind_text16" "', argument " "3"" of type '" "void const *""'");
2753
+ }
2754
+ ecode4 = SWIG_AsVal_int(argv[3], &val4);
2755
+ if (!SWIG_IsOK(ecode4)) {
2756
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "sqlite3_bind_text16" "', argument " "4"" of type '" "int""'");
2757
+ }
2758
+ arg4 = (int)(val4);
2759
+ {
2760
+ int res = SWIG_ConvertFunctionPtr(argv[4], (void**)(&arg5), SWIGTYPE_p_f_p_void__void);
2761
+ if (!SWIG_IsOK(res)) {
2762
+ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "sqlite3_bind_text16" "', argument " "5"" of type '" "void (*)(void *)""'");
2763
+ }
2764
+ }
2765
+ result = (int)sqlite3_bind_text16(arg1,arg2,(void const *)arg3,arg4,arg5);
2766
+ vresult = SWIG_From_int((int)(result));
2767
+ return vresult;
2768
+ fail:
2769
+ return Qnil;
2770
+ }
2771
+
2772
+
2773
+ SWIGINTERN VALUE
2774
+ _wrap_sqlite3_bind_parameter_count(int argc, VALUE *argv, VALUE self) {
2775
+ sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ;
2776
+ int result;
2777
+ void *argp1 = 0 ;
2778
+ int res1 = 0 ;
2779
+ VALUE vresult = Qnil;
2780
+
2781
+ if ((argc < 1) || (argc > 1)) {
2782
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
2783
+ }
2784
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 );
2785
+ if (!SWIG_IsOK(res1)) {
2786
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_bind_parameter_count" "', argument " "1"" of type '" "sqlite3_stmt *""'");
2787
+ }
2788
+ arg1 = (sqlite3_stmt *)(argp1);
2789
+ result = (int)sqlite3_bind_parameter_count(arg1);
2790
+ vresult = SWIG_From_int((int)(result));
2791
+ return vresult;
2792
+ fail:
2793
+ return Qnil;
2794
+ }
2795
+
2796
+
2797
+ SWIGINTERN VALUE
2798
+ _wrap_sqlite3_bind_parameter_name(int argc, VALUE *argv, VALUE self) {
2799
+ sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ;
2800
+ int arg2 ;
2801
+ char *result = 0 ;
2802
+ void *argp1 = 0 ;
2803
+ int res1 = 0 ;
2804
+ int val2 ;
2805
+ int ecode2 = 0 ;
2806
+ VALUE vresult = Qnil;
2807
+
2808
+ if ((argc < 2) || (argc > 2)) {
2809
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
2810
+ }
2811
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 );
2812
+ if (!SWIG_IsOK(res1)) {
2813
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_bind_parameter_name" "', argument " "1"" of type '" "sqlite3_stmt *""'");
2814
+ }
2815
+ arg1 = (sqlite3_stmt *)(argp1);
2816
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
2817
+ if (!SWIG_IsOK(ecode2)) {
2818
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sqlite3_bind_parameter_name" "', argument " "2"" of type '" "int""'");
2819
+ }
2820
+ arg2 = (int)(val2);
2821
+ result = (char *)sqlite3_bind_parameter_name(arg1,arg2);
2822
+ vresult = SWIG_FromCharPtr((const char *)result);
2823
+ return vresult;
2824
+ fail:
2825
+ return Qnil;
2826
+ }
2827
+
2828
+
2829
+ SWIGINTERN VALUE
2830
+ _wrap_sqlite3_bind_parameter_index(int argc, VALUE *argv, VALUE self) {
2831
+ sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ;
2832
+ char *arg2 = (char *) 0 ;
2833
+ int result;
2834
+ void *argp1 = 0 ;
2835
+ int res1 = 0 ;
2836
+ int res2 ;
2837
+ char *buf2 = 0 ;
2838
+ int alloc2 = 0 ;
2839
+ VALUE vresult = Qnil;
2840
+
2841
+ if ((argc < 2) || (argc > 2)) {
2842
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
2843
+ }
2844
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 );
2845
+ if (!SWIG_IsOK(res1)) {
2846
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_bind_parameter_index" "', argument " "1"" of type '" "sqlite3_stmt *""'");
2847
+ }
2848
+ arg1 = (sqlite3_stmt *)(argp1);
2849
+ res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
2850
+ if (!SWIG_IsOK(res2)) {
2851
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sqlite3_bind_parameter_index" "', argument " "2"" of type '" "char const *""'");
2852
+ }
2853
+ arg2 = (char *)(buf2);
2854
+ result = (int)sqlite3_bind_parameter_index(arg1,(char const *)arg2);
2855
+ vresult = SWIG_From_int((int)(result));
2856
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2857
+ return vresult;
2858
+ fail:
2859
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2860
+ return Qnil;
2861
+ }
2862
+
2863
+
2864
+ SWIGINTERN VALUE
2865
+ _wrap_sqlite3_column_count(int argc, VALUE *argv, VALUE self) {
2866
+ sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ;
2867
+ int result;
2868
+ void *argp1 = 0 ;
2869
+ int res1 = 0 ;
2870
+ VALUE vresult = Qnil;
2871
+
2872
+ if ((argc < 1) || (argc > 1)) {
2873
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
2874
+ }
2875
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 );
2876
+ if (!SWIG_IsOK(res1)) {
2877
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_column_count" "', argument " "1"" of type '" "sqlite3_stmt *""'");
2878
+ }
2879
+ arg1 = (sqlite3_stmt *)(argp1);
2880
+ result = (int)sqlite3_column_count(arg1);
2881
+ vresult = SWIG_From_int((int)(result));
2882
+ return vresult;
2883
+ fail:
2884
+ return Qnil;
2885
+ }
2886
+
2887
+
2888
+ SWIGINTERN VALUE
2889
+ _wrap_sqlite3_column_name(int argc, VALUE *argv, VALUE self) {
2890
+ sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ;
2891
+ int arg2 ;
2892
+ char *result = 0 ;
2893
+ void *argp1 = 0 ;
2894
+ int res1 = 0 ;
2895
+ int val2 ;
2896
+ int ecode2 = 0 ;
2897
+ VALUE vresult = Qnil;
2898
+
2899
+ if ((argc < 2) || (argc > 2)) {
2900
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
2901
+ }
2902
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 );
2903
+ if (!SWIG_IsOK(res1)) {
2904
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_column_name" "', argument " "1"" of type '" "sqlite3_stmt *""'");
2905
+ }
2906
+ arg1 = (sqlite3_stmt *)(argp1);
2907
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
2908
+ if (!SWIG_IsOK(ecode2)) {
2909
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sqlite3_column_name" "', argument " "2"" of type '" "int""'");
2910
+ }
2911
+ arg2 = (int)(val2);
2912
+ result = (char *)sqlite3_column_name(arg1,arg2);
2913
+ vresult = SWIG_FromCharPtr((const char *)result);
2914
+ return vresult;
2915
+ fail:
2916
+ return Qnil;
2917
+ }
2918
+
2919
+
2920
+ SWIGINTERN VALUE
2921
+ _wrap_sqlite3_column_name16(int argc, VALUE *argv, VALUE self) {
2922
+ sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ;
2923
+ int arg2 ;
2924
+ void *result = 0 ;
2925
+ void *argp1 = 0 ;
2926
+ int res1 = 0 ;
2927
+ int val2 ;
2928
+ int ecode2 = 0 ;
2929
+ VALUE vresult = Qnil;
2930
+
2931
+ if ((argc < 2) || (argc > 2)) {
2932
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
2933
+ }
2934
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 );
2935
+ if (!SWIG_IsOK(res1)) {
2936
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_column_name16" "', argument " "1"" of type '" "sqlite3_stmt *""'");
2937
+ }
2938
+ arg1 = (sqlite3_stmt *)(argp1);
2939
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
2940
+ if (!SWIG_IsOK(ecode2)) {
2941
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sqlite3_column_name16" "', argument " "2"" of type '" "int""'");
2942
+ }
2943
+ arg2 = (int)(val2);
2944
+ result = (void *)sqlite3_column_name16(arg1,arg2);
2945
+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
2946
+ return vresult;
2947
+ fail:
2948
+ return Qnil;
2949
+ }
2950
+
2951
+
2952
+ SWIGINTERN VALUE
2953
+ _wrap_sqlite3_column_decltype(int argc, VALUE *argv, VALUE self) {
2954
+ sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ;
2955
+ int arg2 ;
2956
+ char *result = 0 ;
2957
+ void *argp1 = 0 ;
2958
+ int res1 = 0 ;
2959
+ int val2 ;
2960
+ int ecode2 = 0 ;
2961
+ VALUE vresult = Qnil;
2962
+
2963
+ if ((argc < 2) || (argc > 2)) {
2964
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
2965
+ }
2966
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 );
2967
+ if (!SWIG_IsOK(res1)) {
2968
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_column_decltype" "', argument " "1"" of type '" "sqlite3_stmt *""'");
2969
+ }
2970
+ arg1 = (sqlite3_stmt *)(argp1);
2971
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
2972
+ if (!SWIG_IsOK(ecode2)) {
2973
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sqlite3_column_decltype" "', argument " "2"" of type '" "int""'");
2974
+ }
2975
+ arg2 = (int)(val2);
2976
+ result = (char *)sqlite3_column_decltype(arg1,arg2);
2977
+ vresult = SWIG_FromCharPtr((const char *)result);
2978
+ return vresult;
2979
+ fail:
2980
+ return Qnil;
2981
+ }
2982
+
2983
+
2984
+ SWIGINTERN VALUE
2985
+ _wrap_sqlite3_column_decltype16(int argc, VALUE *argv, VALUE self) {
2986
+ sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ;
2987
+ int arg2 ;
2988
+ void *result = 0 ;
2989
+ void *argp1 = 0 ;
2990
+ int res1 = 0 ;
2991
+ int val2 ;
2992
+ int ecode2 = 0 ;
2993
+ VALUE vresult = Qnil;
2994
+
2995
+ if ((argc < 2) || (argc > 2)) {
2996
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
2997
+ }
2998
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 );
2999
+ if (!SWIG_IsOK(res1)) {
3000
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_column_decltype16" "', argument " "1"" of type '" "sqlite3_stmt *""'");
3001
+ }
3002
+ arg1 = (sqlite3_stmt *)(argp1);
3003
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
3004
+ if (!SWIG_IsOK(ecode2)) {
3005
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sqlite3_column_decltype16" "', argument " "2"" of type '" "int""'");
3006
+ }
3007
+ arg2 = (int)(val2);
3008
+ result = (void *)sqlite3_column_decltype16(arg1,arg2);
3009
+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
3010
+ return vresult;
3011
+ fail:
3012
+ return Qnil;
3013
+ }
3014
+
3015
+
3016
+ SWIGINTERN VALUE
3017
+ _wrap_sqlite3_step(int argc, VALUE *argv, VALUE self) {
3018
+ sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ;
3019
+ int result;
3020
+ void *argp1 = 0 ;
3021
+ int res1 = 0 ;
3022
+ VALUE vresult = Qnil;
3023
+
3024
+ if ((argc < 1) || (argc > 1)) {
3025
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3026
+ }
3027
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 );
3028
+ if (!SWIG_IsOK(res1)) {
3029
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_step" "', argument " "1"" of type '" "sqlite3_stmt *""'");
3030
+ }
3031
+ arg1 = (sqlite3_stmt *)(argp1);
3032
+ result = (int)sqlite3_step(arg1);
3033
+ vresult = SWIG_From_int((int)(result));
3034
+ return vresult;
3035
+ fail:
3036
+ return Qnil;
3037
+ }
3038
+
3039
+
3040
+ SWIGINTERN VALUE
3041
+ _wrap_sqlite3_data_count(int argc, VALUE *argv, VALUE self) {
3042
+ sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ;
3043
+ int result;
3044
+ void *argp1 = 0 ;
3045
+ int res1 = 0 ;
3046
+ VALUE vresult = Qnil;
3047
+
3048
+ if ((argc < 1) || (argc > 1)) {
3049
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3050
+ }
3051
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 );
3052
+ if (!SWIG_IsOK(res1)) {
3053
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_data_count" "', argument " "1"" of type '" "sqlite3_stmt *""'");
3054
+ }
3055
+ arg1 = (sqlite3_stmt *)(argp1);
3056
+ result = (int)sqlite3_data_count(arg1);
3057
+ vresult = SWIG_From_int((int)(result));
3058
+ return vresult;
3059
+ fail:
3060
+ return Qnil;
3061
+ }
3062
+
3063
+
3064
+ SWIGINTERN VALUE
3065
+ _wrap_sqlite3_column_blob(int argc, VALUE *argv, VALUE self) {
3066
+ sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ;
3067
+ int arg2 ;
3068
+ BLOB *result = 0 ;
3069
+ void *argp1 = 0 ;
3070
+ int res1 = 0 ;
3071
+ int val2 ;
3072
+ int ecode2 = 0 ;
3073
+ VALUE vresult = Qnil;
3074
+
3075
+ if ((argc < 2) || (argc > 2)) {
3076
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
3077
+ }
3078
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 );
3079
+ if (!SWIG_IsOK(res1)) {
3080
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_column_blob" "', argument " "1"" of type '" "sqlite3_stmt *""'");
3081
+ }
3082
+ arg1 = (sqlite3_stmt *)(argp1);
3083
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
3084
+ if (!SWIG_IsOK(ecode2)) {
3085
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sqlite3_column_blob" "', argument " "2"" of type '" "int""'");
3086
+ }
3087
+ arg2 = (int)(val2);
3088
+ result = (BLOB *)sqlite3_column_blob(arg1,arg2);
3089
+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BLOB, 0 | 0 );
3090
+ return vresult;
3091
+ fail:
3092
+ return Qnil;
3093
+ }
3094
+
3095
+
3096
+ SWIGINTERN VALUE
3097
+ _wrap_sqlite3_column_bytes(int argc, VALUE *argv, VALUE self) {
3098
+ sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ;
3099
+ int arg2 ;
3100
+ int result;
3101
+ void *argp1 = 0 ;
3102
+ int res1 = 0 ;
3103
+ int val2 ;
3104
+ int ecode2 = 0 ;
3105
+ VALUE vresult = Qnil;
3106
+
3107
+ if ((argc < 2) || (argc > 2)) {
3108
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
3109
+ }
3110
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 );
3111
+ if (!SWIG_IsOK(res1)) {
3112
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_column_bytes" "', argument " "1"" of type '" "sqlite3_stmt *""'");
3113
+ }
3114
+ arg1 = (sqlite3_stmt *)(argp1);
3115
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
3116
+ if (!SWIG_IsOK(ecode2)) {
3117
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sqlite3_column_bytes" "', argument " "2"" of type '" "int""'");
3118
+ }
3119
+ arg2 = (int)(val2);
3120
+ result = (int)sqlite3_column_bytes(arg1,arg2);
3121
+ vresult = SWIG_From_int((int)(result));
3122
+ return vresult;
3123
+ fail:
3124
+ return Qnil;
3125
+ }
3126
+
3127
+
3128
+ SWIGINTERN VALUE
3129
+ _wrap_sqlite3_column_bytes16(int argc, VALUE *argv, VALUE self) {
3130
+ sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ;
3131
+ int arg2 ;
3132
+ int result;
3133
+ void *argp1 = 0 ;
3134
+ int res1 = 0 ;
3135
+ int val2 ;
3136
+ int ecode2 = 0 ;
3137
+ VALUE vresult = Qnil;
3138
+
3139
+ if ((argc < 2) || (argc > 2)) {
3140
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
3141
+ }
3142
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 );
3143
+ if (!SWIG_IsOK(res1)) {
3144
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_column_bytes16" "', argument " "1"" of type '" "sqlite3_stmt *""'");
3145
+ }
3146
+ arg1 = (sqlite3_stmt *)(argp1);
3147
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
3148
+ if (!SWIG_IsOK(ecode2)) {
3149
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sqlite3_column_bytes16" "', argument " "2"" of type '" "int""'");
3150
+ }
3151
+ arg2 = (int)(val2);
3152
+ result = (int)sqlite3_column_bytes16(arg1,arg2);
3153
+ vresult = SWIG_From_int((int)(result));
3154
+ return vresult;
3155
+ fail:
3156
+ return Qnil;
3157
+ }
3158
+
3159
+
3160
+ SWIGINTERN VALUE
3161
+ _wrap_sqlite3_column_double(int argc, VALUE *argv, VALUE self) {
3162
+ sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ;
3163
+ int arg2 ;
3164
+ double result;
3165
+ void *argp1 = 0 ;
3166
+ int res1 = 0 ;
3167
+ int val2 ;
3168
+ int ecode2 = 0 ;
3169
+ VALUE vresult = Qnil;
3170
+
3171
+ if ((argc < 2) || (argc > 2)) {
3172
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
3173
+ }
3174
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 );
3175
+ if (!SWIG_IsOK(res1)) {
3176
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_column_double" "', argument " "1"" of type '" "sqlite3_stmt *""'");
3177
+ }
3178
+ arg1 = (sqlite3_stmt *)(argp1);
3179
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
3180
+ if (!SWIG_IsOK(ecode2)) {
3181
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sqlite3_column_double" "', argument " "2"" of type '" "int""'");
3182
+ }
3183
+ arg2 = (int)(val2);
3184
+ result = (double)sqlite3_column_double(arg1,arg2);
3185
+ vresult = SWIG_From_double((double)(result));
3186
+ return vresult;
3187
+ fail:
3188
+ return Qnil;
3189
+ }
3190
+
3191
+
3192
+ SWIGINTERN VALUE
3193
+ _wrap_sqlite3_column_int(int argc, VALUE *argv, VALUE self) {
3194
+ sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ;
3195
+ int arg2 ;
3196
+ double result;
3197
+ void *argp1 = 0 ;
3198
+ int res1 = 0 ;
3199
+ int val2 ;
3200
+ int ecode2 = 0 ;
3201
+ VALUE vresult = Qnil;
3202
+
3203
+ if ((argc < 2) || (argc > 2)) {
3204
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
3205
+ }
3206
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 );
3207
+ if (!SWIG_IsOK(res1)) {
3208
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_column_int" "', argument " "1"" of type '" "sqlite3_stmt *""'");
3209
+ }
3210
+ arg1 = (sqlite3_stmt *)(argp1);
3211
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
3212
+ if (!SWIG_IsOK(ecode2)) {
3213
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sqlite3_column_int" "', argument " "2"" of type '" "int""'");
3214
+ }
3215
+ arg2 = (int)(val2);
3216
+ result = (double)sqlite3_column_int(arg1,arg2);
3217
+ vresult = SWIG_From_double((double)(result));
3218
+ return vresult;
3219
+ fail:
3220
+ return Qnil;
3221
+ }
3222
+
3223
+
3224
+ SWIGINTERN VALUE
3225
+ _wrap_sqlite3_column_int64(int argc, VALUE *argv, VALUE self) {
3226
+ sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ;
3227
+ int arg2 ;
3228
+ sqlite_int64 result;
3229
+ void *argp1 = 0 ;
3230
+ int res1 = 0 ;
3231
+ int val2 ;
3232
+ int ecode2 = 0 ;
3233
+ VALUE vresult = Qnil;
3234
+
3235
+ if ((argc < 2) || (argc > 2)) {
3236
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
3237
+ }
3238
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 );
3239
+ if (!SWIG_IsOK(res1)) {
3240
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_column_int64" "', argument " "1"" of type '" "sqlite3_stmt *""'");
3241
+ }
3242
+ arg1 = (sqlite3_stmt *)(argp1);
3243
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
3244
+ if (!SWIG_IsOK(ecode2)) {
3245
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sqlite3_column_int64" "', argument " "2"" of type '" "int""'");
3246
+ }
3247
+ arg2 = (int)(val2);
3248
+ result = sqlite3_column_int64(arg1,arg2);
3249
+ {
3250
+ vresult = LONG2NUM(result);
3251
+ }
3252
+ return vresult;
3253
+ fail:
3254
+ return Qnil;
3255
+ }
3256
+
3257
+
3258
+ SWIGINTERN VALUE
3259
+ _wrap_sqlite3_column_text(int argc, VALUE *argv, VALUE self) {
3260
+ sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ;
3261
+ int arg2 ;
3262
+ char *result = 0 ;
3263
+ void *argp1 = 0 ;
3264
+ int res1 = 0 ;
3265
+ int val2 ;
3266
+ int ecode2 = 0 ;
3267
+ VALUE vresult = Qnil;
3268
+
3269
+ if ((argc < 2) || (argc > 2)) {
3270
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
3271
+ }
3272
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 );
3273
+ if (!SWIG_IsOK(res1)) {
3274
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_column_text" "', argument " "1"" of type '" "sqlite3_stmt *""'");
3275
+ }
3276
+ arg1 = (sqlite3_stmt *)(argp1);
3277
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
3278
+ if (!SWIG_IsOK(ecode2)) {
3279
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sqlite3_column_text" "', argument " "2"" of type '" "int""'");
3280
+ }
3281
+ arg2 = (int)(val2);
3282
+ result = (char *)sqlite3_column_text(arg1,arg2);
3283
+ vresult = SWIG_FromCharPtr((const char *)result);
3284
+ return vresult;
3285
+ fail:
3286
+ return Qnil;
3287
+ }
3288
+
3289
+
3290
+ SWIGINTERN VALUE
3291
+ _wrap_sqlite3_column_text16(int argc, VALUE *argv, VALUE self) {
3292
+ sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ;
3293
+ int arg2 ;
3294
+ void *result = 0 ;
3295
+ void *argp1 = 0 ;
3296
+ int res1 = 0 ;
3297
+ int val2 ;
3298
+ int ecode2 = 0 ;
3299
+ VALUE vresult = Qnil;
3300
+
3301
+ if ((argc < 2) || (argc > 2)) {
3302
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
3303
+ }
3304
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 );
3305
+ if (!SWIG_IsOK(res1)) {
3306
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_column_text16" "', argument " "1"" of type '" "sqlite3_stmt *""'");
3307
+ }
3308
+ arg1 = (sqlite3_stmt *)(argp1);
3309
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
3310
+ if (!SWIG_IsOK(ecode2)) {
3311
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sqlite3_column_text16" "', argument " "2"" of type '" "int""'");
3312
+ }
3313
+ arg2 = (int)(val2);
3314
+ result = (void *)sqlite3_column_text16(arg1,arg2);
3315
+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
3316
+ return vresult;
3317
+ fail:
3318
+ return Qnil;
3319
+ }
3320
+
3321
+
3322
+ SWIGINTERN VALUE
3323
+ _wrap_sqlite3_column_type(int argc, VALUE *argv, VALUE self) {
3324
+ sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ;
3325
+ int arg2 ;
3326
+ int result;
3327
+ void *argp1 = 0 ;
3328
+ int res1 = 0 ;
3329
+ int val2 ;
3330
+ int ecode2 = 0 ;
3331
+ VALUE vresult = Qnil;
3332
+
3333
+ if ((argc < 2) || (argc > 2)) {
3334
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
3335
+ }
3336
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 );
3337
+ if (!SWIG_IsOK(res1)) {
3338
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_column_type" "', argument " "1"" of type '" "sqlite3_stmt *""'");
3339
+ }
3340
+ arg1 = (sqlite3_stmt *)(argp1);
3341
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
3342
+ if (!SWIG_IsOK(ecode2)) {
3343
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sqlite3_column_type" "', argument " "2"" of type '" "int""'");
3344
+ }
3345
+ arg2 = (int)(val2);
3346
+ result = (int)sqlite3_column_type(arg1,arg2);
3347
+ vresult = SWIG_From_int((int)(result));
3348
+ return vresult;
3349
+ fail:
3350
+ return Qnil;
3351
+ }
3352
+
3353
+
3354
+ SWIGINTERN VALUE
3355
+ _wrap_sqlite3_finalize(int argc, VALUE *argv, VALUE self) {
3356
+ sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ;
3357
+ int result;
3358
+ void *argp1 = 0 ;
3359
+ int res1 = 0 ;
3360
+ VALUE vresult = Qnil;
3361
+
3362
+ if ((argc < 1) || (argc > 1)) {
3363
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3364
+ }
3365
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 );
3366
+ if (!SWIG_IsOK(res1)) {
3367
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_finalize" "', argument " "1"" of type '" "sqlite3_stmt *""'");
3368
+ }
3369
+ arg1 = (sqlite3_stmt *)(argp1);
3370
+ result = (int)sqlite3_finalize(arg1);
3371
+ vresult = SWIG_From_int((int)(result));
3372
+ return vresult;
3373
+ fail:
3374
+ return Qnil;
3375
+ }
3376
+
3377
+
3378
+ SWIGINTERN VALUE
3379
+ _wrap_sqlite3_reset(int argc, VALUE *argv, VALUE self) {
3380
+ sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ;
3381
+ int result;
3382
+ void *argp1 = 0 ;
3383
+ int res1 = 0 ;
3384
+ VALUE vresult = Qnil;
3385
+
3386
+ if ((argc < 1) || (argc > 1)) {
3387
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3388
+ }
3389
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 );
3390
+ if (!SWIG_IsOK(res1)) {
3391
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_reset" "', argument " "1"" of type '" "sqlite3_stmt *""'");
3392
+ }
3393
+ arg1 = (sqlite3_stmt *)(argp1);
3394
+ result = (int)sqlite3_reset(arg1);
3395
+ vresult = SWIG_From_int((int)(result));
3396
+ return vresult;
3397
+ fail:
3398
+ return Qnil;
3399
+ }
3400
+
3401
+
3402
+ SWIGINTERN VALUE
3403
+ _wrap_sqlite3_create_function(int argc, VALUE *argv, VALUE self) {
3404
+ sqlite3 *arg1 = (sqlite3 *) 0 ;
3405
+ char *arg2 = (char *) 0 ;
3406
+ int arg3 ;
3407
+ int arg4 ;
3408
+ void *arg5 = (void *) 0 ;
3409
+ void (*arg6)(sqlite3_context *,int,sqlite3_value **) = (void (*)(sqlite3_context *,int,sqlite3_value **)) 0 ;
3410
+ void (*arg7)(sqlite3_context *,int,sqlite3_value **) = (void (*)(sqlite3_context *,int,sqlite3_value **)) 0 ;
3411
+ void (*arg8)(sqlite3_context *) = (void (*)(sqlite3_context *)) 0 ;
3412
+ int result;
3413
+ void *argp1 = 0 ;
3414
+ int res1 = 0 ;
3415
+ int res2 ;
3416
+ char *buf2 = 0 ;
3417
+ int alloc2 = 0 ;
3418
+ int val3 ;
3419
+ int ecode3 = 0 ;
3420
+ int val4 ;
3421
+ int ecode4 = 0 ;
3422
+ int res5 ;
3423
+ VALUE vresult = Qnil;
3424
+
3425
+ if ((argc < 8) || (argc > 8)) {
3426
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 8)",argc); SWIG_fail;
3427
+ }
3428
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3, 0 | 0 );
3429
+ if (!SWIG_IsOK(res1)) {
3430
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_create_function" "', argument " "1"" of type '" "sqlite3 *""'");
3431
+ }
3432
+ arg1 = (sqlite3 *)(argp1);
3433
+ res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
3434
+ if (!SWIG_IsOK(res2)) {
3435
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sqlite3_create_function" "', argument " "2"" of type '" "char const *""'");
3436
+ }
3437
+ arg2 = (char *)(buf2);
3438
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
3439
+ if (!SWIG_IsOK(ecode3)) {
3440
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "sqlite3_create_function" "', argument " "3"" of type '" "int""'");
3441
+ }
3442
+ arg3 = (int)(val3);
3443
+ ecode4 = SWIG_AsVal_int(argv[3], &val4);
3444
+ if (!SWIG_IsOK(ecode4)) {
3445
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "sqlite3_create_function" "', argument " "4"" of type '" "int""'");
3446
+ }
3447
+ arg4 = (int)(val4);
3448
+ res5 = SWIG_ConvertPtr(argv[4],SWIG_as_voidptrptr(&arg5), 0, 0);
3449
+ if (!SWIG_IsOK(res5)) {
3450
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "sqlite3_create_function" "', argument " "5"" of type '" "void *""'");
3451
+ }
3452
+ {
3453
+ int res = SWIG_ConvertFunctionPtr(argv[5], (void**)(&arg6), SWIGTYPE_p_f_p_sqlite3_context_int_p_p_sqlite3_value__void);
3454
+ if (!SWIG_IsOK(res)) {
3455
+ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "sqlite3_create_function" "', argument " "6"" of type '" "void (*)(sqlite3_context *,int,sqlite3_value **)""'");
3456
+ }
3457
+ }
3458
+ {
3459
+ int res = SWIG_ConvertFunctionPtr(argv[6], (void**)(&arg7), SWIGTYPE_p_f_p_sqlite3_context_int_p_p_sqlite3_value__void);
3460
+ if (!SWIG_IsOK(res)) {
3461
+ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "sqlite3_create_function" "', argument " "7"" of type '" "void (*)(sqlite3_context *,int,sqlite3_value **)""'");
3462
+ }
3463
+ }
3464
+ {
3465
+ int res = SWIG_ConvertFunctionPtr(argv[7], (void**)(&arg8), SWIGTYPE_p_f_p_sqlite3_context__void);
3466
+ if (!SWIG_IsOK(res)) {
3467
+ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "sqlite3_create_function" "', argument " "8"" of type '" "void (*)(sqlite3_context *)""'");
3468
+ }
3469
+ }
3470
+ result = (int)sqlite3_create_function(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8);
3471
+ vresult = SWIG_From_int((int)(result));
3472
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3473
+ return vresult;
3474
+ fail:
3475
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3476
+ return Qnil;
3477
+ }
3478
+
3479
+
3480
+ SWIGINTERN VALUE
3481
+ _wrap_sqlite3_create_function16(int argc, VALUE *argv, VALUE self) {
3482
+ sqlite3 *arg1 = (sqlite3 *) 0 ;
3483
+ void *arg2 = (void *) 0 ;
3484
+ int arg3 ;
3485
+ int arg4 ;
3486
+ void *arg5 = (void *) 0 ;
3487
+ void (*arg6)(sqlite3_context *,int,sqlite3_value **) = (void (*)(sqlite3_context *,int,sqlite3_value **)) 0 ;
3488
+ void (*arg7)(sqlite3_context *,int,sqlite3_value **) = (void (*)(sqlite3_context *,int,sqlite3_value **)) 0 ;
3489
+ void (*arg8)(sqlite3_context *) = (void (*)(sqlite3_context *)) 0 ;
3490
+ int result;
3491
+ void *argp1 = 0 ;
3492
+ int res1 = 0 ;
3493
+ int res2 ;
3494
+ int val3 ;
3495
+ int ecode3 = 0 ;
3496
+ int val4 ;
3497
+ int ecode4 = 0 ;
3498
+ int res5 ;
3499
+ VALUE vresult = Qnil;
3500
+
3501
+ if ((argc < 8) || (argc > 8)) {
3502
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 8)",argc); SWIG_fail;
3503
+ }
3504
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3, 0 | 0 );
3505
+ if (!SWIG_IsOK(res1)) {
3506
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_create_function16" "', argument " "1"" of type '" "sqlite3 *""'");
3507
+ }
3508
+ arg1 = (sqlite3 *)(argp1);
3509
+ res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
3510
+ if (!SWIG_IsOK(res2)) {
3511
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sqlite3_create_function16" "', argument " "2"" of type '" "void const *""'");
3512
+ }
3513
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
3514
+ if (!SWIG_IsOK(ecode3)) {
3515
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "sqlite3_create_function16" "', argument " "3"" of type '" "int""'");
3516
+ }
3517
+ arg3 = (int)(val3);
3518
+ ecode4 = SWIG_AsVal_int(argv[3], &val4);
3519
+ if (!SWIG_IsOK(ecode4)) {
3520
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "sqlite3_create_function16" "', argument " "4"" of type '" "int""'");
3521
+ }
3522
+ arg4 = (int)(val4);
3523
+ res5 = SWIG_ConvertPtr(argv[4],SWIG_as_voidptrptr(&arg5), 0, 0);
3524
+ if (!SWIG_IsOK(res5)) {
3525
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "sqlite3_create_function16" "', argument " "5"" of type '" "void *""'");
3526
+ }
3527
+ {
3528
+ int res = SWIG_ConvertFunctionPtr(argv[5], (void**)(&arg6), SWIGTYPE_p_f_p_sqlite3_context_int_p_p_sqlite3_value__void);
3529
+ if (!SWIG_IsOK(res)) {
3530
+ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "sqlite3_create_function16" "', argument " "6"" of type '" "void (*)(sqlite3_context *,int,sqlite3_value **)""'");
3531
+ }
3532
+ }
3533
+ {
3534
+ int res = SWIG_ConvertFunctionPtr(argv[6], (void**)(&arg7), SWIGTYPE_p_f_p_sqlite3_context_int_p_p_sqlite3_value__void);
3535
+ if (!SWIG_IsOK(res)) {
3536
+ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "sqlite3_create_function16" "', argument " "7"" of type '" "void (*)(sqlite3_context *,int,sqlite3_value **)""'");
3537
+ }
3538
+ }
3539
+ {
3540
+ int res = SWIG_ConvertFunctionPtr(argv[7], (void**)(&arg8), SWIGTYPE_p_f_p_sqlite3_context__void);
3541
+ if (!SWIG_IsOK(res)) {
3542
+ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "sqlite3_create_function16" "', argument " "8"" of type '" "void (*)(sqlite3_context *)""'");
3543
+ }
3544
+ }
3545
+ result = (int)sqlite3_create_function16(arg1,(void const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8);
3546
+ vresult = SWIG_From_int((int)(result));
3547
+ return vresult;
3548
+ fail:
3549
+ return Qnil;
3550
+ }
3551
+
3552
+
3553
+ SWIGINTERN VALUE
3554
+ _wrap_sqlite3_aggregate_count(int argc, VALUE *argv, VALUE self) {
3555
+ sqlite3_context *arg1 = (sqlite3_context *) 0 ;
3556
+ int result;
3557
+ void *argp1 = 0 ;
3558
+ int res1 = 0 ;
3559
+ VALUE vresult = Qnil;
3560
+
3561
+ if ((argc < 1) || (argc > 1)) {
3562
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3563
+ }
3564
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_context, 0 | 0 );
3565
+ if (!SWIG_IsOK(res1)) {
3566
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_aggregate_count" "', argument " "1"" of type '" "sqlite3_context *""'");
3567
+ }
3568
+ arg1 = (sqlite3_context *)(argp1);
3569
+ result = (int)sqlite3_aggregate_count(arg1);
3570
+ vresult = SWIG_From_int((int)(result));
3571
+ return vresult;
3572
+ fail:
3573
+ return Qnil;
3574
+ }
3575
+
3576
+
3577
+ SWIGINTERN VALUE
3578
+ _wrap_sqlite3_value_blob(int argc, VALUE *argv, VALUE self) {
3579
+ sqlite3_value *arg1 = (sqlite3_value *) 0 ;
3580
+ VALBLOB *result = 0 ;
3581
+ void *argp1 = 0 ;
3582
+ int res1 = 0 ;
3583
+ VALUE vresult = Qnil;
3584
+
3585
+ if ((argc < 1) || (argc > 1)) {
3586
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3587
+ }
3588
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_value, 0 | 0 );
3589
+ if (!SWIG_IsOK(res1)) {
3590
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_value_blob" "', argument " "1"" of type '" "sqlite3_value *""'");
3591
+ }
3592
+ arg1 = (sqlite3_value *)(argp1);
3593
+ result = (VALBLOB *)sqlite3_value_blob(arg1);
3594
+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VALBLOB, 0 | 0 );
3595
+ return vresult;
3596
+ fail:
3597
+ return Qnil;
3598
+ }
3599
+
3600
+
3601
+ SWIGINTERN VALUE
3602
+ _wrap_sqlite3_value_bytes(int argc, VALUE *argv, VALUE self) {
3603
+ sqlite3_value *arg1 = (sqlite3_value *) 0 ;
3604
+ int result;
3605
+ void *argp1 = 0 ;
3606
+ int res1 = 0 ;
3607
+ VALUE vresult = Qnil;
3608
+
3609
+ if ((argc < 1) || (argc > 1)) {
3610
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3611
+ }
3612
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_value, 0 | 0 );
3613
+ if (!SWIG_IsOK(res1)) {
3614
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_value_bytes" "', argument " "1"" of type '" "sqlite3_value *""'");
3615
+ }
3616
+ arg1 = (sqlite3_value *)(argp1);
3617
+ result = (int)sqlite3_value_bytes(arg1);
3618
+ vresult = SWIG_From_int((int)(result));
3619
+ return vresult;
3620
+ fail:
3621
+ return Qnil;
3622
+ }
3623
+
3624
+
3625
+ SWIGINTERN VALUE
3626
+ _wrap_sqlite3_value_bytes16(int argc, VALUE *argv, VALUE self) {
3627
+ sqlite3_value *arg1 = (sqlite3_value *) 0 ;
3628
+ int result;
3629
+ void *argp1 = 0 ;
3630
+ int res1 = 0 ;
3631
+ VALUE vresult = Qnil;
3632
+
3633
+ if ((argc < 1) || (argc > 1)) {
3634
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3635
+ }
3636
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_value, 0 | 0 );
3637
+ if (!SWIG_IsOK(res1)) {
3638
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_value_bytes16" "', argument " "1"" of type '" "sqlite3_value *""'");
3639
+ }
3640
+ arg1 = (sqlite3_value *)(argp1);
3641
+ result = (int)sqlite3_value_bytes16(arg1);
3642
+ vresult = SWIG_From_int((int)(result));
3643
+ return vresult;
3644
+ fail:
3645
+ return Qnil;
3646
+ }
3647
+
3648
+
3649
+ SWIGINTERN VALUE
3650
+ _wrap_sqlite3_value_double(int argc, VALUE *argv, VALUE self) {
3651
+ sqlite3_value *arg1 = (sqlite3_value *) 0 ;
3652
+ double result;
3653
+ void *argp1 = 0 ;
3654
+ int res1 = 0 ;
3655
+ VALUE vresult = Qnil;
3656
+
3657
+ if ((argc < 1) || (argc > 1)) {
3658
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3659
+ }
3660
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_value, 0 | 0 );
3661
+ if (!SWIG_IsOK(res1)) {
3662
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_value_double" "', argument " "1"" of type '" "sqlite3_value *""'");
3663
+ }
3664
+ arg1 = (sqlite3_value *)(argp1);
3665
+ result = (double)sqlite3_value_double(arg1);
3666
+ vresult = SWIG_From_double((double)(result));
3667
+ return vresult;
3668
+ fail:
3669
+ return Qnil;
3670
+ }
3671
+
3672
+
3673
+ SWIGINTERN VALUE
3674
+ _wrap_sqlite3_value_int(int argc, VALUE *argv, VALUE self) {
3675
+ sqlite3_value *arg1 = (sqlite3_value *) 0 ;
3676
+ int result;
3677
+ void *argp1 = 0 ;
3678
+ int res1 = 0 ;
3679
+ VALUE vresult = Qnil;
3680
+
3681
+ if ((argc < 1) || (argc > 1)) {
3682
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3683
+ }
3684
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_value, 0 | 0 );
3685
+ if (!SWIG_IsOK(res1)) {
3686
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_value_int" "', argument " "1"" of type '" "sqlite3_value *""'");
3687
+ }
3688
+ arg1 = (sqlite3_value *)(argp1);
3689
+ result = (int)sqlite3_value_int(arg1);
3690
+ vresult = SWIG_From_int((int)(result));
3691
+ return vresult;
3692
+ fail:
3693
+ return Qnil;
3694
+ }
3695
+
3696
+
3697
+ SWIGINTERN VALUE
3698
+ _wrap_sqlite3_value_int64(int argc, VALUE *argv, VALUE self) {
3699
+ sqlite3_value *arg1 = (sqlite3_value *) 0 ;
3700
+ sqlite_int64 result;
3701
+ void *argp1 = 0 ;
3702
+ int res1 = 0 ;
3703
+ VALUE vresult = Qnil;
3704
+
3705
+ if ((argc < 1) || (argc > 1)) {
3706
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3707
+ }
3708
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_value, 0 | 0 );
3709
+ if (!SWIG_IsOK(res1)) {
3710
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_value_int64" "', argument " "1"" of type '" "sqlite3_value *""'");
3711
+ }
3712
+ arg1 = (sqlite3_value *)(argp1);
3713
+ result = sqlite3_value_int64(arg1);
3714
+ {
3715
+ vresult = LONG2NUM(result);
3716
+ }
3717
+ return vresult;
3718
+ fail:
3719
+ return Qnil;
3720
+ }
3721
+
3722
+
3723
+ SWIGINTERN VALUE
3724
+ _wrap_sqlite3_value_text(int argc, VALUE *argv, VALUE self) {
3725
+ sqlite3_value *arg1 = (sqlite3_value *) 0 ;
3726
+ char *result = 0 ;
3727
+ void *argp1 = 0 ;
3728
+ int res1 = 0 ;
3729
+ VALUE vresult = Qnil;
3730
+
3731
+ if ((argc < 1) || (argc > 1)) {
3732
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3733
+ }
3734
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_value, 0 | 0 );
3735
+ if (!SWIG_IsOK(res1)) {
3736
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_value_text" "', argument " "1"" of type '" "sqlite3_value *""'");
3737
+ }
3738
+ arg1 = (sqlite3_value *)(argp1);
3739
+ result = (char *)sqlite3_value_text(arg1);
3740
+ vresult = SWIG_FromCharPtr((const char *)result);
3741
+ return vresult;
3742
+ fail:
3743
+ return Qnil;
3744
+ }
3745
+
3746
+
3747
+ SWIGINTERN VALUE
3748
+ _wrap_sqlite3_value_text16(int argc, VALUE *argv, VALUE self) {
3749
+ sqlite3_value *arg1 = (sqlite3_value *) 0 ;
3750
+ void *result = 0 ;
3751
+ void *argp1 = 0 ;
3752
+ int res1 = 0 ;
3753
+ VALUE vresult = Qnil;
3754
+
3755
+ if ((argc < 1) || (argc > 1)) {
3756
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3757
+ }
3758
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_value, 0 | 0 );
3759
+ if (!SWIG_IsOK(res1)) {
3760
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_value_text16" "', argument " "1"" of type '" "sqlite3_value *""'");
3761
+ }
3762
+ arg1 = (sqlite3_value *)(argp1);
3763
+ result = (void *)sqlite3_value_text16(arg1);
3764
+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
3765
+ return vresult;
3766
+ fail:
3767
+ return Qnil;
3768
+ }
3769
+
3770
+
3771
+ SWIGINTERN VALUE
3772
+ _wrap_sqlite3_value_text16le(int argc, VALUE *argv, VALUE self) {
3773
+ sqlite3_value *arg1 = (sqlite3_value *) 0 ;
3774
+ void *result = 0 ;
3775
+ void *argp1 = 0 ;
3776
+ int res1 = 0 ;
3777
+ VALUE vresult = Qnil;
3778
+
3779
+ if ((argc < 1) || (argc > 1)) {
3780
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3781
+ }
3782
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_value, 0 | 0 );
3783
+ if (!SWIG_IsOK(res1)) {
3784
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_value_text16le" "', argument " "1"" of type '" "sqlite3_value *""'");
3785
+ }
3786
+ arg1 = (sqlite3_value *)(argp1);
3787
+ result = (void *)sqlite3_value_text16le(arg1);
3788
+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
3789
+ return vresult;
3790
+ fail:
3791
+ return Qnil;
3792
+ }
3793
+
3794
+
3795
+ SWIGINTERN VALUE
3796
+ _wrap_sqlite3_value_text16be(int argc, VALUE *argv, VALUE self) {
3797
+ sqlite3_value *arg1 = (sqlite3_value *) 0 ;
3798
+ void *result = 0 ;
3799
+ void *argp1 = 0 ;
3800
+ int res1 = 0 ;
3801
+ VALUE vresult = Qnil;
3802
+
3803
+ if ((argc < 1) || (argc > 1)) {
3804
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3805
+ }
3806
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_value, 0 | 0 );
3807
+ if (!SWIG_IsOK(res1)) {
3808
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_value_text16be" "', argument " "1"" of type '" "sqlite3_value *""'");
3809
+ }
3810
+ arg1 = (sqlite3_value *)(argp1);
3811
+ result = (void *)sqlite3_value_text16be(arg1);
3812
+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
3813
+ return vresult;
3814
+ fail:
3815
+ return Qnil;
3816
+ }
3817
+
3818
+
3819
+ SWIGINTERN VALUE
3820
+ _wrap_sqlite3_value_type(int argc, VALUE *argv, VALUE self) {
3821
+ sqlite3_value *arg1 = (sqlite3_value *) 0 ;
3822
+ int result;
3823
+ void *argp1 = 0 ;
3824
+ int res1 = 0 ;
3825
+ VALUE vresult = Qnil;
3826
+
3827
+ if ((argc < 1) || (argc > 1)) {
3828
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3829
+ }
3830
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_value, 0 | 0 );
3831
+ if (!SWIG_IsOK(res1)) {
3832
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_value_type" "', argument " "1"" of type '" "sqlite3_value *""'");
3833
+ }
3834
+ arg1 = (sqlite3_value *)(argp1);
3835
+ result = (int)sqlite3_value_type(arg1);
3836
+ vresult = SWIG_From_int((int)(result));
3837
+ return vresult;
3838
+ fail:
3839
+ return Qnil;
3840
+ }
3841
+
3842
+
3843
+ SWIGINTERN VALUE
3844
+ _wrap_sqlite3_result_blob(int argc, VALUE *argv, VALUE self) {
3845
+ sqlite3_context *arg1 = (sqlite3_context *) 0 ;
3846
+ void *arg2 = (void *) 0 ;
3847
+ int arg3 ;
3848
+ void (*arg4)(void *) = (void (*)(void *)) 0 ;
3849
+ void *argp1 = 0 ;
3850
+ int res1 = 0 ;
3851
+ int res2 ;
3852
+ int val3 ;
3853
+ int ecode3 = 0 ;
3854
+
3855
+ if ((argc < 4) || (argc > 4)) {
3856
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
3857
+ }
3858
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_context, 0 | 0 );
3859
+ if (!SWIG_IsOK(res1)) {
3860
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_result_blob" "', argument " "1"" of type '" "sqlite3_context *""'");
3861
+ }
3862
+ arg1 = (sqlite3_context *)(argp1);
3863
+ res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
3864
+ if (!SWIG_IsOK(res2)) {
3865
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sqlite3_result_blob" "', argument " "2"" of type '" "void const *""'");
3866
+ }
3867
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
3868
+ if (!SWIG_IsOK(ecode3)) {
3869
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "sqlite3_result_blob" "', argument " "3"" of type '" "int""'");
3870
+ }
3871
+ arg3 = (int)(val3);
3872
+ {
3873
+ int res = SWIG_ConvertFunctionPtr(argv[3], (void**)(&arg4), SWIGTYPE_p_f_p_void__void);
3874
+ if (!SWIG_IsOK(res)) {
3875
+ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "sqlite3_result_blob" "', argument " "4"" of type '" "void (*)(void *)""'");
3876
+ }
3877
+ }
3878
+ sqlite3_result_blob(arg1,(void const *)arg2,arg3,arg4);
3879
+ return Qnil;
3880
+ fail:
3881
+ return Qnil;
3882
+ }
3883
+
3884
+
3885
+ SWIGINTERN VALUE
3886
+ _wrap_sqlite3_result_double(int argc, VALUE *argv, VALUE self) {
3887
+ sqlite3_context *arg1 = (sqlite3_context *) 0 ;
3888
+ double arg2 ;
3889
+ void *argp1 = 0 ;
3890
+ int res1 = 0 ;
3891
+ double val2 ;
3892
+ int ecode2 = 0 ;
3893
+
3894
+ if ((argc < 2) || (argc > 2)) {
3895
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
3896
+ }
3897
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_context, 0 | 0 );
3898
+ if (!SWIG_IsOK(res1)) {
3899
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_result_double" "', argument " "1"" of type '" "sqlite3_context *""'");
3900
+ }
3901
+ arg1 = (sqlite3_context *)(argp1);
3902
+ ecode2 = SWIG_AsVal_double(argv[1], &val2);
3903
+ if (!SWIG_IsOK(ecode2)) {
3904
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sqlite3_result_double" "', argument " "2"" of type '" "double""'");
3905
+ }
3906
+ arg2 = (double)(val2);
3907
+ sqlite3_result_double(arg1,arg2);
3908
+ return Qnil;
3909
+ fail:
3910
+ return Qnil;
3911
+ }
3912
+
3913
+
3914
+ SWIGINTERN VALUE
3915
+ _wrap_sqlite3_result_error(int argc, VALUE *argv, VALUE self) {
3916
+ sqlite3_context *arg1 = (sqlite3_context *) 0 ;
3917
+ char *arg2 = (char *) 0 ;
3918
+ int arg3 ;
3919
+ void *argp1 = 0 ;
3920
+ int res1 = 0 ;
3921
+ int res2 ;
3922
+ char *buf2 = 0 ;
3923
+ int alloc2 = 0 ;
3924
+ int val3 ;
3925
+ int ecode3 = 0 ;
3926
+
3927
+ if ((argc < 3) || (argc > 3)) {
3928
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
3929
+ }
3930
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_context, 0 | 0 );
3931
+ if (!SWIG_IsOK(res1)) {
3932
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_result_error" "', argument " "1"" of type '" "sqlite3_context *""'");
3933
+ }
3934
+ arg1 = (sqlite3_context *)(argp1);
3935
+ res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
3936
+ if (!SWIG_IsOK(res2)) {
3937
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sqlite3_result_error" "', argument " "2"" of type '" "char const *""'");
3938
+ }
3939
+ arg2 = (char *)(buf2);
3940
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
3941
+ if (!SWIG_IsOK(ecode3)) {
3942
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "sqlite3_result_error" "', argument " "3"" of type '" "int""'");
3943
+ }
3944
+ arg3 = (int)(val3);
3945
+ sqlite3_result_error(arg1,(char const *)arg2,arg3);
3946
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3947
+ return Qnil;
3948
+ fail:
3949
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3950
+ return Qnil;
3951
+ }
3952
+
3953
+
3954
+ SWIGINTERN VALUE
3955
+ _wrap_sqlite3_result_error16(int argc, VALUE *argv, VALUE self) {
3956
+ sqlite3_context *arg1 = (sqlite3_context *) 0 ;
3957
+ void *arg2 = (void *) 0 ;
3958
+ int arg3 ;
3959
+ void *argp1 = 0 ;
3960
+ int res1 = 0 ;
3961
+ int res2 ;
3962
+ int val3 ;
3963
+ int ecode3 = 0 ;
3964
+
3965
+ if ((argc < 3) || (argc > 3)) {
3966
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
3967
+ }
3968
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_context, 0 | 0 );
3969
+ if (!SWIG_IsOK(res1)) {
3970
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_result_error16" "', argument " "1"" of type '" "sqlite3_context *""'");
3971
+ }
3972
+ arg1 = (sqlite3_context *)(argp1);
3973
+ res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
3974
+ if (!SWIG_IsOK(res2)) {
3975
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sqlite3_result_error16" "', argument " "2"" of type '" "void const *""'");
3976
+ }
3977
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
3978
+ if (!SWIG_IsOK(ecode3)) {
3979
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "sqlite3_result_error16" "', argument " "3"" of type '" "int""'");
3980
+ }
3981
+ arg3 = (int)(val3);
3982
+ sqlite3_result_error16(arg1,(void const *)arg2,arg3);
3983
+ return Qnil;
3984
+ fail:
3985
+ return Qnil;
3986
+ }
3987
+
3988
+
3989
+ SWIGINTERN VALUE
3990
+ _wrap_sqlite3_result_int(int argc, VALUE *argv, VALUE self) {
3991
+ sqlite3_context *arg1 = (sqlite3_context *) 0 ;
3992
+ int arg2 ;
3993
+ void *argp1 = 0 ;
3994
+ int res1 = 0 ;
3995
+ int val2 ;
3996
+ int ecode2 = 0 ;
3997
+
3998
+ if ((argc < 2) || (argc > 2)) {
3999
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
4000
+ }
4001
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_context, 0 | 0 );
4002
+ if (!SWIG_IsOK(res1)) {
4003
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_result_int" "', argument " "1"" of type '" "sqlite3_context *""'");
4004
+ }
4005
+ arg1 = (sqlite3_context *)(argp1);
4006
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
4007
+ if (!SWIG_IsOK(ecode2)) {
4008
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sqlite3_result_int" "', argument " "2"" of type '" "int""'");
4009
+ }
4010
+ arg2 = (int)(val2);
4011
+ sqlite3_result_int(arg1,arg2);
4012
+ return Qnil;
4013
+ fail:
4014
+ return Qnil;
4015
+ }
4016
+
4017
+
4018
+ SWIGINTERN VALUE
4019
+ _wrap_sqlite3_result_int64(int argc, VALUE *argv, VALUE self) {
4020
+ sqlite3_context *arg1 = (sqlite3_context *) 0 ;
4021
+ sqlite_int64 arg2 ;
4022
+ void *argp1 = 0 ;
4023
+ int res1 = 0 ;
4024
+ void *argp2 ;
4025
+ int res2 = 0 ;
4026
+
4027
+ if ((argc < 2) || (argc > 2)) {
4028
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
4029
+ }
4030
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_context, 0 | 0 );
4031
+ if (!SWIG_IsOK(res1)) {
4032
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_result_int64" "', argument " "1"" of type '" "sqlite3_context *""'");
4033
+ }
4034
+ arg1 = (sqlite3_context *)(argp1);
4035
+ {
4036
+ res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_sqlite_int64, 0 );
4037
+ if (!SWIG_IsOK(res2)) {
4038
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sqlite3_result_int64" "', argument " "2"" of type '" "sqlite_int64""'");
4039
+ }
4040
+ if (!argp2) {
4041
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sqlite3_result_int64" "', argument " "2"" of type '" "sqlite_int64""'");
4042
+ } else {
4043
+ arg2 = *((sqlite_int64 *)(argp2));
4044
+ }
4045
+ }
4046
+ sqlite3_result_int64(arg1,arg2);
4047
+ return Qnil;
4048
+ fail:
4049
+ return Qnil;
4050
+ }
4051
+
4052
+
4053
+ SWIGINTERN VALUE
4054
+ _wrap_sqlite3_result_text(int argc, VALUE *argv, VALUE self) {
4055
+ sqlite3_context *arg1 = (sqlite3_context *) 0 ;
4056
+ char *arg2 = (char *) 0 ;
4057
+ int arg3 ;
4058
+ void (*arg4)(void *) = (void (*)(void *)) 0 ;
4059
+ void *argp1 = 0 ;
4060
+ int res1 = 0 ;
4061
+ int res2 ;
4062
+ char *buf2 = 0 ;
4063
+ int alloc2 = 0 ;
4064
+ int val3 ;
4065
+ int ecode3 = 0 ;
4066
+
4067
+ if ((argc < 4) || (argc > 4)) {
4068
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
4069
+ }
4070
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_context, 0 | 0 );
4071
+ if (!SWIG_IsOK(res1)) {
4072
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_result_text" "', argument " "1"" of type '" "sqlite3_context *""'");
4073
+ }
4074
+ arg1 = (sqlite3_context *)(argp1);
4075
+ res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
4076
+ if (!SWIG_IsOK(res2)) {
4077
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sqlite3_result_text" "', argument " "2"" of type '" "char const *""'");
4078
+ }
4079
+ arg2 = (char *)(buf2);
4080
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
4081
+ if (!SWIG_IsOK(ecode3)) {
4082
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "sqlite3_result_text" "', argument " "3"" of type '" "int""'");
4083
+ }
4084
+ arg3 = (int)(val3);
4085
+ {
4086
+ int res = SWIG_ConvertFunctionPtr(argv[3], (void**)(&arg4), SWIGTYPE_p_f_p_void__void);
4087
+ if (!SWIG_IsOK(res)) {
4088
+ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "sqlite3_result_text" "', argument " "4"" of type '" "void (*)(void *)""'");
4089
+ }
4090
+ }
4091
+ sqlite3_result_text(arg1,(char const *)arg2,arg3,arg4);
4092
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4093
+ return Qnil;
4094
+ fail:
4095
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4096
+ return Qnil;
4097
+ }
4098
+
4099
+
4100
+ SWIGINTERN VALUE
4101
+ _wrap_sqlite3_result_text16(int argc, VALUE *argv, VALUE self) {
4102
+ sqlite3_context *arg1 = (sqlite3_context *) 0 ;
4103
+ void *arg2 = (void *) 0 ;
4104
+ int arg3 ;
4105
+ void (*arg4)(void *) = (void (*)(void *)) 0 ;
4106
+ void *argp1 = 0 ;
4107
+ int res1 = 0 ;
4108
+ int res2 ;
4109
+ int val3 ;
4110
+ int ecode3 = 0 ;
4111
+
4112
+ if ((argc < 4) || (argc > 4)) {
4113
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
4114
+ }
4115
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_context, 0 | 0 );
4116
+ if (!SWIG_IsOK(res1)) {
4117
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_result_text16" "', argument " "1"" of type '" "sqlite3_context *""'");
4118
+ }
4119
+ arg1 = (sqlite3_context *)(argp1);
4120
+ res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
4121
+ if (!SWIG_IsOK(res2)) {
4122
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sqlite3_result_text16" "', argument " "2"" of type '" "void const *""'");
4123
+ }
4124
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
4125
+ if (!SWIG_IsOK(ecode3)) {
4126
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "sqlite3_result_text16" "', argument " "3"" of type '" "int""'");
4127
+ }
4128
+ arg3 = (int)(val3);
4129
+ {
4130
+ int res = SWIG_ConvertFunctionPtr(argv[3], (void**)(&arg4), SWIGTYPE_p_f_p_void__void);
4131
+ if (!SWIG_IsOK(res)) {
4132
+ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "sqlite3_result_text16" "', argument " "4"" of type '" "void (*)(void *)""'");
4133
+ }
4134
+ }
4135
+ sqlite3_result_text16(arg1,(void const *)arg2,arg3,arg4);
4136
+ return Qnil;
4137
+ fail:
4138
+ return Qnil;
4139
+ }
4140
+
4141
+
4142
+ SWIGINTERN VALUE
4143
+ _wrap_sqlite3_result_text16le(int argc, VALUE *argv, VALUE self) {
4144
+ sqlite3_context *arg1 = (sqlite3_context *) 0 ;
4145
+ void *arg2 = (void *) 0 ;
4146
+ int arg3 ;
4147
+ void (*arg4)(void *) = (void (*)(void *)) 0 ;
4148
+ void *argp1 = 0 ;
4149
+ int res1 = 0 ;
4150
+ int res2 ;
4151
+ int val3 ;
4152
+ int ecode3 = 0 ;
4153
+
4154
+ if ((argc < 4) || (argc > 4)) {
4155
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
4156
+ }
4157
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_context, 0 | 0 );
4158
+ if (!SWIG_IsOK(res1)) {
4159
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_result_text16le" "', argument " "1"" of type '" "sqlite3_context *""'");
4160
+ }
4161
+ arg1 = (sqlite3_context *)(argp1);
4162
+ res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
4163
+ if (!SWIG_IsOK(res2)) {
4164
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sqlite3_result_text16le" "', argument " "2"" of type '" "void const *""'");
4165
+ }
4166
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
4167
+ if (!SWIG_IsOK(ecode3)) {
4168
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "sqlite3_result_text16le" "', argument " "3"" of type '" "int""'");
4169
+ }
4170
+ arg3 = (int)(val3);
4171
+ {
4172
+ int res = SWIG_ConvertFunctionPtr(argv[3], (void**)(&arg4), SWIGTYPE_p_f_p_void__void);
4173
+ if (!SWIG_IsOK(res)) {
4174
+ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "sqlite3_result_text16le" "', argument " "4"" of type '" "void (*)(void *)""'");
4175
+ }
4176
+ }
4177
+ sqlite3_result_text16le(arg1,(void const *)arg2,arg3,arg4);
4178
+ return Qnil;
4179
+ fail:
4180
+ return Qnil;
4181
+ }
4182
+
4183
+
4184
+ SWIGINTERN VALUE
4185
+ _wrap_sqlite3_result_text16be(int argc, VALUE *argv, VALUE self) {
4186
+ sqlite3_context *arg1 = (sqlite3_context *) 0 ;
4187
+ void *arg2 = (void *) 0 ;
4188
+ int arg3 ;
4189
+ void (*arg4)(void *) = (void (*)(void *)) 0 ;
4190
+ void *argp1 = 0 ;
4191
+ int res1 = 0 ;
4192
+ int res2 ;
4193
+ int val3 ;
4194
+ int ecode3 = 0 ;
4195
+
4196
+ if ((argc < 4) || (argc > 4)) {
4197
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
4198
+ }
4199
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_context, 0 | 0 );
4200
+ if (!SWIG_IsOK(res1)) {
4201
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_result_text16be" "', argument " "1"" of type '" "sqlite3_context *""'");
4202
+ }
4203
+ arg1 = (sqlite3_context *)(argp1);
4204
+ res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
4205
+ if (!SWIG_IsOK(res2)) {
4206
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sqlite3_result_text16be" "', argument " "2"" of type '" "void const *""'");
4207
+ }
4208
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
4209
+ if (!SWIG_IsOK(ecode3)) {
4210
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "sqlite3_result_text16be" "', argument " "3"" of type '" "int""'");
4211
+ }
4212
+ arg3 = (int)(val3);
4213
+ {
4214
+ int res = SWIG_ConvertFunctionPtr(argv[3], (void**)(&arg4), SWIGTYPE_p_f_p_void__void);
4215
+ if (!SWIG_IsOK(res)) {
4216
+ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "sqlite3_result_text16be" "', argument " "4"" of type '" "void (*)(void *)""'");
4217
+ }
4218
+ }
4219
+ sqlite3_result_text16be(arg1,(void const *)arg2,arg3,arg4);
4220
+ return Qnil;
4221
+ fail:
4222
+ return Qnil;
4223
+ }
4224
+
4225
+
4226
+ SWIGINTERN VALUE
4227
+ _wrap_sqlite3_result_value(int argc, VALUE *argv, VALUE self) {
4228
+ sqlite3_context *arg1 = (sqlite3_context *) 0 ;
4229
+ sqlite3_value *arg2 = (sqlite3_value *) 0 ;
4230
+ void *argp1 = 0 ;
4231
+ int res1 = 0 ;
4232
+ void *argp2 = 0 ;
4233
+ int res2 = 0 ;
4234
+
4235
+ if ((argc < 2) || (argc > 2)) {
4236
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
4237
+ }
4238
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_context, 0 | 0 );
4239
+ if (!SWIG_IsOK(res1)) {
4240
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_result_value" "', argument " "1"" of type '" "sqlite3_context *""'");
4241
+ }
4242
+ arg1 = (sqlite3_context *)(argp1);
4243
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_sqlite3_value, 0 | 0 );
4244
+ if (!SWIG_IsOK(res2)) {
4245
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sqlite3_result_value" "', argument " "2"" of type '" "sqlite3_value *""'");
4246
+ }
4247
+ arg2 = (sqlite3_value *)(argp2);
4248
+ sqlite3_result_value(arg1,arg2);
4249
+ return Qnil;
4250
+ fail:
4251
+ return Qnil;
4252
+ }
4253
+
4254
+
4255
+ SWIGINTERN VALUE
4256
+ _wrap_sqlite3_aggregate_context(int argc, VALUE *argv, VALUE self) {
4257
+ sqlite3_context *arg1 = (sqlite3_context *) 0 ;
4258
+ int arg2 ;
4259
+ VALUE *result = 0 ;
4260
+ void *argp1 = 0 ;
4261
+ int res1 = 0 ;
4262
+ int val2 ;
4263
+ int ecode2 = 0 ;
4264
+ VALUE vresult = Qnil;
4265
+
4266
+ if ((argc < 2) || (argc > 2)) {
4267
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
4268
+ }
4269
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_context, 0 | 0 );
4270
+ if (!SWIG_IsOK(res1)) {
4271
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sqlite3_aggregate_context" "', argument " "1"" of type '" "sqlite3_context *""'");
4272
+ }
4273
+ arg1 = (sqlite3_context *)(argp1);
4274
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
4275
+ if (!SWIG_IsOK(ecode2)) {
4276
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sqlite3_aggregate_context" "', argument " "2"" of type '" "int""'");
4277
+ }
4278
+ arg2 = (int)(val2);
4279
+ result = (VALUE *)sqlite3_aggregate_context(arg1,arg2);
4280
+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_void, 0 | 0 );
4281
+ return vresult;
4282
+ fail:
4283
+ return Qnil;
4284
+ }
4285
+
4286
+
4287
+
4288
+ /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
4289
+
4290
+ static swig_type_info _swigt__p_BLOB = {"_p_BLOB", "BLOB *", 0, 0, (void*)0, 0};
4291
+ static swig_type_info _swigt__p_VALBLOB = {"_p_VALBLOB", "VALBLOB *", 0, 0, (void*)0, 0};
4292
+ static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
4293
+ static swig_type_info _swigt__p_f_p_sqlite3_context__void = {"_p_f_p_sqlite3_context__void", "void (*)(sqlite3_context *)", 0, 0, (void*)0, 0};
4294
+ static swig_type_info _swigt__p_f_p_sqlite3_context_int_p_p_sqlite3_value__void = {"_p_f_p_sqlite3_context_int_p_p_sqlite3_value__void", "void (*)(sqlite3_context *,int,sqlite3_value **)", 0, 0, (void*)0, 0};
4295
+ static swig_type_info _swigt__p_f_p_void__void = {"_p_f_p_void__void", "void (*)(void *)", 0, 0, (void*)0, 0};
4296
+ static swig_type_info _swigt__p_f_p_void_int__int = {"_p_f_p_void_int__int", "int (*)(void *,int)", 0, 0, (void*)0, 0};
4297
+ static swig_type_info _swigt__p_f_p_void_int_p_q_const__char_p_q_const__char_p_q_const__char_p_q_const__char__int = {"_p_f_p_void_int_p_q_const__char_p_q_const__char_p_q_const__char_p_q_const__char__int", "int (*)(void *,int,char const *,char const *,char const *,char const *)", 0, 0, (void*)0, 0};
4298
+ static swig_type_info _swigt__p_f_p_void_p_q_const__char__void = {"_p_f_p_void_p_q_const__char__void", "void (*)(void *,char const *)", 0, 0, (void*)0, 0};
4299
+ static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
4300
+ static swig_type_info _swigt__p_p_sqlite3 = {"_p_p_sqlite3", "sqlite3 **", 0, 0, (void*)0, 0};
4301
+ static swig_type_info _swigt__p_p_sqlite3_stmt = {"_p_p_sqlite3_stmt", "sqlite3_stmt **", 0, 0, (void*)0, 0};
4302
+ static swig_type_info _swigt__p_p_void = {"_p_p_void", "void **|VALUE *", 0, 0, (void*)0, 0};
4303
+ static swig_type_info _swigt__p_sqlite3 = {"_p_sqlite3", "sqlite3 *", 0, 0, (void*)0, 0};
4304
+ static swig_type_info _swigt__p_sqlite3_context = {"_p_sqlite3_context", "sqlite3_context *", 0, 0, (void*)0, 0};
4305
+ static swig_type_info _swigt__p_sqlite3_stmt = {"_p_sqlite3_stmt", "sqlite3_stmt *", 0, 0, (void*)0, 0};
4306
+ static swig_type_info _swigt__p_sqlite3_value = {"_p_sqlite3_value", "sqlite3_value *", 0, 0, (void*)0, 0};
4307
+ static swig_type_info _swigt__p_sqlite_int64 = {"_p_sqlite_int64", "sqlite_int64 *", 0, 0, (void*)0, 0};
4308
+ static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
4309
+
4310
+ static swig_type_info *swig_type_initial[] = {
4311
+ &_swigt__p_BLOB,
4312
+ &_swigt__p_VALBLOB,
4313
+ &_swigt__p_char,
4314
+ &_swigt__p_f_p_sqlite3_context__void,
4315
+ &_swigt__p_f_p_sqlite3_context_int_p_p_sqlite3_value__void,
4316
+ &_swigt__p_f_p_void__void,
4317
+ &_swigt__p_f_p_void_int__int,
4318
+ &_swigt__p_f_p_void_int_p_q_const__char_p_q_const__char_p_q_const__char_p_q_const__char__int,
4319
+ &_swigt__p_f_p_void_p_q_const__char__void,
4320
+ &_swigt__p_p_char,
4321
+ &_swigt__p_p_sqlite3,
4322
+ &_swigt__p_p_sqlite3_stmt,
4323
+ &_swigt__p_p_void,
4324
+ &_swigt__p_sqlite3,
4325
+ &_swigt__p_sqlite3_context,
4326
+ &_swigt__p_sqlite3_stmt,
4327
+ &_swigt__p_sqlite3_value,
4328
+ &_swigt__p_sqlite_int64,
4329
+ &_swigt__p_void,
4330
+ };
4331
+
4332
+ static swig_cast_info _swigc__p_BLOB[] = { {&_swigt__p_BLOB, 0, 0, 0},{0, 0, 0, 0}};
4333
+ static swig_cast_info _swigc__p_VALBLOB[] = { {&_swigt__p_VALBLOB, 0, 0, 0},{0, 0, 0, 0}};
4334
+ static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
4335
+ static swig_cast_info _swigc__p_f_p_sqlite3_context__void[] = { {&_swigt__p_f_p_sqlite3_context__void, 0, 0, 0},{0, 0, 0, 0}};
4336
+ static swig_cast_info _swigc__p_f_p_sqlite3_context_int_p_p_sqlite3_value__void[] = { {&_swigt__p_f_p_sqlite3_context_int_p_p_sqlite3_value__void, 0, 0, 0},{0, 0, 0, 0}};
4337
+ static swig_cast_info _swigc__p_f_p_void__void[] = { {&_swigt__p_f_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
4338
+ static swig_cast_info _swigc__p_f_p_void_int__int[] = { {&_swigt__p_f_p_void_int__int, 0, 0, 0},{0, 0, 0, 0}};
4339
+ static swig_cast_info _swigc__p_f_p_void_int_p_q_const__char_p_q_const__char_p_q_const__char_p_q_const__char__int[] = { {&_swigt__p_f_p_void_int_p_q_const__char_p_q_const__char_p_q_const__char_p_q_const__char__int, 0, 0, 0},{0, 0, 0, 0}};
4340
+ static swig_cast_info _swigc__p_f_p_void_p_q_const__char__void[] = { {&_swigt__p_f_p_void_p_q_const__char__void, 0, 0, 0},{0, 0, 0, 0}};
4341
+ static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
4342
+ static swig_cast_info _swigc__p_p_sqlite3[] = { {&_swigt__p_p_sqlite3, 0, 0, 0},{0, 0, 0, 0}};
4343
+ static swig_cast_info _swigc__p_p_sqlite3_stmt[] = { {&_swigt__p_p_sqlite3_stmt, 0, 0, 0},{0, 0, 0, 0}};
4344
+ static swig_cast_info _swigc__p_p_void[] = { {&_swigt__p_p_void, 0, 0, 0},{0, 0, 0, 0}};
4345
+ static swig_cast_info _swigc__p_sqlite3[] = { {&_swigt__p_sqlite3, 0, 0, 0},{0, 0, 0, 0}};
4346
+ static swig_cast_info _swigc__p_sqlite3_context[] = { {&_swigt__p_sqlite3_context, 0, 0, 0},{0, 0, 0, 0}};
4347
+ static swig_cast_info _swigc__p_sqlite3_stmt[] = { {&_swigt__p_sqlite3_stmt, 0, 0, 0},{0, 0, 0, 0}};
4348
+ static swig_cast_info _swigc__p_sqlite3_value[] = { {&_swigt__p_sqlite3_value, 0, 0, 0},{0, 0, 0, 0}};
4349
+ static swig_cast_info _swigc__p_sqlite_int64[] = { {&_swigt__p_sqlite_int64, 0, 0, 0},{0, 0, 0, 0}};
4350
+ static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
4351
+
4352
+ static swig_cast_info *swig_cast_initial[] = {
4353
+ _swigc__p_BLOB,
4354
+ _swigc__p_VALBLOB,
4355
+ _swigc__p_char,
4356
+ _swigc__p_f_p_sqlite3_context__void,
4357
+ _swigc__p_f_p_sqlite3_context_int_p_p_sqlite3_value__void,
4358
+ _swigc__p_f_p_void__void,
4359
+ _swigc__p_f_p_void_int__int,
4360
+ _swigc__p_f_p_void_int_p_q_const__char_p_q_const__char_p_q_const__char_p_q_const__char__int,
4361
+ _swigc__p_f_p_void_p_q_const__char__void,
4362
+ _swigc__p_p_char,
4363
+ _swigc__p_p_sqlite3,
4364
+ _swigc__p_p_sqlite3_stmt,
4365
+ _swigc__p_p_void,
4366
+ _swigc__p_sqlite3,
4367
+ _swigc__p_sqlite3_context,
4368
+ _swigc__p_sqlite3_stmt,
4369
+ _swigc__p_sqlite3_value,
4370
+ _swigc__p_sqlite_int64,
4371
+ _swigc__p_void,
4372
+ };
4373
+
4374
+
4375
+ /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
4376
+
4377
+ /* -----------------------------------------------------------------------------
4378
+ * Type initialization:
4379
+ * This problem is tough by the requirement that no dynamic
4380
+ * memory is used. Also, since swig_type_info structures store pointers to
4381
+ * swig_cast_info structures and swig_cast_info structures store pointers back
4382
+ * to swig_type_info structures, we need some lookup code at initialization.
4383
+ * The idea is that swig generates all the structures that are needed.
4384
+ * The runtime then collects these partially filled structures.
4385
+ * The SWIG_InitializeModule function takes these initial arrays out of
4386
+ * swig_module, and does all the lookup, filling in the swig_module.types
4387
+ * array with the correct data and linking the correct swig_cast_info
4388
+ * structures together.
4389
+ *
4390
+ * The generated swig_type_info structures are assigned staticly to an initial
4391
+ * array. We just loop through that array, and handle each type individually.
4392
+ * First we lookup if this type has been already loaded, and if so, use the
4393
+ * loaded structure instead of the generated one. Then we have to fill in the
4394
+ * cast linked list. The cast data is initially stored in something like a
4395
+ * two-dimensional array. Each row corresponds to a type (there are the same
4396
+ * number of rows as there are in the swig_type_initial array). Each entry in
4397
+ * a column is one of the swig_cast_info structures for that type.
4398
+ * The cast_initial array is actually an array of arrays, because each row has
4399
+ * a variable number of columns. So to actually build the cast linked list,
4400
+ * we find the array of casts associated with the type, and loop through it
4401
+ * adding the casts to the list. The one last trick we need to do is making
4402
+ * sure the type pointer in the swig_cast_info struct is correct.
4403
+ *
4404
+ * First off, we lookup the cast->type name to see if it is already loaded.
4405
+ * There are three cases to handle:
4406
+ * 1) If the cast->type has already been loaded AND the type we are adding
4407
+ * casting info to has not been loaded (it is in this module), THEN we
4408
+ * replace the cast->type pointer with the type pointer that has already
4409
+ * been loaded.
4410
+ * 2) If BOTH types (the one we are adding casting info to, and the
4411
+ * cast->type) are loaded, THEN the cast info has already been loaded by
4412
+ * the previous module so we just ignore it.
4413
+ * 3) Finally, if cast->type has not already been loaded, then we add that
4414
+ * swig_cast_info to the linked list (because the cast->type) pointer will
4415
+ * be correct.
4416
+ * ----------------------------------------------------------------------------- */
4417
+
4418
+ #ifdef __cplusplus
4419
+ extern "C" {
4420
+ #if 0
4421
+ } /* c-mode */
4422
+ #endif
4423
+ #endif
4424
+
4425
+ #if 0
4426
+ #define SWIGRUNTIME_DEBUG
4427
+ #endif
4428
+
4429
+
4430
+ SWIGRUNTIME void
4431
+ SWIG_InitializeModule(void *clientdata) {
4432
+ size_t i;
4433
+ swig_module_info *module_head, *iter;
4434
+ int found;
4435
+
4436
+ clientdata = clientdata;
4437
+
4438
+ /* check to see if the circular list has been setup, if not, set it up */
4439
+ if (swig_module.next==0) {
4440
+ /* Initialize the swig_module */
4441
+ swig_module.type_initial = swig_type_initial;
4442
+ swig_module.cast_initial = swig_cast_initial;
4443
+ swig_module.next = &swig_module;
4444
+ }
4445
+
4446
+ /* Try and load any already created modules */
4447
+ module_head = SWIG_GetModule(clientdata);
4448
+ if (!module_head) {
4449
+ /* This is the first module loaded for this interpreter */
4450
+ /* so set the swig module into the interpreter */
4451
+ SWIG_SetModule(clientdata, &swig_module);
4452
+ module_head = &swig_module;
4453
+ } else {
4454
+ /* the interpreter has loaded a SWIG module, but has it loaded this one? */
4455
+ found=0;
4456
+ iter=module_head;
4457
+ do {
4458
+ if (iter==&swig_module) {
4459
+ found=1;
4460
+ break;
4461
+ }
4462
+ iter=iter->next;
4463
+ } while (iter!= module_head);
4464
+
4465
+ /* if the is found in the list, then all is done and we may leave */
4466
+ if (found) return;
4467
+ /* otherwise we must add out module into the list */
4468
+ swig_module.next = module_head->next;
4469
+ module_head->next = &swig_module;
4470
+ }
4471
+
4472
+ /* Now work on filling in swig_module.types */
4473
+ #ifdef SWIGRUNTIME_DEBUG
4474
+ printf("SWIG_InitializeModule: size %d\n", swig_module.size);
4475
+ #endif
4476
+ for (i = 0; i < swig_module.size; ++i) {
4477
+ swig_type_info *type = 0;
4478
+ swig_type_info *ret;
4479
+ swig_cast_info *cast;
4480
+
4481
+ #ifdef SWIGRUNTIME_DEBUG
4482
+ printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
4483
+ #endif
4484
+
4485
+ /* if there is another module already loaded */
4486
+ if (swig_module.next != &swig_module) {
4487
+ type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
4488
+ }
4489
+ if (type) {
4490
+ /* Overwrite clientdata field */
4491
+ #ifdef SWIGRUNTIME_DEBUG
4492
+ printf("SWIG_InitializeModule: found type %s\n", type->name);
4493
+ #endif
4494
+ if (swig_module.type_initial[i]->clientdata) {
4495
+ type->clientdata = swig_module.type_initial[i]->clientdata;
4496
+ #ifdef SWIGRUNTIME_DEBUG
4497
+ printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
4498
+ #endif
4499
+ }
4500
+ } else {
4501
+ type = swig_module.type_initial[i];
4502
+ }
4503
+
4504
+ /* Insert casting types */
4505
+ cast = swig_module.cast_initial[i];
4506
+ while (cast->type) {
4507
+
4508
+ /* Don't need to add information already in the list */
4509
+ ret = 0;
4510
+ #ifdef SWIGRUNTIME_DEBUG
4511
+ printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
4512
+ #endif
4513
+ if (swig_module.next != &swig_module) {
4514
+ ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
4515
+ #ifdef SWIGRUNTIME_DEBUG
4516
+ if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
4517
+ #endif
4518
+ }
4519
+ if (ret) {
4520
+ if (type == swig_module.type_initial[i]) {
4521
+ #ifdef SWIGRUNTIME_DEBUG
4522
+ printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
4523
+ #endif
4524
+ cast->type = ret;
4525
+ ret = 0;
4526
+ } else {
4527
+ /* Check for casting already in the list */
4528
+ swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
4529
+ #ifdef SWIGRUNTIME_DEBUG
4530
+ if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
4531
+ #endif
4532
+ if (!ocast) ret = 0;
4533
+ }
4534
+ }
4535
+
4536
+ if (!ret) {
4537
+ #ifdef SWIGRUNTIME_DEBUG
4538
+ printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
4539
+ #endif
4540
+ if (type->cast) {
4541
+ type->cast->prev = cast;
4542
+ cast->next = type->cast;
4543
+ }
4544
+ type->cast = cast;
4545
+ }
4546
+ cast++;
4547
+ }
4548
+ /* Set entry in modules->types array equal to the type */
4549
+ swig_module.types[i] = type;
4550
+ }
4551
+ swig_module.types[i] = 0;
4552
+
4553
+ #ifdef SWIGRUNTIME_DEBUG
4554
+ printf("**** SWIG_InitializeModule: Cast List ******\n");
4555
+ for (i = 0; i < swig_module.size; ++i) {
4556
+ int j = 0;
4557
+ swig_cast_info *cast = swig_module.cast_initial[i];
4558
+ printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
4559
+ while (cast->type) {
4560
+ printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
4561
+ cast++;
4562
+ ++j;
4563
+ }
4564
+ printf("---- Total casts: %d\n",j);
4565
+ }
4566
+ printf("**** SWIG_InitializeModule: Cast List ******\n");
4567
+ #endif
4568
+ }
4569
+
4570
+ /* This function will propagate the clientdata field of type to
4571
+ * any new swig_type_info structures that have been added into the list
4572
+ * of equivalent types. It is like calling
4573
+ * SWIG_TypeClientData(type, clientdata) a second time.
4574
+ */
4575
+ SWIGRUNTIME void
4576
+ SWIG_PropagateClientData(void) {
4577
+ size_t i;
4578
+ swig_cast_info *equiv;
4579
+ static int init_run = 0;
4580
+
4581
+ if (init_run) return;
4582
+ init_run = 1;
4583
+
4584
+ for (i = 0; i < swig_module.size; i++) {
4585
+ if (swig_module.types[i]->clientdata) {
4586
+ equiv = swig_module.types[i]->cast;
4587
+ while (equiv) {
4588
+ if (!equiv->converter) {
4589
+ if (equiv->type && !equiv->type->clientdata)
4590
+ SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
4591
+ }
4592
+ equiv = equiv->next;
4593
+ }
4594
+ }
4595
+ }
4596
+ }
4597
+
4598
+ #ifdef __cplusplus
4599
+ #if 0
4600
+ { /* c-mode */
4601
+ #endif
4602
+ }
4603
+ #endif
4604
+
4605
+
4606
+ #ifdef __cplusplus
4607
+ extern "C"
4608
+ #endif
4609
+ SWIGEXPORT void Init_sqlite3_c(void) {
4610
+ size_t i;
4611
+
4612
+ SWIG_InitRuntime();
4613
+ mSqlite3_c = rb_define_module("Sqlite3_c");
4614
+
4615
+ SWIG_InitializeModule(0);
4616
+ for (i = 0; i < swig_module.size; i++) {
4617
+ SWIG_define_class(swig_module.types[i]);
4618
+ }
4619
+
4620
+ SWIG_RubyInitializeTrackings();
4621
+ rb_define_module_function(mSqlite3_c, "sqlite3_libversion", _wrap_sqlite3_libversion, -1);
4622
+ rb_define_module_function(mSqlite3_c, "sqlite3_close", _wrap_sqlite3_close, -1);
4623
+ rb_define_module_function(mSqlite3_c, "sqlite3_last_insert_rowid", _wrap_sqlite3_last_insert_rowid, -1);
4624
+ rb_define_module_function(mSqlite3_c, "sqlite3_changes", _wrap_sqlite3_changes, -1);
4625
+ rb_define_module_function(mSqlite3_c, "sqlite3_total_changes", _wrap_sqlite3_total_changes, -1);
4626
+ rb_define_module_function(mSqlite3_c, "sqlite3_interrupt", _wrap_sqlite3_interrupt, -1);
4627
+ rb_define_module_function(mSqlite3_c, "sqlite3_complete", _wrap_sqlite3_complete, -1);
4628
+ rb_define_module_function(mSqlite3_c, "sqlite3_complete16", _wrap_sqlite3_complete16, -1);
4629
+ rb_define_module_function(mSqlite3_c, "sqlite3_busy_handler", _wrap_sqlite3_busy_handler, -1);
4630
+ rb_define_module_function(mSqlite3_c, "sqlite3_busy_timeout", _wrap_sqlite3_busy_timeout, -1);
4631
+ rb_define_module_function(mSqlite3_c, "sqlite3_set_authorizer", _wrap_sqlite3_set_authorizer, -1);
4632
+ rb_define_module_function(mSqlite3_c, "sqlite3_trace", _wrap_sqlite3_trace, -1);
4633
+ rb_define_module_function(mSqlite3_c, "sqlite3_open", _wrap_sqlite3_open, -1);
4634
+ rb_define_module_function(mSqlite3_c, "sqlite3_open16", _wrap_sqlite3_open16, -1);
4635
+ rb_define_module_function(mSqlite3_c, "sqlite3_errcode", _wrap_sqlite3_errcode, -1);
4636
+ rb_define_module_function(mSqlite3_c, "sqlite3_errmsg", _wrap_sqlite3_errmsg, -1);
4637
+ rb_define_module_function(mSqlite3_c, "sqlite3_errmsg16", _wrap_sqlite3_errmsg16, -1);
4638
+ rb_define_module_function(mSqlite3_c, "sqlite3_prepare", _wrap_sqlite3_prepare, -1);
4639
+ rb_define_module_function(mSqlite3_c, "sqlite3_prepare_v2", _wrap_sqlite3_prepare_v2, -1);
4640
+ rb_define_module_function(mSqlite3_c, "sqlite3_prepare16", _wrap_sqlite3_prepare16, -1);
4641
+ rb_define_module_function(mSqlite3_c, "sqlite3_bind_blob", _wrap_sqlite3_bind_blob, -1);
4642
+ rb_define_module_function(mSqlite3_c, "sqlite3_bind_double", _wrap_sqlite3_bind_double, -1);
4643
+ rb_define_module_function(mSqlite3_c, "sqlite3_bind_int", _wrap_sqlite3_bind_int, -1);
4644
+ rb_define_module_function(mSqlite3_c, "sqlite3_bind_int64", _wrap_sqlite3_bind_int64, -1);
4645
+ rb_define_module_function(mSqlite3_c, "sqlite3_bind_null", _wrap_sqlite3_bind_null, -1);
4646
+ rb_define_module_function(mSqlite3_c, "sqlite3_bind_text", _wrap_sqlite3_bind_text, -1);
4647
+ rb_define_module_function(mSqlite3_c, "sqlite3_bind_text16", _wrap_sqlite3_bind_text16, -1);
4648
+ rb_define_module_function(mSqlite3_c, "sqlite3_bind_parameter_count", _wrap_sqlite3_bind_parameter_count, -1);
4649
+ rb_define_module_function(mSqlite3_c, "sqlite3_bind_parameter_name", _wrap_sqlite3_bind_parameter_name, -1);
4650
+ rb_define_module_function(mSqlite3_c, "sqlite3_bind_parameter_index", _wrap_sqlite3_bind_parameter_index, -1);
4651
+ rb_define_module_function(mSqlite3_c, "sqlite3_column_count", _wrap_sqlite3_column_count, -1);
4652
+ rb_define_module_function(mSqlite3_c, "sqlite3_column_name", _wrap_sqlite3_column_name, -1);
4653
+ rb_define_module_function(mSqlite3_c, "sqlite3_column_name16", _wrap_sqlite3_column_name16, -1);
4654
+ rb_define_module_function(mSqlite3_c, "sqlite3_column_decltype", _wrap_sqlite3_column_decltype, -1);
4655
+ rb_define_module_function(mSqlite3_c, "sqlite3_column_decltype16", _wrap_sqlite3_column_decltype16, -1);
4656
+ rb_define_module_function(mSqlite3_c, "sqlite3_step", _wrap_sqlite3_step, -1);
4657
+ rb_define_module_function(mSqlite3_c, "sqlite3_data_count", _wrap_sqlite3_data_count, -1);
4658
+ rb_define_module_function(mSqlite3_c, "sqlite3_column_blob", _wrap_sqlite3_column_blob, -1);
4659
+ rb_define_module_function(mSqlite3_c, "sqlite3_column_bytes", _wrap_sqlite3_column_bytes, -1);
4660
+ rb_define_module_function(mSqlite3_c, "sqlite3_column_bytes16", _wrap_sqlite3_column_bytes16, -1);
4661
+ rb_define_module_function(mSqlite3_c, "sqlite3_column_double", _wrap_sqlite3_column_double, -1);
4662
+ rb_define_module_function(mSqlite3_c, "sqlite3_column_int", _wrap_sqlite3_column_int, -1);
4663
+ rb_define_module_function(mSqlite3_c, "sqlite3_column_int64", _wrap_sqlite3_column_int64, -1);
4664
+ rb_define_module_function(mSqlite3_c, "sqlite3_column_text", _wrap_sqlite3_column_text, -1);
4665
+ rb_define_module_function(mSqlite3_c, "sqlite3_column_text16", _wrap_sqlite3_column_text16, -1);
4666
+ rb_define_module_function(mSqlite3_c, "sqlite3_column_type", _wrap_sqlite3_column_type, -1);
4667
+ rb_define_module_function(mSqlite3_c, "sqlite3_finalize", _wrap_sqlite3_finalize, -1);
4668
+ rb_define_module_function(mSqlite3_c, "sqlite3_reset", _wrap_sqlite3_reset, -1);
4669
+ rb_define_module_function(mSqlite3_c, "sqlite3_create_function", _wrap_sqlite3_create_function, -1);
4670
+ rb_define_module_function(mSqlite3_c, "sqlite3_create_function16", _wrap_sqlite3_create_function16, -1);
4671
+ rb_define_module_function(mSqlite3_c, "sqlite3_aggregate_count", _wrap_sqlite3_aggregate_count, -1);
4672
+ rb_define_module_function(mSqlite3_c, "sqlite3_value_blob", _wrap_sqlite3_value_blob, -1);
4673
+ rb_define_module_function(mSqlite3_c, "sqlite3_value_bytes", _wrap_sqlite3_value_bytes, -1);
4674
+ rb_define_module_function(mSqlite3_c, "sqlite3_value_bytes16", _wrap_sqlite3_value_bytes16, -1);
4675
+ rb_define_module_function(mSqlite3_c, "sqlite3_value_double", _wrap_sqlite3_value_double, -1);
4676
+ rb_define_module_function(mSqlite3_c, "sqlite3_value_int", _wrap_sqlite3_value_int, -1);
4677
+ rb_define_module_function(mSqlite3_c, "sqlite3_value_int64", _wrap_sqlite3_value_int64, -1);
4678
+ rb_define_module_function(mSqlite3_c, "sqlite3_value_text", _wrap_sqlite3_value_text, -1);
4679
+ rb_define_module_function(mSqlite3_c, "sqlite3_value_text16", _wrap_sqlite3_value_text16, -1);
4680
+ rb_define_module_function(mSqlite3_c, "sqlite3_value_text16le", _wrap_sqlite3_value_text16le, -1);
4681
+ rb_define_module_function(mSqlite3_c, "sqlite3_value_text16be", _wrap_sqlite3_value_text16be, -1);
4682
+ rb_define_module_function(mSqlite3_c, "sqlite3_value_type", _wrap_sqlite3_value_type, -1);
4683
+ rb_define_module_function(mSqlite3_c, "sqlite3_result_blob", _wrap_sqlite3_result_blob, -1);
4684
+ rb_define_module_function(mSqlite3_c, "sqlite3_result_double", _wrap_sqlite3_result_double, -1);
4685
+ rb_define_module_function(mSqlite3_c, "sqlite3_result_error", _wrap_sqlite3_result_error, -1);
4686
+ rb_define_module_function(mSqlite3_c, "sqlite3_result_error16", _wrap_sqlite3_result_error16, -1);
4687
+ rb_define_module_function(mSqlite3_c, "sqlite3_result_int", _wrap_sqlite3_result_int, -1);
4688
+ rb_define_module_function(mSqlite3_c, "sqlite3_result_int64", _wrap_sqlite3_result_int64, -1);
4689
+ rb_define_module_function(mSqlite3_c, "sqlite3_result_text", _wrap_sqlite3_result_text, -1);
4690
+ rb_define_module_function(mSqlite3_c, "sqlite3_result_text16", _wrap_sqlite3_result_text16, -1);
4691
+ rb_define_module_function(mSqlite3_c, "sqlite3_result_text16le", _wrap_sqlite3_result_text16le, -1);
4692
+ rb_define_module_function(mSqlite3_c, "sqlite3_result_text16be", _wrap_sqlite3_result_text16be, -1);
4693
+ rb_define_module_function(mSqlite3_c, "sqlite3_result_value", _wrap_sqlite3_result_value, -1);
4694
+ rb_define_module_function(mSqlite3_c, "sqlite3_aggregate_context", _wrap_sqlite3_aggregate_context, -1);
4695
+ rb_define_const(mSqlite3_c, "SQLITE_OK", SWIG_From_int((int)(0)));
4696
+ rb_define_const(mSqlite3_c, "SQLITE_ERROR", SWIG_From_int((int)(1)));
4697
+ rb_define_const(mSqlite3_c, "SQLITE_INTERNAL", SWIG_From_int((int)(2)));
4698
+ rb_define_const(mSqlite3_c, "SQLITE_PERM", SWIG_From_int((int)(3)));
4699
+ rb_define_const(mSqlite3_c, "SQLITE_ABORT", SWIG_From_int((int)(4)));
4700
+ rb_define_const(mSqlite3_c, "SQLITE_BUSY", SWIG_From_int((int)(5)));
4701
+ rb_define_const(mSqlite3_c, "SQLITE_LOCKED", SWIG_From_int((int)(6)));
4702
+ rb_define_const(mSqlite3_c, "SQLITE_NOMEM", SWIG_From_int((int)(7)));
4703
+ rb_define_const(mSqlite3_c, "SQLITE_READONLY", SWIG_From_int((int)(8)));
4704
+ rb_define_const(mSqlite3_c, "SQLITE_INTERRUPT", SWIG_From_int((int)(9)));
4705
+ rb_define_const(mSqlite3_c, "SQLITE_IOERR", SWIG_From_int((int)(10)));
4706
+ rb_define_const(mSqlite3_c, "SQLITE_CORRUPT", SWIG_From_int((int)(11)));
4707
+ rb_define_const(mSqlite3_c, "SQLITE_NOTFOUND", SWIG_From_int((int)(12)));
4708
+ rb_define_const(mSqlite3_c, "SQLITE_FULL", SWIG_From_int((int)(13)));
4709
+ rb_define_const(mSqlite3_c, "SQLITE_CANTOPEN", SWIG_From_int((int)(14)));
4710
+ rb_define_const(mSqlite3_c, "SQLITE_PROTOCOL", SWIG_From_int((int)(15)));
4711
+ rb_define_const(mSqlite3_c, "SQLITE_EMPTY", SWIG_From_int((int)(16)));
4712
+ rb_define_const(mSqlite3_c, "SQLITE_SCHEMA", SWIG_From_int((int)(17)));
4713
+ rb_define_const(mSqlite3_c, "SQLITE_TOOBIG", SWIG_From_int((int)(18)));
4714
+ rb_define_const(mSqlite3_c, "SQLITE_CONSTRAINT", SWIG_From_int((int)(19)));
4715
+ rb_define_const(mSqlite3_c, "SQLITE_MISMATCH", SWIG_From_int((int)(20)));
4716
+ rb_define_const(mSqlite3_c, "SQLITE_MISUSE", SWIG_From_int((int)(21)));
4717
+ rb_define_const(mSqlite3_c, "SQLITE_NOLFS", SWIG_From_int((int)(22)));
4718
+ rb_define_const(mSqlite3_c, "SQLITE_AUTH", SWIG_From_int((int)(23)));
4719
+ rb_define_const(mSqlite3_c, "SQLITE_FORMAT", SWIG_From_int((int)(24)));
4720
+ rb_define_const(mSqlite3_c, "SQLITE_RANGE", SWIG_From_int((int)(25)));
4721
+ rb_define_const(mSqlite3_c, "SQLITE_NOTADB", SWIG_From_int((int)(26)));
4722
+ rb_define_const(mSqlite3_c, "SQLITE_ROW", SWIG_From_int((int)(100)));
4723
+ rb_define_const(mSqlite3_c, "SQLITE_DONE", SWIG_From_int((int)(101)));
4724
+ }
4725
+