diff --git a/lib/native/i386-mingw32/sqlite3.dll b/lib/native/i386-mingw32/sqlite3.dll new file mode 100644 index 00000000..98c50c4d Binary files /dev/null and b/lib/native/i386-mingw32/sqlite3.dll differ diff --git a/vendor/plugins/sqlite3-ruby/ChangeLog.cvs b/vendor/plugins/sqlite3-ruby/ChangeLog.cvs new file mode 100644 index 00000000..6e9dd51d --- /dev/null +++ b/vendor/plugins/sqlite3-ruby/ChangeLog.cvs @@ -0,0 +1,88 @@ +2005-01-05 09:40 minam + + * Rakefile, sqlite3-ruby-win32.gemspec, sqlite3-ruby.gemspec: Added + win32 gem. + +2005-01-05 07:31 minam + + * Rakefile, test/tc_integration.rb, test/tests.rb: Added + native-vs-dl benchmark to Rakefile. Added SQLITE3_DRIVERS + environment variable to integration test to specify which + driver(s) should be tested (defaults to "Native"). + +2005-01-04 14:26 minam + + * ext/sqlite3_api/sqlite3_api.i, lib/sqlite3/database.rb, + lib/sqlite3/driver/native/driver.rb, test/tc_database.rb, + test/tc_integration.rb, test/tests.rb: Unit tests: done. Bugs: + fixed. + +2005-01-03 23:13 minam + + * ext/sqlite3_api/sqlite3_api.i, lib/sqlite3/database.rb, + lib/sqlite3/driver/dl/driver.rb, + lib/sqlite3/driver/native/driver.rb, test/tc_integration.rb: + Custom functions (aggregate and otherwise) are supported by the + native driver now. Test cases for the same. + +2005-01-03 13:51 minam + + * ext/sqlite3_api/MANIFEST, ext/sqlite3_api/extconf.rb, + ext/sqlite3_api/post-clean.rb, ext/sqlite3_api/post-distclean.rb, + ext/sqlite3_api/sqlite3_api.i, lib/sqlite3/database.rb, + lib/sqlite3/resultset.rb, lib/sqlite3/version.rb, + lib/sqlite3/driver/dl/driver.rb, + lib/sqlite3/driver/native/driver.rb, test/native-vs-dl.rb, + test/tc_integration.rb: Added preliminary implementation of + native driver (swig-based), and integration tests. + +2004-12-29 19:37 minam + + * lib/sqlite3/driver/dl/driver.rb: Some fixes to allow the DL + driver to work with Ruby 1.8.1. + +2004-12-29 14:52 minam + + * lib/sqlite3/: database.rb, version.rb: Made #quote a class method + (again). Bumped version to 0.6. + +2004-12-25 22:59 minam + + * lib/sqlite3/driver/dl/api.rb: Added check for darwin in supported + platforms (thanks to bitsweat). + +2004-12-22 12:38 minam + + * Rakefile: Rakefile wasn't packaging the README file. + +2004-12-21 22:28 minam + + * Rakefile, sqlite3-ruby.gemspec, test/bm.rb: Packaging now works. + Added benchmarks. + +2004-12-21 21:45 minam + + * LICENSE, README, Rakefile, setup.rb, sqlite3-ruby.gemspec, + doc/faq/faq.rb, doc/faq/faq.yml, lib/sqlite3.rb, + lib/sqlite3/statement.rb, lib/sqlite3/constants.rb, + lib/sqlite3/database.rb, lib/sqlite3/resultset.rb, + lib/sqlite3/translator.rb, lib/sqlite3/value.rb, + lib/sqlite3/version.rb, lib/sqlite3/errors.rb, + lib/sqlite3/pragmas.rb, lib/sqlite3/driver/dl/api.rb, + lib/sqlite3/driver/dl/driver.rb, test/mocks.rb, + test/tc_database.rb, test/tests.rb, test/driver/dl/tc_driver.rb: + Initial import + +2004-12-21 21:45 minam + + * LICENSE, README, Rakefile, setup.rb, sqlite3-ruby.gemspec, + doc/faq/faq.rb, doc/faq/faq.yml, lib/sqlite3.rb, + lib/sqlite3/statement.rb, lib/sqlite3/constants.rb, + lib/sqlite3/database.rb, lib/sqlite3/resultset.rb, + lib/sqlite3/translator.rb, lib/sqlite3/value.rb, + lib/sqlite3/version.rb, lib/sqlite3/errors.rb, + lib/sqlite3/pragmas.rb, lib/sqlite3/driver/dl/api.rb, + lib/sqlite3/driver/dl/driver.rb, test/mocks.rb, + test/tc_database.rb, test/tests.rb, test/driver/dl/tc_driver.rb: + Initial revision + diff --git a/vendor/plugins/sqlite3-ruby/History.txt b/vendor/plugins/sqlite3-ruby/History.txt new file mode 100644 index 00000000..21372fb6 --- /dev/null +++ b/vendor/plugins/sqlite3-ruby/History.txt @@ -0,0 +1,68 @@ +=== 1.2.5 / 25 Jul 2009 + +* Check for illegal nil before executing SQL [Erik Veenstra] +* Switch to Hoe for gem task management and packaging. +* Advertise rake-compiler as development dependency. +* Build gem binaries for Windows. +* Improved Ruby 1.9 support compatibility. +* Taint returned values. Patch #20325. + + +=== 1.2.4.1 (internal) / 5 Jul 2009 + +* Check for illegal nil before executing SQL [Erik Veenstra] +* Switch to Hoe for gem task management and packaging. +* Advertise rake-compiler as development dependency. +* Build gem binaries for Windows. +* Improved Ruby 1.9 support compatibility. + + +=== 1.2.4 / 27 Aug 2008 + +* Package the updated C file for source builds. [Jamis Buck] + + +=== 1.2.3 / 26 Aug 2008 + +* Fix incorrect permissions on database.rb and translator.rb [Various] + +* Avoid using Object#extend for greater speedups [Erik Veenstra] + +* Ruby 1.9 compatibility tweaks for Array#zip [jimmy88@gmail.com] + +* Fix linking against Ruby 1.8.5 [Rob Holland ] + + +=== 1.2.2 / 31 May 2008 + +* Make the table_info method adjust the returned default value for the rows + so that the sqlite3 change in 3.3.8 and greater can be handled + transparently [Jamis Buck ] + +* Ruby 1.9 compatibility tweaks [Roman Le Negrate ] + +* Various performance enhancements [thanks Erik Veenstra] + +* Correct busy_handler documentation [Rob Holland ] + +* Use int_bind64 on Fixnum values larger than a 32bit C int can take. [Rob Holland ] + +* Work around a quirk in SQLite's error reporting by calling sqlite3_reset + to produce a more informative error code upon a failure from + sqlite3_step. [Rob Holland ] + +* Various documentation, test, and style tweaks [Rob Holland ] + +* Be more granular with time/data translation [Rob Holland ] + +* Use Date directly for parsing rather than going via Time [Rob Holland ] + +* Check for the rt library and fdatasync so we link against that when + needed [Rob Holland ] + +* Rename data structures to avoid collision on win32. based on patch + by: Luis Lavena [Rob Holland ] + +* Add test for defaults [Daniel Rodríguez Troitiño] + +* Correctly unquote double-quoted pragma defaults [Łukasz Dargiewicz ] diff --git a/vendor/plugins/sqlite3-ruby/Manifest.txt b/vendor/plugins/sqlite3-ruby/Manifest.txt new file mode 100644 index 00000000..28e2660a --- /dev/null +++ b/vendor/plugins/sqlite3-ruby/Manifest.txt @@ -0,0 +1,41 @@ +ChangeLog.cvs +History.txt +LICENSE +Manifest.txt +README.txt +Rakefile +ext/sqlite3_api/extconf.rb +ext/sqlite3_api/sqlite3_api.i +ext/sqlite3_api/sqlite3_api_wrap.c +faq/faq.rb +faq/faq.yml +lib/sqlite3.rb +lib/sqlite3/constants.rb +lib/sqlite3/database.rb +lib/sqlite3/driver/dl/api.rb +lib/sqlite3/driver/dl/driver.rb +lib/sqlite3/driver/native/driver.rb +lib/sqlite3/errors.rb +lib/sqlite3/pragmas.rb +lib/sqlite3/resultset.rb +lib/sqlite3/statement.rb +lib/sqlite3/translator.rb +lib/sqlite3/value.rb +lib/sqlite3/version.rb +setup.rb +tasks/benchmark.rake +tasks/faq.rake +tasks/gem.rake +tasks/native.rake +tasks/vendor_sqlite3.rake +test/bm.rb +test/driver/dl/tc_driver.rb +test/helper.rb +test/native-vs-dl.rb +test/test_database.rb +test/test_errors.rb +test/test_integration.rb +test/test_integration_open_close.rb +test/test_integration_pending.rb +test/test_integration_resultset.rb +test/test_integration_statement.rb diff --git a/vendor/plugins/sqlite3-ruby/README.txt b/vendor/plugins/sqlite3-ruby/README.txt new file mode 100644 index 00000000..897a648d --- /dev/null +++ b/vendor/plugins/sqlite3-ruby/README.txt @@ -0,0 +1,56 @@ += SQLite3/Ruby Interface + +* http://sqlite3-ruby.rubyforge.org +* http://rubyforge.org/projects/sqlite3-ruby +* http://github.com/jamis/sqlite3-ruby + +== DESCRIPTION + +This module allows Ruby programs to interface with the SQLite3 +database engine (http://www.sqlite.org). You must have the +SQLite engine installed in order to build this module. + +Note that this module is NOT compatible with SQLite 2.x. + +== Compilation and Installation + +Simply do the following, after installing SQLite3: + + ruby setup.rb config + ruby setup.rb setup + ruby setup.rb install + +Alternatively, you can download and install the RubyGem package for +SQLite3/Ruby (you must have RubyGems and SQLite3 installed, first): + + gem install sqlite3-ruby + +If you have sqlite3 installed in a non-standard location, you can specify the location of the include and lib files by doing: + + gem install sqlite3-ruby -- --with-sqlite3-include=/opt/local/include \ + --with-sqlite3-lib=/opt/local/lib + +Also, the gem ships with the C source-code pre-built, so (as of version 1.1.1) +you no longer need to have SWIG installed. However, if you have SWIG installed +and you want to generate the C file yourself, you can specify the +--with-swig option. + +== Usage + +For help figuring out the SQLite3/Ruby interface, check out the +FAQ[http://sqlite-ruby.rubyforge.org/sqlite3/faq.html]. It includes examples of +usage. If you have any questions that you feel should be address in the +FAQ, please send them to jamis@37signals.com + +== Source Code + +The source repository is accessible via git: + + git clone git://github.com/jamis/sqlite3-ruby.git + +== Contact Information + +The project page is http://rubyforge.org/projects/sqlite-ruby. There, you can +find links to mailing lists and forums that you can use to discuss this +library. Additionally, there are trackers for submitting bugs and feature +requests. Feel free to use them! diff --git a/vendor/plugins/sqlite3-ruby/Rakefile b/vendor/plugins/sqlite3-ruby/Rakefile index bd8a3f31..744f6130 100644 --- a/vendor/plugins/sqlite3-ruby/Rakefile +++ b/vendor/plugins/sqlite3-ruby/Rakefile @@ -1,192 +1,5 @@ require 'rubygems' require 'rake' -require 'rake/testtask' -require 'rake/rdoctask' -require 'rake/contrib/sshpublisher' -require "./lib/sqlite3/version" - -PACKAGE_NAME = "sqlite3-ruby" -PACKAGE_VERSION = SQLite3::Version::STRING - -puts "name : #{PACKAGE_NAME}" -puts "version: #{PACKAGE_VERSION}" - -SOURCE_FILES = FileList.new do |fl| - [ "ext", "lib", "test" ].each do |dir| - fl.include "#{dir}/**/*" - end - fl.include "Rakefile" -end - -PACKAGE_FILES = FileList.new do |fl| - [ "api", "doc" ].each do |dir| - fl.include "#{dir}/**/*" - end - fl.include "CHANGELOG.rdoc", "README.rdoc", "LICENSE", "#{PACKAGE_NAME}.gemspec", "setup.rb" - fl.include SOURCE_FILES -end - -Gem.manage_gems - -def can_require( file ) - begin - require file - return true - rescue LoadError - return false - end -end - -desc "Default task" -task :default => [ :test ] - -desc "Clean generated files" -task :clean do - rm_rf "ChangeLog" - rm_rf "pkg" - rm_rf "api" - rm_f "doc/faq/faq.html" - - native_files = [ "Makefile", "mkmf.log", "sqlite3_api.so", - "sqlite3_api.bundle", "sqlite3_api_wrap.o" ] - native_files.each { |f| rm_f "ext/sqlite3_api/#{f}" } -end - -desc "Run benchmarks vs. sqlite-ruby" -task :benchmark do - ruby "test/bm.rb" -end - -desc "Run benchmarks dl vs. native" -task :benchmark2 do - ruby "test/native-vs-dl.rb" -end - -desc "Generate the FAQ document" -task :faq => "doc/faq/faq.html" - -file "doc/faq/faq.html" => [ "doc/faq/faq.rb", "doc/faq/faq.yml" ] do - cd( "doc/faq" ) { ruby "faq.rb > faq.html" } -end - -Rake::TestTask.new do |t| - t.test_files = [ "test/tests.rb" ] - t.verbose = true -end - -desc "Build all packages" -task :package - -package_name = "#{PACKAGE_NAME}-#{PACKAGE_VERSION}" -package_dir = "pkg" -package_dir_path = "#{package_dir}/#{package_name}" - -gz_file = "#{package_name}.tar.gz" -bz2_file = "#{package_name}.tar.bz2" -zip_file = "#{package_name}.zip" -gem_file = "#{package_name}.gem" - -task :gzip => SOURCE_FILES + [ :faq, :rdoc, "#{package_dir}/#{gz_file}" ] -task :bzip => SOURCE_FILES + [ :faq, :rdoc, "#{package_dir}/#{bz2_file}" ] -task :zip => SOURCE_FILES + [ :faq, :rdoc, "#{package_dir}/#{zip_file}" ] -task :gem => SOURCE_FILES + [ :faq, "#{package_dir}/#{gem_file}" ] - -task :package => [ :gzip, :bzip, :zip, :gem ] - -directory package_dir - -file package_dir_path do - mkdir_p package_dir_path rescue nil - PACKAGE_FILES.each do |fn| - f = File.join( package_dir_path, fn ) - if File.directory?( fn ) - mkdir_p f unless File.exist?( f ) - else - dir = File.dirname( f ) - mkdir_p dir unless File.exist?( dir ) - rm_f f - safe_ln fn, f - end - end -end - -file "#{package_dir}/#{zip_file}" => package_dir_path do - rm_f "#{package_dir}/#{zip_file}" - chdir package_dir do - sh %{zip -r #{zip_file} #{package_name}} - end -end - -file "#{package_dir}/#{gz_file}" => package_dir_path do - rm_f "#{package_dir}/#{gz_file}" - chdir package_dir do - sh %{tar czvf #{gz_file} #{package_name}} - end -end - -file "#{package_dir}/#{bz2_file}" => package_dir_path do - rm_f "#{package_dir}/#{bz2_file}" - chdir package_dir do - sh %{tar cjvf #{bz2_file} #{package_name}} - end -end - -file "#{package_dir}/#{gem_file}" => package_dir do - spec = eval(File.read(PACKAGE_NAME+".gemspec")) - Gem::Builder.new(spec).build - mv gem_file, "#{package_dir}/#{gem_file}" -end - -Rake::RDocTask.new do |rdoc| - rdoc.rdoc_dir = 'api' - rdoc.title = "SQLite3/Ruby" - rdoc.options += %w(--line-numbers --inline-source --main README.rdoc) - rdoc.rdoc_files.include('lib/**/*.rb') - - if can_require( "rdoc/generators/template/html/jamis" ) - rdoc.template = "jamis" - end -end - -desc "Publish the API documentation" -task :pubrdoc => [ :rdoc ] do - Rake::SshDirPublisher.new( - "minam@rubyforge.org", - "/var/www/gforge-projects/sqlite-ruby/sqlite3/", - "api" ).upload -end - -desc "Publish the FAQ" -task :pubfaq => [ :faq ] do - Rake::SshFilePublisher.new( - "minam@rubyforge.org", - "/var/www/gforge-projects/sqlite-ruby/sqlite3", - "doc/faq", - "faq.html" ).upload -end - -desc "Publish the documentation" -task :pubdoc => [:pubrdoc, :pubfaq] - -desc "Build the Native extension" -task :build do - cd 'ext/sqlite3_api' do - ruby 'extconf.rb' - system 'make' - end -end - -desc "Package a beta release" -task :beta do - require 'yaml' - system 'svn up' - rev = YAML.load(`svn info`)["Revision"] - version = File.read("lib/sqlite3/version.rb") - version.gsub!(/#:beta-tag:/, %(STRING << ".#{rev}")) - File.open("lib/sqlite3/version.rb", "w") { |f| f.write(version) } - - system "rake gem" - - system "svn revert lib/sqlite3/version.rb" -end +# load rakefile extensions (tasks) +Dir['tasks/*.rake'].each { |f| import f } diff --git a/vendor/plugins/sqlite3-ruby/ext/sqlite3_api/extconf.rb b/vendor/plugins/sqlite3-ruby/ext/sqlite3_api/extconf.rb index b6c9bd6f..331524bb 100644 --- a/vendor/plugins/sqlite3-ruby/ext/sqlite3_api/extconf.rb +++ b/vendor/plugins/sqlite3-ruby/ext/sqlite3_api/extconf.rb @@ -1,16 +1,10 @@ require 'mkmf' -SWIG_WRAP = "sqlite3_api_wrap.c" - -dir_config( "sqlite3", "/usr/local" ) +dir_config( "sqlite3" ) have_library( "rt", "fdatasync" ) -if have_header( "sqlite3.h" ) && have_library( "sqlite3", "sqlite3_open" ) - if !File.exists?( SWIG_WRAP ) || with_config( "swig", false ) - puts "creating #{SWIG_WRAP}" - system "swig -ruby sqlite3_api.i" or raise "could not build wrapper via swig (perhaps swig is not installed?)" - end - +if have_header( "sqlite3.h" ) && have_library( "sqlite3", "sqlite3_open" ) then + $CFLAGS << " -fno-strict-aliasing" unless RUBY_PLATFORM =~ /mswin/ create_makefile( "sqlite3_api" ) end diff --git a/vendor/plugins/sqlite3-ruby/ext/sqlite3_api/sqlite3_api.i b/vendor/plugins/sqlite3-ruby/ext/sqlite3_api/sqlite3_api.i index 784ef865..5e103dee 100644 --- a/vendor/plugins/sqlite3-ruby/ext/sqlite3_api/sqlite3_api.i +++ b/vendor/plugins/sqlite3-ruby/ext/sqlite3_api/sqlite3_api.i @@ -12,6 +12,10 @@ #define RSTRING_LEN(s) (RSTRING(s)->len) #endif +#ifndef STR2CSTR +#define STR2CSTR StringValueCStr +#endif + #define Init_API Init_sqlite3_api struct CallbackData { diff --git a/vendor/plugins/sqlite3-ruby/ext/sqlite3_api/sqlite3_api_wrap.c b/vendor/plugins/sqlite3-ruby/ext/sqlite3_api/sqlite3_api_wrap.c index 90126790..a35f76ed 100644 --- a/vendor/plugins/sqlite3-ruby/ext/sqlite3_api/sqlite3_api_wrap.c +++ b/vendor/plugins/sqlite3-ruby/ext/sqlite3_api/sqlite3_api_wrap.c @@ -1,3102 +1,5018 @@ -/* ---------------------------------------------------------------------------- - * This file was automatically generated by SWIG (http://www.swig.org). - * Version 1.3.27 - * - * This file is not intended to be easily readable and contains a number of - * coding conventions designed to improve portability and efficiency. Do not make - * changes to this file unless you know what you are doing--modify the SWIG - * interface file instead. - * ----------------------------------------------------------------------------- */ - -/*********************************************************************** - * - * This section contains generic SWIG labels for method/variable - * declarations/attributes, and other compiler dependent labels. - * - ************************************************************************/ - -/* template workaround for compilers that cannot correctly implement the C++ standard */ -#ifndef SWIGTEMPLATEDISAMBIGUATOR -# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560) -# define SWIGTEMPLATEDISAMBIGUATOR template -# else -# define SWIGTEMPLATEDISAMBIGUATOR -# endif -#endif - -/* inline attribute */ -#ifndef SWIGINLINE -# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__)) -# define SWIGINLINE inline -# else -# define SWIGINLINE -# endif -#endif - -/* attribute recognised by some compilers to avoid 'unused' warnings */ -#ifndef SWIGUNUSED -# if defined(__GNUC__) || defined(__ICC) -# define SWIGUNUSED __attribute__ ((unused)) -# else -# define SWIGUNUSED -# endif -#endif - -/* internal SWIG method */ -#ifndef SWIGINTERN -# define SWIGINTERN static SWIGUNUSED -#endif - -/* internal inline SWIG method */ -#ifndef SWIGINTERNINLINE -# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE -#endif - -/* exporting methods for Windows DLLs */ -#ifndef SWIGEXPORT -# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) -# if defined(STATIC_LINKED) -# define SWIGEXPORT -# else -# define SWIGEXPORT __declspec(dllexport) -# endif -# else -# define SWIGEXPORT -# endif -#endif - -/* calling conventions for Windows */ -#ifndef SWIGSTDCALL -# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) -# define SWIGSTDCALL __stdcall -# else -# define SWIGSTDCALL -# endif -#endif - - -/* ruby.swg */ -/* Implementation : RUBY */ -#define SWIGRUBY 1 - -#include "ruby.h" - -/* Flags for pointer conversion */ -#define SWIG_POINTER_EXCEPTION 0x1 -#define SWIG_POINTER_OWN 0x1 -#define SWIG_POINTER_DISOWN 0x2 -#define SWIG_TRACK_OBJECTS 0x4 - -#define NUM2USHRT(n) (\ - (0 <= NUM2UINT(n) && NUM2UINT(n) <= USHRT_MAX)\ - ? (unsigned short) NUM2UINT(n) \ - : (rb_raise(rb_eArgError, "integer %d out of range of `unsigned short'",\ - NUM2UINT(n)), (short)0)\ -) - -#define NUM2SHRT(n) (\ - (SHRT_MIN <= NUM2INT(n) && NUM2INT(n) <= SHRT_MAX)\ - ? (short)NUM2INT(n)\ - : (rb_raise(rb_eArgError, "integer %d out of range of `short'",\ - NUM2INT(n)), (short)0)\ -) - -/* Ruby 1.7 defines NUM2LL(), LL2NUM() and ULL2NUM() macros */ -#ifndef NUM2LL -#define NUM2LL(x) NUM2LONG((x)) -#endif -#ifndef LL2NUM -#define LL2NUM(x) INT2NUM((long) (x)) -#endif -#ifndef ULL2NUM -#define ULL2NUM(x) UINT2NUM((unsigned long) (x)) -#endif - -/* Ruby 1.7 doesn't (yet) define NUM2ULL() */ -#ifndef NUM2ULL -#ifdef HAVE_LONG_LONG -#define NUM2ULL(x) rb_num2ull((x)) -#else -#define NUM2ULL(x) NUM2ULONG(x) -#endif -#endif - -/* - * Need to be very careful about how these macros are defined, especially - * when compiling C++ code or C code with an ANSI C compiler. - * - * VALUEFUNC(f) is a macro used to typecast a C function that implements - * a Ruby method so that it can be passed as an argument to API functions - * like rb_define_method() and rb_define_singleton_method(). - * - * VOIDFUNC(f) is a macro used to typecast a C function that implements - * either the "mark" or "free" stuff for a Ruby Data object, so that it - * can be passed as an argument to API functions like Data_Wrap_Struct() - * and Data_Make_Struct(). - */ - -#ifdef __cplusplus -# ifndef RUBY_METHOD_FUNC /* These definitions should work for Ruby 1.4.6 */ -# define PROTECTFUNC(f) ((VALUE (*)()) f) -# define VALUEFUNC(f) ((VALUE (*)()) f) -# define VOIDFUNC(f) ((void (*)()) f) -# else -# ifndef ANYARGS /* These definitions should work for Ruby 1.6 */ -# define PROTECTFUNC(f) ((VALUE (*)()) f) -# define VALUEFUNC(f) ((VALUE (*)()) f) -# define VOIDFUNC(f) ((RUBY_DATA_FUNC) f) -# else /* These definitions should work for Ruby 1.7+ */ -# define PROTECTFUNC(f) ((VALUE (*)(VALUE)) f) -# define VALUEFUNC(f) ((VALUE (*)(ANYARGS)) f) -# define VOIDFUNC(f) ((RUBY_DATA_FUNC) f) -# endif -# endif -#else -# define VALUEFUNC(f) (f) -# define VOIDFUNC(f) (f) -#endif - -typedef struct { - VALUE klass; - VALUE mImpl; - void (*mark)(void *); - void (*destroy)(void *); -} swig_class; - -/* Don't use for expressions have side effect */ -#ifndef RB_STRING_VALUE -#define RB_STRING_VALUE(s) (TYPE(s) == T_STRING ? (s) : (*(volatile VALUE *)&(s) = rb_str_to_str(s))) -#endif -#ifndef StringValue -#define StringValue(s) RB_STRING_VALUE(s) -#endif -#ifndef StringValuePtr -#define StringValuePtr(s) RSTRING(RB_STRING_VALUE(s))->ptr -#endif -#ifndef StringValueLen -#define StringValueLen(s) RSTRING(RB_STRING_VALUE(s))->len -#endif -#ifndef SafeStringValue -#define SafeStringValue(v) do {\ - StringValue(v);\ - rb_check_safe_str(v);\ -} while (0) -#endif - -#ifndef HAVE_RB_DEFINE_ALLOC_FUNC -#define rb_define_alloc_func(klass, func) rb_define_singleton_method((klass), "new", VALUEFUNC((func)), -1) -#define rb_undef_alloc_func(klass) rb_undef_method(CLASS_OF((klass)), "new") -#endif - -/* Contract support */ - -#define SWIG_contract_assert(expr, msg) if (!(expr)) { rb_raise(rb_eRuntimeError, (char *) msg ); } else - - -/*********************************************************************** - * swigrun.swg - * - * This file contains generic CAPI SWIG runtime support for pointer - * type checking. - * - ************************************************************************/ - -/* This should only be incremented when either the layout of swig_type_info changes, - or for whatever reason, the runtime changes incompatibly */ -#define SWIG_RUNTIME_VERSION "2" - -/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */ -#ifdef SWIG_TYPE_TABLE -# define SWIG_QUOTE_STRING(x) #x -# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x) -# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE) -#else -# define SWIG_TYPE_TABLE_NAME -#endif - -/* - You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for - creating a static or dynamic library from the swig runtime code. - In 99.9% of the cases, swig just needs to declare them as 'static'. - - But only do this if is strictly necessary, ie, if you have problems - with your compiler or so. -*/ - -#ifndef SWIGRUNTIME -# define SWIGRUNTIME SWIGINTERN -#endif - -#ifndef SWIGRUNTIMEINLINE -# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE -#endif - -#include - -#ifdef __cplusplus -extern "C" { -#endif - -typedef void *(*swig_converter_func)(void *); -typedef struct swig_type_info *(*swig_dycast_func)(void **); - -/* Structure to store inforomation on one type */ -typedef struct swig_type_info { - const char *name; /* mangled name of this type */ - const char *str; /* human readable name of this type */ - swig_dycast_func dcast; /* dynamic cast function down a hierarchy */ - struct swig_cast_info *cast; /* linked list of types that can cast into this type */ - void *clientdata; /* language specific type data */ -} swig_type_info; - -/* Structure to store a type and conversion function used for casting */ -typedef struct swig_cast_info { - swig_type_info *type; /* pointer to type that is equivalent to this type */ - swig_converter_func converter; /* function to cast the void pointers */ - struct swig_cast_info *next; /* pointer to next cast in linked list */ - struct swig_cast_info *prev; /* pointer to the previous cast */ -} swig_cast_info; - -/* Structure used to store module information - * Each module generates one structure like this, and the runtime collects - * all of these structures and stores them in a circularly linked list.*/ -typedef struct swig_module_info { - swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */ - size_t size; /* Number of types in this module */ - struct swig_module_info *next; /* Pointer to next element in circularly linked list */ - swig_type_info **type_initial; /* Array of initially generated type structures */ - swig_cast_info **cast_initial; /* Array of initially generated casting structures */ - void *clientdata; /* Language specific module data */ -} swig_module_info; - - -/* - Compare two type names skipping the space characters, therefore - "char*" == "char *" and "Class" == "Class", etc. - - Return 0 when the two name types are equivalent, as in - strncmp, but skipping ' '. -*/ -SWIGRUNTIME int -SWIG_TypeNameComp(const char *f1, const char *l1, - const char *f2, const char *l2) { - for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) { - while ((*f1 == ' ') && (f1 != l1)) ++f1; - while ((*f2 == ' ') && (f2 != l2)) ++f2; - if (*f1 != *f2) return (int)(*f1 - *f2); - } - return (l1 - f1) - (l2 - f2); -} - -/* - Check type equivalence in a name list like ||... - Return 0 if not equal, 1 if equal -*/ -SWIGRUNTIME int -SWIG_TypeEquiv(const char *nb, const char *tb) { - int equiv = 0; - const char* te = tb + strlen(tb); - const char* ne = nb; - while (!equiv && *ne) { - for (nb = ne; *ne; ++ne) { - if (*ne == '|') break; - } - equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0; - if (*ne) ++ne; - } - return equiv; -} - -/* - Check type equivalence in a name list like ||... - Return 0 if equal, -1 if nb < tb, 1 if nb > tb -*/ -SWIGRUNTIME int -SWIG_TypeCompare(const char *nb, const char *tb) { - int equiv = 0; - const char* te = tb + strlen(tb); - const char* ne = nb; - while (!equiv && *ne) { - for (nb = ne; *ne; ++ne) { - if (*ne == '|') break; - } - equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0; - if (*ne) ++ne; - } - return equiv; -} - - -/* think of this as a c++ template<> or a scheme macro */ -#define SWIG_TypeCheck_Template(comparison, ty) \ - if (ty) { \ - swig_cast_info *iter = ty->cast; \ - while (iter) { \ - if (comparison) { \ - if (iter == ty->cast) return iter; \ - /* Move iter to the top of the linked list */ \ - iter->prev->next = iter->next; \ - if (iter->next) \ - iter->next->prev = iter->prev; \ - iter->next = ty->cast; \ - iter->prev = 0; \ - if (ty->cast) ty->cast->prev = iter; \ - ty->cast = iter; \ - return iter; \ - } \ - iter = iter->next; \ - } \ - } \ - return 0 - -/* - Check the typename -*/ -SWIGRUNTIME swig_cast_info * -SWIG_TypeCheck(const char *c, swig_type_info *ty) { - SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty); -} - -/* Same as previous function, except strcmp is replaced with a pointer comparison */ -SWIGRUNTIME swig_cast_info * -SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) { - SWIG_TypeCheck_Template(iter->type == from, into); -} - -/* - Cast a pointer up an inheritance hierarchy -*/ -SWIGRUNTIMEINLINE void * -SWIG_TypeCast(swig_cast_info *ty, void *ptr) { - return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr); -} - -/* - Dynamic pointer casting. Down an inheritance hierarchy -*/ -SWIGRUNTIME swig_type_info * -SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) { - swig_type_info *lastty = ty; - if (!ty || !ty->dcast) return ty; - while (ty && (ty->dcast)) { - ty = (*ty->dcast)(ptr); - if (ty) lastty = ty; - } - return lastty; -} - -/* - Return the name associated with this type -*/ -SWIGRUNTIMEINLINE const char * -SWIG_TypeName(const swig_type_info *ty) { - return ty->name; -} - -/* - Return the pretty name associated with this type, - that is an unmangled type name in a form presentable to the user. -*/ -SWIGRUNTIME const char * -SWIG_TypePrettyName(const swig_type_info *type) { - /* The "str" field contains the equivalent pretty names of the - type, separated by vertical-bar characters. We choose - to print the last name, as it is often (?) the most - specific. */ - if (type->str != NULL) { - const char *last_name = type->str; - const char *s; - for (s = type->str; *s; s++) - if (*s == '|') last_name = s+1; - return last_name; - } - else - return type->name; -} - -/* - Set the clientdata field for a type -*/ -SWIGRUNTIME void -SWIG_TypeClientData(swig_type_info *ti, void *clientdata) { - swig_cast_info *cast = ti->cast; - /* if (ti->clientdata == clientdata) return; */ - ti->clientdata = clientdata; - - while (cast) { - if (!cast->converter) { - swig_type_info *tc = cast->type; - if (!tc->clientdata) { - SWIG_TypeClientData(tc, clientdata); - } - } - cast = cast->next; - } -} - -/* - Search for a swig_type_info structure only by mangled name - Search is a O(log #types) - - We start searching at module start, and finish searching when start == end. - Note: if start == end at the beginning of the function, we go all the way around - the circular list. -*/ -SWIGRUNTIME swig_type_info * -SWIG_MangledTypeQueryModule(swig_module_info *start, - swig_module_info *end, - const char *name) { - swig_module_info *iter = start; - do { - if (iter->size) { - register size_t l = 0; - register size_t r = iter->size - 1; - do { - /* since l+r >= 0, we can (>> 1) instead (/ 2) */ - register size_t i = (l + r) >> 1; - const char *iname = iter->types[i]->name; - if (iname) { - register int compare = strcmp(name, iname); - if (compare == 0) { - return iter->types[i]; - } else if (compare < 0) { - if (i) { - r = i - 1; - } else { - break; - } - } else if (compare > 0) { - l = i + 1; - } - } else { - break; /* should never happen */ - } - } while (l <= r); - } - iter = iter->next; - } while (iter != end); - return 0; -} - -/* - Search for a swig_type_info structure for either a mangled name or a human readable name. - It first searches the mangled names of the types, which is a O(log #types) - If a type is not found it then searches the human readable names, which is O(#types). - - We start searching at module start, and finish searching when start == end. - Note: if start == end at the beginning of the function, we go all the way around - the circular list. -*/ -SWIGRUNTIME swig_type_info * -SWIG_TypeQueryModule(swig_module_info *start, - swig_module_info *end, - const char *name) { - /* STEP 1: Search the name field using binary search */ - swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name); - if (ret) { - return ret; - } else { - /* STEP 2: If the type hasn't been found, do a complete search - of the str field (the human readable name) */ - swig_module_info *iter = start; - do { - register size_t i = 0; - for (; i < iter->size; ++i) { - if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name))) - return iter->types[i]; - } - iter = iter->next; - } while (iter != end); - } - - /* neither found a match */ - return 0; -} - - -/* - Pack binary data into a string -*/ -SWIGRUNTIME char * -SWIG_PackData(char *c, void *ptr, size_t sz) { - static const char hex[17] = "0123456789abcdef"; - register const unsigned char *u = (unsigned char *) ptr; - register const unsigned char *eu = u + sz; - for (; u != eu; ++u) { - register unsigned char uu = *u; - *(c++) = hex[(uu & 0xf0) >> 4]; - *(c++) = hex[uu & 0xf]; - } - return c; -} - -/* - Unpack binary data from a string -*/ -SWIGRUNTIME const char * -SWIG_UnpackData(const char *c, void *ptr, size_t sz) { - register unsigned char *u = (unsigned char *) ptr; - register const unsigned char *eu = u + sz; - for (; u != eu; ++u) { - register char d = *(c++); - register unsigned char uu = 0; - if ((d >= '0') && (d <= '9')) - uu = ((d - '0') << 4); - else if ((d >= 'a') && (d <= 'f')) - uu = ((d - ('a'-10)) << 4); - else - return (char *) 0; - d = *(c++); - if ((d >= '0') && (d <= '9')) - uu |= (d - '0'); - else if ((d >= 'a') && (d <= 'f')) - uu |= (d - ('a'-10)); - else - return (char *) 0; - *u = uu; - } - return c; -} - -/* - Pack 'void *' into a string buffer. -*/ -SWIGRUNTIME char * -SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) { - char *r = buff; - if ((2*sizeof(void *) + 2) > bsz) return 0; - *(r++) = '_'; - r = SWIG_PackData(r,&ptr,sizeof(void *)); - if (strlen(name) + 1 > (bsz - (r - buff))) return 0; - strcpy(r,name); - return buff; -} - -SWIGRUNTIME const char * -SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) { - if (*c != '_') { - if (strcmp(c,"NULL") == 0) { - *ptr = (void *) 0; - return name; - } else { - return 0; - } - } - return SWIG_UnpackData(++c,ptr,sizeof(void *)); -} - -SWIGRUNTIME char * -SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) { - char *r = buff; - size_t lname = (name ? strlen(name) : 0); - if ((2*sz + 2 + lname) > bsz) return 0; - *(r++) = '_'; - r = SWIG_PackData(r,ptr,sz); - if (lname) { - strncpy(r,name,lname+1); - } else { - *r = 0; - } - return buff; -} - -SWIGRUNTIME const char * -SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) { - if (*c != '_') { - if (strcmp(c,"NULL") == 0) { - memset(ptr,0,sz); - return name; - } else { - return 0; - } - } - return SWIG_UnpackData(++c,ptr,sz); -} - -#ifdef __cplusplus -} -#endif - -/*********************************************************************** +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 1.3.39 + * + * This file is not intended to be easily readable and contains a number of + * coding conventions designed to improve portability and efficiency. Do not make + * changes to this file unless you know what you are doing--modify the SWIG + * interface file instead. + * ----------------------------------------------------------------------------- */ + +#define SWIGRUBY + +/* ----------------------------------------------------------------------------- + * This section contains generic SWIG labels for method/variable + * declarations/attributes, and other compiler dependent labels. + * ----------------------------------------------------------------------------- */ + +/* template workaround for compilers that cannot correctly implement the C++ standard */ +#ifndef SWIGTEMPLATEDISAMBIGUATOR +# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560) +# define SWIGTEMPLATEDISAMBIGUATOR template +# elif defined(__HP_aCC) +/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */ +/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */ +# define SWIGTEMPLATEDISAMBIGUATOR template +# else +# define SWIGTEMPLATEDISAMBIGUATOR +# endif +#endif + +/* inline attribute */ +#ifndef SWIGINLINE +# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__)) +# define SWIGINLINE inline +# else +# define SWIGINLINE +# endif +#endif + +/* attribute recognised by some compilers to avoid 'unused' warnings */ +#ifndef SWIGUNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define SWIGUNUSED __attribute__ ((__unused__)) +# else +# define SWIGUNUSED +# endif +# elif defined(__ICC) +# define SWIGUNUSED __attribute__ ((__unused__)) +# else +# define SWIGUNUSED +# endif +#endif + +#ifndef SWIG_MSC_UNSUPPRESS_4505 +# if defined(_MSC_VER) +# pragma warning(disable : 4505) /* unreferenced local function has been removed */ +# endif +#endif + +#ifndef SWIGUNUSEDPARM +# ifdef __cplusplus +# define SWIGUNUSEDPARM(p) +# else +# define SWIGUNUSEDPARM(p) p SWIGUNUSED +# endif +#endif + +/* internal SWIG method */ +#ifndef SWIGINTERN +# define SWIGINTERN static SWIGUNUSED +#endif + +/* internal inline SWIG method */ +#ifndef SWIGINTERNINLINE +# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE +#endif + +/* exporting methods */ +#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) +# ifndef GCC_HASCLASSVISIBILITY +# define GCC_HASCLASSVISIBILITY +# endif +#endif + +#ifndef SWIGEXPORT +# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# if defined(STATIC_LINKED) +# define SWIGEXPORT +# else +# define SWIGEXPORT __declspec(dllexport) +# endif +# else +# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY) +# define SWIGEXPORT __attribute__ ((visibility("default"))) +# else +# define SWIGEXPORT +# endif +# endif +#endif + +/* calling conventions for Windows */ +#ifndef SWIGSTDCALL +# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# define SWIGSTDCALL __stdcall +# else +# define SWIGSTDCALL +# endif +#endif + +/* Deal with Microsoft's attempt at deprecating C standard runtime functions */ +#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE) +# define _CRT_SECURE_NO_DEPRECATE +#endif + +/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */ +#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE) +# define _SCL_SECURE_NO_DEPRECATE +#endif + + +/* ----------------------------------------------------------------------------- + * This section contains generic SWIG labels for method/variable + * declarations/attributes, and other compiler dependent labels. + * ----------------------------------------------------------------------------- */ + +/* template workaround for compilers that cannot correctly implement the C++ standard */ +#ifndef SWIGTEMPLATEDISAMBIGUATOR +# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560) +# define SWIGTEMPLATEDISAMBIGUATOR template +# elif defined(__HP_aCC) +/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */ +/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */ +# define SWIGTEMPLATEDISAMBIGUATOR template +# else +# define SWIGTEMPLATEDISAMBIGUATOR +# endif +#endif + +/* inline attribute */ +#ifndef SWIGINLINE +# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__)) +# define SWIGINLINE inline +# else +# define SWIGINLINE +# endif +#endif + +/* attribute recognised by some compilers to avoid 'unused' warnings */ +#ifndef SWIGUNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define SWIGUNUSED __attribute__ ((__unused__)) +# else +# define SWIGUNUSED +# endif +# elif defined(__ICC) +# define SWIGUNUSED __attribute__ ((__unused__)) +# else +# define SWIGUNUSED +# endif +#endif + +#ifndef SWIG_MSC_UNSUPPRESS_4505 +# if defined(_MSC_VER) +# pragma warning(disable : 4505) /* unreferenced local function has been removed */ +# endif +#endif + +#ifndef SWIGUNUSEDPARM +# ifdef __cplusplus +# define SWIGUNUSEDPARM(p) +# else +# define SWIGUNUSEDPARM(p) p SWIGUNUSED +# endif +#endif + +/* internal SWIG method */ +#ifndef SWIGINTERN +# define SWIGINTERN static SWIGUNUSED +#endif + +/* internal inline SWIG method */ +#ifndef SWIGINTERNINLINE +# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE +#endif + +/* exporting methods */ +#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) +# ifndef GCC_HASCLASSVISIBILITY +# define GCC_HASCLASSVISIBILITY +# endif +#endif + +#ifndef SWIGEXPORT +# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# if defined(STATIC_LINKED) +# define SWIGEXPORT +# else +# define SWIGEXPORT __declspec(dllexport) +# endif +# else +# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY) +# define SWIGEXPORT __attribute__ ((visibility("default"))) +# else +# define SWIGEXPORT +# endif +# endif +#endif + +/* calling conventions for Windows */ +#ifndef SWIGSTDCALL +# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# define SWIGSTDCALL __stdcall +# else +# define SWIGSTDCALL +# endif +#endif + +/* Deal with Microsoft's attempt at deprecating C standard runtime functions */ +#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE) +# define _CRT_SECURE_NO_DEPRECATE +#endif + +/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */ +#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE) +# define _SCL_SECURE_NO_DEPRECATE +#endif + + +/* ----------------------------------------------------------------------------- + * swigrun.swg + * + * This file contains generic C API SWIG runtime support for pointer + * type checking. + * ----------------------------------------------------------------------------- */ + +/* This should only be incremented when either the layout of swig_type_info changes, + or for whatever reason, the runtime changes incompatibly */ +#define SWIG_RUNTIME_VERSION "4" + +/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */ +#ifdef SWIG_TYPE_TABLE +# define SWIG_QUOTE_STRING(x) #x +# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x) +# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE) +#else +# define SWIG_TYPE_TABLE_NAME +#endif + +/* + You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for + creating a static or dynamic library from the SWIG runtime code. + In 99.9% of the cases, SWIG just needs to declare them as 'static'. + + But only do this if strictly necessary, ie, if you have problems + with your compiler or suchlike. +*/ + +#ifndef SWIGRUNTIME +# define SWIGRUNTIME SWIGINTERN +#endif + +#ifndef SWIGRUNTIMEINLINE +# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE +#endif + +/* Generic buffer size */ +#ifndef SWIG_BUFFER_SIZE +# define SWIG_BUFFER_SIZE 1024 +#endif + +/* Flags for pointer conversions */ +#define SWIG_POINTER_DISOWN 0x1 +#define SWIG_CAST_NEW_MEMORY 0x2 + +/* Flags for new pointer objects */ +#define SWIG_POINTER_OWN 0x1 + + +/* + Flags/methods for returning states. + + The SWIG conversion methods, as ConvertPtr, return and integer + that tells if the conversion was successful or not. And if not, + an error code can be returned (see swigerrors.swg for the codes). + + Use the following macros/flags to set or process the returning + states. + + In old versions of SWIG, code such as the following was usually written: + + if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) { + // success code + } else { + //fail code + } + + Now you can be more explicit: + + int res = SWIG_ConvertPtr(obj,vptr,ty.flags); + if (SWIG_IsOK(res)) { + // success code + } else { + // fail code + } + + which is the same really, but now you can also do + + Type *ptr; + int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags); + if (SWIG_IsOK(res)) { + // success code + if (SWIG_IsNewObj(res) { + ... + delete *ptr; + } else { + ... + } + } else { + // fail code + } + + I.e., now SWIG_ConvertPtr can return new objects and you can + identify the case and take care of the deallocation. Of course that + also requires SWIG_ConvertPtr to return new result values, such as + + int SWIG_ConvertPtr(obj, ptr,...) { + if () { + if () { + *ptr = ; + return SWIG_NEWOBJ; + } else { + *ptr = ; + return SWIG_OLDOBJ; + } + } else { + return SWIG_BADOBJ; + } + } + + Of course, returning the plain '0(success)/-1(fail)' still works, but you can be + more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the + SWIG errors code. + + Finally, if the SWIG_CASTRANK_MODE is enabled, the result code + allows to return the 'cast rank', for example, if you have this + + int food(double) + int fooi(int); + + and you call + + food(1) // cast rank '1' (1 -> 1.0) + fooi(1) // cast rank '0' + + just use the SWIG_AddCast()/SWIG_CheckState() +*/ + +#define SWIG_OK (0) +#define SWIG_ERROR (-1) +#define SWIG_IsOK(r) (r >= 0) +#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError) + +/* The CastRankLimit says how many bits are used for the cast rank */ +#define SWIG_CASTRANKLIMIT (1 << 8) +/* The NewMask denotes the object was created (using new/malloc) */ +#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1) +/* The TmpMask is for in/out typemaps that use temporal objects */ +#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1) +/* Simple returning values */ +#define SWIG_BADOBJ (SWIG_ERROR) +#define SWIG_OLDOBJ (SWIG_OK) +#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK) +#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK) +/* Check, add and del mask methods */ +#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r) +#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r) +#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK)) +#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r) +#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r) +#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK)) + +/* Cast-Rank Mode */ +#if defined(SWIG_CASTRANK_MODE) +# ifndef SWIG_TypeRank +# define SWIG_TypeRank unsigned long +# endif +# ifndef SWIG_MAXCASTRANK /* Default cast allowed */ +# define SWIG_MAXCASTRANK (2) +# endif +# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1) +# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK) +SWIGINTERNINLINE int SWIG_AddCast(int r) { + return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r; +} +SWIGINTERNINLINE int SWIG_CheckState(int r) { + return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0; +} +#else /* no cast-rank mode */ +# define SWIG_AddCast +# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0) +#endif + + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef void *(*swig_converter_func)(void *, int *); +typedef struct swig_type_info *(*swig_dycast_func)(void **); + +/* Structure to store information on one type */ +typedef struct swig_type_info { + const char *name; /* mangled name of this type */ + const char *str; /* human readable name of this type */ + swig_dycast_func dcast; /* dynamic cast function down a hierarchy */ + struct swig_cast_info *cast; /* linked list of types that can cast into this type */ + void *clientdata; /* language specific type data */ + int owndata; /* flag if the structure owns the clientdata */ +} swig_type_info; + +/* Structure to store a type and conversion function used for casting */ +typedef struct swig_cast_info { + swig_type_info *type; /* pointer to type that is equivalent to this type */ + swig_converter_func converter; /* function to cast the void pointers */ + struct swig_cast_info *next; /* pointer to next cast in linked list */ + struct swig_cast_info *prev; /* pointer to the previous cast */ +} swig_cast_info; + +/* Structure used to store module information + * Each module generates one structure like this, and the runtime collects + * all of these structures and stores them in a circularly linked list.*/ +typedef struct swig_module_info { + swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */ + size_t size; /* Number of types in this module */ + struct swig_module_info *next; /* Pointer to next element in circularly linked list */ + swig_type_info **type_initial; /* Array of initially generated type structures */ + swig_cast_info **cast_initial; /* Array of initially generated casting structures */ + void *clientdata; /* Language specific module data */ +} swig_module_info; + +/* + Compare two type names skipping the space characters, therefore + "char*" == "char *" and "Class" == "Class", etc. + + Return 0 when the two name types are equivalent, as in + strncmp, but skipping ' '. +*/ +SWIGRUNTIME int +SWIG_TypeNameComp(const char *f1, const char *l1, + const char *f2, const char *l2) { + for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) { + while ((*f1 == ' ') && (f1 != l1)) ++f1; + while ((*f2 == ' ') && (f2 != l2)) ++f2; + if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1; + } + return (int)((l1 - f1) - (l2 - f2)); +} + +/* + Check type equivalence in a name list like ||... + Return 0 if not equal, 1 if equal +*/ +SWIGRUNTIME int +SWIG_TypeEquiv(const char *nb, const char *tb) { + int equiv = 0; + const char* te = tb + strlen(tb); + const char* ne = nb; + while (!equiv && *ne) { + for (nb = ne; *ne; ++ne) { + if (*ne == '|') break; + } + equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0; + if (*ne) ++ne; + } + return equiv; +} + +/* + Check type equivalence in a name list like ||... + Return 0 if equal, -1 if nb < tb, 1 if nb > tb +*/ +SWIGRUNTIME int +SWIG_TypeCompare(const char *nb, const char *tb) { + int equiv = 0; + const char* te = tb + strlen(tb); + const char* ne = nb; + while (!equiv && *ne) { + for (nb = ne; *ne; ++ne) { + if (*ne == '|') break; + } + equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0; + if (*ne) ++ne; + } + return equiv; +} + + +/* + Check the typename +*/ +SWIGRUNTIME swig_cast_info * +SWIG_TypeCheck(const char *c, swig_type_info *ty) { + if (ty) { + swig_cast_info *iter = ty->cast; + while (iter) { + if (strcmp(iter->type->name, c) == 0) { + if (iter == ty->cast) + return iter; + /* Move iter to the top of the linked list */ + iter->prev->next = iter->next; + if (iter->next) + iter->next->prev = iter->prev; + iter->next = ty->cast; + iter->prev = 0; + if (ty->cast) ty->cast->prev = iter; + ty->cast = iter; + return iter; + } + iter = iter->next; + } + } + return 0; +} + +/* + Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison +*/ +SWIGRUNTIME swig_cast_info * +SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) { + if (ty) { + swig_cast_info *iter = ty->cast; + while (iter) { + if (iter->type == from) { + if (iter == ty->cast) + return iter; + /* Move iter to the top of the linked list */ + iter->prev->next = iter->next; + if (iter->next) + iter->next->prev = iter->prev; + iter->next = ty->cast; + iter->prev = 0; + if (ty->cast) ty->cast->prev = iter; + ty->cast = iter; + return iter; + } + iter = iter->next; + } + } + return 0; +} + +/* + Cast a pointer up an inheritance hierarchy +*/ +SWIGRUNTIMEINLINE void * +SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) { + return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory); +} + +/* + Dynamic pointer casting. Down an inheritance hierarchy +*/ +SWIGRUNTIME swig_type_info * +SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) { + swig_type_info *lastty = ty; + if (!ty || !ty->dcast) return ty; + while (ty && (ty->dcast)) { + ty = (*ty->dcast)(ptr); + if (ty) lastty = ty; + } + return lastty; +} + +/* + Return the name associated with this type +*/ +SWIGRUNTIMEINLINE const char * +SWIG_TypeName(const swig_type_info *ty) { + return ty->name; +} + +/* + Return the pretty name associated with this type, + that is an unmangled type name in a form presentable to the user. +*/ +SWIGRUNTIME const char * +SWIG_TypePrettyName(const swig_type_info *type) { + /* The "str" field contains the equivalent pretty names of the + type, separated by vertical-bar characters. We choose + to print the last name, as it is often (?) the most + specific. */ + if (!type) return NULL; + if (type->str != NULL) { + const char *last_name = type->str; + const char *s; + for (s = type->str; *s; s++) + if (*s == '|') last_name = s+1; + return last_name; + } + else + return type->name; +} + +/* + Set the clientdata field for a type +*/ +SWIGRUNTIME void +SWIG_TypeClientData(swig_type_info *ti, void *clientdata) { + swig_cast_info *cast = ti->cast; + /* if (ti->clientdata == clientdata) return; */ + ti->clientdata = clientdata; + + while (cast) { + if (!cast->converter) { + swig_type_info *tc = cast->type; + if (!tc->clientdata) { + SWIG_TypeClientData(tc, clientdata); + } + } + cast = cast->next; + } +} +SWIGRUNTIME void +SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) { + SWIG_TypeClientData(ti, clientdata); + ti->owndata = 1; +} + +/* + Search for a swig_type_info structure only by mangled name + Search is a O(log #types) + + We start searching at module start, and finish searching when start == end. + Note: if start == end at the beginning of the function, we go all the way around + the circular list. +*/ +SWIGRUNTIME swig_type_info * +SWIG_MangledTypeQueryModule(swig_module_info *start, + swig_module_info *end, + const char *name) { + swig_module_info *iter = start; + do { + if (iter->size) { + register size_t l = 0; + register size_t r = iter->size - 1; + do { + /* since l+r >= 0, we can (>> 1) instead (/ 2) */ + register size_t i = (l + r) >> 1; + const char *iname = iter->types[i]->name; + if (iname) { + register int compare = strcmp(name, iname); + if (compare == 0) { + return iter->types[i]; + } else if (compare < 0) { + if (i) { + r = i - 1; + } else { + break; + } + } else if (compare > 0) { + l = i + 1; + } + } else { + break; /* should never happen */ + } + } while (l <= r); + } + iter = iter->next; + } while (iter != end); + return 0; +} + +/* + Search for a swig_type_info structure for either a mangled name or a human readable name. + It first searches the mangled names of the types, which is a O(log #types) + If a type is not found it then searches the human readable names, which is O(#types). + + We start searching at module start, and finish searching when start == end. + Note: if start == end at the beginning of the function, we go all the way around + the circular list. +*/ +SWIGRUNTIME swig_type_info * +SWIG_TypeQueryModule(swig_module_info *start, + swig_module_info *end, + const char *name) { + /* STEP 1: Search the name field using binary search */ + swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name); + if (ret) { + return ret; + } else { + /* STEP 2: If the type hasn't been found, do a complete search + of the str field (the human readable name) */ + swig_module_info *iter = start; + do { + register size_t i = 0; + for (; i < iter->size; ++i) { + if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name))) + return iter->types[i]; + } + iter = iter->next; + } while (iter != end); + } + + /* neither found a match */ + return 0; +} + +/* + Pack binary data into a string +*/ +SWIGRUNTIME char * +SWIG_PackData(char *c, void *ptr, size_t sz) { + static const char hex[17] = "0123456789abcdef"; + register const unsigned char *u = (unsigned char *) ptr; + register const unsigned char *eu = u + sz; + for (; u != eu; ++u) { + register unsigned char uu = *u; + *(c++) = hex[(uu & 0xf0) >> 4]; + *(c++) = hex[uu & 0xf]; + } + return c; +} + +/* + Unpack binary data from a string +*/ +SWIGRUNTIME const char * +SWIG_UnpackData(const char *c, void *ptr, size_t sz) { + register unsigned char *u = (unsigned char *) ptr; + register const unsigned char *eu = u + sz; + for (; u != eu; ++u) { + register char d = *(c++); + register unsigned char uu; + if ((d >= '0') && (d <= '9')) + uu = ((d - '0') << 4); + else if ((d >= 'a') && (d <= 'f')) + uu = ((d - ('a'-10)) << 4); + else + return (char *) 0; + d = *(c++); + if ((d >= '0') && (d <= '9')) + uu |= (d - '0'); + else if ((d >= 'a') && (d <= 'f')) + uu |= (d - ('a'-10)); + else + return (char *) 0; + *u = uu; + } + return c; +} + +/* + Pack 'void *' into a string buffer. +*/ +SWIGRUNTIME char * +SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) { + char *r = buff; + if ((2*sizeof(void *) + 2) > bsz) return 0; + *(r++) = '_'; + r = SWIG_PackData(r,&ptr,sizeof(void *)); + if (strlen(name) + 1 > (bsz - (r - buff))) return 0; + strcpy(r,name); + return buff; +} + +SWIGRUNTIME const char * +SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) { + if (*c != '_') { + if (strcmp(c,"NULL") == 0) { + *ptr = (void *) 0; + return name; + } else { + return 0; + } + } + return SWIG_UnpackData(++c,ptr,sizeof(void *)); +} + +SWIGRUNTIME char * +SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) { + char *r = buff; + size_t lname = (name ? strlen(name) : 0); + if ((2*sz + 2 + lname) > bsz) return 0; + *(r++) = '_'; + r = SWIG_PackData(r,ptr,sz); + if (lname) { + strncpy(r,name,lname+1); + } else { + *r = 0; + } + return buff; +} + +SWIGRUNTIME const char * +SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) { + if (*c != '_') { + if (strcmp(c,"NULL") == 0) { + memset(ptr,0,sz); + return name; + } else { + return 0; + } + } + return SWIG_UnpackData(++c,ptr,sz); +} + +#ifdef __cplusplus +} +#endif + +/* Errors in SWIG */ +#define SWIG_UnknownError -1 +#define SWIG_IOError -2 +#define SWIG_RuntimeError -3 +#define SWIG_IndexError -4 +#define SWIG_TypeError -5 +#define SWIG_DivisionByZero -6 +#define SWIG_OverflowError -7 +#define SWIG_SyntaxError -8 +#define SWIG_ValueError -9 +#define SWIG_SystemError -10 +#define SWIG_AttributeError -11 +#define SWIG_MemoryError -12 +#define SWIG_NullReferenceError -13 + + + +#include + +/* Remove global macros defined in Ruby's win32.h */ +#ifdef write +# undef write +#endif +#ifdef read +# undef read +#endif +#ifdef bind +# undef bind +#endif + + +/* Ruby 1.7 defines NUM2LL(), LL2NUM() and ULL2NUM() macros */ +#ifndef NUM2LL +#define NUM2LL(x) NUM2LONG((x)) +#endif +#ifndef LL2NUM +#define LL2NUM(x) INT2NUM((long) (x)) +#endif +#ifndef ULL2NUM +#define ULL2NUM(x) UINT2NUM((unsigned long) (x)) +#endif + +/* Ruby 1.7 doesn't (yet) define NUM2ULL() */ +#ifndef NUM2ULL +#ifdef HAVE_LONG_LONG +#define NUM2ULL(x) rb_num2ull((x)) +#else +#define NUM2ULL(x) NUM2ULONG(x) +#endif +#endif + +/* RSTRING_LEN, etc are new in Ruby 1.9, but ->ptr and ->len no longer work */ +/* Define these for older versions so we can just write code the new way */ +#ifndef RSTRING_LEN +# define RSTRING_LEN(x) RSTRING(x)->len +#endif +#ifndef RSTRING_PTR +# define RSTRING_PTR(x) RSTRING(x)->ptr +#endif +#ifndef RSTRING_END +# define RSTRING_END(x) (RSTRING_PTR(x) + RSTRING_LEN(x)) +#endif +#ifndef RARRAY_LEN +# define RARRAY_LEN(x) RARRAY(x)->len +#endif +#ifndef RARRAY_PTR +# define RARRAY_PTR(x) RARRAY(x)->ptr +#endif +#ifndef RFLOAT_VALUE +# define RFLOAT_VALUE(x) RFLOAT(x)->value +#endif +#ifndef DOUBLE2NUM +# define DOUBLE2NUM(x) rb_float_new(x) +#endif +#ifndef RHASH_TBL +# define RHASH_TBL(x) (RHASH(x)->tbl) +#endif +#ifndef RHASH_ITER_LEV +# define RHASH_ITER_LEV(x) (RHASH(x)->iter_lev) +#endif +#ifndef RHASH_IFNONE +# define RHASH_IFNONE(x) (RHASH(x)->ifnone) +#endif +#ifndef RHASH_SIZE +# define RHASH_SIZE(x) (RHASH(x)->tbl->num_entries) +#endif +#ifndef RHASH_EMPTY_P +# define RHASH_EMPTY_P(x) (RHASH_SIZE(x) == 0) +#endif +#ifndef RSTRUCT_LEN +# define RSTRUCT_LEN(x) RSTRUCT(x)->len +#endif +#ifndef RSTRUCT_PTR +# define RSTRUCT_PTR(x) RSTRUCT(x)->ptr +#endif + + + +/* + * Need to be very careful about how these macros are defined, especially + * when compiling C++ code or C code with an ANSI C compiler. + * + * VALUEFUNC(f) is a macro used to typecast a C function that implements + * a Ruby method so that it can be passed as an argument to API functions + * like rb_define_method() and rb_define_singleton_method(). + * + * VOIDFUNC(f) is a macro used to typecast a C function that implements + * either the "mark" or "free" stuff for a Ruby Data object, so that it + * can be passed as an argument to API functions like Data_Wrap_Struct() + * and Data_Make_Struct(). + */ + +#ifdef __cplusplus +# ifndef RUBY_METHOD_FUNC /* These definitions should work for Ruby 1.4.6 */ +# define PROTECTFUNC(f) ((VALUE (*)()) f) +# define VALUEFUNC(f) ((VALUE (*)()) f) +# define VOIDFUNC(f) ((void (*)()) f) +# else +# ifndef ANYARGS /* These definitions should work for Ruby 1.6 */ +# define PROTECTFUNC(f) ((VALUE (*)()) f) +# define VALUEFUNC(f) ((VALUE (*)()) f) +# define VOIDFUNC(f) ((RUBY_DATA_FUNC) f) +# else /* These definitions should work for Ruby 1.7+ */ +# define PROTECTFUNC(f) ((VALUE (*)(VALUE)) f) +# define VALUEFUNC(f) ((VALUE (*)(ANYARGS)) f) +# define VOIDFUNC(f) ((RUBY_DATA_FUNC) f) +# endif +# endif +#else +# define VALUEFUNC(f) (f) +# define VOIDFUNC(f) (f) +#endif + +/* Don't use for expressions have side effect */ +#ifndef RB_STRING_VALUE +#define RB_STRING_VALUE(s) (TYPE(s) == T_STRING ? (s) : (*(volatile VALUE *)&(s) = rb_str_to_str(s))) +#endif +#ifndef StringValue +#define StringValue(s) RB_STRING_VALUE(s) +#endif +#ifndef StringValuePtr +#define StringValuePtr(s) RSTRING_PTR(RB_STRING_VALUE(s)) +#endif +#ifndef StringValueLen +#define StringValueLen(s) RSTRING_LEN(RB_STRING_VALUE(s)) +#endif +#ifndef SafeStringValue +#define SafeStringValue(v) do {\ + StringValue(v);\ + rb_check_safe_str(v);\ +} while (0) +#endif + +#ifndef HAVE_RB_DEFINE_ALLOC_FUNC +#define rb_define_alloc_func(klass, func) rb_define_singleton_method((klass), "new", VALUEFUNC((func)), -1) +#define rb_undef_alloc_func(klass) rb_undef_method(CLASS_OF((klass)), "new") +#endif + +static VALUE _mSWIG = Qnil; + +/* ----------------------------------------------------------------------------- + * error manipulation + * ----------------------------------------------------------------------------- */ + + +/* Define some additional error types */ +#define SWIG_ObjectPreviouslyDeletedError -100 + + +/* Define custom exceptions for errors that do not map to existing Ruby + exceptions. Note this only works for C++ since a global cannot be + initialized by a funtion in C. For C, fallback to rb_eRuntimeError.*/ + +SWIGINTERN VALUE +getNullReferenceError(void) { + static int init = 0; + static VALUE rb_eNullReferenceError ; + if (!init) { + init = 1; + rb_eNullReferenceError = rb_define_class("NullReferenceError", rb_eRuntimeError); + } + return rb_eNullReferenceError; +} + +SWIGINTERN VALUE +getObjectPreviouslyDeletedError(void) { + static int init = 0; + static VALUE rb_eObjectPreviouslyDeleted ; + if (!init) { + init = 1; + rb_eObjectPreviouslyDeleted = rb_define_class("ObjectPreviouslyDeleted", rb_eRuntimeError); + } + return rb_eObjectPreviouslyDeleted; +} + + +SWIGINTERN VALUE +SWIG_Ruby_ErrorType(int SWIG_code) { + VALUE type; + switch (SWIG_code) { + case SWIG_MemoryError: + type = rb_eNoMemError; + break; + case SWIG_IOError: + type = rb_eIOError; + break; + case SWIG_RuntimeError: + type = rb_eRuntimeError; + break; + case SWIG_IndexError: + type = rb_eIndexError; + break; + case SWIG_TypeError: + type = rb_eTypeError; + break; + case SWIG_DivisionByZero: + type = rb_eZeroDivError; + break; + case SWIG_OverflowError: + type = rb_eRangeError; + break; + case SWIG_SyntaxError: + type = rb_eSyntaxError; + break; + case SWIG_ValueError: + type = rb_eArgError; + break; + case SWIG_SystemError: + type = rb_eFatal; + break; + case SWIG_AttributeError: + type = rb_eRuntimeError; + break; + case SWIG_NullReferenceError: + type = getNullReferenceError(); + break; + case SWIG_ObjectPreviouslyDeletedError: + type = getObjectPreviouslyDeletedError(); + break; + case SWIG_UnknownError: + type = rb_eRuntimeError; + break; + default: + type = rb_eRuntimeError; + } + return type; +} + + +/* This function is called when a user inputs a wrong argument to + a method. + */ +SWIGINTERN +const char* Ruby_Format_TypeError( const char* msg, + const char* type, + const char* name, + const int argn, + VALUE input ) +{ + char buf[128]; + VALUE str; + VALUE asStr; + if ( msg && *msg ) + { + str = rb_str_new2(msg); + } + else + { + str = rb_str_new(NULL, 0); + } + + str = rb_str_cat2( str, "Expected argument " ); + sprintf( buf, "%d of type ", argn-1 ); + str = rb_str_cat2( str, buf ); + str = rb_str_cat2( str, type ); + str = rb_str_cat2( str, ", but got " ); + str = rb_str_cat2( str, rb_obj_classname(input) ); + str = rb_str_cat2( str, " " ); + asStr = rb_inspect(input); + if ( RSTRING_LEN(asStr) > 30 ) + { + str = rb_str_cat( str, StringValuePtr(asStr), 30 ); + str = rb_str_cat2( str, "..." ); + } + else + { + str = rb_str_append( str, asStr ); + } + + if ( name ) + { + str = rb_str_cat2( str, "\n\tin SWIG method '" ); + str = rb_str_cat2( str, name ); + str = rb_str_cat2( str, "'" ); + } + + return StringValuePtr( str ); +} + +/* This function is called when an overloaded method fails */ +SWIGINTERN +void Ruby_Format_OverloadedError( + const int argc, + const int maxargs, + const char* method, + const char* prototypes + ) +{ + const char* msg = "Wrong # of arguments"; + if ( argc <= maxargs ) msg = "Wrong arguments"; + rb_raise(rb_eArgError,"%s for overloaded method '%s'.\n" + "Possible C/C++ prototypes are:\n%s", + msg, method, prototypes); +} + +/* ----------------------------------------------------------------------------- + * See the LICENSE file for information on copyright, usage and redistribution + * of SWIG, and the README file for authors - http://www.swig.org/release.html. + * * rubytracking.swg * * This file contains support for tracking mappings from * Ruby objects to C++ objects. This functionality is needed * to implement mark functions for Ruby's mark and sweep * garbage collector. - ************************************************************************/ + * ----------------------------------------------------------------------------- */ + +#ifdef __cplusplus +extern "C" { +#endif + +/* Ruby 1.8 actually assumes the first case. */ +#if SIZEOF_VOIDP == SIZEOF_LONG +# define SWIG2NUM(v) LONG2NUM((unsigned long)v) +# define NUM2SWIG(x) (unsigned long)NUM2LONG(x) +#elif SIZEOF_VOIDP == SIZEOF_LONG_LONG +# define SWIG2NUM(v) LL2NUM((unsigned long long)v) +# define NUM2SWIG(x) (unsigned long long)NUM2LL(x) +#else +# error sizeof(void*) is not the same as long or long long +#endif + /* Global Ruby hash table to store Trackings from C/C++ - structs to Ruby Objects. */ -static VALUE swig_ruby_trackings; + structs to Ruby Objects. +*/ +static VALUE swig_ruby_trackings = Qnil; + +/* Global variable that stores a reference to the ruby + hash table delete function. */ +static ID swig_ruby_hash_delete; /* Setup a Ruby hash table to store Trackings */ -static void SWIG_RubyInitializeTrackings() { - /* Create a ruby hash table to store Trackings from C++ - objects to Ruby objects. Also make sure to tell - the garabage collector about the hash table. */ - swig_ruby_trackings = rb_hash_new(); - rb_gc_register_address(&swig_ruby_trackings); +SWIGRUNTIME void SWIG_RubyInitializeTrackings(void) { + /* Create a ruby hash table to store Trackings from C++ + objects to Ruby objects. */ + + /* Try to see if some other .so has already created a + tracking hash table, which we keep hidden in an instance var + in the SWIG module. + This is done to allow multiple DSOs to share the same + tracking table. + */ + ID trackings_id = rb_intern( "@__trackings__" ); + VALUE verbose = rb_gv_get("VERBOSE"); + rb_gv_set("VERBOSE", Qfalse); + swig_ruby_trackings = rb_ivar_get( _mSWIG, trackings_id ); + rb_gv_set("VERBOSE", verbose); + + /* No, it hasn't. Create one ourselves */ + if ( swig_ruby_trackings == Qnil ) + { + swig_ruby_trackings = rb_hash_new(); + rb_ivar_set( _mSWIG, trackings_id, swig_ruby_trackings ); + } + + /* Now store a reference to the hash table delete function + so that we only have to look it up once.*/ + swig_ruby_hash_delete = rb_intern("delete"); } /* Get a Ruby number to reference a pointer */ -static VALUE SWIG_RubyPtrToReference(void* ptr) { - /* We cast the pointer to an unsigned long - and then store a reference to it using - a Ruby number object. */ +SWIGRUNTIME VALUE SWIG_RubyPtrToReference(void* ptr) { + /* We cast the pointer to an unsigned long + and then store a reference to it using + a Ruby number object. */ - /* Convert the pointer to a Ruby number */ - unsigned long value = (unsigned long) ptr; - return LONG2NUM(value); + /* Convert the pointer to a Ruby number */ + return SWIG2NUM(ptr); } /* Get a Ruby number to reference an object */ -static VALUE SWIG_RubyObjectToReference(VALUE object) { - /* We cast the object to an unsigned long - and then store a reference to it using - a Ruby number object. */ +SWIGRUNTIME VALUE SWIG_RubyObjectToReference(VALUE object) { + /* We cast the object to an unsigned long + and then store a reference to it using + a Ruby number object. */ - /* Convert the Object to a Ruby number */ - unsigned long value = (unsigned long) object; - return LONG2NUM(value); + /* Convert the Object to a Ruby number */ + return SWIG2NUM(object); } /* Get a Ruby object from a previously stored reference */ -static VALUE SWIG_RubyReferenceToObject(VALUE reference) { - /* The provided Ruby number object is a reference - to the Ruby object we want.*/ +SWIGRUNTIME VALUE SWIG_RubyReferenceToObject(VALUE reference) { + /* The provided Ruby number object is a reference + to the Ruby object we want.*/ - /* First convert the Ruby number to a C number */ - unsigned long value = NUM2LONG(reference); - return (VALUE) value; + /* Convert the Ruby number to a Ruby object */ + return NUM2SWIG(reference); } /* Add a Tracking from a C/C++ struct to a Ruby object */ -static void SWIG_RubyAddTracking(void* ptr, VALUE object) { - /* In a Ruby hash table we store the pointer and - the associated Ruby object. The trick here is - that we cannot store the Ruby object directly - if - we do then it cannot be garbage collected. So - instead we typecast it as a unsigned long and - convert it to a Ruby number object.*/ +SWIGRUNTIME void SWIG_RubyAddTracking(void* ptr, VALUE object) { + /* In a Ruby hash table we store the pointer and + the associated Ruby object. The trick here is + that we cannot store the Ruby object directly - if + we do then it cannot be garbage collected. So + instead we typecast it as a unsigned long and + convert it to a Ruby number object.*/ - /* Get a reference to the pointer as a Ruby number */ - VALUE key = SWIG_RubyPtrToReference(ptr); + /* Get a reference to the pointer as a Ruby number */ + VALUE key = SWIG_RubyPtrToReference(ptr); - /* Get a reference to the Ruby object as a Ruby number */ - VALUE value = SWIG_RubyObjectToReference(object); + /* Get a reference to the Ruby object as a Ruby number */ + VALUE value = SWIG_RubyObjectToReference(object); /* Store the mapping to the global hash table. */ - rb_hash_aset(swig_ruby_trackings, key, value); + rb_hash_aset(swig_ruby_trackings, key, value); } /* Get the Ruby object that owns the specified C/C++ struct */ -static VALUE SWIG_RubyInstanceFor(void* ptr) { - /* Get a reference to the pointer as a Ruby number */ - VALUE key = SWIG_RubyPtrToReference(ptr); +SWIGRUNTIME VALUE SWIG_RubyInstanceFor(void* ptr) { + /* Get a reference to the pointer as a Ruby number */ + VALUE key = SWIG_RubyPtrToReference(ptr); - /* Now lookup the value stored in the global hash table */ - VALUE value = rb_hash_aref(swig_ruby_trackings, key); + /* Now lookup the value stored in the global hash table */ + VALUE value = rb_hash_aref(swig_ruby_trackings, key); - if (value == Qnil) { - /* No object exists - return nil. */ - return Qnil; - } - else { - /* Convert this value to Ruby object */ - return SWIG_RubyReferenceToObject(value); - } -} + if (value == Qnil) { + /* No object exists - return nil. */ + return Qnil; + } + else { + /* Convert this value to Ruby object */ + return SWIG_RubyReferenceToObject(value); + } +} -/* Remove a Tracking from a C/C++ struct to a Ruby object */ -static void SWIG_RubyRemoveTracking(void* ptr) { - /* Get a reference to the pointer as a Ruby number */ - VALUE key = SWIG_RubyPtrToReference(ptr); - - /* Define delete method - in C++ this could be marked as - static but unfortunately not in C. */ - VALUE delete_function = rb_intern("delete"); - - /* Delete the object from the hash table by calling Ruby's - do this we need to call the Hash.delete method.*/ - rb_funcall(swig_ruby_trackings, delete_function, 1, key); +/* Remove a Tracking from a C/C++ struct to a Ruby object. It + is very important to remove objects once they are destroyed + since the same memory address may be reused later to create + a new object. */ +SWIGRUNTIME void SWIG_RubyRemoveTracking(void* ptr) { + /* Get a reference to the pointer as a Ruby number */ + VALUE key = SWIG_RubyPtrToReference(ptr); + + /* Delete the object from the hash table by calling Ruby's + do this we need to call the Hash.delete method.*/ + rb_funcall(swig_ruby_trackings, swig_ruby_hash_delete, 1, key); } /* This is a helper method that unlinks a Ruby object from its underlying C++ object. This is needed if the lifetime of the Ruby object is longer than the C++ object */ -static void SWIG_RubyUnlinkObjects(void* ptr) { - VALUE object = SWIG_RubyInstanceFor(ptr); +SWIGRUNTIME void SWIG_RubyUnlinkObjects(void* ptr) { + VALUE object = SWIG_RubyInstanceFor(ptr); - if (object != Qnil) { - DATA_PTR(object) = 0; - } + if (object != Qnil) { + DATA_PTR(object) = 0; + } } - -/* Common SWIG API */ -#define SWIG_ConvertPtr(obj, pp, type, flags) \ - SWIG_Ruby_ConvertPtr(obj, pp, type, flags) -#define SWIG_NewPointerObj(p, type, flags) \ - SWIG_Ruby_NewPointerObj(p, type, flags) -#define SWIG_MustGetPtr(p, type, argnum, flags) \ - SWIG_Ruby_MustGetPtr(p, type, argnum, flags) -#define SWIG_GetModule(clientdata) \ - SWIG_Ruby_GetModule() -#define SWIG_SetModule(clientdata, pointer) \ - SWIG_Ruby_SetModule(pointer) - -/* Ruby-specific SWIG API */ - -#define SWIG_InitRuntime() \ - SWIG_Ruby_InitRuntime() -#define SWIG_define_class(ty) \ - SWIG_Ruby_define_class(ty) -#define SWIG_NewClassInstance(value, ty) \ - SWIG_Ruby_NewClassInstance(value, ty) -#define SWIG_MangleStr(value) \ - SWIG_Ruby_MangleStr(value) -#define SWIG_CheckConvert(value, ty) \ - SWIG_Ruby_CheckConvert(value, ty) -#define SWIG_NewPackedObj(ptr, sz, ty) \ - SWIG_Ruby_NewPackedObj(ptr, sz, ty) -#define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) \ - SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty, flags) - -/* rubydef.swg */ -#ifdef __cplusplus -extern "C" { -#endif - -static VALUE _mSWIG = Qnil; -static VALUE _cSWIG_Pointer = Qnil; -static VALUE swig_runtime_data_type_pointer = Qnil; - -/* Initialize Ruby runtime support */ -static void -SWIG_Ruby_InitRuntime(void) -{ - if (_mSWIG == Qnil) { - _mSWIG = rb_define_module("SWIG"); - } -} - -/* Define Ruby class for C type */ -static void -SWIG_Ruby_define_class(swig_type_info *type) -{ - VALUE klass; - char *klass_name = (char *) malloc(4 + strlen(type->name) + 1); - sprintf(klass_name, "TYPE%s", type->name); - if (NIL_P(_cSWIG_Pointer)) { - _cSWIG_Pointer = rb_define_class_under(_mSWIG, "Pointer", rb_cObject); - rb_undef_method(CLASS_OF(_cSWIG_Pointer), "new"); - } - klass = rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer); - free((void *) klass_name); -} - -/* Create a new pointer object */ -static VALUE -SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags) -{ - int own = flags & SWIG_POINTER_OWN; - int track = flags & SWIG_TRACK_OBJECTS; - - char *klass_name; - swig_class *sklass; - VALUE klass; - VALUE obj; - - if (!ptr) - return Qnil; - - /* Have we already wrapped this pointer? */ - if (track) { - obj = SWIG_RubyInstanceFor(ptr); - if (obj != Qnil) { - return obj; - } - } - - if (type->clientdata) { - sklass = (swig_class *) type->clientdata; - obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark), (own ? VOIDFUNC(sklass->destroy) : 0), ptr); - } else { - klass_name = (char *) malloc(4 + strlen(type->name) + 1); - sprintf(klass_name, "TYPE%s", type->name); - klass = rb_const_get(_mSWIG, rb_intern(klass_name)); - free((void *) klass_name); - obj = Data_Wrap_Struct(klass, 0, 0, ptr); - } - rb_iv_set(obj, "__swigtype__", rb_str_new2(type->name)); - - /* Keep track of this object if necessary */ - if (track) { - SWIG_RubyAddTracking(ptr, obj); - } - - return obj; -} - -/* Create a new class instance (always owned) */ -static VALUE -SWIG_Ruby_NewClassInstance(VALUE klass, swig_type_info *type) -{ - VALUE obj; - swig_class *sklass = (swig_class *) type->clientdata; - obj = Data_Wrap_Struct(klass, VOIDFUNC(sklass->mark), VOIDFUNC(sklass->destroy), 0); - rb_iv_set(obj, "__swigtype__", rb_str_new2(type->name)); - return obj; -} - -/* Get type mangle from class name */ -static SWIGINLINE char * -SWIG_Ruby_MangleStr(VALUE obj) -{ - VALUE stype = rb_iv_get(obj, "__swigtype__"); - return StringValuePtr(stype); -} - -/* Convert a pointer value */ -static int -SWIG_Ruby_ConvertPtr(VALUE obj, void **ptr, swig_type_info *ty, int flags) -{ - char *c; - swig_cast_info *tc; - - /* Grab the pointer */ - if (NIL_P(obj)) { - *ptr = 0; - return 0; - } else { - Data_Get_Struct(obj, void, *ptr); - } - - /* Check to see if the input object is giving up ownership - of the underlying C struct or C++ object. If so then we - need to reset the destructor since the Ruby object no - longer owns the underlying C++ object.*/ - if (flags & SWIG_POINTER_DISOWN) { - if (flags & SWIG_TRACK_OBJECTS) { - /* We are tracking objects. Thus we change the destructor - * to SWIG_RubyRemoveTracking. This allows us to - * remove the mapping from the C++ to Ruby object - * when the Ruby object is garbage collected. If we don't - * do this, then it is possible we will return a reference - * to a Ruby object that no longer exists thereby crashing Ruby. */ - RDATA(obj)->dfree = SWIG_RubyRemoveTracking; - } else { - RDATA(obj)->dfree = 0; - } - } - - /* Do type-checking if type info was provided */ - if (ty) { - if (ty->clientdata) { - if (rb_obj_is_kind_of(obj, ((swig_class *) (ty->clientdata))->klass)) { - if (*ptr == 0) - rb_raise(rb_eRuntimeError, "This %s already released", ty->str); - return 0; - } - } - if ((c = SWIG_MangleStr(obj)) == NULL) { - if (flags & SWIG_POINTER_EXCEPTION) - rb_raise(rb_eTypeError, "Expected %s", ty->str); - else - return -1; - } - tc = SWIG_TypeCheck(c, ty); - if (!tc) { - if (flags & SWIG_POINTER_EXCEPTION) - rb_raise(rb_eTypeError, "Expected %s", ty->str); - else - return -1; - } - *ptr = SWIG_TypeCast(tc, *ptr); - } - return 0; -} - -/* Convert a pointer value, signal an exception on a type mismatch */ -static SWIGINLINE void * -SWIG_Ruby_MustGetPtr(VALUE obj, swig_type_info *ty, int argnum, int flags) -{ - void *result; - SWIG_ConvertPtr(obj, &result, ty, flags | SWIG_POINTER_EXCEPTION); - return result; -} - -/* Check convert */ -static SWIGINLINE int -SWIG_Ruby_CheckConvert(VALUE obj, swig_type_info *ty) -{ - char *c = SWIG_MangleStr(obj); - if (!c) - return 0; - return SWIG_TypeCheck(c,ty) != 0; -} - -static VALUE -SWIG_Ruby_NewPackedObj(void *ptr, int sz, swig_type_info *type) { - char result[1024]; - char *r = result; - if ((2*sz + 1 + strlen(type->name)) > 1000) return 0; - *(r++) = '_'; - r = SWIG_PackData(r, ptr, sz); - strcpy(r, type->name); - return rb_str_new2(result); -} - -/* Convert a packed value value */ -static void -SWIG_Ruby_ConvertPacked(VALUE obj, void *ptr, int sz, swig_type_info *ty, int flags) { - swig_cast_info *tc; - const char *c; - - if (TYPE(obj) != T_STRING) goto type_error; - c = StringValuePtr(obj); - /* Pointer values must start with leading underscore */ - if (*c != '_') goto type_error; - c++; - c = SWIG_UnpackData(c, ptr, sz); - if (ty) { - tc = SWIG_TypeCheck(c, ty); - if (!tc) goto type_error; - } - return; - -type_error: - - if (flags) { - if (ty) { - rb_raise(rb_eTypeError, "Type error. Expected %s", ty->name); - } else { - rb_raise(rb_eTypeError, "Expected a pointer"); - } - } -} - -static swig_module_info *SWIG_Ruby_GetModule() { - VALUE pointer; - swig_module_info *ret = 0; - - /* first check if pointer already created */ - pointer = rb_gv_get("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME); - if (pointer != Qnil) { - Data_Get_Struct(pointer, swig_module_info, ret); - } - return ret; -} - -static void SWIG_Ruby_SetModule(swig_module_info *pointer) { - /* register a new class */ - VALUE cl = rb_define_class("swig_runtime_data", rb_cObject); - /* create and store the structure pointer to a global variable */ - swig_runtime_data_type_pointer = Data_Wrap_Struct(cl, 0, 0, pointer); - rb_define_readonly_variable("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, &swig_runtime_data_type_pointer); -} - -#ifdef __cplusplus -} -#endif - - - -/* -------- TYPES TABLE (BEGIN) -------- */ - -#define SWIGTYPE_p_CallbackData swig_types[0] -#define SWIGTYPE_p_f_p_sqlite3_context__void swig_types[1] -#define SWIGTYPE_p_f_p_sqlite3_context_int_p_p_sqlite3_value__void swig_types[2] -#define SWIGTYPE_p_f_p_void__void swig_types[3] -#define SWIGTYPE_p_f_p_void_int__int swig_types[4] -#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[5] -#define SWIGTYPE_p_f_p_void_p_q_const__char__void swig_types[6] -#define SWIGTYPE_p_p_char swig_types[7] -#define SWIGTYPE_p_p_sqlite3 swig_types[8] -#define SWIGTYPE_p_p_sqlite3_stmt swig_types[9] -#define SWIGTYPE_p_p_void swig_types[10] -#define SWIGTYPE_p_sqlite3 swig_types[11] -#define SWIGTYPE_p_sqlite3_context swig_types[12] -#define SWIGTYPE_p_sqlite3_stmt swig_types[13] -#define SWIGTYPE_p_sqlite3_value swig_types[14] -#define SWIGTYPE_p_sqlite_int64 swig_types[15] -#define SWIGTYPE_p_unsigned_long swig_types[16] -#define SWIGTYPE_p_void swig_types[17] -static swig_type_info *swig_types[19]; -static swig_module_info swig_module = {swig_types, 18, 0, 0, 0, 0}; -#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) -#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) - -/* -------- TYPES TABLE (END) -------- */ - -#define SWIG_init Init_API -#define SWIG_name "SQLite3::Driver::Native::API" - -static VALUE mAPI; - -static void SWIG_AsVal(VALUE obj, int *val) -{ - *val = (int) NUM2INT(obj); -} - - -#ifdef __cplusplus -extern "C" { -#endif -#ifdef HAVE_SYS_TIME_H -# include -struct timeval rb_time_timeval(VALUE); -#endif -#ifdef __cplusplus -} -#endif - - -#ifdef __cplusplus -extern "C" { -#endif -#include "rubyio.h" -#ifdef __cplusplus -} -#endif - - -#include -#include "ruby.h" - -#ifndef RSTRING_PTR -#define RSTRING_PTR(s) (RSTRING(s)->ptr) -#endif - -#ifndef RSTRING_LEN -#define RSTRING_LEN(s) (RSTRING(s)->len) -#endif - -#define Init_API Init_sqlite3_api - -struct CallbackData { - VALUE proc; - VALUE proc2; - VALUE data; -}; - -typedef struct CallbackData CallbackData; -typedef void RUBY_BLOB; -typedef void RUBY_VALBLOB; - -int Sqlite3_ruby_busy_handler(void* data,int value) { - VALUE result; - CallbackData *cb = (CallbackData*)data; - result = rb_funcall( - cb->proc, rb_intern("call"), 2, cb->data, INT2FIX(value) ); - return FIX2INT(result); -} - -static void mark_CallbackData(void* ptr) { - CallbackData* cb = (CallbackData*)ptr; - if (cb->proc != Qnil) - rb_gc_mark(cb->proc); - if (cb->proc2 != Qnil) - rb_gc_mark(cb->proc2); - if (cb->data != Qnil) - rb_gc_mark(cb->data); -} - -int Sqlite3_ruby_authorizer(void* data,int type, - const char* a,const char* b,const char* c,const char* d) -{ - VALUE result; - CallbackData *cb = (CallbackData*)data; - result = rb_funcall( - cb->proc, rb_intern("call"), 6, cb->data, INT2FIX(type), - ( a ? rb_str_new2(a) : Qnil ), ( b ? rb_str_new2(b) : Qnil ), - ( c ? rb_str_new2(c) : Qnil ), ( d ? rb_str_new2(d) : Qnil ) ); - return FIX2INT(result); -} - -void Sqlite3_ruby_trace(void* data, const char *sql) { - CallbackData *cb = (CallbackData*)data; - rb_funcall( cb->proc, rb_intern("call"), 2, cb->data, - sql ? rb_str_new2(sql) : Qnil ); -} - -void Sqlite3_ruby_function_step(sqlite3_context* ctx,int n, - sqlite3_value** args) -{ - CallbackData *data; - VALUE rb_args; - VALUE *rb_context; - int idx; - - data = (CallbackData*)sqlite3_user_data(ctx); - - if( data->proc2 != Qnil ) { - rb_context = (VALUE*)sqlite3_aggregate_context(ctx,sizeof(VALUE)); - if( *rb_context == 0 ) { - *rb_context = rb_hash_new(); - rb_gc_register_address( rb_context ); - } - } - - rb_args = rb_ary_new2(n+1); - rb_ary_push( rb_args, SWIG_NewPointerObj(ctx,SWIGTYPE_p_sqlite3_context,0) ); - for( idx = 0; idx < n; idx++ ) { - rb_ary_push( rb_args, SWIG_NewPointerObj(args[idx], - SWIGTYPE_p_sqlite3_value,0) ); - } - - rb_apply( data->proc, rb_intern("call"), rb_args ); -} - -void Sqlite3_ruby_function_final(sqlite3_context *ctx) { - VALUE *rb_context; - CallbackData *data; - - rb_context = (VALUE*)sqlite3_aggregate_context(ctx,sizeof(VALUE)); - if( *rb_context == 0 ) { - *rb_context = rb_hash_new(); - rb_gc_register_address( rb_context ); - } - - data = (CallbackData*)sqlite3_user_data(ctx); - - rb_funcall( data->proc2, rb_intern("call"), 1, - SWIG_NewPointerObj(ctx,SWIGTYPE_p_sqlite3_context,0) ); - - rb_gc_unregister_address( rb_context ); -} - -swig_class cCallbackData; - -static VALUE -_wrap_CallbackData_proc_set(int argc, VALUE *argv, VALUE self) { - struct CallbackData *arg1 = (struct CallbackData *) 0 ; - VALUE arg2 ; - - if ((argc < 1) || (argc > 1)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); - SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CallbackData, 0); - arg2 = argv[0]; - if (arg1) (arg1)->proc = arg2; - - return Qnil; -} - - -static VALUE -_wrap_CallbackData_proc_get(int argc, VALUE *argv, VALUE self) { - struct CallbackData *arg1 = (struct CallbackData *) 0 ; - VALUE result; - VALUE vresult = Qnil; - - if ((argc < 0) || (argc > 0)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); - SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CallbackData, 0); - result = (VALUE) ((arg1)->proc); - - vresult = result; - return vresult; -} - - -static VALUE -_wrap_CallbackData_proc2_set(int argc, VALUE *argv, VALUE self) { - struct CallbackData *arg1 = (struct CallbackData *) 0 ; - VALUE arg2 ; - - if ((argc < 1) || (argc > 1)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); - SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CallbackData, 0); - arg2 = argv[0]; - if (arg1) (arg1)->proc2 = arg2; - - return Qnil; -} - - -static VALUE -_wrap_CallbackData_proc2_get(int argc, VALUE *argv, VALUE self) { - struct CallbackData *arg1 = (struct CallbackData *) 0 ; - VALUE result; - VALUE vresult = Qnil; - - if ((argc < 0) || (argc > 0)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); - SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CallbackData, 0); - result = (VALUE) ((arg1)->proc2); - - vresult = result; - return vresult; -} - - -static VALUE -_wrap_CallbackData_data_set(int argc, VALUE *argv, VALUE self) { - struct CallbackData *arg1 = (struct CallbackData *) 0 ; - VALUE arg2 ; - - if ((argc < 1) || (argc > 1)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); - SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CallbackData, 0); - arg2 = argv[0]; - if (arg1) (arg1)->data = arg2; - - return Qnil; -} - - -static VALUE -_wrap_CallbackData_data_get(int argc, VALUE *argv, VALUE self) { - struct CallbackData *arg1 = (struct CallbackData *) 0 ; - VALUE result; - VALUE vresult = Qnil; - - if ((argc < 0) || (argc > 0)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); - SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CallbackData, 0); - result = (VALUE) ((arg1)->data); - - vresult = result; - return vresult; -} - - -#ifdef HAVE_RB_DEFINE_ALLOC_FUNC -static VALUE -_wrap_CallbackData_allocate(VALUE self) { -#else - static VALUE - _wrap_CallbackData_allocate(int argc, VALUE *argv, VALUE self) { -#endif - - - VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_CallbackData); -#ifndef HAVE_RB_DEFINE_ALLOC_FUNC - rb_obj_call_init(vresult, argc, argv); -#endif - return vresult; - } - - -static VALUE -_wrap_new_CallbackData(int argc, VALUE *argv, VALUE self) { - struct CallbackData *result; - - if ((argc < 0) || (argc > 0)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); - result = (struct CallbackData *)(struct CallbackData *) calloc(1, sizeof(struct CallbackData)); - DATA_PTR(self) = result; - - return self; -} - - -static void -free_CallbackData(struct CallbackData *arg1) { - free((char *) arg1); -} - -static VALUE -_wrap_sqlite3_libversion(int argc, VALUE *argv, VALUE self) { - char *result; - VALUE vresult = Qnil; - - if ((argc < 0) || (argc > 0)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); - result = (char *)sqlite3_libversion(); - - { - vresult = result ? rb_str_new2(result) : Qnil; - } - return vresult; -} - - -static VALUE -_wrap_sqlite3_close(int argc, VALUE *argv, VALUE self) { - sqlite3 *arg1 = (sqlite3 *) 0 ; - int result; - VALUE vresult = Qnil; - - if ((argc < 1) || (argc > 1)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3, 0); - result = (int)sqlite3_close(arg1); - - vresult = INT2NUM(result); - return vresult; -} - - -static VALUE -_wrap_sqlite3_last_insert_rowid(int argc, VALUE *argv, VALUE self) { - sqlite3 *arg1 = (sqlite3 *) 0 ; - sqlite_int64 result; - VALUE vresult = Qnil; - - if ((argc < 1) || (argc > 1)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3, 0); - result = sqlite3_last_insert_rowid(arg1); - - { - vresult = rb_ll2inum( result ); - } - return vresult; -} - - -static VALUE -_wrap_sqlite3_changes(int argc, VALUE *argv, VALUE self) { - sqlite3 *arg1 = (sqlite3 *) 0 ; - int result; - VALUE vresult = Qnil; - - if ((argc < 1) || (argc > 1)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3, 0); - result = (int)sqlite3_changes(arg1); - - vresult = INT2NUM(result); - return vresult; -} - - -static VALUE -_wrap_sqlite3_total_changes(int argc, VALUE *argv, VALUE self) { - sqlite3 *arg1 = (sqlite3 *) 0 ; - int result; - VALUE vresult = Qnil; - - if ((argc < 1) || (argc > 1)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3, 0); - result = (int)sqlite3_total_changes(arg1); - - vresult = INT2NUM(result); - return vresult; -} - - -static VALUE -_wrap_sqlite3_interrupt(int argc, VALUE *argv, VALUE self) { - sqlite3 *arg1 = (sqlite3 *) 0 ; - - if ((argc < 1) || (argc > 1)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3, 0); - sqlite3_interrupt(arg1); - - return Qnil; -} - - -static VALUE -_wrap_sqlite3_complete(int argc, VALUE *argv, VALUE self) { - char *arg1 = (char *) 0 ; - int result; - VALUE vresult = Qnil; - - if ((argc < 1) || (argc > 1)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); - arg1 = StringValuePtr(argv[0]); - result = (int)sqlite3_complete((char const *)arg1); - - vresult = INT2NUM(result); - return vresult; -} - - -static VALUE -_wrap_sqlite3_complete16(int argc, VALUE *argv, VALUE self) { - void *arg1 = (void *) 0 ; - int result; - VALUE vresult = Qnil; - - if ((argc < 1) || (argc > 1)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); - { - arg1 = (void*)RSTRING_PTR(argv[0]); - } - result = (int)sqlite3_complete16((void const *)arg1); - - vresult = INT2NUM(result); - return vresult; -} - - -static VALUE -_wrap_sqlite3_busy_handler(int argc, VALUE *argv, VALUE self) { - sqlite3 *arg1 = (sqlite3 *) 0 ; - int (*arg2)(void *,int) = (int (*)(void *,int)) 0 ; - void *arg3 = (void *) 0 ; - int result; - VALUE vresult = Qnil; - - if ((argc < 3) || (argc > 3)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3, 0); - SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_f_p_void_int__int, 0); - SWIG_ConvertPtr(argv[2], (void **) &arg3, 0, SWIG_POINTER_EXCEPTION|0); - result = (int)sqlite3_busy_handler(arg1,arg2,arg3); - - vresult = INT2NUM(result); - return vresult; -} - - -static VALUE -_wrap_sqlite3_busy_timeout(int argc, VALUE *argv, VALUE self) { - sqlite3 *arg1 = (sqlite3 *) 0 ; - int arg2 ; - int result; - VALUE vresult = Qnil; - - if ((argc < 2) || (argc > 2)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3, 0); - arg2 = NUM2INT(argv[1]); - result = (int)sqlite3_busy_timeout(arg1,arg2); - - vresult = INT2NUM(result); - return vresult; -} - - -static VALUE -_wrap_sqlite3_set_authorizer(int argc, VALUE *argv, VALUE self) { - sqlite3 *arg1 = (sqlite3 *) 0 ; - int (*arg2)(void *,int,char const *,char const *,char const *,char const *) = (int (*)(void *,int,char const *,char const *,char const *,char const *)) 0 ; - void *arg3 = (void *) 0 ; - int result; - VALUE vresult = Qnil; - - if ((argc < 3) || (argc > 3)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3, 0); - SWIG_ConvertPtr(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, 0); - SWIG_ConvertPtr(argv[2], (void **) &arg3, 0, SWIG_POINTER_EXCEPTION|0); - result = (int)sqlite3_set_authorizer(arg1,arg2,arg3); - - vresult = INT2NUM(result); - return vresult; -} - - -static VALUE -_wrap_sqlite3_trace(int argc, VALUE *argv, VALUE self) { - sqlite3 *arg1 = (sqlite3 *) 0 ; - void (*arg2)(void *,char const *) = (void (*)(void *,char const *)) 0 ; - void *arg3 = (void *) 0 ; - int result; - VALUE vresult = Qnil; - - if ((argc < 3) || (argc > 3)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3, 0); - SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_f_p_void_p_q_const__char__void, 0); - SWIG_ConvertPtr(argv[2], (void **) &arg3, 0, SWIG_POINTER_EXCEPTION|0); - result = (int)sqlite3_trace(arg1,arg2,arg3); - - vresult = INT2NUM(result); - return vresult; -} - - -static VALUE -_wrap_sqlite3_open(int argc, VALUE *argv, VALUE self) { - char *arg1 = (char *) 0 ; - sqlite3 **arg2 = (sqlite3 **) 0 ; - int result; - VALUE vresult = Qnil; - - if ((argc < 1) || (argc > 1)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); - { - arg1 = STR2CSTR(argv[0]); - arg2 = (sqlite3**)malloc( sizeof( sqlite3* ) ); - } - result = (int)sqlite3_open((char const *)arg1,arg2); - - vresult = INT2NUM(result); - { - VALUE ary; - ary = rb_ary_new2(2); - rb_ary_push( ary, vresult ); - rb_ary_push( ary, SWIG_NewPointerObj( *arg2, SWIGTYPE_p_sqlite3, 0 ) ); - free( arg2 ); - vresult = ary; - } - return vresult; -} - - -static VALUE -_wrap_sqlite3_open16(int argc, VALUE *argv, VALUE self) { - void *arg1 = (void *) 0 ; - sqlite3 **arg2 = (sqlite3 **) 0 ; - int result; - VALUE vresult = Qnil; - - if ((argc < 1) || (argc > 1)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); - { - arg1 = (void*)RSTRING_PTR(argv[0]); - arg2 = (sqlite3**)malloc( sizeof( sqlite3* ) ); - } - result = (int)sqlite3_open16((void const *)arg1,arg2); - - vresult = INT2NUM(result); - { - VALUE ary; - ary = rb_ary_new2(2); - rb_ary_push( ary, vresult ); - rb_ary_push( ary, SWIG_NewPointerObj( *arg2, SWIGTYPE_p_sqlite3, 0 ) ); - free( arg2 ); - vresult = ary; - } - return vresult; -} - - -static VALUE -_wrap_sqlite3_errcode(int argc, VALUE *argv, VALUE self) { - sqlite3 *arg1 = (sqlite3 *) 0 ; - int result; - VALUE vresult = Qnil; - - if ((argc < 1) || (argc > 1)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3, 0); - result = (int)sqlite3_errcode(arg1); - - vresult = INT2NUM(result); - return vresult; -} - - -static VALUE -_wrap_sqlite3_errmsg(int argc, VALUE *argv, VALUE self) { - sqlite3 *arg1 = (sqlite3 *) 0 ; - char *result; - VALUE vresult = Qnil; - - if ((argc < 1) || (argc > 1)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3, 0); - result = (char *)sqlite3_errmsg(arg1); - - { - vresult = result ? rb_str_new2(result) : Qnil; - } - return vresult; -} - - -static VALUE -_wrap_sqlite3_errmsg16(int argc, VALUE *argv, VALUE self) { - sqlite3 *arg1 = (sqlite3 *) 0 ; - void *result; - VALUE vresult = Qnil; - - if ((argc < 1) || (argc > 1)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3, 0); - result = (void *)sqlite3_errmsg16(arg1); - - { - int i; - if( result ) { - for( i = 0; ((char*)result)[i]; i += 2 ); - vresult = rb_str_new( (char*)result, i ); - } else vresult = Qnil; - } - return vresult; -} - - -static VALUE -_wrap_sqlite3_prepare(int argc, VALUE *argv, VALUE self) { - sqlite3 *arg1 = (sqlite3 *) 0 ; - char *arg2 = (char *) 0 ; - int arg3 ; - sqlite3_stmt **arg4 = (sqlite3_stmt **) 0 ; - char **arg5 = (char **) 0 ; - int result; - sqlite3_stmt *stmt2 ; - char *errmsg2 ; - VALUE vresult = Qnil; - - if ((argc < 2) || (argc > 2)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3, 0); - { - arg2 = RSTRING_PTR(argv[1]); - arg3 = RSTRING_LEN(argv[1]); - arg4 = &stmt2; - arg5 = &errmsg2; - } - result = (int)sqlite3_prepare(arg1,(char const *)arg2,arg3,arg4,(char const **)arg5); - - vresult = INT2NUM(result); - { - VALUE ary; - ary = rb_ary_new2(3); - rb_ary_push( ary, vresult ); - rb_ary_push( ary, SWIG_NewPointerObj( stmt2, SWIGTYPE_p_sqlite3_stmt, 0 ) ); - rb_ary_push( ary, errmsg2 ? rb_str_new2( errmsg2 ) : Qnil ); - vresult = ary; - } - return vresult; -} - - -static VALUE -_wrap_sqlite3_prepare16(int argc, VALUE *argv, VALUE self) { - sqlite3 *arg1 = (sqlite3 *) 0 ; - void *arg2 = (void *) 0 ; - int arg3 ; - sqlite3_stmt **arg4 = (sqlite3_stmt **) 0 ; - void **arg5 = (void **) 0 ; - int result; - sqlite3_stmt *stmt2 ; - void *errmsg2 ; - VALUE vresult = Qnil; - - if ((argc < 2) || (argc > 2)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3, 0); - { - arg2 = RSTRING_PTR(argv[1]); - arg3 = RSTRING_LEN(argv[1]); - arg4 = &stmt2; - arg5 = &errmsg2; - } - result = (int)sqlite3_prepare16(arg1,(void const *)arg2,arg3,arg4,(void const **)arg5); - - vresult = INT2NUM(result); - { - VALUE ary; - int i; - - for( i = 0; ((char*)errmsg2)[i]; i += 2 ); - - ary = rb_ary_new2(3); - rb_ary_push( ary, vresult ); - rb_ary_push( ary, SWIG_NewPointerObj( stmt2, SWIGTYPE_p_sqlite3_stmt, 0 ) ); - rb_ary_push( ary, errmsg2 ? rb_str_new( (char*)errmsg2, i ) : Qnil ); - vresult = ary; - } - return vresult; -} - - -static VALUE -_wrap_sqlite3_bind_blob(int argc, VALUE *argv, VALUE self) { - sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; - int arg2 ; - void *arg3 = (void *) 0 ; - int arg4 ; - void (*arg5)(void *) = (void (*)(void *)) 0 ; - int result; - VALUE vresult = Qnil; - - if ((argc < 3) || (argc > 3)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); - arg2 = NUM2INT(argv[1]); - { - arg3 = (void*)RSTRING_PTR(argv[2]); - arg4 = RSTRING_LEN(argv[2]); - arg5 = SQLITE_TRANSIENT; - } - result = (int)sqlite3_bind_blob(arg1,arg2,(void const *)arg3,arg4,arg5); - - vresult = INT2NUM(result); - return vresult; -} - - -static VALUE -_wrap_sqlite3_bind_double(int argc, VALUE *argv, VALUE self) { - sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; - int arg2 ; - double arg3 ; - int result; - VALUE vresult = Qnil; - - if ((argc < 3) || (argc > 3)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); - arg2 = NUM2INT(argv[1]); - arg3 = (double) NUM2DBL(argv[2]); - result = (int)sqlite3_bind_double(arg1,arg2,arg3); - - vresult = INT2NUM(result); - return vresult; -} - - -static VALUE -_wrap_sqlite3_bind_int(int argc, VALUE *argv, VALUE self) { - sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; - int arg2 ; - int arg3 ; - int result; - VALUE vresult = Qnil; - - if ((argc < 3) || (argc > 3)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); - arg2 = NUM2INT(argv[1]); - arg3 = NUM2INT(argv[2]); - result = (int)sqlite3_bind_int(arg1,arg2,arg3); - - vresult = INT2NUM(result); - return vresult; -} - - -static VALUE -_wrap_sqlite3_bind_int64(int argc, VALUE *argv, VALUE self) { - sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; - int arg2 ; - sqlite_int64 arg3 ; - int result; - VALUE vresult = Qnil; - - if ((argc < 3) || (argc > 3)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); - arg2 = NUM2INT(argv[1]); - { - arg3 = rb_num2ll( argv[2] ); - } - result = (int)sqlite3_bind_int64(arg1,arg2,arg3); - - vresult = INT2NUM(result); - return vresult; -} - - -static VALUE -_wrap_sqlite3_bind_null(int argc, VALUE *argv, VALUE self) { - sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; - int arg2 ; - int result; - VALUE vresult = Qnil; - - if ((argc < 2) || (argc > 2)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); - arg2 = NUM2INT(argv[1]); - result = (int)sqlite3_bind_null(arg1,arg2); - - vresult = INT2NUM(result); - return vresult; -} - - -static VALUE -_wrap_sqlite3_bind_text(int argc, VALUE *argv, VALUE self) { - sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; - int arg2 ; - char *arg3 = (char *) 0 ; - int arg4 ; - void (*arg5)(void *) = (void (*)(void *)) 0 ; - int result; - VALUE vresult = Qnil; - - if ((argc < 3) || (argc > 3)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); - arg2 = NUM2INT(argv[1]); - { - arg3 = RSTRING_PTR(argv[2]); - arg4 = RSTRING_LEN(argv[2]); - arg5 = SQLITE_TRANSIENT; - } - result = (int)sqlite3_bind_text(arg1,arg2,(char const *)arg3,arg4,arg5); - - vresult = INT2NUM(result); - return vresult; -} - - -static VALUE -_wrap_sqlite3_bind_text16(int argc, VALUE *argv, VALUE self) { - sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; - int arg2 ; - void *arg3 = (void *) 0 ; - int arg4 ; - void (*arg5)(void *) = (void (*)(void *)) 0 ; - int result; - VALUE vresult = Qnil; - - if ((argc < 3) || (argc > 3)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); - arg2 = NUM2INT(argv[1]); - { - arg3 = (void*)RSTRING_PTR(argv[2]); - arg4 = RSTRING_LEN(argv[2]); - arg5 = SQLITE_TRANSIENT; - } - result = (int)sqlite3_bind_text16(arg1,arg2,(void const *)arg3,arg4,arg5); - - vresult = INT2NUM(result); - return vresult; -} - - -static VALUE -_wrap_sqlite3_bind_parameter_count(int argc, VALUE *argv, VALUE self) { - sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; - int result; - VALUE vresult = Qnil; - - if ((argc < 1) || (argc > 1)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); - result = (int)sqlite3_bind_parameter_count(arg1); - - vresult = INT2NUM(result); - return vresult; -} - - -static VALUE -_wrap_sqlite3_bind_parameter_name(int argc, VALUE *argv, VALUE self) { - sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; - int arg2 ; - char *result; - VALUE vresult = Qnil; - - if ((argc < 2) || (argc > 2)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); - arg2 = NUM2INT(argv[1]); - result = (char *)sqlite3_bind_parameter_name(arg1,arg2); - - { - vresult = result ? rb_str_new2(result) : Qnil; - } - return vresult; -} - - -static VALUE -_wrap_sqlite3_bind_parameter_index(int argc, VALUE *argv, VALUE self) { - sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; - char *arg2 = (char *) 0 ; - int result; - VALUE vresult = Qnil; - - if ((argc < 2) || (argc > 2)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); - arg2 = StringValuePtr(argv[1]); - result = (int)sqlite3_bind_parameter_index(arg1,(char const *)arg2); - - vresult = INT2NUM(result); - return vresult; -} - - -static VALUE -_wrap_sqlite3_column_count(int argc, VALUE *argv, VALUE self) { - sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; - int result; - VALUE vresult = Qnil; - - if ((argc < 1) || (argc > 1)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); - result = (int)sqlite3_column_count(arg1); - - vresult = INT2NUM(result); - return vresult; -} - - -static VALUE -_wrap_sqlite3_column_name(int argc, VALUE *argv, VALUE self) { - sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; - int arg2 ; - char *result; - VALUE vresult = Qnil; - - if ((argc < 2) || (argc > 2)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); - arg2 = NUM2INT(argv[1]); - result = (char *)sqlite3_column_name(arg1,arg2); - - { - vresult = result ? rb_str_new2(result) : Qnil; - } - return vresult; -} - - -static VALUE -_wrap_sqlite3_column_name16(int argc, VALUE *argv, VALUE self) { - sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; - int arg2 ; - void *result; - VALUE vresult = Qnil; - - if ((argc < 2) || (argc > 2)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); - arg2 = NUM2INT(argv[1]); - result = (void *)sqlite3_column_name16(arg1,arg2); - - { - int i; - if( result ) { - for( i = 0; ((char*)result)[i]; i += 2 ); - vresult = rb_str_new( (char*)result, i ); - } else vresult = Qnil; - } - return vresult; -} - - -static VALUE -_wrap_sqlite3_column_decltype(int argc, VALUE *argv, VALUE self) { - sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; - int arg2 ; - char *result; - VALUE vresult = Qnil; - - if ((argc < 2) || (argc > 2)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); - arg2 = NUM2INT(argv[1]); - result = (char *)sqlite3_column_decltype(arg1,arg2); - - { - vresult = result ? rb_str_new2(result) : Qnil; - } - return vresult; -} - - -static VALUE -_wrap_sqlite3_column_decltype16(int argc, VALUE *argv, VALUE self) { - sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; - int arg2 ; - void *result; - VALUE vresult = Qnil; - - if ((argc < 2) || (argc > 2)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); - arg2 = NUM2INT(argv[1]); - result = (void *)sqlite3_column_decltype16(arg1,arg2); - - { - int i; - if( result ) { - for( i = 0; ((char*)result)[i]; i += 2 ); - vresult = rb_str_new( (char*)result, i ); - } else vresult = Qnil; - } - return vresult; -} - - -static VALUE -_wrap_sqlite3_step(int argc, VALUE *argv, VALUE self) { - sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; - int result; - VALUE vresult = Qnil; - - if ((argc < 1) || (argc > 1)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); - result = (int)sqlite3_step(arg1); - - vresult = INT2NUM(result); - return vresult; -} - - -static VALUE -_wrap_sqlite3_data_count(int argc, VALUE *argv, VALUE self) { - sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; - int result; - VALUE vresult = Qnil; - - if ((argc < 1) || (argc > 1)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); - result = (int)sqlite3_data_count(arg1); - - vresult = INT2NUM(result); - return vresult; -} - - -static VALUE -_wrap_sqlite3_column_blob(int argc, VALUE *argv, VALUE self) { - sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; - int arg2 ; - RUBY_BLOB *result; - VALUE vresult = Qnil; - - if ((argc < 2) || (argc > 2)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); - arg2 = NUM2INT(argv[1]); - result = (RUBY_BLOB *)sqlite3_column_blob(arg1,arg2); - - { - vresult = result ? - rb_str_new( (char*)result, sqlite3_column_bytes( arg1, arg2 ) ) : Qnil; - } - return vresult; -} - - -static VALUE -_wrap_sqlite3_column_bytes(int argc, VALUE *argv, VALUE self) { - sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; - int arg2 ; - int result; - VALUE vresult = Qnil; - - if ((argc < 2) || (argc > 2)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); - arg2 = NUM2INT(argv[1]); - result = (int)sqlite3_column_bytes(arg1,arg2); - - vresult = INT2NUM(result); - return vresult; -} - - -static VALUE -_wrap_sqlite3_column_bytes16(int argc, VALUE *argv, VALUE self) { - sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; - int arg2 ; - int result; - VALUE vresult = Qnil; - - if ((argc < 2) || (argc > 2)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); - arg2 = NUM2INT(argv[1]); - result = (int)sqlite3_column_bytes16(arg1,arg2); - - vresult = INT2NUM(result); - return vresult; -} - - -static VALUE -_wrap_sqlite3_column_double(int argc, VALUE *argv, VALUE self) { - sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; - int arg2 ; - double result; - VALUE vresult = Qnil; - - if ((argc < 2) || (argc > 2)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); - arg2 = NUM2INT(argv[1]); - result = (double)sqlite3_column_double(arg1,arg2); - - vresult = rb_float_new(result); - return vresult; -} - - -static VALUE -_wrap_sqlite3_column_int(int argc, VALUE *argv, VALUE self) { - sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; - int arg2 ; - double result; - VALUE vresult = Qnil; - - if ((argc < 2) || (argc > 2)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); - arg2 = NUM2INT(argv[1]); - result = (double)sqlite3_column_int(arg1,arg2); - - vresult = rb_float_new(result); - return vresult; -} - - -static VALUE -_wrap_sqlite3_column_int64(int argc, VALUE *argv, VALUE self) { - sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; - int arg2 ; - sqlite_int64 result; - VALUE vresult = Qnil; - - if ((argc < 2) || (argc > 2)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); - arg2 = NUM2INT(argv[1]); - result = sqlite3_column_int64(arg1,arg2); - - { - vresult = rb_ll2inum( result ); - } - return vresult; -} - - -static VALUE -_wrap_sqlite3_column_text(int argc, VALUE *argv, VALUE self) { - sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; - int arg2 ; - char *result; - VALUE vresult = Qnil; - - if ((argc < 2) || (argc > 2)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); - arg2 = NUM2INT(argv[1]); - result = (char *)sqlite3_column_text(arg1,arg2); - - { - vresult = result ? rb_str_new2(result) : Qnil; - } - return vresult; -} - - -static VALUE -_wrap_sqlite3_column_text16(int argc, VALUE *argv, VALUE self) { - sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; - int arg2 ; - void *result; - VALUE vresult = Qnil; - - if ((argc < 2) || (argc > 2)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); - arg2 = NUM2INT(argv[1]); - result = (void *)sqlite3_column_text16(arg1,arg2); - - { - int i; - if( result ) { - for( i = 0; ((char*)result)[i]; i += 2 ); - vresult = rb_str_new( (char*)result, i ); - } else vresult = Qnil; - } - return vresult; -} - - -static VALUE -_wrap_sqlite3_column_type(int argc, VALUE *argv, VALUE self) { - sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; - int arg2 ; - int result; - VALUE vresult = Qnil; - - if ((argc < 2) || (argc > 2)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); - arg2 = NUM2INT(argv[1]); - result = (int)sqlite3_column_type(arg1,arg2); - - vresult = INT2NUM(result); - return vresult; -} - - -static VALUE -_wrap_sqlite3_finalize(int argc, VALUE *argv, VALUE self) { - sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; - int result; - VALUE vresult = Qnil; - - if ((argc < 1) || (argc > 1)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); - result = (int)sqlite3_finalize(arg1); - - vresult = INT2NUM(result); - return vresult; -} - - -static VALUE -_wrap_sqlite3_reset(int argc, VALUE *argv, VALUE self) { - sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; - int result; - VALUE vresult = Qnil; - - if ((argc < 1) || (argc > 1)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); - result = (int)sqlite3_reset(arg1); - - vresult = INT2NUM(result); - return vresult; -} - - -static VALUE -_wrap_sqlite3_create_function(int argc, VALUE *argv, VALUE self) { - sqlite3 *arg1 = (sqlite3 *) 0 ; - char *arg2 = (char *) 0 ; - int arg3 ; - int arg4 ; - void *arg5 = (void *) 0 ; - void (*arg6)(sqlite3_context *,int,sqlite3_value **) = (void (*)(sqlite3_context *,int,sqlite3_value **)) 0 ; - void (*arg7)(sqlite3_context *,int,sqlite3_value **) = (void (*)(sqlite3_context *,int,sqlite3_value **)) 0 ; - void (*arg8)(sqlite3_context *) = (void (*)(sqlite3_context *)) 0 ; - int result; - VALUE vresult = Qnil; - - if ((argc < 8) || (argc > 8)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 8)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3, 0); - arg2 = StringValuePtr(argv[1]); - arg3 = NUM2INT(argv[2]); - arg4 = NUM2INT(argv[3]); - SWIG_ConvertPtr(argv[4], (void **) &arg5, 0, SWIG_POINTER_EXCEPTION|0); - SWIG_ConvertPtr(argv[5], (void **) &arg6, SWIGTYPE_p_f_p_sqlite3_context_int_p_p_sqlite3_value__void, 0); - SWIG_ConvertPtr(argv[6], (void **) &arg7, SWIGTYPE_p_f_p_sqlite3_context_int_p_p_sqlite3_value__void, 0); - SWIG_ConvertPtr(argv[7], (void **) &arg8, SWIGTYPE_p_f_p_sqlite3_context__void, 0); - result = (int)sqlite3_create_function(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8); - - vresult = INT2NUM(result); - return vresult; -} - - -static VALUE -_wrap_sqlite3_create_function16(int argc, VALUE *argv, VALUE self) { - sqlite3 *arg1 = (sqlite3 *) 0 ; - void *arg2 = (void *) 0 ; - int arg3 ; - int arg4 ; - void *arg5 = (void *) 0 ; - void (*arg6)(sqlite3_context *,int,sqlite3_value **) = (void (*)(sqlite3_context *,int,sqlite3_value **)) 0 ; - void (*arg7)(sqlite3_context *,int,sqlite3_value **) = (void (*)(sqlite3_context *,int,sqlite3_value **)) 0 ; - void (*arg8)(sqlite3_context *) = (void (*)(sqlite3_context *)) 0 ; - int result; - VALUE vresult = Qnil; - - if ((argc < 8) || (argc > 8)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 8)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3, 0); - { - arg2 = (void*)RSTRING_PTR(argv[1]); - } - arg3 = NUM2INT(argv[2]); - arg4 = NUM2INT(argv[3]); - SWIG_ConvertPtr(argv[4], (void **) &arg5, 0, SWIG_POINTER_EXCEPTION|0); - SWIG_ConvertPtr(argv[5], (void **) &arg6, SWIGTYPE_p_f_p_sqlite3_context_int_p_p_sqlite3_value__void, 0); - SWIG_ConvertPtr(argv[6], (void **) &arg7, SWIGTYPE_p_f_p_sqlite3_context_int_p_p_sqlite3_value__void, 0); - SWIG_ConvertPtr(argv[7], (void **) &arg8, SWIGTYPE_p_f_p_sqlite3_context__void, 0); - result = (int)sqlite3_create_function16(arg1,(void const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8); - - vresult = INT2NUM(result); - return vresult; -} - - -static VALUE -_wrap_sqlite3_aggregate_count(int argc, VALUE *argv, VALUE self) { - sqlite3_context *arg1 = (sqlite3_context *) 0 ; - int result; - VALUE vresult = Qnil; - - if ((argc < 1) || (argc > 1)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_context, 0); - result = (int)sqlite3_aggregate_count(arg1); - - vresult = INT2NUM(result); - return vresult; -} - - -static VALUE -_wrap_sqlite3_value_blob(int argc, VALUE *argv, VALUE self) { - sqlite3_value *arg1 = (sqlite3_value *) 0 ; - RUBY_VALBLOB *result; - VALUE vresult = Qnil; - - if ((argc < 1) || (argc > 1)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_value, 0); - result = (RUBY_VALBLOB *)sqlite3_value_blob(arg1); - - { - vresult = result ? rb_str_new( (char*)result, sqlite3_value_bytes( arg1 ) ) : Qnil; - } - return vresult; -} - - -static VALUE -_wrap_sqlite3_value_bytes(int argc, VALUE *argv, VALUE self) { - sqlite3_value *arg1 = (sqlite3_value *) 0 ; - int result; - VALUE vresult = Qnil; - - if ((argc < 1) || (argc > 1)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_value, 0); - result = (int)sqlite3_value_bytes(arg1); - - vresult = INT2NUM(result); - return vresult; -} - - -static VALUE -_wrap_sqlite3_value_bytes16(int argc, VALUE *argv, VALUE self) { - sqlite3_value *arg1 = (sqlite3_value *) 0 ; - int result; - VALUE vresult = Qnil; - - if ((argc < 1) || (argc > 1)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_value, 0); - result = (int)sqlite3_value_bytes16(arg1); - - vresult = INT2NUM(result); - return vresult; -} - - -static VALUE -_wrap_sqlite3_value_double(int argc, VALUE *argv, VALUE self) { - sqlite3_value *arg1 = (sqlite3_value *) 0 ; - double result; - VALUE vresult = Qnil; - - if ((argc < 1) || (argc > 1)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_value, 0); - result = (double)sqlite3_value_double(arg1); - - vresult = rb_float_new(result); - return vresult; -} - - -static VALUE -_wrap_sqlite3_value_int(int argc, VALUE *argv, VALUE self) { - sqlite3_value *arg1 = (sqlite3_value *) 0 ; - int result; - VALUE vresult = Qnil; - - if ((argc < 1) || (argc > 1)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_value, 0); - result = (int)sqlite3_value_int(arg1); - - vresult = INT2NUM(result); - return vresult; -} - - -static VALUE -_wrap_sqlite3_value_int64(int argc, VALUE *argv, VALUE self) { - sqlite3_value *arg1 = (sqlite3_value *) 0 ; - sqlite_int64 result; - VALUE vresult = Qnil; - - if ((argc < 1) || (argc > 1)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_value, 0); - result = sqlite3_value_int64(arg1); - - { - vresult = rb_ll2inum( result ); - } - return vresult; -} - - -static VALUE -_wrap_sqlite3_value_text(int argc, VALUE *argv, VALUE self) { - sqlite3_value *arg1 = (sqlite3_value *) 0 ; - char *result; - VALUE vresult = Qnil; - - if ((argc < 1) || (argc > 1)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_value, 0); - result = (char *)sqlite3_value_text(arg1); - - { - vresult = result ? rb_str_new2(result) : Qnil; - } - return vresult; -} - - -static VALUE -_wrap_sqlite3_value_text16(int argc, VALUE *argv, VALUE self) { - sqlite3_value *arg1 = (sqlite3_value *) 0 ; - void *result; - VALUE vresult = Qnil; - - if ((argc < 1) || (argc > 1)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_value, 0); - result = (void *)sqlite3_value_text16(arg1); - - { - int i; - if( result ) { - for( i = 0; ((char*)result)[i]; i += 2 ); - vresult = rb_str_new( (char*)result, i ); - } else vresult = Qnil; - } - return vresult; -} - - -static VALUE -_wrap_sqlite3_value_text16le(int argc, VALUE *argv, VALUE self) { - sqlite3_value *arg1 = (sqlite3_value *) 0 ; - void *result; - VALUE vresult = Qnil; - - if ((argc < 1) || (argc > 1)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_value, 0); - result = (void *)sqlite3_value_text16le(arg1); - - { - int i; - if( result ) { - for( i = 0; ((char*)result)[i]; i += 2 ); - vresult = rb_str_new( (char*)result, i ); - } else vresult = Qnil; - } - return vresult; -} - - -static VALUE -_wrap_sqlite3_value_text16be(int argc, VALUE *argv, VALUE self) { - sqlite3_value *arg1 = (sqlite3_value *) 0 ; - void *result; - VALUE vresult = Qnil; - - if ((argc < 1) || (argc > 1)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_value, 0); - result = (void *)sqlite3_value_text16be(arg1); - - { - int i; - if( result ) { - for( i = 0; ((char*)result)[i]; i += 2 ); - vresult = rb_str_new( (char*)result, i ); - } else vresult = Qnil; - } - return vresult; -} - - -static VALUE -_wrap_sqlite3_value_type(int argc, VALUE *argv, VALUE self) { - sqlite3_value *arg1 = (sqlite3_value *) 0 ; - int result; - VALUE vresult = Qnil; - - if ((argc < 1) || (argc > 1)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_value, 0); - result = (int)sqlite3_value_type(arg1); - - vresult = INT2NUM(result); - return vresult; -} - - -static VALUE -_wrap_sqlite3_result_blob(int argc, VALUE *argv, VALUE self) { - sqlite3_context *arg1 = (sqlite3_context *) 0 ; - void *arg2 = (void *) 0 ; - int arg3 ; - void (*arg4)(void *) = (void (*)(void *)) 0 ; - - if ((argc < 2) || (argc > 2)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_context, 0); - { - arg2 = (void*)RSTRING_PTR(argv[1]); - arg3 = RSTRING_LEN(argv[1]); - arg4 = SQLITE_TRANSIENT; - } - sqlite3_result_blob(arg1,(void const *)arg2,arg3,arg4); - - return Qnil; -} - - -static VALUE -_wrap_sqlite3_result_double(int argc, VALUE *argv, VALUE self) { - sqlite3_context *arg1 = (sqlite3_context *) 0 ; - double arg2 ; - - if ((argc < 2) || (argc > 2)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_context, 0); - arg2 = (double) NUM2DBL(argv[1]); - sqlite3_result_double(arg1,arg2); - - return Qnil; -} - - -static VALUE -_wrap_sqlite3_result_error(int argc, VALUE *argv, VALUE self) { - sqlite3_context *arg1 = (sqlite3_context *) 0 ; - char *arg2 = (char *) 0 ; - int arg3 ; - - if ((argc < 2) || (argc > 2)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_context, 0); - { - arg2 = RSTRING_PTR(argv[1]); - arg3 = RSTRING_LEN(argv[1]); - } - sqlite3_result_error(arg1,(char const *)arg2,arg3); - - return Qnil; -} - - -static VALUE -_wrap_sqlite3_result_error16(int argc, VALUE *argv, VALUE self) { - sqlite3_context *arg1 = (sqlite3_context *) 0 ; - void *arg2 = (void *) 0 ; - int arg3 ; - - if ((argc < 2) || (argc > 2)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_context, 0); - { - arg2 = (void*)RSTRING_PTR(argv[1]); - arg3 = RSTRING_LEN(argv[1]); - } - sqlite3_result_error16(arg1,(void const *)arg2,arg3); - - return Qnil; -} - - -static VALUE -_wrap_sqlite3_result_int(int argc, VALUE *argv, VALUE self) { - sqlite3_context *arg1 = (sqlite3_context *) 0 ; - int arg2 ; - - if ((argc < 2) || (argc > 2)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_context, 0); - arg2 = NUM2INT(argv[1]); - sqlite3_result_int(arg1,arg2); - - return Qnil; -} - - -static VALUE -_wrap_sqlite3_result_int64(int argc, VALUE *argv, VALUE self) { - sqlite3_context *arg1 = (sqlite3_context *) 0 ; - sqlite_int64 arg2 ; - - if ((argc < 2) || (argc > 2)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_context, 0); - { - arg2 = rb_num2ll( argv[1] ); - } - sqlite3_result_int64(arg1,arg2); - - return Qnil; -} - - -static VALUE -_wrap_sqlite3_result_text(int argc, VALUE *argv, VALUE self) { - sqlite3_context *arg1 = (sqlite3_context *) 0 ; - char *arg2 = (char *) 0 ; - int arg3 ; - void (*arg4)(void *) = (void (*)(void *)) 0 ; - - if ((argc < 2) || (argc > 2)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_context, 0); - { - arg2 = RSTRING_PTR(argv[1]); - arg3 = RSTRING_LEN(argv[1]); - arg4 = SQLITE_TRANSIENT; - } - sqlite3_result_text(arg1,(char const *)arg2,arg3,arg4); - - return Qnil; -} - - -static VALUE -_wrap_sqlite3_result_text16(int argc, VALUE *argv, VALUE self) { - sqlite3_context *arg1 = (sqlite3_context *) 0 ; - void *arg2 = (void *) 0 ; - int arg3 ; - void (*arg4)(void *) = (void (*)(void *)) 0 ; - - if ((argc < 2) || (argc > 2)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_context, 0); - { - arg2 = (void*)RSTRING_PTR(argv[1]); - arg3 = RSTRING_LEN(argv[1]); - arg4 = SQLITE_TRANSIENT; - } - sqlite3_result_text16(arg1,(void const *)arg2,arg3,arg4); - - return Qnil; -} - - -static VALUE -_wrap_sqlite3_result_text16le(int argc, VALUE *argv, VALUE self) { - sqlite3_context *arg1 = (sqlite3_context *) 0 ; - void *arg2 = (void *) 0 ; - int arg3 ; - void (*arg4)(void *) = (void (*)(void *)) 0 ; - - if ((argc < 2) || (argc > 2)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_context, 0); - { - arg2 = (void*)RSTRING_PTR(argv[1]); - arg3 = RSTRING_LEN(argv[1]); - arg4 = SQLITE_TRANSIENT; - } - sqlite3_result_text16le(arg1,(void const *)arg2,arg3,arg4); - - return Qnil; -} - - -static VALUE -_wrap_sqlite3_result_text16be(int argc, VALUE *argv, VALUE self) { - sqlite3_context *arg1 = (sqlite3_context *) 0 ; - void *arg2 = (void *) 0 ; - int arg3 ; - void (*arg4)(void *) = (void (*)(void *)) 0 ; - - if ((argc < 2) || (argc > 2)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_context, 0); - { - arg2 = (void*)RSTRING_PTR(argv[1]); - arg3 = RSTRING_LEN(argv[1]); - arg4 = SQLITE_TRANSIENT; - } - sqlite3_result_text16be(arg1,(void const *)arg2,arg3,arg4); - - return Qnil; -} - - -static VALUE -_wrap_sqlite3_result_value(int argc, VALUE *argv, VALUE self) { - sqlite3_context *arg1 = (sqlite3_context *) 0 ; - sqlite3_value *arg2 = (sqlite3_value *) 0 ; - - if ((argc < 2) || (argc > 2)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); - SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_context, 0); - SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_sqlite3_value, 0); - sqlite3_result_value(arg1,arg2); - - return Qnil; -} - - -static VALUE -_wrap_sqlite3_aggregate_context(int argc, VALUE *argv, VALUE self) { - sqlite3_context *arg1 = (sqlite3_context *) 0 ; - int arg2 ; - VALUE *result; - VALUE vresult = Qnil; - - if ((argc < 1) || (argc > 1)) - rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); - { - SWIG_ConvertPtr(argv[0],(void**)&arg1, SWIGTYPE_p_sqlite3_context, 1); - arg2 = 4; - } - result = (VALUE *)sqlite3_aggregate_context(arg1,arg2); - - { - vresult = *(VALUE*)result; - } - return vresult; -} - - - -/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ - -static swig_type_info _swigt__p_CallbackData = {"_p_CallbackData", "struct CallbackData *", 0, 0, 0}; -static swig_type_info _swigt__p_f_p_sqlite3_context__void = {"_p_f_p_sqlite3_context__void", "void (*)(sqlite3_context *)", 0, 0, 0}; -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, 0}; -static swig_type_info _swigt__p_f_p_void__void = {"_p_f_p_void__void", "void (*)(void *)", 0, 0, 0}; -static swig_type_info _swigt__p_f_p_void_int__int = {"_p_f_p_void_int__int", "int (*)(void *,int)", 0, 0, 0}; -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, 0}; -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, 0}; -static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, 0}; -static swig_type_info _swigt__p_p_sqlite3 = {"_p_p_sqlite3", "sqlite3 **", 0, 0, 0}; -static swig_type_info _swigt__p_p_sqlite3_stmt = {"_p_p_sqlite3_stmt", "sqlite3_stmt **", 0, 0, 0}; -static swig_type_info _swigt__p_p_void = {"_p_p_void", "void **", 0, 0, 0}; -static swig_type_info _swigt__p_sqlite3 = {"_p_sqlite3", "sqlite3 *", 0, 0, 0}; -static swig_type_info _swigt__p_sqlite3_context = {"_p_sqlite3_context", "sqlite3_context *", 0, 0, 0}; -static swig_type_info _swigt__p_sqlite3_stmt = {"_p_sqlite3_stmt", "sqlite3_stmt *", 0, 0, 0}; -static swig_type_info _swigt__p_sqlite3_value = {"_p_sqlite3_value", "sqlite3_value *", 0, 0, 0}; -static swig_type_info _swigt__p_sqlite_int64 = {"_p_sqlite_int64", "sqlite_int64 *", 0, 0, 0}; -static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|VALUE *", 0, 0, 0}; -static swig_type_info _swigt__p_void = {"_p_void", "void *|RUBY_VALBLOB *", 0, 0, 0}; - -static swig_type_info *swig_type_initial[] = { - &_swigt__p_CallbackData, - &_swigt__p_f_p_sqlite3_context__void, - &_swigt__p_f_p_sqlite3_context_int_p_p_sqlite3_value__void, - &_swigt__p_f_p_void__void, - &_swigt__p_f_p_void_int__int, - &_swigt__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_p_q_const__char__void, - &_swigt__p_p_char, - &_swigt__p_p_sqlite3, - &_swigt__p_p_sqlite3_stmt, - &_swigt__p_p_void, - &_swigt__p_sqlite3, - &_swigt__p_sqlite3_context, - &_swigt__p_sqlite3_stmt, - &_swigt__p_sqlite3_value, - &_swigt__p_sqlite_int64, - &_swigt__p_unsigned_long, - &_swigt__p_void, -}; - -static swig_cast_info _swigc__p_CallbackData[] = { {&_swigt__p_CallbackData, 0, 0, 0},{0, 0, 0, 0}}; -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}}; -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}}; -static swig_cast_info _swigc__p_f_p_void__void[] = { {&_swigt__p_f_p_void__void, 0, 0, 0},{0, 0, 0, 0}}; -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}}; -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}}; -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}}; -static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_p_sqlite3[] = { {&_swigt__p_p_sqlite3, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_p_sqlite3_stmt[] = { {&_swigt__p_p_sqlite3_stmt, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_p_void[] = { {&_swigt__p_p_void, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_sqlite3[] = { {&_swigt__p_sqlite3, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_sqlite3_context[] = { {&_swigt__p_sqlite3_context, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_sqlite3_stmt[] = { {&_swigt__p_sqlite3_stmt, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_sqlite3_value[] = { {&_swigt__p_sqlite3_value, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_sqlite_int64[] = { {&_swigt__p_sqlite_int64, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}}; - -static swig_cast_info *swig_cast_initial[] = { - _swigc__p_CallbackData, - _swigc__p_f_p_sqlite3_context__void, - _swigc__p_f_p_sqlite3_context_int_p_p_sqlite3_value__void, - _swigc__p_f_p_void__void, - _swigc__p_f_p_void_int__int, - _swigc__p_f_p_void_int_p_q_const__char_p_q_const__char_p_q_const__char_p_q_const__char__int, - _swigc__p_f_p_void_p_q_const__char__void, - _swigc__p_p_char, - _swigc__p_p_sqlite3, - _swigc__p_p_sqlite3_stmt, - _swigc__p_p_void, - _swigc__p_sqlite3, - _swigc__p_sqlite3_context, - _swigc__p_sqlite3_stmt, - _swigc__p_sqlite3_value, - _swigc__p_sqlite_int64, - _swigc__p_unsigned_long, - _swigc__p_void, -}; - - -/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */ - -/************************************************************************* - * Type initialization: - * This problem is tough by the requirement that no dynamic - * memory is used. Also, since swig_type_info structures store pointers to - * swig_cast_info structures and swig_cast_info structures store pointers back - * to swig_type_info structures, we need some lookup code at initialization. - * The idea is that swig generates all the structures that are needed. - * The runtime then collects these partially filled structures. - * The SWIG_InitializeModule function takes these initial arrays out of - * swig_module, and does all the lookup, filling in the swig_module.types - * array with the correct data and linking the correct swig_cast_info - * structures together. - - * The generated swig_type_info structures are assigned staticly to an initial - * array. We just loop though that array, and handle each type individually. - * First we lookup if this type has been already loaded, and if so, use the - * loaded structure instead of the generated one. Then we have to fill in the - * cast linked list. The cast data is initially stored in something like a - * two-dimensional array. Each row corresponds to a type (there are the same - * number of rows as there are in the swig_type_initial array). Each entry in - * a column is one of the swig_cast_info structures for that type. - * The cast_initial array is actually an array of arrays, because each row has - * a variable number of columns. So to actually build the cast linked list, - * we find the array of casts associated with the type, and loop through it - * adding the casts to the list. The one last trick we need to do is making - * sure the type pointer in the swig_cast_info struct is correct. - - * First off, we lookup the cast->type name to see if it is already loaded. - * There are three cases to handle: - * 1) If the cast->type has already been loaded AND the type we are adding - * casting info to has not been loaded (it is in this module), THEN we - * replace the cast->type pointer with the type pointer that has already - * been loaded. - * 2) If BOTH types (the one we are adding casting info to, and the - * cast->type) are loaded, THEN the cast info has already been loaded by - * the previous module so we just ignore it. - * 3) Finally, if cast->type has not already been loaded, then we add that - * swig_cast_info to the linked list (because the cast->type) pointer will - * be correct. -**/ - -#ifdef __cplusplus -extern "C" { -#endif - -SWIGRUNTIME void -SWIG_InitializeModule(void *clientdata) { - swig_type_info *type, *ret; - swig_cast_info *cast; - size_t i; - swig_module_info *module_head; - static int init_run = 0; - - clientdata = clientdata; - - if (init_run) return; - init_run = 1; - - /* Initialize the swig_module */ - swig_module.type_initial = swig_type_initial; - swig_module.cast_initial = swig_cast_initial; - - /* Try and load any already created modules */ - module_head = SWIG_GetModule(clientdata); - if (module_head) { - swig_module.next = module_head->next; - module_head->next = &swig_module; - } else { - /* This is the first module loaded */ - swig_module.next = &swig_module; - SWIG_SetModule(clientdata, &swig_module); - } - - /* Now work on filling in swig_module.types */ - for (i = 0; i < swig_module.size; ++i) { - type = 0; - - /* if there is another module already loaded */ - if (swig_module.next != &swig_module) { - type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name); - } - if (type) { - /* Overwrite clientdata field */ - if (swig_module.type_initial[i]->clientdata) type->clientdata = swig_module.type_initial[i]->clientdata; - } else { - type = swig_module.type_initial[i]; - } - - /* Insert casting types */ - cast = swig_module.cast_initial[i]; - while (cast->type) { - - /* Don't need to add information already in the list */ - ret = 0; - if (swig_module.next != &swig_module) { - ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name); - } - if (ret && type == swig_module.type_initial[i]) { - cast->type = ret; - ret = 0; - } - - if (!ret) { - if (type->cast) { - type->cast->prev = cast; - cast->next = type->cast; - } - type->cast = cast; - } - - cast++; - } - - /* Set entry in modules->types array equal to the type */ - swig_module.types[i] = type; - } - swig_module.types[i] = 0; -} - -/* This function will propagate the clientdata field of type to -* any new swig_type_info structures that have been added into the list -* of equivalent types. It is like calling -* SWIG_TypeClientData(type, clientdata) a second time. -*/ -SWIGRUNTIME void -SWIG_PropagateClientData(void) { - size_t i; - swig_cast_info *equiv; - static int init_run = 0; - - if (init_run) return; - init_run = 1; - - for (i = 0; i < swig_module.size; i++) { - if (swig_module.types[i]->clientdata) { - equiv = swig_module.types[i]->cast; - while (equiv) { - if (!equiv->converter) { - if (equiv->type && !equiv->type->clientdata) - SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata); - } - equiv = equiv->next; - } - } - } -} - -#ifdef __cplusplus -} -#endif - - -#ifdef __cplusplus -extern "C" -#endif -SWIGEXPORT void Init_API(void) { - size_t i; - - SWIG_InitRuntime(); - mAPI = rb_define_module("SQLite3"); - mAPI = rb_define_module_under(mAPI, "Driver"); - mAPI = rb_define_module_under(mAPI, "Native"); - mAPI = rb_define_module_under(mAPI, "API"); - - SWIG_InitializeModule(0); - for (i = 0; i < swig_module.size; i++) { - SWIG_define_class(swig_module.types[i]); - } - - SWIG_RubyInitializeTrackings(); - - cCallbackData.klass = rb_define_class_under(mAPI, "CallbackData", rb_cObject); - SWIG_TypeClientData(SWIGTYPE_p_CallbackData, (void *) &cCallbackData); - rb_define_alloc_func(cCallbackData.klass, _wrap_CallbackData_allocate); - rb_define_method(cCallbackData.klass, "initialize", _wrap_new_CallbackData, -1); - rb_define_method(cCallbackData.klass, "proc=", _wrap_CallbackData_proc_set, -1); - rb_define_method(cCallbackData.klass, "proc", _wrap_CallbackData_proc_get, -1); - rb_define_method(cCallbackData.klass, "proc2=", _wrap_CallbackData_proc2_set, -1); - rb_define_method(cCallbackData.klass, "proc2", _wrap_CallbackData_proc2_get, -1); - rb_define_method(cCallbackData.klass, "data=", _wrap_CallbackData_data_set, -1); - rb_define_method(cCallbackData.klass, "data", _wrap_CallbackData_data_get, -1); - cCallbackData.mark = (void (*)(void *)) mark_CallbackData; - cCallbackData.destroy = (void (*)(void *)) free_CallbackData; - rb_define_const(mAPI,"Sqlite3_ruby_busy_handler", SWIG_NewPointerObj((void *) Sqlite3_ruby_busy_handler, SWIGTYPE_p_f_p_void_int__int,0)); - rb_define_const(mAPI,"Sqlite3_ruby_authorizer", SWIG_NewPointerObj((void *) Sqlite3_ruby_authorizer, SWIGTYPE_p_f_p_void_int_p_q_const__char_p_q_const__char_p_q_const__char_p_q_const__char__int,0)); - rb_define_const(mAPI,"Sqlite3_ruby_trace", SWIG_NewPointerObj((void *) Sqlite3_ruby_trace, SWIGTYPE_p_f_p_void_p_q_const__char__void,0)); - rb_define_const(mAPI,"Sqlite3_ruby_function_step", SWIG_NewPointerObj((void *) Sqlite3_ruby_function_step, SWIGTYPE_p_f_p_sqlite3_context_int_p_p_sqlite3_value__void,0)); - rb_define_const(mAPI,"Sqlite3_ruby_function_final", SWIG_NewPointerObj((void *) Sqlite3_ruby_function_final, SWIGTYPE_p_f_p_sqlite3_context__void,0)); - rb_define_module_function(mAPI, "sqlite3_libversion", _wrap_sqlite3_libversion, -1); - rb_define_module_function(mAPI, "sqlite3_close", _wrap_sqlite3_close, -1); - rb_define_module_function(mAPI, "sqlite3_last_insert_rowid", _wrap_sqlite3_last_insert_rowid, -1); - rb_define_module_function(mAPI, "sqlite3_changes", _wrap_sqlite3_changes, -1); - rb_define_module_function(mAPI, "sqlite3_total_changes", _wrap_sqlite3_total_changes, -1); - rb_define_module_function(mAPI, "sqlite3_interrupt", _wrap_sqlite3_interrupt, -1); - rb_define_module_function(mAPI, "sqlite3_complete", _wrap_sqlite3_complete, -1); - rb_define_module_function(mAPI, "sqlite3_complete16", _wrap_sqlite3_complete16, -1); - rb_define_module_function(mAPI, "sqlite3_busy_handler", _wrap_sqlite3_busy_handler, -1); - rb_define_module_function(mAPI, "sqlite3_busy_timeout", _wrap_sqlite3_busy_timeout, -1); - rb_define_module_function(mAPI, "sqlite3_set_authorizer", _wrap_sqlite3_set_authorizer, -1); - rb_define_module_function(mAPI, "sqlite3_trace", _wrap_sqlite3_trace, -1); - rb_define_module_function(mAPI, "sqlite3_open", _wrap_sqlite3_open, -1); - rb_define_module_function(mAPI, "sqlite3_open16", _wrap_sqlite3_open16, -1); - rb_define_module_function(mAPI, "sqlite3_errcode", _wrap_sqlite3_errcode, -1); - rb_define_module_function(mAPI, "sqlite3_errmsg", _wrap_sqlite3_errmsg, -1); - rb_define_module_function(mAPI, "sqlite3_errmsg16", _wrap_sqlite3_errmsg16, -1); - rb_define_module_function(mAPI, "sqlite3_prepare", _wrap_sqlite3_prepare, -1); - rb_define_module_function(mAPI, "sqlite3_prepare16", _wrap_sqlite3_prepare16, -1); - rb_define_module_function(mAPI, "sqlite3_bind_blob", _wrap_sqlite3_bind_blob, -1); - rb_define_module_function(mAPI, "sqlite3_bind_double", _wrap_sqlite3_bind_double, -1); - rb_define_module_function(mAPI, "sqlite3_bind_int", _wrap_sqlite3_bind_int, -1); - rb_define_module_function(mAPI, "sqlite3_bind_int64", _wrap_sqlite3_bind_int64, -1); - rb_define_module_function(mAPI, "sqlite3_bind_null", _wrap_sqlite3_bind_null, -1); - rb_define_module_function(mAPI, "sqlite3_bind_text", _wrap_sqlite3_bind_text, -1); - rb_define_module_function(mAPI, "sqlite3_bind_text16", _wrap_sqlite3_bind_text16, -1); - rb_define_module_function(mAPI, "sqlite3_bind_parameter_count", _wrap_sqlite3_bind_parameter_count, -1); - rb_define_module_function(mAPI, "sqlite3_bind_parameter_name", _wrap_sqlite3_bind_parameter_name, -1); - rb_define_module_function(mAPI, "sqlite3_bind_parameter_index", _wrap_sqlite3_bind_parameter_index, -1); - rb_define_module_function(mAPI, "sqlite3_column_count", _wrap_sqlite3_column_count, -1); - rb_define_module_function(mAPI, "sqlite3_column_name", _wrap_sqlite3_column_name, -1); - rb_define_module_function(mAPI, "sqlite3_column_name16", _wrap_sqlite3_column_name16, -1); - rb_define_module_function(mAPI, "sqlite3_column_decltype", _wrap_sqlite3_column_decltype, -1); - rb_define_module_function(mAPI, "sqlite3_column_decltype16", _wrap_sqlite3_column_decltype16, -1); - rb_define_module_function(mAPI, "sqlite3_step", _wrap_sqlite3_step, -1); - rb_define_module_function(mAPI, "sqlite3_data_count", _wrap_sqlite3_data_count, -1); - rb_define_module_function(mAPI, "sqlite3_column_blob", _wrap_sqlite3_column_blob, -1); - rb_define_module_function(mAPI, "sqlite3_column_bytes", _wrap_sqlite3_column_bytes, -1); - rb_define_module_function(mAPI, "sqlite3_column_bytes16", _wrap_sqlite3_column_bytes16, -1); - rb_define_module_function(mAPI, "sqlite3_column_double", _wrap_sqlite3_column_double, -1); - rb_define_module_function(mAPI, "sqlite3_column_int", _wrap_sqlite3_column_int, -1); - rb_define_module_function(mAPI, "sqlite3_column_int64", _wrap_sqlite3_column_int64, -1); - rb_define_module_function(mAPI, "sqlite3_column_text", _wrap_sqlite3_column_text, -1); - rb_define_module_function(mAPI, "sqlite3_column_text16", _wrap_sqlite3_column_text16, -1); - rb_define_module_function(mAPI, "sqlite3_column_type", _wrap_sqlite3_column_type, -1); - rb_define_module_function(mAPI, "sqlite3_finalize", _wrap_sqlite3_finalize, -1); - rb_define_module_function(mAPI, "sqlite3_reset", _wrap_sqlite3_reset, -1); - rb_define_module_function(mAPI, "sqlite3_create_function", _wrap_sqlite3_create_function, -1); - rb_define_module_function(mAPI, "sqlite3_create_function16", _wrap_sqlite3_create_function16, -1); - rb_define_module_function(mAPI, "sqlite3_aggregate_count", _wrap_sqlite3_aggregate_count, -1); - rb_define_module_function(mAPI, "sqlite3_value_blob", _wrap_sqlite3_value_blob, -1); - rb_define_module_function(mAPI, "sqlite3_value_bytes", _wrap_sqlite3_value_bytes, -1); - rb_define_module_function(mAPI, "sqlite3_value_bytes16", _wrap_sqlite3_value_bytes16, -1); - rb_define_module_function(mAPI, "sqlite3_value_double", _wrap_sqlite3_value_double, -1); - rb_define_module_function(mAPI, "sqlite3_value_int", _wrap_sqlite3_value_int, -1); - rb_define_module_function(mAPI, "sqlite3_value_int64", _wrap_sqlite3_value_int64, -1); - rb_define_module_function(mAPI, "sqlite3_value_text", _wrap_sqlite3_value_text, -1); - rb_define_module_function(mAPI, "sqlite3_value_text16", _wrap_sqlite3_value_text16, -1); - rb_define_module_function(mAPI, "sqlite3_value_text16le", _wrap_sqlite3_value_text16le, -1); - rb_define_module_function(mAPI, "sqlite3_value_text16be", _wrap_sqlite3_value_text16be, -1); - rb_define_module_function(mAPI, "sqlite3_value_type", _wrap_sqlite3_value_type, -1); - rb_define_module_function(mAPI, "sqlite3_result_blob", _wrap_sqlite3_result_blob, -1); - rb_define_module_function(mAPI, "sqlite3_result_double", _wrap_sqlite3_result_double, -1); - rb_define_module_function(mAPI, "sqlite3_result_error", _wrap_sqlite3_result_error, -1); - rb_define_module_function(mAPI, "sqlite3_result_error16", _wrap_sqlite3_result_error16, -1); - rb_define_module_function(mAPI, "sqlite3_result_int", _wrap_sqlite3_result_int, -1); - rb_define_module_function(mAPI, "sqlite3_result_int64", _wrap_sqlite3_result_int64, -1); - rb_define_module_function(mAPI, "sqlite3_result_text", _wrap_sqlite3_result_text, -1); - rb_define_module_function(mAPI, "sqlite3_result_text16", _wrap_sqlite3_result_text16, -1); - rb_define_module_function(mAPI, "sqlite3_result_text16le", _wrap_sqlite3_result_text16le, -1); - rb_define_module_function(mAPI, "sqlite3_result_text16be", _wrap_sqlite3_result_text16be, -1); - rb_define_module_function(mAPI, "sqlite3_result_value", _wrap_sqlite3_result_value, -1); - rb_define_module_function(mAPI, "sqlite3_aggregate_context", _wrap_sqlite3_aggregate_context, -1); -} - + + +#ifdef __cplusplus +} +#endif + +/* ----------------------------------------------------------------------------- + * Ruby API portion that goes into the runtime + * ----------------------------------------------------------------------------- */ + +#ifdef __cplusplus +extern "C" { +#endif + +SWIGINTERN VALUE +SWIG_Ruby_AppendOutput(VALUE target, VALUE o) { + if (NIL_P(target)) { + target = o; + } else { + if (TYPE(target) != T_ARRAY) { + VALUE o2 = target; + target = rb_ary_new(); + rb_ary_push(target, o2); + } + rb_ary_push(target, o); + } + return target; +} + +/* For ruby1.8.4 and earlier. */ +#ifndef RUBY_INIT_STACK + RUBY_EXTERN void Init_stack(VALUE* addr); +# define RUBY_INIT_STACK \ + VALUE variable_in_this_stack_frame; \ + Init_stack(&variable_in_this_stack_frame); +#endif + + +#ifdef __cplusplus +} +#endif + + +/* ----------------------------------------------------------------------------- + * See the LICENSE file for information on copyright, usage and redistribution + * of SWIG, and the README file for authors - http://www.swig.org/release.html. + * + * rubyrun.swg + * + * This file contains the runtime support for Ruby modules + * and includes code for managing global variables and pointer + * type checking. + * ----------------------------------------------------------------------------- */ + +/* For backward compatibility only */ +#define SWIG_POINTER_EXCEPTION 0 + +/* for raw pointers */ +#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, 0) +#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, own) +#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Ruby_NewPointerObj(ptr, type, flags) +#define SWIG_AcquirePtr(ptr, own) SWIG_Ruby_AcquirePtr(ptr, own) +#define swig_owntype ruby_owntype + +/* for raw packed data */ +#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty, flags) +#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Ruby_NewPackedObj(ptr, sz, type) + +/* for class or struct pointers */ +#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags) +#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags) + +/* for C or C++ function pointers */ +#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_ConvertPtr(obj, pptr, type, 0) +#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_NewPointerObj(ptr, type, 0) + +/* for C++ member pointers, ie, member methods */ +#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty) +#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Ruby_NewPackedObj(ptr, sz, type) + + +/* Runtime API */ + +#define SWIG_GetModule(clientdata) SWIG_Ruby_GetModule() +#define SWIG_SetModule(clientdata, pointer) SWIG_Ruby_SetModule(pointer) + + +/* Error manipulation */ + +#define SWIG_ErrorType(code) SWIG_Ruby_ErrorType(code) +#define SWIG_Error(code, msg) rb_raise(SWIG_Ruby_ErrorType(code), msg) +#define SWIG_fail goto fail + + +/* Ruby-specific SWIG API */ + +#define SWIG_InitRuntime() SWIG_Ruby_InitRuntime() +#define SWIG_define_class(ty) SWIG_Ruby_define_class(ty) +#define SWIG_NewClassInstance(value, ty) SWIG_Ruby_NewClassInstance(value, ty) +#define SWIG_MangleStr(value) SWIG_Ruby_MangleStr(value) +#define SWIG_CheckConvert(value, ty) SWIG_Ruby_CheckConvert(value, ty) + +#include "assert.h" + +/* ----------------------------------------------------------------------------- + * pointers/data manipulation + * ----------------------------------------------------------------------------- */ + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct { + VALUE klass; + VALUE mImpl; + void (*mark)(void *); + void (*destroy)(void *); + int trackObjects; +} swig_class; + + +/* Global pointer used to keep some internal SWIG stuff */ +static VALUE _cSWIG_Pointer = Qnil; +static VALUE swig_runtime_data_type_pointer = Qnil; + +/* Global IDs used to keep some internal SWIG stuff */ +static ID swig_arity_id = 0; +static ID swig_call_id = 0; + +/* + If your swig extension is to be run within an embedded ruby and has + director callbacks, you should set -DRUBY_EMBEDDED during compilation. + This will reset ruby's stack frame on each entry point from the main + program the first time a virtual director function is invoked (in a + non-recursive way). + If this is not done, you run the risk of Ruby trashing the stack. +*/ + +#ifdef RUBY_EMBEDDED + +# define SWIG_INIT_STACK \ + if ( !swig_virtual_calls ) { RUBY_INIT_STACK } \ + ++swig_virtual_calls; +# define SWIG_RELEASE_STACK --swig_virtual_calls; +# define Ruby_DirectorTypeMismatchException(x) \ + rb_raise( rb_eTypeError, x ); return c_result; + + static unsigned int swig_virtual_calls = 0; + +#else /* normal non-embedded extension */ + +# define SWIG_INIT_STACK +# define SWIG_RELEASE_STACK +# define Ruby_DirectorTypeMismatchException(x) \ + throw Swig::DirectorTypeMismatchException( x ); + +#endif /* RUBY_EMBEDDED */ + + +SWIGRUNTIME VALUE +getExceptionClass(void) { + static int init = 0; + static VALUE rubyExceptionClass ; + if (!init) { + init = 1; + rubyExceptionClass = rb_const_get(_mSWIG, rb_intern("Exception")); + } + return rubyExceptionClass; +} + +/* This code checks to see if the Ruby object being raised as part + of an exception inherits from the Ruby class Exception. If so, + the object is simply returned. If not, then a new Ruby exception + object is created and that will be returned to Ruby.*/ +SWIGRUNTIME VALUE +SWIG_Ruby_ExceptionType(swig_type_info *desc, VALUE obj) { + VALUE exceptionClass = getExceptionClass(); + if (rb_obj_is_kind_of(obj, exceptionClass)) { + return obj; + } else { + return rb_exc_new3(rb_eRuntimeError, rb_obj_as_string(obj)); + } +} + +/* Initialize Ruby runtime support */ +SWIGRUNTIME void +SWIG_Ruby_InitRuntime(void) +{ + if (_mSWIG == Qnil) { + _mSWIG = rb_define_module("SWIG"); + swig_call_id = rb_intern("call"); + swig_arity_id = rb_intern("arity"); + } +} + +/* Define Ruby class for C type */ +SWIGRUNTIME void +SWIG_Ruby_define_class(swig_type_info *type) +{ + VALUE klass; + char *klass_name = (char *) malloc(4 + strlen(type->name) + 1); + sprintf(klass_name, "TYPE%s", type->name); + if (NIL_P(_cSWIG_Pointer)) { + _cSWIG_Pointer = rb_define_class_under(_mSWIG, "Pointer", rb_cObject); + rb_undef_method(CLASS_OF(_cSWIG_Pointer), "new"); + } + klass = rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer); + free((void *) klass_name); +} + +/* Create a new pointer object */ +SWIGRUNTIME VALUE +SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags) +{ + int own = flags & SWIG_POINTER_OWN; + int track; + char *klass_name; + swig_class *sklass; + VALUE klass; + VALUE obj; + + if (!ptr) + return Qnil; + + if (type->clientdata) { + sklass = (swig_class *) type->clientdata; + + /* Are we tracking this class and have we already returned this Ruby object? */ + track = sklass->trackObjects; + if (track) { + obj = SWIG_RubyInstanceFor(ptr); + + /* Check the object's type and make sure it has the correct type. + It might not in cases where methods do things like + downcast methods. */ + if (obj != Qnil) { + VALUE value = rb_iv_get(obj, "@__swigtype__"); + char* type_name = RSTRING_PTR(value); + + if (strcmp(type->name, type_name) == 0) { + return obj; + } + } + } + + /* Create a new Ruby object */ + obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark), + ( own ? VOIDFUNC(sklass->destroy) : + (track ? VOIDFUNC(SWIG_RubyRemoveTracking) : 0 ) + ), ptr); + + /* If tracking is on for this class then track this object. */ + if (track) { + SWIG_RubyAddTracking(ptr, obj); + } + } else { + klass_name = (char *) malloc(4 + strlen(type->name) + 1); + sprintf(klass_name, "TYPE%s", type->name); + klass = rb_const_get(_mSWIG, rb_intern(klass_name)); + free((void *) klass_name); + obj = Data_Wrap_Struct(klass, 0, 0, ptr); + } + rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name)); + + return obj; +} + +/* Create a new class instance (always owned) */ +SWIGRUNTIME VALUE +SWIG_Ruby_NewClassInstance(VALUE klass, swig_type_info *type) +{ + VALUE obj; + swig_class *sklass = (swig_class *) type->clientdata; + obj = Data_Wrap_Struct(klass, VOIDFUNC(sklass->mark), VOIDFUNC(sklass->destroy), 0); + rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name)); + return obj; +} + +/* Get type mangle from class name */ +SWIGRUNTIMEINLINE char * +SWIG_Ruby_MangleStr(VALUE obj) +{ + VALUE stype = rb_iv_get(obj, "@__swigtype__"); + return StringValuePtr(stype); +} + +/* Acquire a pointer value */ +typedef void (*ruby_owntype)(void*); + +SWIGRUNTIME ruby_owntype +SWIG_Ruby_AcquirePtr(VALUE obj, ruby_owntype own) { + if (obj) { + ruby_owntype oldown = RDATA(obj)->dfree; + RDATA(obj)->dfree = own; + return oldown; + } else { + return 0; + } +} + +/* Convert a pointer value */ +SWIGRUNTIME int +SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags, ruby_owntype *own) +{ + char *c; + swig_cast_info *tc; + void *vptr = 0; + + /* Grab the pointer */ + if (NIL_P(obj)) { + *ptr = 0; + return SWIG_OK; + } else { + if (TYPE(obj) != T_DATA) { + return SWIG_ERROR; + } + Data_Get_Struct(obj, void, vptr); + } + + if (own) *own = RDATA(obj)->dfree; + + /* Check to see if the input object is giving up ownership + of the underlying C struct or C++ object. If so then we + need to reset the destructor since the Ruby object no + longer owns the underlying C++ object.*/ + if (flags & SWIG_POINTER_DISOWN) { + /* Is tracking on for this class? */ + int track = 0; + if (ty && ty->clientdata) { + swig_class *sklass = (swig_class *) ty->clientdata; + track = sklass->trackObjects; + } + + if (track) { + /* We are tracking objects for this class. Thus we change the destructor + * to SWIG_RubyRemoveTracking. This allows us to + * remove the mapping from the C++ to Ruby object + * when the Ruby object is garbage collected. If we don't + * do this, then it is possible we will return a reference + * to a Ruby object that no longer exists thereby crashing Ruby. */ + RDATA(obj)->dfree = SWIG_RubyRemoveTracking; + } else { + RDATA(obj)->dfree = 0; + } + } + + /* Do type-checking if type info was provided */ + if (ty) { + if (ty->clientdata) { + if (rb_obj_is_kind_of(obj, ((swig_class *) (ty->clientdata))->klass)) { + if (vptr == 0) { + /* The object has already been deleted */ + return SWIG_ObjectPreviouslyDeletedError; + } + *ptr = vptr; + return SWIG_OK; + } + } + if ((c = SWIG_MangleStr(obj)) == NULL) { + return SWIG_ERROR; + } + tc = SWIG_TypeCheck(c, ty); + if (!tc) { + return SWIG_ERROR; + } else { + int newmemory = 0; + *ptr = SWIG_TypeCast(tc, vptr, &newmemory); + assert(!newmemory); /* newmemory handling not yet implemented */ + } + } else { + *ptr = vptr; + } + + return SWIG_OK; +} + +/* Check convert */ +SWIGRUNTIMEINLINE int +SWIG_Ruby_CheckConvert(VALUE obj, swig_type_info *ty) +{ + char *c = SWIG_MangleStr(obj); + if (!c) return 0; + return SWIG_TypeCheck(c,ty) != 0; +} + +SWIGRUNTIME VALUE +SWIG_Ruby_NewPackedObj(void *ptr, int sz, swig_type_info *type) { + char result[1024]; + char *r = result; + if ((2*sz + 1 + strlen(type->name)) > 1000) return 0; + *(r++) = '_'; + r = SWIG_PackData(r, ptr, sz); + strcpy(r, type->name); + return rb_str_new2(result); +} + +/* Convert a packed value value */ +SWIGRUNTIME int +SWIG_Ruby_ConvertPacked(VALUE obj, void *ptr, int sz, swig_type_info *ty) { + swig_cast_info *tc; + const char *c; + + if (TYPE(obj) != T_STRING) goto type_error; + c = StringValuePtr(obj); + /* Pointer values must start with leading underscore */ + if (*c != '_') goto type_error; + c++; + c = SWIG_UnpackData(c, ptr, sz); + if (ty) { + tc = SWIG_TypeCheck(c, ty); + if (!tc) goto type_error; + } + return SWIG_OK; + + type_error: + return SWIG_ERROR; +} + +SWIGRUNTIME swig_module_info * +SWIG_Ruby_GetModule(void) +{ + VALUE pointer; + swig_module_info *ret = 0; + VALUE verbose = rb_gv_get("VERBOSE"); + + /* temporarily disable warnings, since the pointer check causes warnings with 'ruby -w' */ + rb_gv_set("VERBOSE", Qfalse); + + /* first check if pointer already created */ + pointer = rb_gv_get("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME); + if (pointer != Qnil) { + Data_Get_Struct(pointer, swig_module_info, ret); + } + + /* reinstate warnings */ + rb_gv_set("VERBOSE", verbose); + return ret; +} + +SWIGRUNTIME void +SWIG_Ruby_SetModule(swig_module_info *pointer) +{ + /* register a new class */ + VALUE cl = rb_define_class("swig_runtime_data", rb_cObject); + /* create and store the structure pointer to a global variable */ + swig_runtime_data_type_pointer = Data_Wrap_Struct(cl, 0, 0, pointer); + rb_define_readonly_variable("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, &swig_runtime_data_type_pointer); +} + +/* This function can be used to check whether a proc or method or similarly + callable function has been passed. Usually used in a %typecheck, like: + + %typecheck(c_callback_t, precedence=SWIG_TYPECHECK_POINTER) { + $result = SWIG_Ruby_isCallable( $input ); + } + */ +SWIGINTERN +int SWIG_Ruby_isCallable( VALUE proc ) +{ + if ( rb_respond_to( proc, swig_call_id ) == Qtrue ) + return 1; + return 0; +} + +/* This function can be used to check the arity (number of arguments) + a proc or method can take. Usually used in a %typecheck. + Valid arities will be that equal to minimal or those < 0 + which indicate a variable number of parameters at the end. + */ +SWIGINTERN +int SWIG_Ruby_arity( VALUE proc, int minimal ) +{ + if ( rb_respond_to( proc, swig_arity_id ) == Qtrue ) + { + VALUE num = rb_funcall( proc, swig_arity_id, 0 ); + int arity = NUM2INT(num); + if ( arity < 0 && (arity+1) < -minimal ) return 1; + if ( arity == minimal ) return 1; + return 1; + } + return 0; +} + + +#ifdef __cplusplus +} +#endif + + + +#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) + +#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else + + + +/* -------- TYPES TABLE (BEGIN) -------- */ + +#define SWIGTYPE_p_CallbackData swig_types[0] +#define SWIGTYPE_p_char swig_types[1] +#define SWIGTYPE_p_f_p_sqlite3_context__void swig_types[2] +#define SWIGTYPE_p_f_p_sqlite3_context_int_p_p_sqlite3_value__void swig_types[3] +#define SWIGTYPE_p_f_p_void__void swig_types[4] +#define SWIGTYPE_p_f_p_void_int__int swig_types[5] +#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[6] +#define SWIGTYPE_p_f_p_void_p_q_const__char__void swig_types[7] +#define SWIGTYPE_p_p_char swig_types[8] +#define SWIGTYPE_p_p_sqlite3 swig_types[9] +#define SWIGTYPE_p_p_sqlite3_stmt swig_types[10] +#define SWIGTYPE_p_p_void swig_types[11] +#define SWIGTYPE_p_sqlite3 swig_types[12] +#define SWIGTYPE_p_sqlite3_context swig_types[13] +#define SWIGTYPE_p_sqlite3_stmt swig_types[14] +#define SWIGTYPE_p_sqlite3_value swig_types[15] +#define SWIGTYPE_p_sqlite_int64 swig_types[16] +#define SWIGTYPE_p_void swig_types[17] +static swig_type_info *swig_types[19]; +static swig_module_info swig_module = {swig_types, 18, 0, 0, 0, 0}; +#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) +#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) + +/* -------- TYPES TABLE (END) -------- */ + +#define SWIG_init Init_API +#define SWIG_name "SQLite3::Driver::Native::API" + +static VALUE mAPI; + +#define SWIG_RUBY_THREAD_BEGIN_BLOCK +#define SWIG_RUBY_THREAD_END_BLOCK + + +#define SWIGVERSION 0x010339 +#define SWIG_VERSION SWIGVERSION + + +#define SWIG_as_voidptr(a) (void *)((const void *)(a)) +#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a)) + + +#ifdef __cplusplus +extern "C" { +#endif + +// Ruby 1.9 changed the file name of this header +#ifdef HAVE_RUBY_IO_H +#include "ruby/io.h" +#else +#include "rubyio.h" +#endif + +#ifdef __cplusplus +} +#endif + + +#ifdef __cplusplus +extern "C" { +#endif +#ifdef HAVE_SYS_TIME_H +# include +struct timeval rb_time_timeval(VALUE); +#endif +#ifdef __cplusplus +} +#endif + + +#include +#include "ruby.h" + +#ifndef RSTRING_PTR +#define RSTRING_PTR(s) (RSTRING(s)->ptr) +#endif + +#ifndef RSTRING_LEN +#define RSTRING_LEN(s) (RSTRING(s)->len) +#endif + +#ifndef STR2CSTR +#define STR2CSTR StringValueCStr +#endif + +#define Init_API Init_sqlite3_api + +struct CallbackData { + VALUE proc; + VALUE proc2; + VALUE data; +}; + +typedef struct CallbackData CallbackData; +typedef void RUBY_BLOB; +typedef void RUBY_VALBLOB; + +int Sqlite3_ruby_busy_handler(void* data,int value) { + VALUE result; + CallbackData *cb = (CallbackData*)data; + result = rb_funcall( + cb->proc, rb_intern("call"), 2, cb->data, INT2FIX(value) ); + return FIX2INT(result); +} + +static void mark_CallbackData(void* ptr) { + CallbackData* cb = (CallbackData*)ptr; + if (cb->proc != Qnil) + rb_gc_mark(cb->proc); + if (cb->proc2 != Qnil) + rb_gc_mark(cb->proc2); + if (cb->data != Qnil) + rb_gc_mark(cb->data); +} + +int Sqlite3_ruby_authorizer(void* data,int type, + const char* a,const char* b,const char* c,const char* d) +{ + VALUE result; + CallbackData *cb = (CallbackData*)data; + result = rb_funcall( + cb->proc, rb_intern("call"), 6, cb->data, INT2FIX(type), + ( a ? rb_str_new2(a) : Qnil ), ( b ? rb_str_new2(b) : Qnil ), + ( c ? rb_str_new2(c) : Qnil ), ( d ? rb_str_new2(d) : Qnil ) ); + return FIX2INT(result); +} + +void Sqlite3_ruby_trace(void* data, const char *sql) { + CallbackData *cb = (CallbackData*)data; + rb_funcall( cb->proc, rb_intern("call"), 2, cb->data, + sql ? rb_str_new2(sql) : Qnil ); +} + +void Sqlite3_ruby_function_step(sqlite3_context* ctx,int n, + sqlite3_value** args) +{ + CallbackData *data; + VALUE rb_args; + VALUE *rb_context; + int idx; + + data = (CallbackData*)sqlite3_user_data(ctx); + + if( data->proc2 != Qnil ) { + rb_context = (VALUE*)sqlite3_aggregate_context(ctx,sizeof(VALUE)); + if( *rb_context == 0 ) { + *rb_context = rb_hash_new(); + rb_gc_register_address( rb_context ); + } + } + + rb_args = rb_ary_new2(n+1); + rb_ary_push( rb_args, SWIG_NewPointerObj(ctx,SWIGTYPE_p_sqlite3_context,0) ); + for( idx = 0; idx < n; idx++ ) { + rb_ary_push( rb_args, SWIG_NewPointerObj(args[idx], + SWIGTYPE_p_sqlite3_value,0) ); + } + + rb_apply( data->proc, rb_intern("call"), rb_args ); +} + +void Sqlite3_ruby_function_final(sqlite3_context *ctx) { + VALUE *rb_context; + CallbackData *data; + + rb_context = (VALUE*)sqlite3_aggregate_context(ctx,sizeof(VALUE)); + if( *rb_context == 0 ) { + *rb_context = rb_hash_new(); + rb_gc_register_address( rb_context ); + } + + data = (CallbackData*)sqlite3_user_data(ctx); + + rb_funcall( data->proc2, rb_intern("call"), 1, + SWIG_NewPointerObj(ctx,SWIGTYPE_p_sqlite3_context,0) ); + + rb_gc_unregister_address( rb_context ); +} + + +#include +#if !defined(SWIG_NO_LLONG_MAX) +# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__) +# define LLONG_MAX __LONG_LONG_MAX__ +# define LLONG_MIN (-LLONG_MAX - 1LL) +# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL) +# endif +#endif + + + #define SWIG_From_long LONG2NUM + + +SWIGINTERNINLINE VALUE +SWIG_From_int (int value) +{ + return SWIG_From_long (value); +} + + +SWIGINTERN swig_type_info* +SWIG_pchar_descriptor(void) +{ + static int init = 0; + static swig_type_info* info = 0; + if (!init) { + info = SWIG_TypeQuery("_p_char"); + init = 1; + } + return info; +} + + +SWIGINTERN int +SWIG_AsCharPtrAndSize(VALUE obj, char** cptr, size_t* psize, int *alloc) +{ + if (TYPE(obj) == T_STRING) { + #if defined(StringValuePtr) + char *cstr = StringValuePtr(obj); + #else + char *cstr = STR2CSTR(obj); + #endif + size_t size = RSTRING_LEN(obj) + 1; + if (cptr) { + if (alloc) { + if (*alloc == SWIG_NEWOBJ) { + *cptr = (char *)memcpy((char *)malloc((size)*sizeof(char)), cstr, sizeof(char)*(size)); + } else { + *cptr = cstr; + *alloc = SWIG_OLDOBJ; + } + } + } + if (psize) *psize = size; + return SWIG_OK; + } else { + swig_type_info* pchar_descriptor = SWIG_pchar_descriptor(); + if (pchar_descriptor) { + void* vptr = 0; + if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) { + if (cptr) *cptr = (char *)vptr; + if (psize) *psize = vptr ? (strlen((char*)vptr) + 1) : 0; + if (alloc) *alloc = SWIG_OLDOBJ; + return SWIG_OK; + } + } + } + return SWIG_TypeError; +} + + + + + +SWIGINTERN VALUE +SWIG_ruby_failed(void) +{ + return Qnil; +} + + +/*@SWIG:C:\\Users\\Luis\\Downloads\\swigwin-1.3.39\\Lib\\ruby\\rubyprimtypes.swg,23,%ruby_aux_method@*/ +SWIGINTERN VALUE SWIG_AUX_NUM2LONG(VALUE *args) +{ + VALUE obj = args[0]; + VALUE type = TYPE(obj); + long *res = (long *)(args[1]); + *res = type == T_FIXNUM ? NUM2LONG(obj) : rb_big2long(obj); + return obj; +} +/*@SWIG@*/ + +SWIGINTERN int +SWIG_AsVal_long (VALUE obj, long* val) +{ + VALUE type = TYPE(obj); + if ((type == T_FIXNUM) || (type == T_BIGNUM)) { + long v; + VALUE a[2]; + a[0] = obj; + a[1] = (VALUE)(&v); + if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2LONG), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) { + if (val) *val = v; + return SWIG_OK; + } + } + return SWIG_TypeError; +} + + +SWIGINTERN int +SWIG_AsVal_int (VALUE obj, int *val) +{ + long v; + int res = SWIG_AsVal_long (obj, &v); + if (SWIG_IsOK(res)) { + if ((v < INT_MIN || v > INT_MAX)) { + return SWIG_OverflowError; + } else { + if (val) *val = (int)(v); + } + } + return res; +} + + +/*@SWIG:C:\\Users\\Luis\\Downloads\\swigwin-1.3.39\\Lib\\ruby\\rubyprimtypes.swg,23,%ruby_aux_method@*/ +SWIGINTERN VALUE SWIG_AUX_NUM2DBL(VALUE *args) +{ + VALUE obj = args[0]; + VALUE type = TYPE(obj); + double *res = (double *)(args[1]); + *res = (type == T_FLOAT ? NUM2DBL(obj) : (type == T_FIXNUM ? (double) FIX2INT(obj) : rb_big2dbl(obj))); + return obj; +} +/*@SWIG@*/ + +SWIGINTERN int +SWIG_AsVal_double (VALUE obj, double *val) +{ + VALUE type = TYPE(obj); + if ((type == T_FLOAT) || (type == T_FIXNUM) || (type == T_BIGNUM)) { + double v; + VALUE a[2]; + a[0] = obj; + a[1] = (VALUE)(&v); + if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2DBL), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) { + if (val) *val = v; + return SWIG_OK; + } + } + return SWIG_TypeError; +} + + + #define SWIG_From_double rb_float_new + +swig_class SwigClassCallbackData; + +SWIGINTERN VALUE +_wrap_CallbackData_proc_set(int argc, VALUE *argv, VALUE self) { + struct CallbackData *arg1 = (struct CallbackData *) 0 ; + VALUE arg2 = (VALUE) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((argc < 1) || (argc > 1)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CallbackData, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct CallbackData *","proc", 1, self )); + } + arg1 = (struct CallbackData *)(argp1); + arg2 = argv[0]; + if (arg1) (arg1)->proc = arg2; + return Qnil; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_CallbackData_proc_get(int argc, VALUE *argv, VALUE self) { + struct CallbackData *arg1 = (struct CallbackData *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + VALUE result; + VALUE vresult = Qnil; + + if ((argc < 0) || (argc > 0)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CallbackData, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct CallbackData *","proc", 1, self )); + } + arg1 = (struct CallbackData *)(argp1); + result = (VALUE) ((arg1)->proc); + vresult = result; + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_CallbackData_proc2_set(int argc, VALUE *argv, VALUE self) { + struct CallbackData *arg1 = (struct CallbackData *) 0 ; + VALUE arg2 = (VALUE) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((argc < 1) || (argc > 1)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CallbackData, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct CallbackData *","proc2", 1, self )); + } + arg1 = (struct CallbackData *)(argp1); + arg2 = argv[0]; + if (arg1) (arg1)->proc2 = arg2; + return Qnil; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_CallbackData_proc2_get(int argc, VALUE *argv, VALUE self) { + struct CallbackData *arg1 = (struct CallbackData *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + VALUE result; + VALUE vresult = Qnil; + + if ((argc < 0) || (argc > 0)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CallbackData, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct CallbackData *","proc2", 1, self )); + } + arg1 = (struct CallbackData *)(argp1); + result = (VALUE) ((arg1)->proc2); + vresult = result; + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_CallbackData_data_set(int argc, VALUE *argv, VALUE self) { + struct CallbackData *arg1 = (struct CallbackData *) 0 ; + VALUE arg2 = (VALUE) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((argc < 1) || (argc > 1)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CallbackData, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct CallbackData *","data", 1, self )); + } + arg1 = (struct CallbackData *)(argp1); + arg2 = argv[0]; + if (arg1) (arg1)->data = arg2; + return Qnil; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_CallbackData_data_get(int argc, VALUE *argv, VALUE self) { + struct CallbackData *arg1 = (struct CallbackData *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + VALUE result; + VALUE vresult = Qnil; + + if ((argc < 0) || (argc > 0)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CallbackData, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct CallbackData *","data", 1, self )); + } + arg1 = (struct CallbackData *)(argp1); + result = (VALUE) ((arg1)->data); + vresult = result; + return vresult; +fail: + return Qnil; +} + + +#ifdef HAVE_RB_DEFINE_ALLOC_FUNC +SWIGINTERN VALUE +_wrap_CallbackData_allocate(VALUE self) { +#else + SWIGINTERN VALUE + _wrap_CallbackData_allocate(int argc, VALUE *argv, VALUE self) { +#endif + + + VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_CallbackData); +#ifndef HAVE_RB_DEFINE_ALLOC_FUNC + rb_obj_call_init(vresult, argc, argv); +#endif + return vresult; + } + + +SWIGINTERN VALUE +_wrap_new_CallbackData(int argc, VALUE *argv, VALUE self) { + struct CallbackData *result = 0 ; + + if ((argc < 0) || (argc > 0)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail; + } + result = (struct CallbackData *)calloc(1, sizeof(struct CallbackData)); + DATA_PTR(self) = result; + return self; +fail: + return Qnil; +} + + +SWIGINTERN void +free_CallbackData(struct CallbackData *arg1) { + free((char *) arg1); +} + +SWIGINTERN VALUE +_wrap_sqlite3_libversion(int argc, VALUE *argv, VALUE self) { + char *result = 0 ; + VALUE vresult = Qnil; + + if ((argc < 0) || (argc > 0)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail; + } + result = (char *)sqlite3_libversion(); + { + vresult = result ? rb_str_new2(result) : Qnil; + } + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_close(int argc, VALUE *argv, VALUE self) { + sqlite3 *arg1 = (sqlite3 *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3 *","sqlite3_close", 1, argv[0] )); + } + arg1 = (sqlite3 *)(argp1); + result = (int)sqlite3_close(arg1); + vresult = SWIG_From_int((int)(result)); + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_last_insert_rowid(int argc, VALUE *argv, VALUE self) { + sqlite3 *arg1 = (sqlite3 *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + sqlite_int64 result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3 *","sqlite3_last_insert_rowid", 1, argv[0] )); + } + arg1 = (sqlite3 *)(argp1); + result = sqlite3_last_insert_rowid(arg1); + { + vresult = rb_ll2inum( result ); + } + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_changes(int argc, VALUE *argv, VALUE self) { + sqlite3 *arg1 = (sqlite3 *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3 *","sqlite3_changes", 1, argv[0] )); + } + arg1 = (sqlite3 *)(argp1); + result = (int)sqlite3_changes(arg1); + vresult = SWIG_From_int((int)(result)); + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_total_changes(int argc, VALUE *argv, VALUE self) { + sqlite3 *arg1 = (sqlite3 *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3 *","sqlite3_total_changes", 1, argv[0] )); + } + arg1 = (sqlite3 *)(argp1); + result = (int)sqlite3_total_changes(arg1); + vresult = SWIG_From_int((int)(result)); + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_interrupt(int argc, VALUE *argv, VALUE self) { + sqlite3 *arg1 = (sqlite3 *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((argc < 1) || (argc > 1)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3 *","sqlite3_interrupt", 1, argv[0] )); + } + arg1 = (sqlite3 *)(argp1); + sqlite3_interrupt(arg1); + return Qnil; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_complete(int argc, VALUE *argv, VALUE self) { + char *arg1 = (char *) 0 ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; + } + res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","sqlite3_complete", 1, argv[0] )); + } + arg1 = (char *)(buf1); + result = (int)sqlite3_complete((char const *)arg1); + vresult = SWIG_From_int((int)(result)); + if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); + return vresult; +fail: + if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_complete16(int argc, VALUE *argv, VALUE self) { + void *arg1 = (void *) 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; + } + { + arg1 = (void*)RSTRING_PTR(argv[0]); + } + result = (int)sqlite3_complete16((void const *)arg1); + vresult = SWIG_From_int((int)(result)); + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_busy_handler(int argc, VALUE *argv, VALUE self) { + sqlite3 *arg1 = (sqlite3 *) 0 ; + int (*arg2)(void *,int) = (int (*)(void *,int)) 0 ; + void *arg3 = (void *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res3 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 3) || (argc > 3)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3 *","sqlite3_busy_handler", 1, argv[0] )); + } + arg1 = (sqlite3 *)(argp1); + { + int res = SWIG_ConvertFunctionPtr(argv[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_int__int); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "int (*)(void *,int)","sqlite3_busy_handler", 2, argv[1] )); + } + } + res3 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg3), 0, 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "void *","sqlite3_busy_handler", 3, argv[2] )); + } + result = (int)sqlite3_busy_handler(arg1,arg2,arg3); + vresult = SWIG_From_int((int)(result)); + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_busy_timeout(int argc, VALUE *argv, VALUE self) { + sqlite3 *arg1 = (sqlite3 *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 2) || (argc > 2)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3 *","sqlite3_busy_timeout", 1, argv[0] )); + } + arg1 = (sqlite3 *)(argp1); + ecode2 = SWIG_AsVal_int(argv[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","sqlite3_busy_timeout", 2, argv[1] )); + } + arg2 = (int)(val2); + result = (int)sqlite3_busy_timeout(arg1,arg2); + vresult = SWIG_From_int((int)(result)); + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_set_authorizer(int argc, VALUE *argv, VALUE self) { + sqlite3 *arg1 = (sqlite3 *) 0 ; + int (*arg2)(void *,int,char const *,char const *,char const *,char const *) = (int (*)(void *,int,char const *,char const *,char const *,char const *)) 0 ; + void *arg3 = (void *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res3 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 3) || (argc > 3)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3 *","sqlite3_set_authorizer", 1, argv[0] )); + } + arg1 = (sqlite3 *)(argp1); + { + 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); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "int (*)(void *,int,char const *,char const *,char const *,char const *)","sqlite3_set_authorizer", 2, argv[1] )); + } + } + res3 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg3), 0, 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "void *","sqlite3_set_authorizer", 3, argv[2] )); + } + result = (int)sqlite3_set_authorizer(arg1,arg2,arg3); + vresult = SWIG_From_int((int)(result)); + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_trace(int argc, VALUE *argv, VALUE self) { + sqlite3 *arg1 = (sqlite3 *) 0 ; + void (*arg2)(void *,char const *) = (void (*)(void *,char const *)) 0 ; + void *arg3 = (void *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res3 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 3) || (argc > 3)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3 *","sqlite3_trace", 1, argv[0] )); + } + arg1 = (sqlite3 *)(argp1); + { + int res = SWIG_ConvertFunctionPtr(argv[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__char__void); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "void (*)(void *,char const *)","sqlite3_trace", 2, argv[1] )); + } + } + res3 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg3), 0, 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "void *","sqlite3_trace", 3, argv[2] )); + } + result = (int)sqlite3_trace(arg1,arg2,arg3); + vresult = SWIG_From_int((int)(result)); + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_open(int argc, VALUE *argv, VALUE self) { + char *arg1 = (char *) 0 ; + sqlite3 **arg2 = (sqlite3 **) 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; + } + { + arg1 = STR2CSTR(argv[0]); + arg2 = (sqlite3**)malloc( sizeof( sqlite3* ) ); + } + result = (int)sqlite3_open((char const *)arg1,arg2); + vresult = SWIG_From_int((int)(result)); + { + VALUE ary; + ary = rb_ary_new2(2); + rb_ary_push( ary, vresult ); + rb_ary_push( ary, SWIG_NewPointerObj( *arg2, SWIGTYPE_p_sqlite3, 0 ) ); + free( arg2 ); + vresult = ary; + } + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_open16(int argc, VALUE *argv, VALUE self) { + void *arg1 = (void *) 0 ; + sqlite3 **arg2 = (sqlite3 **) 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; + } + { + arg1 = (void*)RSTRING_PTR(argv[0]); + arg2 = (sqlite3**)malloc( sizeof( sqlite3* ) ); + } + result = (int)sqlite3_open16((void const *)arg1,arg2); + vresult = SWIG_From_int((int)(result)); + { + VALUE ary; + ary = rb_ary_new2(2); + rb_ary_push( ary, vresult ); + rb_ary_push( ary, SWIG_NewPointerObj( *arg2, SWIGTYPE_p_sqlite3, 0 ) ); + free( arg2 ); + vresult = ary; + } + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_errcode(int argc, VALUE *argv, VALUE self) { + sqlite3 *arg1 = (sqlite3 *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3 *","sqlite3_errcode", 1, argv[0] )); + } + arg1 = (sqlite3 *)(argp1); + result = (int)sqlite3_errcode(arg1); + vresult = SWIG_From_int((int)(result)); + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_errmsg(int argc, VALUE *argv, VALUE self) { + sqlite3 *arg1 = (sqlite3 *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char *result = 0 ; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3 *","sqlite3_errmsg", 1, argv[0] )); + } + arg1 = (sqlite3 *)(argp1); + result = (char *)sqlite3_errmsg(arg1); + { + vresult = result ? rb_str_new2(result) : Qnil; + } + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_errmsg16(int argc, VALUE *argv, VALUE self) { + sqlite3 *arg1 = (sqlite3 *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *result = 0 ; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3 *","sqlite3_errmsg16", 1, argv[0] )); + } + arg1 = (sqlite3 *)(argp1); + result = (void *)sqlite3_errmsg16(arg1); + { + int i; + if( result ) { + for( i = 0; ((char*)result)[i]; i += 2 ); + vresult = rb_str_new( (char*)result, i ); + } else vresult = Qnil; + } + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_prepare(int argc, VALUE *argv, VALUE self) { + sqlite3 *arg1 = (sqlite3 *) 0 ; + char *arg2 = (char *) 0 ; + int arg3 ; + sqlite3_stmt **arg4 = (sqlite3_stmt **) 0 ; + char **arg5 = (char **) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + sqlite3_stmt *stmt2 ; + char *errmsg2 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 2) || (argc > 2)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3 *","sqlite3_prepare", 1, argv[0] )); + } + arg1 = (sqlite3 *)(argp1); + { + arg2 = RSTRING_PTR(argv[1]); + arg3 = RSTRING_LEN(argv[1]); + arg4 = &stmt2; + arg5 = &errmsg2; + } + result = (int)sqlite3_prepare(arg1,(char const *)arg2,arg3,arg4,(char const **)arg5); + vresult = SWIG_From_int((int)(result)); + { + VALUE ary; + ary = rb_ary_new2(3); + rb_ary_push( ary, vresult ); + rb_ary_push( ary, SWIG_NewPointerObj( stmt2, SWIGTYPE_p_sqlite3_stmt, 0 ) ); + rb_ary_push( ary, errmsg2 ? rb_str_new2( errmsg2 ) : Qnil ); + vresult = ary; + } + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_prepare16(int argc, VALUE *argv, VALUE self) { + sqlite3 *arg1 = (sqlite3 *) 0 ; + void *arg2 = (void *) 0 ; + int arg3 ; + sqlite3_stmt **arg4 = (sqlite3_stmt **) 0 ; + void **arg5 = (void **) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + sqlite3_stmt *stmt2 ; + void *errmsg2 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 2) || (argc > 2)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3 *","sqlite3_prepare16", 1, argv[0] )); + } + arg1 = (sqlite3 *)(argp1); + { + arg2 = RSTRING_PTR(argv[1]); + arg3 = RSTRING_LEN(argv[1]); + arg4 = &stmt2; + arg5 = &errmsg2; + } + result = (int)sqlite3_prepare16(arg1,(void const *)arg2,arg3,arg4,(void const **)arg5); + vresult = SWIG_From_int((int)(result)); + { + VALUE ary; + int i; + + for( i = 0; ((char*)errmsg2)[i]; i += 2 ); + + ary = rb_ary_new2(3); + rb_ary_push( ary, vresult ); + rb_ary_push( ary, SWIG_NewPointerObj( stmt2, SWIGTYPE_p_sqlite3_stmt, 0 ) ); + rb_ary_push( ary, errmsg2 ? rb_str_new( (char*)errmsg2, i ) : Qnil ); + vresult = ary; + } + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_bind_blob(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + int arg2 ; + void *arg3 = (void *) 0 ; + int arg4 ; + void (*arg5)(void *) = (void (*)(void *)) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 3) || (argc > 3)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_stmt *","sqlite3_bind_blob", 1, argv[0] )); + } + arg1 = (sqlite3_stmt *)(argp1); + ecode2 = SWIG_AsVal_int(argv[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","sqlite3_bind_blob", 2, argv[1] )); + } + arg2 = (int)(val2); + { + arg3 = (void*)RSTRING_PTR(argv[2]); + arg4 = RSTRING_LEN(argv[2]); + arg5 = SQLITE_TRANSIENT; + } + result = (int)sqlite3_bind_blob(arg1,arg2,(void const *)arg3,arg4,arg5); + vresult = SWIG_From_int((int)(result)); + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_bind_double(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + int arg2 ; + double arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + double val3 ; + int ecode3 = 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 3) || (argc > 3)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_stmt *","sqlite3_bind_double", 1, argv[0] )); + } + arg1 = (sqlite3_stmt *)(argp1); + ecode2 = SWIG_AsVal_int(argv[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","sqlite3_bind_double", 2, argv[1] )); + } + arg2 = (int)(val2); + ecode3 = SWIG_AsVal_double(argv[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","sqlite3_bind_double", 3, argv[2] )); + } + arg3 = (double)(val3); + result = (int)sqlite3_bind_double(arg1,arg2,arg3); + vresult = SWIG_From_int((int)(result)); + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_bind_int(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + int arg2 ; + int arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 3) || (argc > 3)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_stmt *","sqlite3_bind_int", 1, argv[0] )); + } + arg1 = (sqlite3_stmt *)(argp1); + ecode2 = SWIG_AsVal_int(argv[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","sqlite3_bind_int", 2, argv[1] )); + } + arg2 = (int)(val2); + ecode3 = SWIG_AsVal_int(argv[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","sqlite3_bind_int", 3, argv[2] )); + } + arg3 = (int)(val3); + result = (int)sqlite3_bind_int(arg1,arg2,arg3); + vresult = SWIG_From_int((int)(result)); + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_bind_int64(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + int arg2 ; + sqlite_int64 arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 3) || (argc > 3)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_stmt *","sqlite3_bind_int64", 1, argv[0] )); + } + arg1 = (sqlite3_stmt *)(argp1); + ecode2 = SWIG_AsVal_int(argv[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","sqlite3_bind_int64", 2, argv[1] )); + } + arg2 = (int)(val2); + { + arg3 = rb_num2ll( argv[2] ); + } + result = (int)sqlite3_bind_int64(arg1,arg2,arg3); + vresult = SWIG_From_int((int)(result)); + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_bind_null(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 2) || (argc > 2)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_stmt *","sqlite3_bind_null", 1, argv[0] )); + } + arg1 = (sqlite3_stmt *)(argp1); + ecode2 = SWIG_AsVal_int(argv[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","sqlite3_bind_null", 2, argv[1] )); + } + arg2 = (int)(val2); + result = (int)sqlite3_bind_null(arg1,arg2); + vresult = SWIG_From_int((int)(result)); + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_bind_text(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + int arg2 ; + char *arg3 = (char *) 0 ; + int arg4 ; + void (*arg5)(void *) = (void (*)(void *)) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 3) || (argc > 3)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_stmt *","sqlite3_bind_text", 1, argv[0] )); + } + arg1 = (sqlite3_stmt *)(argp1); + ecode2 = SWIG_AsVal_int(argv[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","sqlite3_bind_text", 2, argv[1] )); + } + arg2 = (int)(val2); + { + arg3 = RSTRING_PTR(argv[2]); + arg4 = RSTRING_LEN(argv[2]); + arg5 = SQLITE_TRANSIENT; + } + result = (int)sqlite3_bind_text(arg1,arg2,(char const *)arg3,arg4,arg5); + vresult = SWIG_From_int((int)(result)); + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_bind_text16(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + int arg2 ; + void *arg3 = (void *) 0 ; + int arg4 ; + void (*arg5)(void *) = (void (*)(void *)) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 3) || (argc > 3)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_stmt *","sqlite3_bind_text16", 1, argv[0] )); + } + arg1 = (sqlite3_stmt *)(argp1); + ecode2 = SWIG_AsVal_int(argv[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","sqlite3_bind_text16", 2, argv[1] )); + } + arg2 = (int)(val2); + { + arg3 = (void*)RSTRING_PTR(argv[2]); + arg4 = RSTRING_LEN(argv[2]); + arg5 = SQLITE_TRANSIENT; + } + result = (int)sqlite3_bind_text16(arg1,arg2,(void const *)arg3,arg4,arg5); + vresult = SWIG_From_int((int)(result)); + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_bind_parameter_count(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_stmt *","sqlite3_bind_parameter_count", 1, argv[0] )); + } + arg1 = (sqlite3_stmt *)(argp1); + result = (int)sqlite3_bind_parameter_count(arg1); + vresult = SWIG_From_int((int)(result)); + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_bind_parameter_name(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + char *result = 0 ; + VALUE vresult = Qnil; + + if ((argc < 2) || (argc > 2)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_stmt *","sqlite3_bind_parameter_name", 1, argv[0] )); + } + arg1 = (sqlite3_stmt *)(argp1); + ecode2 = SWIG_AsVal_int(argv[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","sqlite3_bind_parameter_name", 2, argv[1] )); + } + arg2 = (int)(val2); + result = (char *)sqlite3_bind_parameter_name(arg1,arg2); + { + vresult = result ? rb_str_new2(result) : Qnil; + } + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_bind_parameter_index(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + char *arg2 = (char *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 2) || (argc > 2)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_stmt *","sqlite3_bind_parameter_index", 1, argv[0] )); + } + arg1 = (sqlite3_stmt *)(argp1); + res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","sqlite3_bind_parameter_index", 2, argv[1] )); + } + arg2 = (char *)(buf2); + result = (int)sqlite3_bind_parameter_index(arg1,(char const *)arg2); + vresult = SWIG_From_int((int)(result)); + if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); + return vresult; +fail: + if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_column_count(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_stmt *","sqlite3_column_count", 1, argv[0] )); + } + arg1 = (sqlite3_stmt *)(argp1); + result = (int)sqlite3_column_count(arg1); + vresult = SWIG_From_int((int)(result)); + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_column_name(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + char *result = 0 ; + VALUE vresult = Qnil; + + if ((argc < 2) || (argc > 2)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_stmt *","sqlite3_column_name", 1, argv[0] )); + } + arg1 = (sqlite3_stmt *)(argp1); + ecode2 = SWIG_AsVal_int(argv[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","sqlite3_column_name", 2, argv[1] )); + } + arg2 = (int)(val2); + result = (char *)sqlite3_column_name(arg1,arg2); + { + vresult = result ? rb_str_new2(result) : Qnil; + } + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_column_name16(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *result = 0 ; + VALUE vresult = Qnil; + + if ((argc < 2) || (argc > 2)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_stmt *","sqlite3_column_name16", 1, argv[0] )); + } + arg1 = (sqlite3_stmt *)(argp1); + ecode2 = SWIG_AsVal_int(argv[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","sqlite3_column_name16", 2, argv[1] )); + } + arg2 = (int)(val2); + result = (void *)sqlite3_column_name16(arg1,arg2); + { + int i; + if( result ) { + for( i = 0; ((char*)result)[i]; i += 2 ); + vresult = rb_str_new( (char*)result, i ); + } else vresult = Qnil; + } + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_column_decltype(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + char *result = 0 ; + VALUE vresult = Qnil; + + if ((argc < 2) || (argc > 2)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_stmt *","sqlite3_column_decltype", 1, argv[0] )); + } + arg1 = (sqlite3_stmt *)(argp1); + ecode2 = SWIG_AsVal_int(argv[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","sqlite3_column_decltype", 2, argv[1] )); + } + arg2 = (int)(val2); + result = (char *)sqlite3_column_decltype(arg1,arg2); + { + vresult = result ? rb_str_new2(result) : Qnil; + } + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_column_decltype16(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *result = 0 ; + VALUE vresult = Qnil; + + if ((argc < 2) || (argc > 2)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_stmt *","sqlite3_column_decltype16", 1, argv[0] )); + } + arg1 = (sqlite3_stmt *)(argp1); + ecode2 = SWIG_AsVal_int(argv[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","sqlite3_column_decltype16", 2, argv[1] )); + } + arg2 = (int)(val2); + result = (void *)sqlite3_column_decltype16(arg1,arg2); + { + int i; + if( result ) { + for( i = 0; ((char*)result)[i]; i += 2 ); + vresult = rb_str_new( (char*)result, i ); + } else vresult = Qnil; + } + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_step(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_stmt *","sqlite3_step", 1, argv[0] )); + } + arg1 = (sqlite3_stmt *)(argp1); + result = (int)sqlite3_step(arg1); + vresult = SWIG_From_int((int)(result)); + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_data_count(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_stmt *","sqlite3_data_count", 1, argv[0] )); + } + arg1 = (sqlite3_stmt *)(argp1); + result = (int)sqlite3_data_count(arg1); + vresult = SWIG_From_int((int)(result)); + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_column_blob(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + RUBY_BLOB *result = 0 ; + VALUE vresult = Qnil; + + if ((argc < 2) || (argc > 2)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_stmt *","sqlite3_column_blob", 1, argv[0] )); + } + arg1 = (sqlite3_stmt *)(argp1); + ecode2 = SWIG_AsVal_int(argv[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","sqlite3_column_blob", 2, argv[1] )); + } + arg2 = (int)(val2); + result = (RUBY_BLOB *)sqlite3_column_blob(arg1,arg2); + { + vresult = result ? + rb_str_new( (char*)result, sqlite3_column_bytes( arg1, arg2 ) ) : Qnil; + } + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_column_bytes(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 2) || (argc > 2)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_stmt *","sqlite3_column_bytes", 1, argv[0] )); + } + arg1 = (sqlite3_stmt *)(argp1); + ecode2 = SWIG_AsVal_int(argv[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","sqlite3_column_bytes", 2, argv[1] )); + } + arg2 = (int)(val2); + result = (int)sqlite3_column_bytes(arg1,arg2); + vresult = SWIG_From_int((int)(result)); + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_column_bytes16(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 2) || (argc > 2)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_stmt *","sqlite3_column_bytes16", 1, argv[0] )); + } + arg1 = (sqlite3_stmt *)(argp1); + ecode2 = SWIG_AsVal_int(argv[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","sqlite3_column_bytes16", 2, argv[1] )); + } + arg2 = (int)(val2); + result = (int)sqlite3_column_bytes16(arg1,arg2); + vresult = SWIG_From_int((int)(result)); + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_column_double(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + double result; + VALUE vresult = Qnil; + + if ((argc < 2) || (argc > 2)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_stmt *","sqlite3_column_double", 1, argv[0] )); + } + arg1 = (sqlite3_stmt *)(argp1); + ecode2 = SWIG_AsVal_int(argv[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","sqlite3_column_double", 2, argv[1] )); + } + arg2 = (int)(val2); + result = (double)sqlite3_column_double(arg1,arg2); + vresult = SWIG_From_double((double)(result)); + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_column_int(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + double result; + VALUE vresult = Qnil; + + if ((argc < 2) || (argc > 2)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_stmt *","sqlite3_column_int", 1, argv[0] )); + } + arg1 = (sqlite3_stmt *)(argp1); + ecode2 = SWIG_AsVal_int(argv[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","sqlite3_column_int", 2, argv[1] )); + } + arg2 = (int)(val2); + result = (double)sqlite3_column_int(arg1,arg2); + vresult = SWIG_From_double((double)(result)); + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_column_int64(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + sqlite_int64 result; + VALUE vresult = Qnil; + + if ((argc < 2) || (argc > 2)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_stmt *","sqlite3_column_int64", 1, argv[0] )); + } + arg1 = (sqlite3_stmt *)(argp1); + ecode2 = SWIG_AsVal_int(argv[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","sqlite3_column_int64", 2, argv[1] )); + } + arg2 = (int)(val2); + result = sqlite3_column_int64(arg1,arg2); + { + vresult = rb_ll2inum( result ); + } + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_column_text(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + char *result = 0 ; + VALUE vresult = Qnil; + + if ((argc < 2) || (argc > 2)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_stmt *","sqlite3_column_text", 1, argv[0] )); + } + arg1 = (sqlite3_stmt *)(argp1); + ecode2 = SWIG_AsVal_int(argv[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","sqlite3_column_text", 2, argv[1] )); + } + arg2 = (int)(val2); + result = (char *)sqlite3_column_text(arg1,arg2); + { + vresult = result ? rb_str_new2(result) : Qnil; + } + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_column_text16(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *result = 0 ; + VALUE vresult = Qnil; + + if ((argc < 2) || (argc > 2)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_stmt *","sqlite3_column_text16", 1, argv[0] )); + } + arg1 = (sqlite3_stmt *)(argp1); + ecode2 = SWIG_AsVal_int(argv[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","sqlite3_column_text16", 2, argv[1] )); + } + arg2 = (int)(val2); + result = (void *)sqlite3_column_text16(arg1,arg2); + { + int i; + if( result ) { + for( i = 0; ((char*)result)[i]; i += 2 ); + vresult = rb_str_new( (char*)result, i ); + } else vresult = Qnil; + } + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_column_type(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 2) || (argc > 2)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_stmt *","sqlite3_column_type", 1, argv[0] )); + } + arg1 = (sqlite3_stmt *)(argp1); + ecode2 = SWIG_AsVal_int(argv[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","sqlite3_column_type", 2, argv[1] )); + } + arg2 = (int)(val2); + result = (int)sqlite3_column_type(arg1,arg2); + vresult = SWIG_From_int((int)(result)); + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_finalize(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_stmt *","sqlite3_finalize", 1, argv[0] )); + } + arg1 = (sqlite3_stmt *)(argp1); + result = (int)sqlite3_finalize(arg1); + vresult = SWIG_From_int((int)(result)); + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_reset(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_stmt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_stmt *","sqlite3_reset", 1, argv[0] )); + } + arg1 = (sqlite3_stmt *)(argp1); + result = (int)sqlite3_reset(arg1); + vresult = SWIG_From_int((int)(result)); + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_create_function(int argc, VALUE *argv, VALUE self) { + sqlite3 *arg1 = (sqlite3 *) 0 ; + char *arg2 = (char *) 0 ; + int arg3 ; + int arg4 ; + void *arg5 = (void *) 0 ; + void (*arg6)(sqlite3_context *,int,sqlite3_value **) = (void (*)(sqlite3_context *,int,sqlite3_value **)) 0 ; + void (*arg7)(sqlite3_context *,int,sqlite3_value **) = (void (*)(sqlite3_context *,int,sqlite3_value **)) 0 ; + void (*arg8)(sqlite3_context *) = (void (*)(sqlite3_context *)) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + int val3 ; + int ecode3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int res5 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 8) || (argc > 8)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 8)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3 *","sqlite3_create_function", 1, argv[0] )); + } + arg1 = (sqlite3 *)(argp1); + res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","sqlite3_create_function", 2, argv[1] )); + } + arg2 = (char *)(buf2); + ecode3 = SWIG_AsVal_int(argv[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","sqlite3_create_function", 3, argv[2] )); + } + arg3 = (int)(val3); + ecode4 = SWIG_AsVal_int(argv[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","sqlite3_create_function", 4, argv[3] )); + } + arg4 = (int)(val4); + res5 = SWIG_ConvertPtr(argv[4],SWIG_as_voidptrptr(&arg5), 0, 0); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "void *","sqlite3_create_function", 5, argv[4] )); + } + { + int res = SWIG_ConvertFunctionPtr(argv[5], (void**)(&arg6), SWIGTYPE_p_f_p_sqlite3_context_int_p_p_sqlite3_value__void); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "void (*)(sqlite3_context *,int,sqlite3_value **)","sqlite3_create_function", 6, argv[5] )); + } + } + { + int res = SWIG_ConvertFunctionPtr(argv[6], (void**)(&arg7), SWIGTYPE_p_f_p_sqlite3_context_int_p_p_sqlite3_value__void); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "void (*)(sqlite3_context *,int,sqlite3_value **)","sqlite3_create_function", 7, argv[6] )); + } + } + { + int res = SWIG_ConvertFunctionPtr(argv[7], (void**)(&arg8), SWIGTYPE_p_f_p_sqlite3_context__void); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "void (*)(sqlite3_context *)","sqlite3_create_function", 8, argv[7] )); + } + } + result = (int)sqlite3_create_function(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8); + vresult = SWIG_From_int((int)(result)); + if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); + return vresult; +fail: + if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_create_function16(int argc, VALUE *argv, VALUE self) { + sqlite3 *arg1 = (sqlite3 *) 0 ; + void *arg2 = (void *) 0 ; + int arg3 ; + int arg4 ; + void *arg5 = (void *) 0 ; + void (*arg6)(sqlite3_context *,int,sqlite3_value **) = (void (*)(sqlite3_context *,int,sqlite3_value **)) 0 ; + void (*arg7)(sqlite3_context *,int,sqlite3_value **) = (void (*)(sqlite3_context *,int,sqlite3_value **)) 0 ; + void (*arg8)(sqlite3_context *) = (void (*)(sqlite3_context *)) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val3 ; + int ecode3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int res5 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 8) || (argc > 8)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 8)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3 *","sqlite3_create_function16", 1, argv[0] )); + } + arg1 = (sqlite3 *)(argp1); + { + arg2 = (void*)RSTRING_PTR(argv[1]); + } + ecode3 = SWIG_AsVal_int(argv[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","sqlite3_create_function16", 3, argv[2] )); + } + arg3 = (int)(val3); + ecode4 = SWIG_AsVal_int(argv[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","sqlite3_create_function16", 4, argv[3] )); + } + arg4 = (int)(val4); + res5 = SWIG_ConvertPtr(argv[4],SWIG_as_voidptrptr(&arg5), 0, 0); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "void *","sqlite3_create_function16", 5, argv[4] )); + } + { + int res = SWIG_ConvertFunctionPtr(argv[5], (void**)(&arg6), SWIGTYPE_p_f_p_sqlite3_context_int_p_p_sqlite3_value__void); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "void (*)(sqlite3_context *,int,sqlite3_value **)","sqlite3_create_function16", 6, argv[5] )); + } + } + { + int res = SWIG_ConvertFunctionPtr(argv[6], (void**)(&arg7), SWIGTYPE_p_f_p_sqlite3_context_int_p_p_sqlite3_value__void); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "void (*)(sqlite3_context *,int,sqlite3_value **)","sqlite3_create_function16", 7, argv[6] )); + } + } + { + int res = SWIG_ConvertFunctionPtr(argv[7], (void**)(&arg8), SWIGTYPE_p_f_p_sqlite3_context__void); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "void (*)(sqlite3_context *)","sqlite3_create_function16", 8, argv[7] )); + } + } + result = (int)sqlite3_create_function16(arg1,(void const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8); + vresult = SWIG_From_int((int)(result)); + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_aggregate_count(int argc, VALUE *argv, VALUE self) { + sqlite3_context *arg1 = (sqlite3_context *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_context, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_context *","sqlite3_aggregate_count", 1, argv[0] )); + } + arg1 = (sqlite3_context *)(argp1); + result = (int)sqlite3_aggregate_count(arg1); + vresult = SWIG_From_int((int)(result)); + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_value_blob(int argc, VALUE *argv, VALUE self) { + sqlite3_value *arg1 = (sqlite3_value *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + RUBY_VALBLOB *result = 0 ; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_value, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_value *","sqlite3_value_blob", 1, argv[0] )); + } + arg1 = (sqlite3_value *)(argp1); + result = (RUBY_VALBLOB *)sqlite3_value_blob(arg1); + { + vresult = result ? rb_str_new( (char*)result, sqlite3_value_bytes( arg1 ) ) : Qnil; + } + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_value_bytes(int argc, VALUE *argv, VALUE self) { + sqlite3_value *arg1 = (sqlite3_value *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_value, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_value *","sqlite3_value_bytes", 1, argv[0] )); + } + arg1 = (sqlite3_value *)(argp1); + result = (int)sqlite3_value_bytes(arg1); + vresult = SWIG_From_int((int)(result)); + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_value_bytes16(int argc, VALUE *argv, VALUE self) { + sqlite3_value *arg1 = (sqlite3_value *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_value, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_value *","sqlite3_value_bytes16", 1, argv[0] )); + } + arg1 = (sqlite3_value *)(argp1); + result = (int)sqlite3_value_bytes16(arg1); + vresult = SWIG_From_int((int)(result)); + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_value_double(int argc, VALUE *argv, VALUE self) { + sqlite3_value *arg1 = (sqlite3_value *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_value, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_value *","sqlite3_value_double", 1, argv[0] )); + } + arg1 = (sqlite3_value *)(argp1); + result = (double)sqlite3_value_double(arg1); + vresult = SWIG_From_double((double)(result)); + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_value_int(int argc, VALUE *argv, VALUE self) { + sqlite3_value *arg1 = (sqlite3_value *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_value, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_value *","sqlite3_value_int", 1, argv[0] )); + } + arg1 = (sqlite3_value *)(argp1); + result = (int)sqlite3_value_int(arg1); + vresult = SWIG_From_int((int)(result)); + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_value_int64(int argc, VALUE *argv, VALUE self) { + sqlite3_value *arg1 = (sqlite3_value *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + sqlite_int64 result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_value, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_value *","sqlite3_value_int64", 1, argv[0] )); + } + arg1 = (sqlite3_value *)(argp1); + result = sqlite3_value_int64(arg1); + { + vresult = rb_ll2inum( result ); + } + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_value_text(int argc, VALUE *argv, VALUE self) { + sqlite3_value *arg1 = (sqlite3_value *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char *result = 0 ; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_value, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_value *","sqlite3_value_text", 1, argv[0] )); + } + arg1 = (sqlite3_value *)(argp1); + result = (char *)sqlite3_value_text(arg1); + { + vresult = result ? rb_str_new2(result) : Qnil; + } + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_value_text16(int argc, VALUE *argv, VALUE self) { + sqlite3_value *arg1 = (sqlite3_value *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *result = 0 ; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_value, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_value *","sqlite3_value_text16", 1, argv[0] )); + } + arg1 = (sqlite3_value *)(argp1); + result = (void *)sqlite3_value_text16(arg1); + { + int i; + if( result ) { + for( i = 0; ((char*)result)[i]; i += 2 ); + vresult = rb_str_new( (char*)result, i ); + } else vresult = Qnil; + } + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_value_text16le(int argc, VALUE *argv, VALUE self) { + sqlite3_value *arg1 = (sqlite3_value *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *result = 0 ; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_value, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_value *","sqlite3_value_text16le", 1, argv[0] )); + } + arg1 = (sqlite3_value *)(argp1); + result = (void *)sqlite3_value_text16le(arg1); + { + int i; + if( result ) { + for( i = 0; ((char*)result)[i]; i += 2 ); + vresult = rb_str_new( (char*)result, i ); + } else vresult = Qnil; + } + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_value_text16be(int argc, VALUE *argv, VALUE self) { + sqlite3_value *arg1 = (sqlite3_value *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *result = 0 ; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_value, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_value *","sqlite3_value_text16be", 1, argv[0] )); + } + arg1 = (sqlite3_value *)(argp1); + result = (void *)sqlite3_value_text16be(arg1); + { + int i; + if( result ) { + for( i = 0; ((char*)result)[i]; i += 2 ); + vresult = rb_str_new( (char*)result, i ); + } else vresult = Qnil; + } + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_value_type(int argc, VALUE *argv, VALUE self) { + sqlite3_value *arg1 = (sqlite3_value *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_value, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_value *","sqlite3_value_type", 1, argv[0] )); + } + arg1 = (sqlite3_value *)(argp1); + result = (int)sqlite3_value_type(arg1); + vresult = SWIG_From_int((int)(result)); + return vresult; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_result_blob(int argc, VALUE *argv, VALUE self) { + sqlite3_context *arg1 = (sqlite3_context *) 0 ; + void *arg2 = (void *) 0 ; + int arg3 ; + void (*arg4)(void *) = (void (*)(void *)) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((argc < 2) || (argc > 2)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_context, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_context *","sqlite3_result_blob", 1, argv[0] )); + } + arg1 = (sqlite3_context *)(argp1); + { + arg2 = (void*)RSTRING_PTR(argv[1]); + arg3 = RSTRING_LEN(argv[1]); + arg4 = SQLITE_TRANSIENT; + } + sqlite3_result_blob(arg1,(void const *)arg2,arg3,arg4); + return Qnil; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_result_double(int argc, VALUE *argv, VALUE self) { + sqlite3_context *arg1 = (sqlite3_context *) 0 ; + double arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + double val2 ; + int ecode2 = 0 ; + + if ((argc < 2) || (argc > 2)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_context, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_context *","sqlite3_result_double", 1, argv[0] )); + } + arg1 = (sqlite3_context *)(argp1); + ecode2 = SWIG_AsVal_double(argv[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","sqlite3_result_double", 2, argv[1] )); + } + arg2 = (double)(val2); + sqlite3_result_double(arg1,arg2); + return Qnil; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_result_error(int argc, VALUE *argv, VALUE self) { + sqlite3_context *arg1 = (sqlite3_context *) 0 ; + char *arg2 = (char *) 0 ; + int arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((argc < 2) || (argc > 2)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_context, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_context *","sqlite3_result_error", 1, argv[0] )); + } + arg1 = (sqlite3_context *)(argp1); + { + arg2 = RSTRING_PTR(argv[1]); + arg3 = RSTRING_LEN(argv[1]); + } + sqlite3_result_error(arg1,(char const *)arg2,arg3); + return Qnil; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_result_error16(int argc, VALUE *argv, VALUE self) { + sqlite3_context *arg1 = (sqlite3_context *) 0 ; + void *arg2 = (void *) 0 ; + int arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((argc < 2) || (argc > 2)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_context, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_context *","sqlite3_result_error16", 1, argv[0] )); + } + arg1 = (sqlite3_context *)(argp1); + { + arg2 = (void*)RSTRING_PTR(argv[1]); + arg3 = RSTRING_LEN(argv[1]); + } + sqlite3_result_error16(arg1,(void const *)arg2,arg3); + return Qnil; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_result_int(int argc, VALUE *argv, VALUE self) { + sqlite3_context *arg1 = (sqlite3_context *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + + if ((argc < 2) || (argc > 2)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_context, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_context *","sqlite3_result_int", 1, argv[0] )); + } + arg1 = (sqlite3_context *)(argp1); + ecode2 = SWIG_AsVal_int(argv[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","sqlite3_result_int", 2, argv[1] )); + } + arg2 = (int)(val2); + sqlite3_result_int(arg1,arg2); + return Qnil; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_result_int64(int argc, VALUE *argv, VALUE self) { + sqlite3_context *arg1 = (sqlite3_context *) 0 ; + sqlite_int64 arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((argc < 2) || (argc > 2)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_context, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_context *","sqlite3_result_int64", 1, argv[0] )); + } + arg1 = (sqlite3_context *)(argp1); + { + arg2 = rb_num2ll( argv[1] ); + } + sqlite3_result_int64(arg1,arg2); + return Qnil; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_result_text(int argc, VALUE *argv, VALUE self) { + sqlite3_context *arg1 = (sqlite3_context *) 0 ; + char *arg2 = (char *) 0 ; + int arg3 ; + void (*arg4)(void *) = (void (*)(void *)) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((argc < 2) || (argc > 2)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_context, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_context *","sqlite3_result_text", 1, argv[0] )); + } + arg1 = (sqlite3_context *)(argp1); + { + arg2 = RSTRING_PTR(argv[1]); + arg3 = RSTRING_LEN(argv[1]); + arg4 = SQLITE_TRANSIENT; + } + sqlite3_result_text(arg1,(char const *)arg2,arg3,arg4); + return Qnil; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_result_text16(int argc, VALUE *argv, VALUE self) { + sqlite3_context *arg1 = (sqlite3_context *) 0 ; + void *arg2 = (void *) 0 ; + int arg3 ; + void (*arg4)(void *) = (void (*)(void *)) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((argc < 2) || (argc > 2)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_context, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_context *","sqlite3_result_text16", 1, argv[0] )); + } + arg1 = (sqlite3_context *)(argp1); + { + arg2 = (void*)RSTRING_PTR(argv[1]); + arg3 = RSTRING_LEN(argv[1]); + arg4 = SQLITE_TRANSIENT; + } + sqlite3_result_text16(arg1,(void const *)arg2,arg3,arg4); + return Qnil; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_result_text16le(int argc, VALUE *argv, VALUE self) { + sqlite3_context *arg1 = (sqlite3_context *) 0 ; + void *arg2 = (void *) 0 ; + int arg3 ; + void (*arg4)(void *) = (void (*)(void *)) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((argc < 2) || (argc > 2)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_context, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_context *","sqlite3_result_text16le", 1, argv[0] )); + } + arg1 = (sqlite3_context *)(argp1); + { + arg2 = (void*)RSTRING_PTR(argv[1]); + arg3 = RSTRING_LEN(argv[1]); + arg4 = SQLITE_TRANSIENT; + } + sqlite3_result_text16le(arg1,(void const *)arg2,arg3,arg4); + return Qnil; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_result_text16be(int argc, VALUE *argv, VALUE self) { + sqlite3_context *arg1 = (sqlite3_context *) 0 ; + void *arg2 = (void *) 0 ; + int arg3 ; + void (*arg4)(void *) = (void (*)(void *)) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((argc < 2) || (argc > 2)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_context, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_context *","sqlite3_result_text16be", 1, argv[0] )); + } + arg1 = (sqlite3_context *)(argp1); + { + arg2 = (void*)RSTRING_PTR(argv[1]); + arg3 = RSTRING_LEN(argv[1]); + arg4 = SQLITE_TRANSIENT; + } + sqlite3_result_text16be(arg1,(void const *)arg2,arg3,arg4); + return Qnil; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_result_value(int argc, VALUE *argv, VALUE self) { + sqlite3_context *arg1 = (sqlite3_context *) 0 ; + sqlite3_value *arg2 = (sqlite3_value *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((argc < 2) || (argc > 2)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_sqlite3_context, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "sqlite3_context *","sqlite3_result_value", 1, argv[0] )); + } + arg1 = (sqlite3_context *)(argp1); + res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_sqlite3_value, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "sqlite3_value *","sqlite3_result_value", 2, argv[1] )); + } + arg2 = (sqlite3_value *)(argp2); + sqlite3_result_value(arg1,arg2); + return Qnil; +fail: + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_sqlite3_aggregate_context(int argc, VALUE *argv, VALUE self) { + sqlite3_context *arg1 = (sqlite3_context *) 0 ; + int arg2 ; + VALUE *result = 0 ; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; + } + { + SWIG_ConvertPtr(argv[0],(void**)&arg1, SWIGTYPE_p_sqlite3_context, 1); + arg2 = 4; + } + result = (VALUE *)sqlite3_aggregate_context(arg1,arg2); + { + vresult = *(VALUE*)result; + } + return vresult; +fail: + return Qnil; +} + + + +/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ + +static swig_type_info _swigt__p_CallbackData = {"_p_CallbackData", "CallbackData *|struct CallbackData *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; +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}; +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}; +static swig_type_info _swigt__p_f_p_void__void = {"_p_f_p_void__void", "void (*)(void *)", 0, 0, (void*)0, 0}; +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}; +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}; +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}; +static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_p_sqlite3 = {"_p_p_sqlite3", "sqlite3 **", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_p_sqlite3_stmt = {"_p_p_sqlite3_stmt", "sqlite3_stmt **", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_p_void = {"_p_p_void", "void **", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_sqlite3 = {"_p_sqlite3", "sqlite3 *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_sqlite3_context = {"_p_sqlite3_context", "sqlite3_context *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_sqlite3_stmt = {"_p_sqlite3_stmt", "sqlite3_stmt *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_sqlite3_value = {"_p_sqlite3_value", "sqlite3_value *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_sqlite_int64 = {"_p_sqlite_int64", "sqlite_int64 *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_void = {"_p_void", "RUBY_VALBLOB *|RUBY_BLOB *|void *", 0, 0, (void*)0, 0}; + +static swig_type_info *swig_type_initial[] = { + &_swigt__p_CallbackData, + &_swigt__p_char, + &_swigt__p_f_p_sqlite3_context__void, + &_swigt__p_f_p_sqlite3_context_int_p_p_sqlite3_value__void, + &_swigt__p_f_p_void__void, + &_swigt__p_f_p_void_int__int, + &_swigt__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_p_q_const__char__void, + &_swigt__p_p_char, + &_swigt__p_p_sqlite3, + &_swigt__p_p_sqlite3_stmt, + &_swigt__p_p_void, + &_swigt__p_sqlite3, + &_swigt__p_sqlite3_context, + &_swigt__p_sqlite3_stmt, + &_swigt__p_sqlite3_value, + &_swigt__p_sqlite_int64, + &_swigt__p_void, +}; + +static swig_cast_info _swigc__p_CallbackData[] = { {&_swigt__p_CallbackData, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; +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}}; +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}}; +static swig_cast_info _swigc__p_f_p_void__void[] = { {&_swigt__p_f_p_void__void, 0, 0, 0},{0, 0, 0, 0}}; +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}}; +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}}; +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}}; +static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_sqlite3[] = { {&_swigt__p_p_sqlite3, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_sqlite3_stmt[] = { {&_swigt__p_p_sqlite3_stmt, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_void[] = { {&_swigt__p_p_void, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_sqlite3[] = { {&_swigt__p_sqlite3, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_sqlite3_context[] = { {&_swigt__p_sqlite3_context, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_sqlite3_stmt[] = { {&_swigt__p_sqlite3_stmt, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_sqlite3_value[] = { {&_swigt__p_sqlite3_value, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_sqlite_int64[] = { {&_swigt__p_sqlite_int64, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}}; + +static swig_cast_info *swig_cast_initial[] = { + _swigc__p_CallbackData, + _swigc__p_char, + _swigc__p_f_p_sqlite3_context__void, + _swigc__p_f_p_sqlite3_context_int_p_p_sqlite3_value__void, + _swigc__p_f_p_void__void, + _swigc__p_f_p_void_int__int, + _swigc__p_f_p_void_int_p_q_const__char_p_q_const__char_p_q_const__char_p_q_const__char__int, + _swigc__p_f_p_void_p_q_const__char__void, + _swigc__p_p_char, + _swigc__p_p_sqlite3, + _swigc__p_p_sqlite3_stmt, + _swigc__p_p_void, + _swigc__p_sqlite3, + _swigc__p_sqlite3_context, + _swigc__p_sqlite3_stmt, + _swigc__p_sqlite3_value, + _swigc__p_sqlite_int64, + _swigc__p_void, +}; + + +/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */ + +/* ----------------------------------------------------------------------------- + * Type initialization: + * This problem is tough by the requirement that no dynamic + * memory is used. Also, since swig_type_info structures store pointers to + * swig_cast_info structures and swig_cast_info structures store pointers back + * to swig_type_info structures, we need some lookup code at initialization. + * The idea is that swig generates all the structures that are needed. + * The runtime then collects these partially filled structures. + * The SWIG_InitializeModule function takes these initial arrays out of + * swig_module, and does all the lookup, filling in the swig_module.types + * array with the correct data and linking the correct swig_cast_info + * structures together. + * + * The generated swig_type_info structures are assigned staticly to an initial + * array. We just loop through that array, and handle each type individually. + * First we lookup if this type has been already loaded, and if so, use the + * loaded structure instead of the generated one. Then we have to fill in the + * cast linked list. The cast data is initially stored in something like a + * two-dimensional array. Each row corresponds to a type (there are the same + * number of rows as there are in the swig_type_initial array). Each entry in + * a column is one of the swig_cast_info structures for that type. + * The cast_initial array is actually an array of arrays, because each row has + * a variable number of columns. So to actually build the cast linked list, + * we find the array of casts associated with the type, and loop through it + * adding the casts to the list. The one last trick we need to do is making + * sure the type pointer in the swig_cast_info struct is correct. + * + * First off, we lookup the cast->type name to see if it is already loaded. + * There are three cases to handle: + * 1) If the cast->type has already been loaded AND the type we are adding + * casting info to has not been loaded (it is in this module), THEN we + * replace the cast->type pointer with the type pointer that has already + * been loaded. + * 2) If BOTH types (the one we are adding casting info to, and the + * cast->type) are loaded, THEN the cast info has already been loaded by + * the previous module so we just ignore it. + * 3) Finally, if cast->type has not already been loaded, then we add that + * swig_cast_info to the linked list (because the cast->type) pointer will + * be correct. + * ----------------------------------------------------------------------------- */ + +#ifdef __cplusplus +extern "C" { +#if 0 +} /* c-mode */ +#endif +#endif + +#if 0 +#define SWIGRUNTIME_DEBUG +#endif + + +SWIGRUNTIME void +SWIG_InitializeModule(void *clientdata) { + size_t i; + swig_module_info *module_head, *iter; + int found, init; + + clientdata = clientdata; + + /* check to see if the circular list has been setup, if not, set it up */ + if (swig_module.next==0) { + /* Initialize the swig_module */ + swig_module.type_initial = swig_type_initial; + swig_module.cast_initial = swig_cast_initial; + swig_module.next = &swig_module; + init = 1; + } else { + init = 0; + } + + /* Try and load any already created modules */ + module_head = SWIG_GetModule(clientdata); + if (!module_head) { + /* This is the first module loaded for this interpreter */ + /* so set the swig module into the interpreter */ + SWIG_SetModule(clientdata, &swig_module); + module_head = &swig_module; + } else { + /* the interpreter has loaded a SWIG module, but has it loaded this one? */ + found=0; + iter=module_head; + do { + if (iter==&swig_module) { + found=1; + break; + } + iter=iter->next; + } while (iter!= module_head); + + /* if the is found in the list, then all is done and we may leave */ + if (found) return; + /* otherwise we must add out module into the list */ + swig_module.next = module_head->next; + module_head->next = &swig_module; + } + + /* When multiple interpeters are used, a module could have already been initialized in + a different interpreter, but not yet have a pointer in this interpreter. + In this case, we do not want to continue adding types... everything should be + set up already */ + if (init == 0) return; + + /* Now work on filling in swig_module.types */ +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: size %d\n", swig_module.size); +#endif + for (i = 0; i < swig_module.size; ++i) { + swig_type_info *type = 0; + swig_type_info *ret; + swig_cast_info *cast; + +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name); +#endif + + /* if there is another module already loaded */ + if (swig_module.next != &swig_module) { + type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name); + } + if (type) { + /* Overwrite clientdata field */ +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: found type %s\n", type->name); +#endif + if (swig_module.type_initial[i]->clientdata) { + type->clientdata = swig_module.type_initial[i]->clientdata; +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name); +#endif + } + } else { + type = swig_module.type_initial[i]; + } + + /* Insert casting types */ + cast = swig_module.cast_initial[i]; + while (cast->type) { + + /* Don't need to add information already in the list */ + ret = 0; +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: look cast %s\n", cast->type->name); +#endif + if (swig_module.next != &swig_module) { + ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name); +#ifdef SWIGRUNTIME_DEBUG + if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name); +#endif + } + if (ret) { + if (type == swig_module.type_initial[i]) { +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: skip old type %s\n", ret->name); +#endif + cast->type = ret; + ret = 0; + } else { + /* Check for casting already in the list */ + swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type); +#ifdef SWIGRUNTIME_DEBUG + if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name); +#endif + if (!ocast) ret = 0; + } + } + + if (!ret) { +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name); +#endif + if (type->cast) { + type->cast->prev = cast; + cast->next = type->cast; + } + type->cast = cast; + } + cast++; + } + /* Set entry in modules->types array equal to the type */ + swig_module.types[i] = type; + } + swig_module.types[i] = 0; + +#ifdef SWIGRUNTIME_DEBUG + printf("**** SWIG_InitializeModule: Cast List ******\n"); + for (i = 0; i < swig_module.size; ++i) { + int j = 0; + swig_cast_info *cast = swig_module.cast_initial[i]; + printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name); + while (cast->type) { + printf("SWIG_InitializeModule: cast type %s\n", cast->type->name); + cast++; + ++j; + } + printf("---- Total casts: %d\n",j); + } + printf("**** SWIG_InitializeModule: Cast List ******\n"); +#endif +} + +/* This function will propagate the clientdata field of type to +* any new swig_type_info structures that have been added into the list +* of equivalent types. It is like calling +* SWIG_TypeClientData(type, clientdata) a second time. +*/ +SWIGRUNTIME void +SWIG_PropagateClientData(void) { + size_t i; + swig_cast_info *equiv; + static int init_run = 0; + + if (init_run) return; + init_run = 1; + + for (i = 0; i < swig_module.size; i++) { + if (swig_module.types[i]->clientdata) { + equiv = swig_module.types[i]->cast; + while (equiv) { + if (!equiv->converter) { + if (equiv->type && !equiv->type->clientdata) + SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata); + } + equiv = equiv->next; + } + } + } +} + +#ifdef __cplusplus +#if 0 +{ /* c-mode */ +#endif +} +#endif + +/* + +*/ +#ifdef __cplusplus +extern "C" +#endif +SWIGEXPORT void Init_API(void) { + size_t i; + + SWIG_InitRuntime(); + mAPI = rb_define_module("SQLite3"); + mAPI = rb_define_module_under(mAPI, "Driver"); + mAPI = rb_define_module_under(mAPI, "Native"); + mAPI = rb_define_module_under(mAPI, "API"); + + SWIG_InitializeModule(0); + for (i = 0; i < swig_module.size; i++) { + SWIG_define_class(swig_module.types[i]); + } + + SWIG_RubyInitializeTrackings(); + + SwigClassCallbackData.klass = rb_define_class_under(mAPI, "CallbackData", rb_cObject); + SWIG_TypeClientData(SWIGTYPE_p_CallbackData, (void *) &SwigClassCallbackData); + rb_define_alloc_func(SwigClassCallbackData.klass, _wrap_CallbackData_allocate); + rb_define_method(SwigClassCallbackData.klass, "initialize", _wrap_new_CallbackData, -1); + rb_define_method(SwigClassCallbackData.klass, "proc=", _wrap_CallbackData_proc_set, -1); + rb_define_method(SwigClassCallbackData.klass, "proc", _wrap_CallbackData_proc_get, -1); + rb_define_method(SwigClassCallbackData.klass, "proc2=", _wrap_CallbackData_proc2_set, -1); + rb_define_method(SwigClassCallbackData.klass, "proc2", _wrap_CallbackData_proc2_get, -1); + rb_define_method(SwigClassCallbackData.klass, "data=", _wrap_CallbackData_data_set, -1); + rb_define_method(SwigClassCallbackData.klass, "data", _wrap_CallbackData_data_get, -1); + SwigClassCallbackData.mark = (void (*)(void *)) mark_CallbackData; + SwigClassCallbackData.destroy = (void (*)(void *)) free_CallbackData; + SwigClassCallbackData.trackObjects = 0; + rb_define_const(mAPI, "Sqlite3_ruby_busy_handler", SWIG_NewFunctionPtrObj((void *)Sqlite3_ruby_busy_handler, SWIGTYPE_p_f_p_void_int__int)); + rb_define_const(mAPI, "Sqlite3_ruby_authorizer", SWIG_NewFunctionPtrObj((void *)Sqlite3_ruby_authorizer, SWIGTYPE_p_f_p_void_int_p_q_const__char_p_q_const__char_p_q_const__char_p_q_const__char__int)); + rb_define_const(mAPI, "Sqlite3_ruby_trace", SWIG_NewFunctionPtrObj((void *)Sqlite3_ruby_trace, SWIGTYPE_p_f_p_void_p_q_const__char__void)); + rb_define_const(mAPI, "Sqlite3_ruby_function_step", SWIG_NewFunctionPtrObj((void *)Sqlite3_ruby_function_step, SWIGTYPE_p_f_p_sqlite3_context_int_p_p_sqlite3_value__void)); + rb_define_const(mAPI, "Sqlite3_ruby_function_final", SWIG_NewFunctionPtrObj((void *)Sqlite3_ruby_function_final, SWIGTYPE_p_f_p_sqlite3_context__void)); + rb_define_module_function(mAPI, "sqlite3_libversion", _wrap_sqlite3_libversion, -1); + rb_define_module_function(mAPI, "sqlite3_close", _wrap_sqlite3_close, -1); + rb_define_module_function(mAPI, "sqlite3_last_insert_rowid", _wrap_sqlite3_last_insert_rowid, -1); + rb_define_module_function(mAPI, "sqlite3_changes", _wrap_sqlite3_changes, -1); + rb_define_module_function(mAPI, "sqlite3_total_changes", _wrap_sqlite3_total_changes, -1); + rb_define_module_function(mAPI, "sqlite3_interrupt", _wrap_sqlite3_interrupt, -1); + rb_define_module_function(mAPI, "sqlite3_complete", _wrap_sqlite3_complete, -1); + rb_define_module_function(mAPI, "sqlite3_complete16", _wrap_sqlite3_complete16, -1); + rb_define_module_function(mAPI, "sqlite3_busy_handler", _wrap_sqlite3_busy_handler, -1); + rb_define_module_function(mAPI, "sqlite3_busy_timeout", _wrap_sqlite3_busy_timeout, -1); + rb_define_module_function(mAPI, "sqlite3_set_authorizer", _wrap_sqlite3_set_authorizer, -1); + rb_define_module_function(mAPI, "sqlite3_trace", _wrap_sqlite3_trace, -1); + rb_define_module_function(mAPI, "sqlite3_open", _wrap_sqlite3_open, -1); + rb_define_module_function(mAPI, "sqlite3_open16", _wrap_sqlite3_open16, -1); + rb_define_module_function(mAPI, "sqlite3_errcode", _wrap_sqlite3_errcode, -1); + rb_define_module_function(mAPI, "sqlite3_errmsg", _wrap_sqlite3_errmsg, -1); + rb_define_module_function(mAPI, "sqlite3_errmsg16", _wrap_sqlite3_errmsg16, -1); + rb_define_module_function(mAPI, "sqlite3_prepare", _wrap_sqlite3_prepare, -1); + rb_define_module_function(mAPI, "sqlite3_prepare16", _wrap_sqlite3_prepare16, -1); + rb_define_module_function(mAPI, "sqlite3_bind_blob", _wrap_sqlite3_bind_blob, -1); + rb_define_module_function(mAPI, "sqlite3_bind_double", _wrap_sqlite3_bind_double, -1); + rb_define_module_function(mAPI, "sqlite3_bind_int", _wrap_sqlite3_bind_int, -1); + rb_define_module_function(mAPI, "sqlite3_bind_int64", _wrap_sqlite3_bind_int64, -1); + rb_define_module_function(mAPI, "sqlite3_bind_null", _wrap_sqlite3_bind_null, -1); + rb_define_module_function(mAPI, "sqlite3_bind_text", _wrap_sqlite3_bind_text, -1); + rb_define_module_function(mAPI, "sqlite3_bind_text16", _wrap_sqlite3_bind_text16, -1); + rb_define_module_function(mAPI, "sqlite3_bind_parameter_count", _wrap_sqlite3_bind_parameter_count, -1); + rb_define_module_function(mAPI, "sqlite3_bind_parameter_name", _wrap_sqlite3_bind_parameter_name, -1); + rb_define_module_function(mAPI, "sqlite3_bind_parameter_index", _wrap_sqlite3_bind_parameter_index, -1); + rb_define_module_function(mAPI, "sqlite3_column_count", _wrap_sqlite3_column_count, -1); + rb_define_module_function(mAPI, "sqlite3_column_name", _wrap_sqlite3_column_name, -1); + rb_define_module_function(mAPI, "sqlite3_column_name16", _wrap_sqlite3_column_name16, -1); + rb_define_module_function(mAPI, "sqlite3_column_decltype", _wrap_sqlite3_column_decltype, -1); + rb_define_module_function(mAPI, "sqlite3_column_decltype16", _wrap_sqlite3_column_decltype16, -1); + rb_define_module_function(mAPI, "sqlite3_step", _wrap_sqlite3_step, -1); + rb_define_module_function(mAPI, "sqlite3_data_count", _wrap_sqlite3_data_count, -1); + rb_define_module_function(mAPI, "sqlite3_column_blob", _wrap_sqlite3_column_blob, -1); + rb_define_module_function(mAPI, "sqlite3_column_bytes", _wrap_sqlite3_column_bytes, -1); + rb_define_module_function(mAPI, "sqlite3_column_bytes16", _wrap_sqlite3_column_bytes16, -1); + rb_define_module_function(mAPI, "sqlite3_column_double", _wrap_sqlite3_column_double, -1); + rb_define_module_function(mAPI, "sqlite3_column_int", _wrap_sqlite3_column_int, -1); + rb_define_module_function(mAPI, "sqlite3_column_int64", _wrap_sqlite3_column_int64, -1); + rb_define_module_function(mAPI, "sqlite3_column_text", _wrap_sqlite3_column_text, -1); + rb_define_module_function(mAPI, "sqlite3_column_text16", _wrap_sqlite3_column_text16, -1); + rb_define_module_function(mAPI, "sqlite3_column_type", _wrap_sqlite3_column_type, -1); + rb_define_module_function(mAPI, "sqlite3_finalize", _wrap_sqlite3_finalize, -1); + rb_define_module_function(mAPI, "sqlite3_reset", _wrap_sqlite3_reset, -1); + rb_define_module_function(mAPI, "sqlite3_create_function", _wrap_sqlite3_create_function, -1); + rb_define_module_function(mAPI, "sqlite3_create_function16", _wrap_sqlite3_create_function16, -1); + rb_define_module_function(mAPI, "sqlite3_aggregate_count", _wrap_sqlite3_aggregate_count, -1); + rb_define_module_function(mAPI, "sqlite3_value_blob", _wrap_sqlite3_value_blob, -1); + rb_define_module_function(mAPI, "sqlite3_value_bytes", _wrap_sqlite3_value_bytes, -1); + rb_define_module_function(mAPI, "sqlite3_value_bytes16", _wrap_sqlite3_value_bytes16, -1); + rb_define_module_function(mAPI, "sqlite3_value_double", _wrap_sqlite3_value_double, -1); + rb_define_module_function(mAPI, "sqlite3_value_int", _wrap_sqlite3_value_int, -1); + rb_define_module_function(mAPI, "sqlite3_value_int64", _wrap_sqlite3_value_int64, -1); + rb_define_module_function(mAPI, "sqlite3_value_text", _wrap_sqlite3_value_text, -1); + rb_define_module_function(mAPI, "sqlite3_value_text16", _wrap_sqlite3_value_text16, -1); + rb_define_module_function(mAPI, "sqlite3_value_text16le", _wrap_sqlite3_value_text16le, -1); + rb_define_module_function(mAPI, "sqlite3_value_text16be", _wrap_sqlite3_value_text16be, -1); + rb_define_module_function(mAPI, "sqlite3_value_type", _wrap_sqlite3_value_type, -1); + rb_define_module_function(mAPI, "sqlite3_result_blob", _wrap_sqlite3_result_blob, -1); + rb_define_module_function(mAPI, "sqlite3_result_double", _wrap_sqlite3_result_double, -1); + rb_define_module_function(mAPI, "sqlite3_result_error", _wrap_sqlite3_result_error, -1); + rb_define_module_function(mAPI, "sqlite3_result_error16", _wrap_sqlite3_result_error16, -1); + rb_define_module_function(mAPI, "sqlite3_result_int", _wrap_sqlite3_result_int, -1); + rb_define_module_function(mAPI, "sqlite3_result_int64", _wrap_sqlite3_result_int64, -1); + rb_define_module_function(mAPI, "sqlite3_result_text", _wrap_sqlite3_result_text, -1); + rb_define_module_function(mAPI, "sqlite3_result_text16", _wrap_sqlite3_result_text16, -1); + rb_define_module_function(mAPI, "sqlite3_result_text16le", _wrap_sqlite3_result_text16le, -1); + rb_define_module_function(mAPI, "sqlite3_result_text16be", _wrap_sqlite3_result_text16be, -1); + rb_define_module_function(mAPI, "sqlite3_result_value", _wrap_sqlite3_result_value, -1); + rb_define_module_function(mAPI, "sqlite3_aggregate_context", _wrap_sqlite3_aggregate_context, -1); +} + diff --git a/vendor/plugins/sqlite3-ruby/lib/sqlite3/database.rb b/vendor/plugins/sqlite3-ruby/lib/sqlite3/database.rb index 627166c0..e2ba69c1 100644 --- a/vendor/plugins/sqlite3-ruby/lib/sqlite3/database.rb +++ b/vendor/plugins/sqlite3-ruby/lib/sqlite3/database.rb @@ -12,14 +12,12 @@ module SQLite3 # # require 'sqlite3' # - # db = SQLite3::Database.new( "data.db" ) - # - # db.execute( "select * from table" ) do |row| - # p row + # SQLite3::Database.new( "data.db" ) do |db| + # db.execute( "select * from table" ) do |row| + # p row + # end # end # - # db.close - # # It wraps the lower-level methods provides by the selected driver, and # includes the Pragmas module for access to various pragma convenience # methods. @@ -69,7 +67,7 @@ module SQLite3 # # By default, the new database will return result rows as arrays # (#results_as_hash) and has type translation disabled (#type_translation=). - def initialize( file_name, options={} ) + def initialize( file_name, options={} ) # :yields: db utf16 = options.fetch(:utf16, false) load_driver( options[:driver] ) @@ -83,6 +81,14 @@ module SQLite3 @type_translation = options.fetch(:type_translation,false) @translator = nil @transaction_active = false + + if block_given? + begin + yield self + ensure + self.close + end + end end # Return +true+ if the string is a valid (ie, parsable) SQL statement, and diff --git a/vendor/plugins/sqlite3-ruby/lib/sqlite3/driver/dl/api.rb b/vendor/plugins/sqlite3-ruby/lib/sqlite3/driver/dl/api.rb index 15a8007c..60a2c3d1 100644 --- a/vendor/plugins/sqlite3-ruby/lib/sqlite3/driver/dl/api.rb +++ b/vendor/plugins/sqlite3-ruby/lib/sqlite3/driver/dl/api.rb @@ -10,7 +10,7 @@ module SQLite3 ; module Driver; module DL; "libsqlite3.dylib" when /linux/, /freebsd|netbsd|openbsd|dragonfly/, /solaris/ "libsqlite3.so" - when /win32/ + when /mswin|mingw/ "sqlite3.dll" else abort <<-EOF diff --git a/vendor/plugins/sqlite3-ruby/lib/sqlite3/driver/native/driver.rb b/vendor/plugins/sqlite3-ruby/lib/sqlite3/driver/native/driver.rb index e9784082..1cf0f826 100644 --- a/vendor/plugins/sqlite3-ruby/lib/sqlite3/driver/native/driver.rb +++ b/vendor/plugins/sqlite3-ruby/lib/sqlite3/driver/native/driver.rb @@ -1,4 +1,12 @@ -require 'sqlite3_api' +# support multiple ruby version (fat binaries under windows) +begin + require 'sqlite3_api' +rescue LoadError + if RUBY_PLATFORM =~ /mingw|mswin/ then + RUBY_VERSION =~ /(\d+.\d+)/ + require "#{$1}/sqlite3_api" + end +end module SQLite3 ; module Driver ; module Native diff --git a/vendor/plugins/sqlite3-ruby/lib/sqlite3/resultset.rb b/vendor/plugins/sqlite3-ruby/lib/sqlite3/resultset.rb index 5da10f52..66c671c2 100644 --- a/vendor/plugins/sqlite3-ruby/lib/sqlite3/resultset.rb +++ b/vendor/plugins/sqlite3-ruby/lib/sqlite3/resultset.rb @@ -122,7 +122,10 @@ module SQLite3 if @db.results_as_hash new_row = HashWithTypes[ *( @stmt.columns.zip( row ).to_a.flatten ) ] - row.each_with_index { |value,idx| new_row[idx] = value } + row.each_with_index { |value,idx| + value.taint + new_row[idx] = value + } row = new_row else if row.respond_to?(:fields) @@ -131,6 +134,7 @@ module SQLite3 row = ArrayWithTypesAndFields.new(row) end row.fields = @stmt.columns + row.each { |column| column.taint } end row.types = @stmt.types diff --git a/vendor/plugins/sqlite3-ruby/lib/sqlite3/statement.rb b/vendor/plugins/sqlite3-ruby/lib/sqlite3/statement.rb index eeca6a2b..fd9a3060 100644 --- a/vendor/plugins/sqlite3-ruby/lib/sqlite3/statement.rb +++ b/vendor/plugins/sqlite3-ruby/lib/sqlite3/statement.rb @@ -31,6 +31,7 @@ module SQLite3 # statement (i.e., separated by semicolons), then the #remainder property # will be set to the trailing text. def initialize( db, sql, utf16=false ) + raise ArgumentError, "nil argument passed as sql text" unless sql @db = db @driver = @db.driver @closed = false @@ -193,8 +194,8 @@ module SQLite3 # that this may execute the statement in order to obtain the metadata; this # makes it a (potentially) expensive operation. def types - get_metadata unless @types - return @types + get_metadata unless defined?(@types) + @types end # A convenience method for obtaining the metadata about the query. Note diff --git a/vendor/plugins/sqlite3-ruby/lib/sqlite3/version.rb b/vendor/plugins/sqlite3-ruby/lib/sqlite3/version.rb index 24465445..b162acde 100644 --- a/vendor/plugins/sqlite3-ruby/lib/sqlite3/version.rb +++ b/vendor/plugins/sqlite3-ruby/lib/sqlite3/version.rb @@ -4,11 +4,13 @@ module SQLite3 MAJOR = 1 MINOR = 2 - TINY = 4 + TINY = 5 + BUILD = nil - STRING = [ MAJOR, MINOR, TINY ].join( "." ) + STRING = [ MAJOR, MINOR, TINY, BUILD ].compact.join( "." ) #:beta-tag: + VERSION = '1.2.5' end end diff --git a/vendor/plugins/sqlite3-ruby/sqlite3-ruby.gemspec b/vendor/plugins/sqlite3-ruby/sqlite3-ruby.gemspec new file mode 100644 index 00000000..c8495011 --- /dev/null +++ b/vendor/plugins/sqlite3-ruby/sqlite3-ruby.gemspec @@ -0,0 +1,141 @@ +--- !ruby/object:Gem::Specification +name: sqlite3-ruby +version: !ruby/object:Gem::Version + version: 1.2.5 +platform: ruby +authors: +- Jamis Buck +autorequire: +bindir: bin +cert_chain: [] + +date: 2009-07-25 00:00:00 -03:00 +default_executable: +dependencies: +- !ruby/object:Gem::Dependency + name: mocha + type: :development + version_requirement: + version_requirements: !ruby/object:Gem::Requirement + requirements: + - - ">=" + - !ruby/object:Gem::Version + version: "0" + version: +- !ruby/object:Gem::Dependency + name: rake-compiler + type: :development + version_requirement: + version_requirements: !ruby/object:Gem::Requirement + requirements: + - - ~> + - !ruby/object:Gem::Version + version: 0.5.0 + version: +- !ruby/object:Gem::Dependency + name: hoe + type: :development + version_requirement: + version_requirements: !ruby/object:Gem::Requirement + requirements: + - - ">=" + - !ruby/object:Gem::Version + version: 2.3.2 + version: +description: |- + This module allows Ruby programs to interface with the SQLite3 + database engine (http://www.sqlite.org). You must have the + SQLite engine installed in order to build this module. + + Note that this module is NOT compatible with SQLite 2.x. +email: +- jamis@37signals.com +executables: [] + +extensions: +- ext/sqlite3_api/extconf.rb +extra_rdoc_files: +- History.txt +- Manifest.txt +- README.txt +files: +- ChangeLog.cvs +- History.txt +- LICENSE +- Manifest.txt +- README.txt +- Rakefile +- ext/sqlite3_api/extconf.rb +- ext/sqlite3_api/sqlite3_api.i +- ext/sqlite3_api/sqlite3_api_wrap.c +- faq/faq.rb +- faq/faq.yml +- lib/sqlite3.rb +- lib/sqlite3/constants.rb +- lib/sqlite3/database.rb +- lib/sqlite3/driver/dl/api.rb +- lib/sqlite3/driver/dl/driver.rb +- lib/sqlite3/driver/native/driver.rb +- lib/sqlite3/errors.rb +- lib/sqlite3/pragmas.rb +- lib/sqlite3/resultset.rb +- lib/sqlite3/statement.rb +- lib/sqlite3/translator.rb +- lib/sqlite3/value.rb +- lib/sqlite3/version.rb +- setup.rb +- tasks/benchmark.rake +- tasks/faq.rake +- tasks/gem.rake +- tasks/native.rake +- tasks/vendor_sqlite3.rake +- test/bm.rb +- test/driver/dl/tc_driver.rb +- test/helper.rb +- test/native-vs-dl.rb +- test/test_database.rb +- test/test_errors.rb +- test/test_integration.rb +- test/test_integration_open_close.rb +- test/test_integration_pending.rb +- test/test_integration_resultset.rb +- test/test_integration_statement.rb +has_rdoc: true +homepage: http://sqlite3-ruby.rubyforge.org +licenses: [] + +post_install_message: +rdoc_options: +- --main +- README.txt +- --main=README.txt +require_paths: +- lib +- ext +required_ruby_version: !ruby/object:Gem::Requirement + requirements: + - - ">" + - !ruby/object:Gem::Version + version: 1.8.5 + version: +required_rubygems_version: !ruby/object:Gem::Requirement + requirements: + - - ">=" + - !ruby/object:Gem::Version + version: "0" + version: +requirements: [] + +rubyforge_project: sqlite-ruby +rubygems_version: 1.3.5 +signing_key: +specification_version: 3 +summary: This module allows Ruby programs to interface with the SQLite3 database engine (http://www.sqlite.org) +test_files: +- test/test_database.rb +- test/test_errors.rb +- test/test_integration.rb +- test/test_integration_open_close.rb +- test/test_integration_pending.rb +- test/test_integration_resultset.rb +- test/test_integration_statement.rb diff --git a/vendor/plugins/sqlite3-ruby/test/mocks.rb b/vendor/plugins/sqlite3-ruby/test/helper.rb similarity index 67% rename from vendor/plugins/sqlite3-ruby/test/mocks.rb rename to vendor/plugins/sqlite3-ruby/test/helper.rb index f02eed06..6d5aa90e 100644 --- a/vendor/plugins/sqlite3-ruby/test/mocks.rb +++ b/vendor/plugins/sqlite3-ruby/test/helper.rb @@ -1,6 +1,12 @@ -require 'rubygems' -gem 'mocha' +# add lib folder to the path +$:.unshift File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib')) +require 'sqlite3' + +require 'rubygems' +require 'test/unit' + +# define mocks to be used require 'mocha' class Driver < Mocha::Mock @@ -43,3 +49,19 @@ class Statement < Mocha::Mock stubs( :execute ).returns(MockResultSet.new) end end + +# UTF conversion extensions +class String + def to_utf16(terminate=false) + self.split(//).map { |c| c[0] }.pack("v*") + + (terminate ? "\0\0" : "") + end + + def from_utf16 + result = "" + length.times do |i| + result << self[i,1] if i % 2 == 0 && self[i] != 0 + end + result + end +end diff --git a/vendor/plugins/sqlite3-ruby/test/tc_integration.rb b/vendor/plugins/sqlite3-ruby/test/tc_integration.rb deleted file mode 100644 index 515c7114..00000000 --- a/vendor/plugins/sqlite3-ruby/test/tc_integration.rb +++ /dev/null @@ -1,1044 +0,0 @@ -$:.unshift "#{File.dirname(__FILE__)}/../lib" -$:.unshift "#{File.dirname(__FILE__)}/../ext/sqlite3_api" - -require 'test/unit' -require 'benchmark' -require 'sqlite3/database' -require 'thread' - -class String - def to_utf16(terminate=false) - self.split(//).map { |c| c[0] }.pack("v*") + - (terminate ? "\0\0" : "") - end - - def from_utf16 - result = "" - length.times do |i| - result << self[i,1] if i % 2 == 0 && self[i] != 0 - end - result - end -end - -module Integration - - drivers_to_test = ( ENV["SQLITE3_DRIVERS"] || "Native" ).split(',') - drivers_to_test.each do |driver| - - # == TC_OpenClose ========================================================= - - test_case = Class.new( Test::Unit::TestCase ) do - define_method( "test_create_close" ) do - begin - db = SQLite3::Database.new( "test-create.db", - :driver => driver ) - assert File.exist?( "test-create.db" ) - assert_nothing_raised { db.close } - ensure - File.delete( "test-create.db" ) rescue nil - end - end - - define_method( "test_open_close" ) do - begin - File.open( "test-open.db", "w" ) { |f| } - assert File.exist?( "test-open.db" ) - db = SQLite3::Database.new( "test-open.db", - :driver => driver ) - assert_nothing_raised { db.close } - ensure - File.delete( "test-open.db" ) rescue nil - end - end - - define_method( "test_bad_open" ) do - assert_raise( SQLite3::CantOpenException ) do - SQLite3::Database.new( ".", :driver => driver ) - end - end - end - const_set( "TC_OpenClose_#{driver}", test_case ) - - # == TC_Database ========================================================== - - test_case = Class.new( Test::Unit::TestCase ) do - define_method( "setup" ) do - @db = SQLite3::Database.new( "test.db", :driver=>driver ) - @db.transaction do - @db.execute "create table foo ( a integer primary key, b text )" - @db.execute "insert into foo ( b ) values ( 'foo' )" - @db.execute "insert into foo ( b ) values ( 'bar' )" - @db.execute "insert into foo ( b ) values ( 'baz' )" - end - end - - define_method( "teardown" ) do - @db.close - File.delete( "test.db" ) - end - - define_method( "test_table_info_with_type_translation_active" ) do - @db.type_translation = true - assert_nothing_raised { @db.table_info("foo") } - end - - define_method( "test_table_info_with_defaults_for_version_3_3_8_and_higher" ) do - @db.transaction do - @db.execute "create table defaults_test ( a string default NULL, b string default 'Hello' )" - data = @db.table_info( "defaults_test" ) - assert_equal({"name" => "a", "type" => "string", "dflt_value" => nil, "notnull" => "0", "cid" => "0", "pk" => "0"}, - data[0]) - assert_equal({"name" => "b", "type" => "string", "dflt_value" => "Hello", "notnull" => "0", "cid" => "1", "pk" => "0"}, - data[1]) - end - end - - define_method( "test_table_info_without_defaults_for_version_3_3_8_and_higher" ) do - @db.transaction do - @db.execute "create table no_defaults_test ( a integer default 1, b integer )" - data = @db.table_info( "no_defaults_test" ) - assert_equal({"name" => "a", "type" => "integer", "dflt_value" => "1", "notnull" => "0", "cid" => "0", "pk" => "0"}, - data[0]) - assert_equal({"name" => "b", "type" => "integer", "dflt_value" => nil, "notnull" => "0", "cid" => "1", "pk" => "0"}, - data[1]) - end - end - - define_method( "test_complete_fail" ) do - assert !@db.complete?( "select * from foo" ) - end - define_method( "test_complete_success" ) do - assert @db.complete?( "select * from foo;" ) - end - - define_method( "test_complete_fail_utf16" ) do - assert !@db.complete?( "select * from foo".to_utf16(false), true ) - end - - define_method( "test_complete_success_utf16" ) do - assert @db.complete?( "select * from foo;".to_utf16(true), true ) - end - - define_method( "test_errmsg" ) do - assert_equal "not an error", @db.errmsg - end - - define_method( "test_errmsg_utf16" ) do - assert_equal "not an error".to_utf16, @db.errmsg(true) - end - - define_method( "test_errcode" ) do - assert_equal 0, @db.errcode - end - - define_method( "test_trace" ) do - result = nil - @db.trace( "data" ) { |data,sql| result = [ data, sql ]; 0 } - @db.execute "select * from foo" - assert_equal ["data","select * from foo"], result - end - - define_method( "test_authorizer_okay" ) do - @db.authorizer( "data" ) { |data,type,a,b,c,d| 0 } - rows = @db.execute "select * from foo" - assert_equal 3, rows.length - end - - define_method( "test_authorizer_error" ) do - @db.authorizer( "data" ) { |data,type,a,b,c,d| 1 } - assert_raise( SQLite3::AuthorizationException ) do - @db.execute "select * from foo" - end - end - -# FIXME: this test is failing with sqlite3 3.2.5 -# define_method( "test_authorizer_silent" ) do -# @db.authorizer( "data" ) { |data,type,a,b,c,d| 2 } -# rows = @db.execute "select * from foo" -# assert rows.empty? -# end - - define_method( "test_prepare_invalid_syntax" ) do - assert_raise( SQLite3::SQLException ) do - @db.prepare "select from foo" - end - end - - define_method( "test_prepare_invalid_column" ) do - assert_raise( SQLite3::SQLException ) do - @db.prepare "select k from foo" - end - end - - define_method( "test_prepare_invalid_table" ) do - assert_raise( SQLite3::SQLException ) do - @db.prepare "select * from barf" - end - end - - define_method( "test_prepare_no_block" ) do - stmt = @db.prepare "select * from foo" - assert stmt.respond_to?(:execute) - stmt.close - end - - define_method( "test_prepare_with_block" ) do - called = false - @db.prepare "select * from foo" do |stmt| - called = true - assert stmt.respond_to?(:execute) - end - assert called - end - - define_method( "test_execute_no_block_no_bind_no_match" ) do - rows = @db.execute( "select * from foo where a > 100" ) - assert rows.empty? - end - - define_method( "test_execute_with_block_no_bind_no_match" ) do - called = false - @db.execute( "select * from foo where a > 100" ) do |row| - called = true - end - assert !called - end - - define_method( "test_execute_no_block_with_bind_no_match" ) do - rows = @db.execute( "select * from foo where a > ?", 100 ) - assert rows.empty? - end - - define_method( "test_execute_with_block_with_bind_no_match" ) do - called = false - @db.execute( "select * from foo where a > ?", 100 ) do |row| - called = true - end - assert !called - end - - define_method( "test_execute_no_block_no_bind_with_match" ) do - rows = @db.execute( "select * from foo where a = 1" ) - assert_equal 1, rows.length - end - - define_method( "test_execute_with_block_no_bind_with_match" ) do - called = 0 - @db.execute( "select * from foo where a = 1" ) do |row| - called += 1 - end - assert_equal 1, called - end - - define_method( "test_execute_no_block_with_bind_with_match" ) do - rows = @db.execute( "select * from foo where a = ?", 1 ) - assert_equal 1, rows.length - end - - define_method( "test_execute_with_block_with_bind_with_match" ) do - called = 0 - @db.execute( "select * from foo where a = ?", 1 ) do |row| - called += 1 - end - assert_equal 1, called - end - - define_method( "test_execute2_no_block_no_bind_no_match" ) do - columns, *rows = @db.execute2( "select * from foo where a > 100" ) - assert rows.empty? - assert [ "a", "b" ], columns - end - - define_method( "test_execute2_with_block_no_bind_no_match" ) do - called = 0 - @db.execute2( "select * from foo where a > 100" ) do |row| - assert [ "a", "b" ], row unless called == 0 - called += 1 - end - assert_equal 1, called - end - - define_method( "test_execute2_no_block_with_bind_no_match" ) do - columns, *rows = @db.execute2( "select * from foo where a > ?", 100 ) - assert rows.empty? - assert [ "a", "b" ], columns - end - - define_method( "test_execute2_with_block_with_bind_no_match" ) do - called = 0 - @db.execute2( "select * from foo where a > ?", 100 ) do |row| - assert [ "a", "b" ], row unless called == 0 - called += 1 - end - assert_equal 1, called - end - - define_method( "test_execute2_no_block_no_bind_with_match" ) do - columns, *rows = @db.execute2( "select * from foo where a = 1" ) - assert_equal 1, rows.length - assert [ "a", "b" ], columns - end - - define_method( "test_execute2_with_block_no_bind_with_match" ) do - called = 0 - @db.execute2( "select * from foo where a = 1" ) do |row| - assert [ "a", "b" ], row unless called == 0 - called += 1 - end - assert_equal 2, called - end - - define_method( "test_execute2_no_block_with_bind_with_match" ) do - columns, *rows = @db.execute2( "select * from foo where a = ?", 1 ) - assert_equal 1, rows.length - assert [ "a", "b" ], columns - end - - define_method( "test_execute2_with_block_with_bind_with_match" ) do - called = 0 - @db.execute2( "select * from foo where a = ?", 1 ) do |row| - called += 1 - end - assert_equal 2, called - end - - define_method( "test_execute_batch_empty" ) do - assert_nothing_raised { @db.execute_batch "" } - end - - define_method( "test_execute_batch_no_bind" ) do - @db.transaction do - @db.execute_batch <<-SQL - create table bar ( a, b, c ); - insert into bar values ( 'one', 2, 'three' ); - insert into bar values ( 'four', 5, 'six' ); - insert into bar values ( 'seven', 8, 'nine' ); - SQL - end - rows = @db.execute( "select * from bar" ) - assert_equal 3, rows.length - end - - define_method( "test_execute_batch_with_bind" ) do - @db.execute_batch( <<-SQL, 1 ) - create table bar ( a, b, c ); - insert into bar values ( 'one', 2, ? ); - insert into bar values ( 'four', 5, ? ); - insert into bar values ( 'seven', 8, ? ); - SQL - rows = @db.execute( "select * from bar" ).map { |a,b,c| c } - assert_equal %w{1 1 1}, rows - end - - define_method( "test_query_no_block_no_bind_no_match" ) do - result = @db.query( "select * from foo where a > 100" ) - assert_nil result.next - result.close - end - - define_method( "test_query_with_block_no_bind_no_match" ) do - r = nil - @db.query( "select * from foo where a > 100" ) do |result| - assert_nil result.next - r = result - end - assert r.closed? - end - - define_method( "test_query_no_block_with_bind_no_match" ) do - result = @db.query( "select * from foo where a > ?", 100 ) - assert_nil result.next - result.close - end - - define_method( "test_query_with_block_with_bind_no_match" ) do - r = nil - @db.query( "select * from foo where a > ?", 100 ) do |result| - assert_nil result.next - r = result - end - assert r.closed? - end - - define_method( "test_query_no_block_no_bind_with_match" ) do - result = @db.query( "select * from foo where a = 1" ) - assert_not_nil result.next - assert_nil result.next - result.close - end - - define_method( "test_query_with_block_no_bind_with_match" ) do - r = nil - @db.query( "select * from foo where a = 1" ) do |result| - assert_not_nil result.next - assert_nil result.next - r = result - end - assert r.closed? - end - - define_method( "test_query_no_block_with_bind_with_match" ) do - result = @db.query( "select * from foo where a = ?", 1 ) - assert_not_nil result.next - assert_nil result.next - result.close - end - - define_method( "test_query_with_block_with_bind_with_match" ) do - r = nil - @db.query( "select * from foo where a = ?", 1 ) do |result| - assert_not_nil result.next - assert_nil result.next - r = result - end - assert r.closed? - end - - define_method( "test_get_first_row_no_bind_no_match" ) do - result = @db.get_first_row( "select * from foo where a=100" ) - assert_nil result - end - - define_method( "test_get_first_row_no_bind_with_match" ) do - result = @db.get_first_row( "select * from foo where a=1" ) - assert_equal [ "1", "foo" ], result - end - - define_method( "test_get_first_row_with_bind_no_match" ) do - result = @db.get_first_row( "select * from foo where a=?", 100 ) - assert_nil result - end - - define_method( "test_get_first_row_with_bind_with_match" ) do - result = @db.get_first_row( "select * from foo where a=?", 1 ) - assert_equal [ "1", "foo" ], result - end - - define_method( "test_get_first_value_no_bind_no_match" ) do - result = @db.get_first_value( "select b, a from foo where a=100" ) - assert_nil result - end - - define_method( "test_get_first_value_no_bind_with_match" ) do - result = @db.get_first_value( "select b, a from foo where a=1" ) - assert_equal "foo", result - end - - define_method( "test_get_first_value_with_bind_no_match" ) do - result = @db.get_first_value( "select b, a from foo where a=?", 100 ) - assert_nil result - end - - define_method( "test_get_first_value_with_bind_with_match" ) do - result = @db.get_first_value( "select b, a from foo where a=?", 1 ) - assert_equal "foo", result - end - - define_method( "test_last_insert_row_id" ) do - @db.execute "insert into foo ( b ) values ( 'test' )" - assert_equal 4, @db.last_insert_row_id - @db.execute "insert into foo ( b ) values ( 'again' )" - assert_equal 5, @db.last_insert_row_id - end - - define_method( "test_changes" ) do - @db.execute "insert into foo ( b ) values ( 'test' )" - assert_equal 1, @db.changes - @db.execute "delete from foo where 1=1" - assert_equal 4, @db.changes - end - - define_method( "test_total_changes" ) do - assert_equal 3, @db.total_changes - @db.execute "insert into foo ( b ) values ( 'test' )" - @db.execute "delete from foo where 1=1" - assert_equal 8, @db.total_changes - end - - define_method( "test_transaction_nest" ) do - assert_raise( SQLite3::SQLException ) do - @db.transaction do - @db.transaction do - end - end - end - end - - define_method( "test_transaction_rollback" ) do - @db.transaction - @db.execute_batch <<-SQL - insert into foo (b) values ( 'test1' ); - insert into foo (b) values ( 'test2' ); - insert into foo (b) values ( 'test3' ); - insert into foo (b) values ( 'test4' ); - SQL - assert_equal 7, @db.get_first_value("select count(*) from foo").to_i - @db.rollback - assert_equal 3, @db.get_first_value("select count(*) from foo").to_i - end - - define_method( "test_transaction_commit" ) do - @db.transaction - @db.execute_batch <<-SQL - insert into foo (b) values ( 'test1' ); - insert into foo (b) values ( 'test2' ); - insert into foo (b) values ( 'test3' ); - insert into foo (b) values ( 'test4' ); - SQL - assert_equal 7, @db.get_first_value("select count(*) from foo").to_i - @db.commit - assert_equal 7, @db.get_first_value("select count(*) from foo").to_i - end - - define_method( "test_transaction_rollback_in_block" ) do - assert_raise( SQLite3::SQLException ) do - @db.transaction do - @db.rollback - end - end - end - - define_method( "test_transaction_commit_in_block" ) do - assert_raise( SQLite3::SQLException ) do - @db.transaction do - @db.commit - end - end - end - - define_method( "test_transaction_active" ) do - assert !@db.transaction_active? - @db.transaction - assert @db.transaction_active? - @db.commit - assert !@db.transaction_active? - end - - define_method( "no_tests_at" ) do |file,line,method| - warn "[(#{self.class}):#{file}:#{line}] no tests for #{method}" - end - - define_method( "test_interrupt" ) do - @db.create_function( "abort", 1 ) do |func,x| - @db.interrupt - func.result = x - end - - assert_raise( SQLite3::SQLException ) do - @db.execute "select abort(a) from foo" - end - end - - define_method( "test_busy_handler_outwait" ) do - busy = Mutex.new - busy.lock - handler_call_count = 0 - - t = Thread.new do - begin - db2 = SQLite3::Database.open( "test.db", :driver=>driver ) - db2.transaction( :exclusive ) do - busy.lock - end - ensure - db2.close if db2 - end - end - - @db.busy_handler do |data,count| - handler_call_count += 1 - busy.unlock - true - end - - assert_nothing_raised do - @db.execute "insert into foo (b) values ( 'from 2' )" - end - - t.join - - assert_equal 1, handler_call_count - end - - define_method( "test_busy_handler_impatient" ) do - busy = Mutex.new - busy.lock - handler_call_count = 0 - - t = Thread.new do - begin - db2 = SQLite3::Database.open( "test.db", :driver=>driver ) - db2.transaction( :exclusive ) do - busy.lock - end - ensure - db2.close if db2 - end - end - - @db.busy_handler do |data, count| - handler_call_count += 1 - false - end - - assert_raise( SQLite3::BusyException ) do - @db.execute "insert into foo (b) values ( 'from 2' )" - end - - busy.unlock - t.join - - assert_equal 1, handler_call_count - end - - define_method( "test_busy_timeout" ) do - @db.busy_timeout 1000 - busy = Mutex.new - busy.lock - - t = Thread.new do - begin - db2 = SQLite3::Database.open( "test.db", :driver=>driver ) - db2.transaction( :exclusive ) do - busy.lock - end - ensure - db2.close if db2 - end - end - - time = Benchmark.measure do - assert_raise( SQLite3::BusyException ) do - @db.execute "insert into foo (b) values ( 'from 2' )" - end - end - - busy.unlock - t.join - - assert time.real*1000 >= 1000 - end - - define_method( "test_create_function" ) do - @db.create_function( "munge", 1 ) do |func,x| - func.result = ">>>#{x}<<<" - end - - value = @db.get_first_value( "select munge(b) from foo where a=1" ) - assert_match( />>>.*<<driver ) - @db.transaction do - @db.execute "create table foo ( a integer primary key, b text )" - @db.execute "insert into foo ( b ) values ( 'foo' )" - @db.execute "insert into foo ( b ) values ( 'bar' )" - @db.execute "insert into foo ( b ) values ( 'baz' )" - end - @stmt = @db.prepare( "select * from foo where a in ( ?, :named )" ) - end - - define_method( "teardown" ) do - @stmt.close - @db.close - File.delete( "test.db" ) - end - - define_method( "test_remainder_empty" ) do - assert_equal "", @stmt.remainder - end - - define_method( "test_remainder_nonempty" ) do - called = false - @db.prepare( "select * from foo;\n blah" ) do |stmt| - called = true - assert_equal "\n blah", stmt.remainder - end - assert called - end - - define_method( "test_bind_params_empty" ) do - assert_nothing_raised { @stmt.bind_params } - assert @stmt.execute!.empty? - end - - define_method( "test_bind_params_array" ) do - @stmt.bind_params 1, 2 - assert_equal 2, @stmt.execute!.length - end - - define_method( "test_bind_params_hash" ) do - @stmt.bind_params ":named" => 2 - assert_equal 1, @stmt.execute!.length - end - - define_method( "test_bind_params_hash_without_colon" ) do - @stmt.bind_params "named" => 2 - assert_equal 1, @stmt.execute!.length - end - - define_method( "test_bind_params_hash_as_symbol" ) do - @stmt.bind_params :named => 2 - assert_equal 1, @stmt.execute!.length - end - - define_method( "test_bind_params_mixed" ) do - @stmt.bind_params( 1, ":named" => 2 ) - assert_equal 2, @stmt.execute!.length - end - - define_method( "test_bind_param_by_index" ) do - @stmt.bind_params( 1, 2 ) - assert_equal 2, @stmt.execute!.length - end - - define_method( "test_bind_param_by_name_bad" ) do - assert_raise( SQLite3::Exception ) { @stmt.bind_param( "@named", 2 ) } - end - - define_method( "test_bind_param_by_name_good" ) do - @stmt.bind_param( ":named", 2 ) - assert_equal 1, @stmt.execute!.length - end - - define_method( "test_bind_param_with_various_types" ) do - @db.transaction do - @db.execute "create table all_types ( a integer primary key, b float, c string, d integer )" - @db.execute "insert into all_types ( b, c, d ) values ( 1.4, 'hello', 68719476735 )" - end - - assert_equal 1, @db.execute( "select * from all_types where b = ?", 1.4 ).length - assert_equal 1, @db.execute( "select * from all_types where c = ?", 'hello').length - assert_equal 1, @db.execute( "select * from all_types where d = ?", 68719476735).length - end - - define_method( "test_execute_no_bind_no_block" ) do - assert_instance_of SQLite3::ResultSet, @stmt.execute - end - - define_method( "test_execute_with_bind_no_block" ) do - assert_instance_of SQLite3::ResultSet, @stmt.execute( 1, 2 ) - end - - define_method( "test_execute_no_bind_with_block" ) do - called = false - @stmt.execute { |row| called = true } - assert called - end - - define_method( "test_execute_with_bind_with_block" ) do - called = 0 - @stmt.execute( 1, 2 ) { |row| called += 1 } - assert_equal 1, called - end - - define_method( "test_reexecute" ) do - r = @stmt.execute( 1, 2 ) - assert_equal 2, r.to_a.length - assert_nothing_raised { r = @stmt.execute( 1, 2 ) } - assert_equal 2, r.to_a.length - end - - define_method( "test_execute_bang_no_bind_no_block" ) do - assert @stmt.execute!.empty? - end - - define_method( "test_execute_bang_with_bind_no_block" ) do - assert_equal 2, @stmt.execute!( 1, 2 ).length - end - - define_method( "test_execute_bang_no_bind_with_block" ) do - called = 0 - @stmt.execute! { |row| called += 1 } - assert_equal 0, called - end - - define_method( "test_execute_bang_with_bind_with_block" ) do - called = 0 - @stmt.execute!( 1, 2 ) { |row| called += 1 } - assert_equal 2, called - end - - define_method( "test_columns" ) do - c1 = @stmt.columns - c2 = @stmt.columns - assert_same c1, c2 - assert_equal 2, c1.length - end - - define_method( "test_columns_computed" ) do - called = false - @db.prepare( "select count(*) from foo" ) do |stmt| - called = true - assert_equal [ "count(*)" ], stmt.columns - end - assert called - end - - define_method( "test_types" ) do - t1 = @stmt.types - t2 = @stmt.types - assert_same t1, t2 - assert_equal 2, t1.length - end - - define_method( "test_types_computed" ) do - called = false - @db.prepare( "select count(*) from foo" ) do |stmt| - called = true - assert_equal [ nil ], stmt.types - end - assert called - end - - define_method( "test_close" ) do - stmt = @db.prepare( "select * from foo" ) - assert !stmt.closed? - stmt.close - assert stmt.closed? - assert_raise( SQLite3::Exception ) { stmt.execute } - assert_raise( SQLite3::Exception ) { stmt.execute! } - assert_raise( SQLite3::Exception ) { stmt.close } - assert_raise( SQLite3::Exception ) { stmt.bind_params 5 } - assert_raise( SQLite3::Exception ) { stmt.bind_param 1, 5 } - assert_raise( SQLite3::Exception ) { stmt.columns } - assert_raise( SQLite3::Exception ) { stmt.types } - end - - define_method( "test_committing_tx_with_statement_active" ) do - called = false - @db.prepare( "select count(*) from foo" ) do |stmt| - called = true - count = stmt.execute!.first.first.to_i - @db.transaction do - @db.execute "insert into foo ( b ) values ( 'hello' )" - end - new_count = stmt.execute!.first.first.to_i - assert_equal new_count, count+1 - end - assert called - end - end - const_set( "TC_Statement_#{driver}", test_case ) - - # == TC_ResultSet ========================================================= - - test_case = Class.new( Test::Unit::TestCase ) do - define_method( "setup" ) do - @db = SQLite3::Database.new( "test.db", :driver=>driver ) - @db.transaction do - @db.execute "create table foo ( a integer primary key, b text )" - @db.execute "insert into foo ( b ) values ( 'foo' )" - @db.execute "insert into foo ( b ) values ( 'bar' )" - @db.execute "insert into foo ( b ) values ( 'baz' )" - end - @stmt = @db.prepare( "select * from foo where a in ( ?, ? )" ) - @result = @stmt.execute - end - - define_method( "teardown" ) do - @stmt.close - @db.close - File.delete( "test.db" ) - end - - define_method( "test_reset_unused" ) do - assert_nothing_raised { @result.reset } - assert @result.to_a.empty? - end - - define_method( "test_reset_used" ) do - @result.to_a - assert_nothing_raised { @result.reset } - assert @result.to_a.empty? - end - - define_method( "test_reset_with_bind" ) do - @result.to_a - assert_nothing_raised { @result.reset( 1, 2 ) } - assert_equal 2, @result.to_a.length - end - - define_method( "test_eof_inner" ) do - @result.reset( 1 ) - assert !@result.eof? - end - - define_method( "test_eof_edge" ) do - @result.reset( 1 ) - @result.next # to first row - @result.next # to end of result set - assert @result.eof? - end - - define_method( "test_next_eof" ) do - @result.reset( 1 ) - assert_not_nil @result.next - assert_nil @result.next - end - - define_method( "test_next_no_type_translation_no_hash" ) do - @result.reset( 1 ) - assert_equal [ "1", "foo" ], @result.next - end - - define_method( "test_next_type_translation" ) do - @db.type_translation = true - @result.reset( 1 ) - assert_equal [ 1, "foo" ], @result.next - end - - define_method( "test_next_type_translation_with_untyped_column" ) do - @db.type_translation = true - @db.query( "select count(*) from foo" ) do |result| - assert_equal ["3"], result.next - end - end - - define_method( "test_type_translation_with_null_column" ) do - @db.type_translation = true - @db.execute "create table bar ( a integer, b time, c string )" - @db.execute "insert into bar (a, b, c) values (NULL, '1974-07-25 14:39:00', 'hello')" - @db.execute "insert into bar (a, b, c) values (1, NULL, 'hello')" - @db.execute "insert into bar (a, b, c) values (2, '1974-07-25 14:39:00', NULL)" - @db.query( "select * from bar" ) do |result| - assert_equal [nil, Time.local(1974, 7, 25, 14, 39, 0), 'hello'], result.next - assert_equal [1, nil, 'hello'], result.next - assert_equal [2, Time.local(1974, 7, 25, 14, 39, 0), nil], result.next - end - end - - define_method( "test_date_and_time_translation" ) do - @db.type_translation = true - @db.execute "create table bar ( a date, b datetime, c time, d timestamp )" - @db.execute "insert into bar (a, b, c, d) values ('1999-01-08', '1997-12-17 07:37:16', '07:37:16', '2004-10-19 10:23:54')" - @db.query( "select * from bar" ) do |result| - result = result.next - assert result[0].is_a?(Date) - assert result[1].is_a?(DateTime) - assert result[2].is_a?(Time) - assert result[3].is_a?(Time) - end - end - - define_method( "test_next_results_as_hash" ) do - @db.results_as_hash = true - @result.reset( 1 ) - assert_equal( { "a" => "1", "b" => "foo", 0 => "1", 1 => "foo" }, - @result.next ) - end - - define_method( "test_each" ) do - called = 0 - @result.reset( 1, 2 ) - @result.each { |row| called += 1 } - assert_equal 2, called - end - - define_method( "test_enumerable" ) do - @result.reset( 1, 2 ) - assert_equal 2, @result.to_a.length - end - - define_method( "test_types" ) do - assert_equal [ "integer", "text" ], @result.types - end - - define_method( "test_columns" ) do - assert_equal [ "a", "b" ], @result.columns - end - - define_method( "test_close" ) do - stmt = @db.prepare( "select * from foo" ) - result = stmt.execute - assert !result.closed? - result.close - assert result.closed? - assert stmt.closed? - assert_raise( SQLite3::Exception ) { result.reset } - assert_raise( SQLite3::Exception ) { result.next } - assert_raise( SQLite3::Exception ) { result.each } - assert_raise( SQLite3::Exception ) { result.close } - assert_raise( SQLite3::Exception ) { result.types } - assert_raise( SQLite3::Exception ) { result.columns } - end - end - const_set( "TC_ResultSet_#{driver}", test_case ) - end - -end diff --git a/vendor/plugins/sqlite3-ruby/test/tc_database.rb b/vendor/plugins/sqlite3-ruby/test/test_database.rb similarity index 86% rename from vendor/plugins/sqlite3-ruby/test/tc_database.rb rename to vendor/plugins/sqlite3-ruby/test/test_database.rb index bddee6e5..ca4d8e35 100644 --- a/vendor/plugins/sqlite3-ruby/test/tc_database.rb +++ b/vendor/plugins/sqlite3-ruby/test/test_database.rb @@ -1,9 +1,4 @@ -$:.unshift "../lib" - -require 'sqlite3/database' -require 'test/unit' - -require 'mocks' +require File.join(File.dirname(__FILE__), 'helper') class TC_Database_Init < Test::Unit::TestCase def test_new @@ -16,6 +11,18 @@ class TC_Database_Init < Test::Unit::TestCase assert !db.results_as_hash assert !db.type_translation end + + def test_new_with_block + driver = Driver.new + driver.expects(:open).once.with('foo.db', false).returns([0, 'cookie']) + Driver.stubs(:new).returns(driver) + returned_db = SQLite3::Database.new( "foo.db", :driver => Driver ) do |db| + assert !db.closed? + assert !db.results_as_hash + assert !db.type_translation + end + assert returned_db.closed? + end def test_open driver = Driver.new @@ -27,6 +34,18 @@ class TC_Database_Init < Test::Unit::TestCase assert !db.type_translation end + def test_open_with_block + driver = Driver.new + driver.expects(:open).once.with('foo.db', false).returns([0, 'cookie']) + Driver.stubs(:new).returns(driver) + returned_db = SQLite3::Database.open( "foo.db", :driver => Driver ) do |db| + assert !db.closed? + assert !db.results_as_hash + assert !db.type_translation + end + assert returned_db.closed? + end + def test_with_type_translation db = SQLite3::Database.open( "foo.db", :driver => Driver, :type_translation => true ) diff --git a/vendor/plugins/sqlite3-ruby/test/tc_errors.rb b/vendor/plugins/sqlite3-ruby/test/test_errors.rb similarity index 84% rename from vendor/plugins/sqlite3-ruby/test/tc_errors.rb rename to vendor/plugins/sqlite3-ruby/test/test_errors.rb index cec552fd..132fbc90 100644 --- a/vendor/plugins/sqlite3-ruby/test/tc_errors.rb +++ b/vendor/plugins/sqlite3-ruby/test/test_errors.rb @@ -1,8 +1,4 @@ -$:.unshift "../lib" - -require 'sqlite3/errors' -require 'test/unit' -require 'mocha' +require File.join(File.dirname(__FILE__), 'helper') class TC_Errors < Test::Unit::TestCase (1..26).each do |code| diff --git a/vendor/plugins/sqlite3-ruby/test/test_integration.rb b/vendor/plugins/sqlite3-ruby/test/test_integration.rb new file mode 100644 index 00000000..314a7118 --- /dev/null +++ b/vendor/plugins/sqlite3-ruby/test/test_integration.rb @@ -0,0 +1,542 @@ +require File.join(File.dirname(__FILE__), 'helper') + +class TC_Database_Integration < Test::Unit::TestCase + def setup + @db = SQLite3::Database.new( "test.db" ) + @db.transaction do + @db.execute "create table foo ( a integer primary key, b text )" + @db.execute "insert into foo ( b ) values ( 'foo' )" + @db.execute "insert into foo ( b ) values ( 'bar' )" + @db.execute "insert into foo ( b ) values ( 'baz' )" + end + end + + def teardown + @db.close + File.delete( "test.db" ) + end + + def test_table_info_with_type_translation_active + @db.type_translation = true + assert_nothing_raised { @db.table_info("foo") } + end + + def test_table_info_with_defaults_for_version_3_3_8_and_higher + @db.transaction do + @db.execute "create table defaults_test ( a string default NULL, b string default 'Hello' )" + data = @db.table_info( "defaults_test" ) + assert_equal({"name" => "a", "type" => "string", "dflt_value" => nil, "notnull" => "0", "cid" => "0", "pk" => "0"}, + data[0]) + assert_equal({"name" => "b", "type" => "string", "dflt_value" => "Hello", "notnull" => "0", "cid" => "1", "pk" => "0"}, + data[1]) + end + end + + def test_table_info_without_defaults_for_version_3_3_8_and_higher + @db.transaction do + @db.execute "create table no_defaults_test ( a integer default 1, b integer )" + data = @db.table_info( "no_defaults_test" ) + assert_equal({"name" => "a", "type" => "integer", "dflt_value" => "1", "notnull" => "0", "cid" => "0", "pk" => "0"}, + data[0]) + assert_equal({"name" => "b", "type" => "integer", "dflt_value" => nil, "notnull" => "0", "cid" => "1", "pk" => "0"}, + data[1]) + end + end + + def test_complete_fail + assert !@db.complete?( "select * from foo" ) + end + def test_complete_success + assert @db.complete?( "select * from foo;" ) + end + + def test_complete_fail_utf16 + assert !@db.complete?( "select * from foo".to_utf16(false), true ) + end + + def test_complete_success_utf16 + assert @db.complete?( "select * from foo;".to_utf16(true), true ) + end + + def test_errmsg + assert_equal "not an error", @db.errmsg + end + + def test_errmsg_utf16 + assert_equal "not an error".to_utf16, @db.errmsg(true) + end + + def test_errcode + assert_equal 0, @db.errcode + end + + def test_trace + result = nil + @db.trace( "data" ) { |data,sql| result = [ data, sql ]; 0 } + @db.execute "select * from foo" + assert_equal ["data","select * from foo"], result + end + + def test_authorizer_okay + @db.authorizer( "data" ) { |data,type,a,b,c,d| 0 } + rows = @db.execute "select * from foo" + assert_equal 3, rows.length + end + + def test_authorizer_error + @db.authorizer( "data" ) { |data,type,a,b,c,d| 1 } + assert_raise( SQLite3::AuthorizationException ) do + @db.execute "select * from foo" + end + end + + def test_authorizer_silent + @db.authorizer( "data" ) { |data,type,a,b,c,d| 2 } + rows = @db.execute "select * from foo" + assert rows.empty? + end + + def test_prepare_invalid_syntax + assert_raise( SQLite3::SQLException ) do + @db.prepare "select from foo" + end + end + + def test_prepare_invalid_column + assert_raise( SQLite3::SQLException ) do + @db.prepare "select k from foo" + end + end + + def test_prepare_invalid_table + assert_raise( SQLite3::SQLException ) do + @db.prepare "select * from barf" + end + end + + def test_prepare_no_block + stmt = @db.prepare "select * from foo" + assert stmt.respond_to?(:execute) + stmt.close + end + + def test_prepare_with_block + called = false + @db.prepare "select * from foo" do |stmt| + called = true + assert stmt.respond_to?(:execute) + end + assert called + end + + def test_execute_no_block_no_bind_no_match + rows = @db.execute( "select * from foo where a > 100" ) + assert rows.empty? + end + + def test_execute_with_block_no_bind_no_match + called = false + @db.execute( "select * from foo where a > 100" ) do |row| + called = true + end + assert !called + end + + def test_execute_no_block_with_bind_no_match + rows = @db.execute( "select * from foo where a > ?", 100 ) + assert rows.empty? + end + + def test_execute_with_block_with_bind_no_match + called = false + @db.execute( "select * from foo where a > ?", 100 ) do |row| + called = true + end + assert !called + end + + def test_execute_no_block_no_bind_with_match + rows = @db.execute( "select * from foo where a = 1" ) + assert_equal 1, rows.length + end + + def test_execute_with_block_no_bind_with_match + called = 0 + @db.execute( "select * from foo where a = 1" ) do |row| + called += 1 + end + assert_equal 1, called + end + + def test_execute_no_block_with_bind_with_match + rows = @db.execute( "select * from foo where a = ?", 1 ) + assert_equal 1, rows.length + end + + def test_execute_with_block_with_bind_with_match + called = 0 + @db.execute( "select * from foo where a = ?", 1 ) do |row| + called += 1 + end + assert_equal 1, called + end + + def test_execute2_no_block_no_bind_no_match + columns, *rows = @db.execute2( "select * from foo where a > 100" ) + assert rows.empty? + assert [ "a", "b" ], columns + end + + def test_execute2_with_block_no_bind_no_match + called = 0 + @db.execute2( "select * from foo where a > 100" ) do |row| + assert [ "a", "b" ], row unless called == 0 + called += 1 + end + assert_equal 1, called + end + + def test_execute2_no_block_with_bind_no_match + columns, *rows = @db.execute2( "select * from foo where a > ?", 100 ) + assert rows.empty? + assert [ "a", "b" ], columns + end + + def test_execute2_with_block_with_bind_no_match + called = 0 + @db.execute2( "select * from foo where a > ?", 100 ) do |row| + assert [ "a", "b" ], row unless called == 0 + called += 1 + end + assert_equal 1, called + end + + def test_execute2_no_block_no_bind_with_match + columns, *rows = @db.execute2( "select * from foo where a = 1" ) + assert_equal 1, rows.length + assert [ "a", "b" ], columns + end + + def test_execute2_with_block_no_bind_with_match + called = 0 + @db.execute2( "select * from foo where a = 1" ) do |row| + assert [ "a", "b" ], row unless called == 0 + called += 1 + end + assert_equal 2, called + end + + def test_execute2_no_block_with_bind_with_match + columns, *rows = @db.execute2( "select * from foo where a = ?", 1 ) + assert_equal 1, rows.length + assert [ "a", "b" ], columns + end + + def test_execute2_with_block_with_bind_with_match + called = 0 + @db.execute2( "select * from foo where a = ?", 1 ) do |row| + called += 1 + end + assert_equal 2, called + end + + def test_execute_batch_empty + assert_nothing_raised { @db.execute_batch "" } + end + + def test_execute_batch_no_bind + @db.transaction do + @db.execute_batch <<-SQL + create table bar ( a, b, c ); + insert into bar values ( 'one', 2, 'three' ); + insert into bar values ( 'four', 5, 'six' ); + insert into bar values ( 'seven', 8, 'nine' ); + SQL + end + rows = @db.execute( "select * from bar" ) + assert_equal 3, rows.length + end + + def test_execute_batch_with_bind + @db.execute_batch( <<-SQL, 1 ) + create table bar ( a, b, c ); + insert into bar values ( 'one', 2, ? ); + insert into bar values ( 'four', 5, ? ); + insert into bar values ( 'seven', 8, ? ); + SQL + rows = @db.execute( "select * from bar" ).map { |a,b,c| c } + assert_equal %w{1 1 1}, rows + end + + def test_query_no_block_no_bind_no_match + result = @db.query( "select * from foo where a > 100" ) + assert_nil result.next + result.close + end + + def test_query_with_block_no_bind_no_match + r = nil + @db.query( "select * from foo where a > 100" ) do |result| + assert_nil result.next + r = result + end + assert r.closed? + end + + def test_query_no_block_with_bind_no_match + result = @db.query( "select * from foo where a > ?", 100 ) + assert_nil result.next + result.close + end + + def test_query_with_block_with_bind_no_match + r = nil + @db.query( "select * from foo where a > ?", 100 ) do |result| + assert_nil result.next + r = result + end + assert r.closed? + end + + def test_query_no_block_no_bind_with_match + result = @db.query( "select * from foo where a = 1" ) + assert_not_nil result.next + assert_nil result.next + result.close + end + + def test_query_with_block_no_bind_with_match + r = nil + @db.query( "select * from foo where a = 1" ) do |result| + assert_not_nil result.next + assert_nil result.next + r = result + end + assert r.closed? + end + + def test_query_no_block_with_bind_with_match + result = @db.query( "select * from foo where a = ?", 1 ) + assert_not_nil result.next + assert_nil result.next + result.close + end + + def test_query_with_block_with_bind_with_match + r = nil + @db.query( "select * from foo where a = ?", 1 ) do |result| + assert_not_nil result.next + assert_nil result.next + r = result + end + assert r.closed? + end + + def test_get_first_row_no_bind_no_match + result = @db.get_first_row( "select * from foo where a=100" ) + assert_nil result + end + + def test_get_first_row_no_bind_with_match + result = @db.get_first_row( "select * from foo where a=1" ) + assert_equal [ "1", "foo" ], result + end + + def test_get_first_row_with_bind_no_match + result = @db.get_first_row( "select * from foo where a=?", 100 ) + assert_nil result + end + + def test_get_first_row_with_bind_with_match + result = @db.get_first_row( "select * from foo where a=?", 1 ) + assert_equal [ "1", "foo" ], result + end + + def test_get_first_value_no_bind_no_match + result = @db.get_first_value( "select b, a from foo where a=100" ) + assert_nil result + end + + def test_get_first_value_no_bind_with_match + result = @db.get_first_value( "select b, a from foo where a=1" ) + assert_equal "foo", result + end + + def test_get_first_value_with_bind_no_match + result = @db.get_first_value( "select b, a from foo where a=?", 100 ) + assert_nil result + end + + def test_get_first_value_with_bind_with_match + result = @db.get_first_value( "select b, a from foo where a=?", 1 ) + assert_equal "foo", result + end + + def test_last_insert_row_id + @db.execute "insert into foo ( b ) values ( 'test' )" + assert_equal 4, @db.last_insert_row_id + @db.execute "insert into foo ( b ) values ( 'again' )" + assert_equal 5, @db.last_insert_row_id + end + + def test_changes + @db.execute "insert into foo ( b ) values ( 'test' )" + assert_equal 1, @db.changes + @db.execute "delete from foo where 1=1" + assert_equal 4, @db.changes + end + + def test_total_changes + assert_equal 3, @db.total_changes + @db.execute "insert into foo ( b ) values ( 'test' )" + @db.execute "delete from foo where 1=1" + assert_equal 8, @db.total_changes + end + + def test_transaction_nest + assert_raise( SQLite3::SQLException ) do + @db.transaction do + @db.transaction do + end + end + end + end + + def test_transaction_rollback + @db.transaction + @db.execute_batch <<-SQL + insert into foo (b) values ( 'test1' ); + insert into foo (b) values ( 'test2' ); + insert into foo (b) values ( 'test3' ); + insert into foo (b) values ( 'test4' ); + SQL + assert_equal 7, @db.get_first_value("select count(*) from foo").to_i + @db.rollback + assert_equal 3, @db.get_first_value("select count(*) from foo").to_i + end + + def test_transaction_commit + @db.transaction + @db.execute_batch <<-SQL + insert into foo (b) values ( 'test1' ); + insert into foo (b) values ( 'test2' ); + insert into foo (b) values ( 'test3' ); + insert into foo (b) values ( 'test4' ); + SQL + assert_equal 7, @db.get_first_value("select count(*) from foo").to_i + @db.commit + assert_equal 7, @db.get_first_value("select count(*) from foo").to_i + end + + def test_transaction_rollback_in_block + assert_raise( SQLite3::SQLException ) do + @db.transaction do + @db.rollback + end + end + end + + def test_transaction_commit_in_block + assert_raise( SQLite3::SQLException ) do + @db.transaction do + @db.commit + end + end + end + + def test_transaction_active + assert !@db.transaction_active? + @db.transaction + assert @db.transaction_active? + @db.commit + assert !@db.transaction_active? + end + + def test_interrupt + @db.create_function( "abort", 1 ) do |func,x| + @db.interrupt + func.result = x + end + + assert_raise( SQLite3::SQLException ) do + @db.execute "select abort(a) from foo" + end + end + + def test_create_function + @db.create_function( "munge", 1 ) do |func,x| + func.result = ">>>#{x}<<<" + end + + value = @db.get_first_value( "select munge(b) from foo where a=1" ) + assert_match( />>>.*<<= 1000 + end +end \ No newline at end of file diff --git a/vendor/plugins/sqlite3-ruby/test/test_integration_resultset.rb b/vendor/plugins/sqlite3-ruby/test/test_integration_resultset.rb new file mode 100644 index 00000000..aee998b4 --- /dev/null +++ b/vendor/plugins/sqlite3-ruby/test/test_integration_resultset.rb @@ -0,0 +1,159 @@ +require File.join(File.dirname(__FILE__), 'helper') + +class TC_ResultSet < Test::Unit::TestCase + def setup + @db = SQLite3::Database.new( "test.db" ) + @db.transaction do + @db.execute "create table foo ( a integer primary key, b text )" + @db.execute "insert into foo ( b ) values ( 'foo' )" + @db.execute "insert into foo ( b ) values ( 'bar' )" + @db.execute "insert into foo ( b ) values ( 'baz' )" + end + @stmt = @db.prepare( "select * from foo where a in ( ?, ? )" ) + @result = @stmt.execute + end + + def teardown + @stmt.close + @db.close + File.delete( "test.db" ) + end + + def test_reset_unused + assert_nothing_raised { @result.reset } + assert @result.to_a.empty? + end + + def test_reset_used + @result.to_a + assert_nothing_raised { @result.reset } + assert @result.to_a.empty? + end + + def test_reset_with_bind + @result.to_a + assert_nothing_raised { @result.reset( 1, 2 ) } + assert_equal 2, @result.to_a.length + end + + def test_eof_inner + @result.reset( 1 ) + assert !@result.eof? + end + + def test_eof_edge + @result.reset( 1 ) + @result.next # to first row + @result.next # to end of result set + assert @result.eof? + end + + def test_next_eof + @result.reset( 1 ) + assert_not_nil @result.next + assert_nil @result.next + end + + def test_next_no_type_translation_no_hash + @result.reset( 1 ) + assert_equal [ "1", "foo" ], @result.next + end + + def test_next_type_translation + @db.type_translation = true + @result.reset( 1 ) + assert_equal [ 1, "foo" ], @result.next + end + + def test_next_type_translation_with_untyped_column + @db.type_translation = true + @db.query( "select count(*) from foo" ) do |result| + assert_equal ["3"], result.next + end + end + + def test_type_translation_with_null_column + @db.type_translation = true + @db.execute "create table bar ( a integer, b time, c string )" + @db.execute "insert into bar (a, b, c) values (NULL, '1974-07-25 14:39:00', 'hello')" + @db.execute "insert into bar (a, b, c) values (1, NULL, 'hello')" + @db.execute "insert into bar (a, b, c) values (2, '1974-07-25 14:39:00', NULL)" + @db.query( "select * from bar" ) do |result| + assert_equal [nil, Time.local(1974, 7, 25, 14, 39, 0), 'hello'], result.next + assert_equal [1, nil, 'hello'], result.next + assert_equal [2, Time.local(1974, 7, 25, 14, 39, 0), nil], result.next + end + end + + def test_date_and_time_translation + @db.type_translation = true + @db.execute "create table bar ( a date, b datetime, c time, d timestamp )" + @db.execute "insert into bar (a, b, c, d) values ('1999-01-08', '1997-12-17 07:37:16', '07:37:16', '2004-10-19 10:23:54')" + @db.query( "select * from bar" ) do |result| + result = result.next + assert result[0].is_a?(Date) + assert result[1].is_a?(DateTime) + assert result[2].is_a?(Time) + assert result[3].is_a?(Time) + end + end + + def test_next_results_as_hash + @db.results_as_hash = true + @result.reset( 1 ) + assert_equal( { "a" => "1", "b" => "foo", 0 => "1", 1 => "foo" }, + @result.next ) + end + + def test_tainted_results_as_hash + @db.results_as_hash = true + @result.reset( 1 ) + row = @result.next + row.each do |_, v| + assert_equal true, v.tainted? + end + end + + def test_tainted_row_values + @result.reset( 1 ) + row = @result.next + row.each do |v| + assert_equal true, v.tainted? + end + end + + def test_each + called = 0 + @result.reset( 1, 2 ) + @result.each { |row| called += 1 } + assert_equal 2, called + end + + def test_enumerable + @result.reset( 1, 2 ) + assert_equal 2, @result.to_a.length + end + + def test_types + assert_equal [ "integer", "text" ], @result.types + end + + def test_columns + assert_equal [ "a", "b" ], @result.columns + end + + def test_close + stmt = @db.prepare( "select * from foo" ) + result = stmt.execute + assert !result.closed? + result.close + assert result.closed? + assert stmt.closed? + assert_raise( SQLite3::Exception ) { result.reset } + assert_raise( SQLite3::Exception ) { result.next } + assert_raise( SQLite3::Exception ) { result.each } + assert_raise( SQLite3::Exception ) { result.close } + assert_raise( SQLite3::Exception ) { result.types } + assert_raise( SQLite3::Exception ) { result.columns } + end +end diff --git a/vendor/plugins/sqlite3-ruby/test/test_integration_statement.rb b/vendor/plugins/sqlite3-ruby/test/test_integration_statement.rb new file mode 100644 index 00000000..926d510f --- /dev/null +++ b/vendor/plugins/sqlite3-ruby/test/test_integration_statement.rb @@ -0,0 +1,195 @@ +require File.join(File.dirname(__FILE__), 'helper') + +class TC_Statement < Test::Unit::TestCase + def setup + @db = SQLite3::Database.new( "test.db" ) + @db.transaction do + @db.execute "create table foo ( a integer primary key, b text )" + @db.execute "insert into foo ( b ) values ( 'foo' )" + @db.execute "insert into foo ( b ) values ( 'bar' )" + @db.execute "insert into foo ( b ) values ( 'baz' )" + end + @stmt = @db.prepare( "select * from foo where a in ( ?, :named )" ) + end + + def teardown + @stmt.close + @db.close + File.delete( "test.db" ) + end + + def test_remainder_empty + assert_equal "", @stmt.remainder + end + + def test_remainder_nonempty + called = false + @db.prepare( "select * from foo;\n blah" ) do |stmt| + called = true + assert_equal "\n blah", stmt.remainder + end + assert called + end + + def test_bind_params_empty + assert_nothing_raised { @stmt.bind_params } + assert @stmt.execute!.empty? + end + + def test_bind_params_array + @stmt.bind_params 1, 2 + assert_equal 2, @stmt.execute!.length + end + + def test_bind_params_hash + @stmt.bind_params ":named" => 2 + assert_equal 1, @stmt.execute!.length + end + + def test_bind_params_hash_without_colon + @stmt.bind_params "named" => 2 + assert_equal 1, @stmt.execute!.length + end + + def test_bind_params_hash_as_symbol + @stmt.bind_params :named => 2 + assert_equal 1, @stmt.execute!.length + end + + def test_bind_params_mixed + @stmt.bind_params( 1, ":named" => 2 ) + assert_equal 2, @stmt.execute!.length + end + + def test_bind_param_by_index + @stmt.bind_params( 1, 2 ) + assert_equal 2, @stmt.execute!.length + end + + def test_bind_param_by_name_bad + assert_raise( SQLite3::Exception ) { @stmt.bind_param( "@named", 2 ) } + end + + def test_bind_param_by_name_good + @stmt.bind_param( ":named", 2 ) + assert_equal 1, @stmt.execute!.length + end + + def test_bind_param_with_various_types + @db.transaction do + @db.execute "create table all_types ( a integer primary key, b float, c string, d integer )" + @db.execute "insert into all_types ( b, c, d ) values ( 1.4, 'hello', 68719476735 )" + end + + assert_equal 1, @db.execute( "select * from all_types where b = ?", 1.4 ).length + assert_equal 1, @db.execute( "select * from all_types where c = ?", 'hello').length + assert_equal 1, @db.execute( "select * from all_types where d = ?", 68719476735).length + end + + def test_execute_no_bind_no_block + assert_instance_of SQLite3::ResultSet, @stmt.execute + end + + def test_execute_with_bind_no_block + assert_instance_of SQLite3::ResultSet, @stmt.execute( 1, 2 ) + end + + def test_execute_no_bind_with_block + called = false + @stmt.execute { |row| called = true } + assert called + end + + def test_execute_with_bind_with_block + called = 0 + @stmt.execute( 1, 2 ) { |row| called += 1 } + assert_equal 1, called + end + + def test_reexecute + r = @stmt.execute( 1, 2 ) + assert_equal 2, r.to_a.length + assert_nothing_raised { r = @stmt.execute( 1, 2 ) } + assert_equal 2, r.to_a.length + end + + def test_execute_bang_no_bind_no_block + assert @stmt.execute!.empty? + end + + def test_execute_bang_with_bind_no_block + assert_equal 2, @stmt.execute!( 1, 2 ).length + end + + def test_execute_bang_no_bind_with_block + called = 0 + @stmt.execute! { |row| called += 1 } + assert_equal 0, called + end + + def test_execute_bang_with_bind_with_block + called = 0 + @stmt.execute!( 1, 2 ) { |row| called += 1 } + assert_equal 2, called + end + + def test_columns + c1 = @stmt.columns + c2 = @stmt.columns + assert_same c1, c2 + assert_equal 2, c1.length + end + + def test_columns_computed + called = false + @db.prepare( "select count(*) from foo" ) do |stmt| + called = true + assert_equal [ "count(*)" ], stmt.columns + end + assert called + end + + def test_types + t1 = @stmt.types + t2 = @stmt.types + assert_same t1, t2 + assert_equal 2, t1.length + end + + def test_types_computed + called = false + @db.prepare( "select count(*) from foo" ) do |stmt| + called = true + assert_equal [ nil ], stmt.types + end + assert called + end + + def test_close + stmt = @db.prepare( "select * from foo" ) + assert !stmt.closed? + stmt.close + assert stmt.closed? + assert_raise( SQLite3::Exception ) { stmt.execute } + assert_raise( SQLite3::Exception ) { stmt.execute! } + assert_raise( SQLite3::Exception ) { stmt.close } + assert_raise( SQLite3::Exception ) { stmt.bind_params 5 } + assert_raise( SQLite3::Exception ) { stmt.bind_param 1, 5 } + assert_raise( SQLite3::Exception ) { stmt.columns } + assert_raise( SQLite3::Exception ) { stmt.types } + end + + def test_committing_tx_with_statement_active + called = false + @db.prepare( "select count(*) from foo" ) do |stmt| + called = true + count = stmt.execute!.first.first.to_i + @db.transaction do + @db.execute "insert into foo ( b ) values ( 'hello' )" + end + new_count = stmt.execute!.first.first.to_i + assert_equal new_count, count+1 + end + assert called + end +end diff --git a/vendor/plugins/sqlite3-ruby/test/tests.rb b/vendor/plugins/sqlite3-ruby/test/tests.rb deleted file mode 100644 index cf24d271..00000000 --- a/vendor/plugins/sqlite3-ruby/test/tests.rb +++ /dev/null @@ -1,6 +0,0 @@ -Dir.chdir File.dirname( __FILE__ ) -$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../lib" -$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../ext/sqlite3_api" -p $LOAD_PATH - -Dir["**/tc_*.rb"].each { |file| load file }