From a71e64a1728935cecb19a568a3b4a0b85d7fd3e4 Mon Sep 17 00:00:00 2001 From: Jacques Distler Date: Tue, 22 Dec 2009 20:48:32 -0600 Subject: [PATCH] Update Vendored sqlite3-ruby --- lib/native/i386-mingw32/sqlite3.dll | Bin 0 -> 250368 bytes vendor/plugins/sqlite3-ruby/ChangeLog.cvs | 88 + vendor/plugins/sqlite3-ruby/History.txt | 68 + vendor/plugins/sqlite3-ruby/Manifest.txt | 41 + vendor/plugins/sqlite3-ruby/README.txt | 56 + vendor/plugins/sqlite3-ruby/Rakefile | 191 +- .../sqlite3-ruby/ext/sqlite3_api/extconf.rb | 12 +- .../ext/sqlite3_api/sqlite3_api.i | 4 + .../ext/sqlite3_api/sqlite3_api_wrap.c | 8036 ++++++++++------- .../sqlite3-ruby/lib/sqlite3/database.rb | 20 +- .../sqlite3-ruby/lib/sqlite3/driver/dl/api.rb | 2 +- .../lib/sqlite3/driver/native/driver.rb | 10 +- .../sqlite3-ruby/lib/sqlite3/resultset.rb | 6 +- .../sqlite3-ruby/lib/sqlite3/statement.rb | 5 +- .../sqlite3-ruby/lib/sqlite3/version.rb | 6 +- .../plugins/sqlite3-ruby/sqlite3-ruby.gemspec | 141 + .../sqlite3-ruby/test/{mocks.rb => helper.rb} | 26 +- .../sqlite3-ruby/test/tc_integration.rb | 1044 --- .../test/{tc_database.rb => test_database.rb} | 31 +- .../test/{tc_errors.rb => test_errors.rb} | 6 +- .../sqlite3-ruby/test/test_integration.rb | 542 ++ .../test/test_integration_open_close.rb | 30 + .../test/test_integration_pending.rb | 111 + .../test/test_integration_resultset.rb | 159 + .../test/test_integration_statement.rb | 195 + vendor/plugins/sqlite3-ruby/test/tests.rb | 6 - 26 files changed, 6501 insertions(+), 4335 deletions(-) create mode 100644 lib/native/i386-mingw32/sqlite3.dll create mode 100644 vendor/plugins/sqlite3-ruby/ChangeLog.cvs create mode 100644 vendor/plugins/sqlite3-ruby/History.txt create mode 100644 vendor/plugins/sqlite3-ruby/Manifest.txt create mode 100644 vendor/plugins/sqlite3-ruby/README.txt create mode 100644 vendor/plugins/sqlite3-ruby/sqlite3-ruby.gemspec rename vendor/plugins/sqlite3-ruby/test/{mocks.rb => helper.rb} (67%) delete mode 100644 vendor/plugins/sqlite3-ruby/test/tc_integration.rb rename vendor/plugins/sqlite3-ruby/test/{tc_database.rb => test_database.rb} (86%) rename vendor/plugins/sqlite3-ruby/test/{tc_errors.rb => test_errors.rb} (84%) create mode 100644 vendor/plugins/sqlite3-ruby/test/test_integration.rb create mode 100644 vendor/plugins/sqlite3-ruby/test/test_integration_open_close.rb create mode 100644 vendor/plugins/sqlite3-ruby/test/test_integration_pending.rb create mode 100644 vendor/plugins/sqlite3-ruby/test/test_integration_resultset.rb create mode 100644 vendor/plugins/sqlite3-ruby/test/test_integration_statement.rb delete mode 100644 vendor/plugins/sqlite3-ruby/test/tests.rb diff --git a/lib/native/i386-mingw32/sqlite3.dll b/lib/native/i386-mingw32/sqlite3.dll new file mode 100644 index 0000000000000000000000000000000000000000..98c50c4d23a0d29b3de032a923ff4e49229d4fa0 GIT binary patch literal 250368 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 z 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 z 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

dG0ue&ZS4;Bm-{wC>iK--R=A)YR0x7GiUvfe?Z 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 Ws}zPjUYdvjtpr2;_4] + + +=== 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 }