Changed layout to support tagging and branching

5 files changed, 358 insertions, 0 deletions

diff --git a/ext/sqlite3_api/MANIFEST b/ext/sqlite3_api/MANIFEST
new file mode 100644
index 0000000..f335e44
--- /dev/null
+++ b/ext/sqlite3_api/MANIFEST
@@ -0,0 +1,4 @@
+extconf.rb
+post-clean.rb
+post-distclean.rb
+sqlite3_api.i
diff --git a/ext/sqlite3_api/extconf.rb b/ext/sqlite3_api/extconf.rb
new file mode 100644
index 0000000..528eb2d
--- /dev/null
+++ b/ext/sqlite3_api/extconf.rb
@@ -0,0 +1,8 @@
+require 'mkmf'
+
+dir_config( "sqlite3" )
+
+if have_header( "sqlite3.h" ) and have_library( "sqlite3", "sqlite3_open" )
+  system "swig -ruby sqlite3_api.i"
+  create_makefile( "sqlite3_api" )
+end
diff --git a/ext/sqlite3_api/post-clean.rb b/ext/sqlite3_api/post-clean.rb
new file mode 100644
index 0000000..1017f72
--- /dev/null
+++ b/ext/sqlite3_api/post-clean.rb
@@ -0,0 +1,3 @@
+# post-distclean.rb
+
+File.delete File.join( curr_srcdir, "sqlite3_api_wrap.c" ) rescue nil
diff --git a/ext/sqlite3_api/post-distclean.rb b/ext/sqlite3_api/post-distclean.rb
new file mode 100644
index 0000000..f8543b1
--- /dev/null
+++ b/ext/sqlite3_api/post-distclean.rb
@@ -0,0 +1,4 @@
+# post-distclean.rb
+
+# on a distclean, always do a clean, as well
+eval File.read( File.join( curr_srcdir, "post-clean.rb" ) )
diff --git a/ext/sqlite3_api/sqlite3_api.i b/ext/sqlite3_api/sqlite3_api.i
new file mode 100644
index 0000000..a3e5e5b
--- /dev/null
+++ b/ext/sqlite3_api/sqlite3_api.i
@@ -0,0 +1,339 @@
+%module "SQLite3::driver::native::API"
+%include "typemaps.i"
+%{
+#include <sqlite3.h>
+#include "ruby.h"
+#include "intern.h"
+
+#define Init_API Init_sqlite3_api
+
+struct CallbackData {
+  VALUE proc;
+  VALUE proc2;
+  VALUE data;
+};
+
+typedef struct CallbackData CallbackData;
+typedef void BLOB;
+typedef void 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);
+}
+
+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 );
+}
+%}
+
+struct CallbackData {
+  VALUE proc;
+  VALUE proc2;
+  VALUE data;
+};
+
+%typemap(in) const void *str {
+  $1 = (void*)RSTRING($input)->ptr;
+}
+
+%typemap(in) (const char *filename, sqlite3**) {
+  $1 = STR2CSTR($input);
+  $2 = (sqlite3**)malloc( sizeof( sqlite3* ) );
+}
+
+%typemap(argout) (const char *filename, sqlite3**) {
+  VALUE ary;
+  ary = rb_ary_new2(2);
+  rb_ary_push( ary, $result );
+  rb_ary_push( ary, SWIG_NewPointerObj( *$2, SWIGTYPE_p_sqlite3, 0 ) );
+  free( $2 );
+  $result = ary;
+}
+
+%typemap(in) (const void *filename, sqlite3**) {
+  $1 = (void*)RSTRING($input)->ptr;
+  $2 = (sqlite3**)malloc( sizeof( sqlite3* ) );
+}
+
+%typemap(argout) (const void *filename, sqlite3**) {
+  VALUE ary;
+  ary = rb_ary_new2(2);
+  rb_ary_push( ary, $result );
+  rb_ary_push( ary, SWIG_NewPointerObj( *$2, SWIGTYPE_p_sqlite3, 0 ) );
+  free( $2 );
+  $result = ary;
+}
+
+typedef void BLOB;
+%typemap(out) const BLOB * {
+  $result = $1 ?
+    rb_str_new( (char*)$1, sqlite3_column_bytes( arg1, arg2 ) ) : Qnil;
+}
+
+typedef void VALBLOB;
+%typemap(out) const VALBLOB * {
+  $result = $1 ? rb_str_new( (char*)$1, sqlite3_value_bytes( arg1 ) ) : Qnil;
+}
+
+%typemap(out) const void * {
+  int i;
+  if( $1 ) {
+    for( i = 0; ((char*)$1)[i]; i += 2 );
+    $result = rb_str_new( (char*)$1, i );
+  } else $result = Qnil;
+}
+
+%typemap(in) (const char * sql,int,sqlite3_stmt**,const char**) (sqlite3_stmt *stmt, char *errmsg) {
+  $1 = RSTRING($input)->ptr;
+  $2 = RSTRING($input)->len;
+  $3 = &stmt2;
+  $4 = &errmsg2;
+}
+
+%typemap(argout) (const char* sql,int,sqlite3_stmt**,const char**) {
+  VALUE ary;
+  ary = rb_ary_new2(3);
+  rb_ary_push( ary, $result );
+  rb_ary_push( ary, SWIG_NewPointerObj( stmt2, SWIGTYPE_p_sqlite3_stmt, 0 ) );
+  rb_ary_push( ary, errmsg2 ? rb_str_new2( errmsg2 ) : Qnil );
+  $result = ary;
+}
+
+%typemap(in) (const void* sql,int,sqlite3_stmt**,const void**) (sqlite3_stmt *stmt, void *errmsg) {
+  $1 = RSTRING($input)->ptr;
+  $2 = RSTRING($input)->len;
+  $3 = &stmt2;
+  $4 = &errmsg2;
+}
+
+%typemap(argout) (const void* sql,int,sqlite3_stmt**,const void**) {
+  VALUE ary;
+  int i;
+
+  for( i = 0; ((char*)errmsg2)[i]; i += 2 );
+
+  ary = rb_ary_new2(3);
+  rb_ary_push( ary, $result );
+  rb_ary_push( ary, SWIG_NewPointerObj( stmt2, SWIGTYPE_p_sqlite3_stmt, 0 ) );
+  rb_ary_push( ary, errmsg2 ? rb_str_new( (char*)errmsg2, i ) : Qnil );
+  $result = ary;
+}
+
+%typemap(in) (const void *blob,int) {
+  $1 = (void*)RSTRING($input)->ptr;
+  $2 = RSTRING($input)->len;
+}
+
+%typemap(in) (const void *blob,int,void(*free)(void*)) {
+  $1 = (void*)RSTRING($input)->ptr;
+  $2 = RSTRING($input)->len;
+  $3 = SQLITE_TRANSIENT;
+}
+
+%typemap(in) (const char *text,int) {
+  $1 = RSTRING($input)->ptr;
+  $2 = RSTRING($input)->len;
+}
+
+%typemap(in) (const char *text,int,void(*free)(void*)) {
+  $1 = RSTRING($input)->ptr;
+  $2 = RSTRING($input)->len;
+  $3 = SQLITE_TRANSIENT;
+}
+
+%typemap(in) (const void *utf16,int) {
+  $1 = (void*)RSTRING($input)->ptr;
+  $2 = RSTRING($input)->len;
+}
+
+%typemap(in) (const void *utf16,int,void(*free)(void*)) {
+  $1 = (void*)RSTRING($input)->ptr;
+  $2 = RSTRING($input)->len;
+  $3 = SQLITE_TRANSIENT;
+}
+
+%typemap(out) sqlite_int64 {
+  $result = rb_ll2inum( $1 );
+}
+
+%typemap(out) const char * {
+  $result = $1 ? rb_str_new2($1) : Qnil;
+}
+
+%typemap(in) sqlite_int64 {
+  $1 = rb_big2ll( $input );
+}
+
+%typemap(in) (sqlite3_context*,int data_size) {
+  SWIG_ConvertPtr($input,(void**)&$1, SWIGTYPE_p_sqlite3_context, 1);
+  $2 = 4;
+}
+
+%typemap(out) VALUE* {
+  $result = *(VALUE*)$1;
+}
+
+%constant int Sqlite3_ruby_busy_handler(void*,int);
+%constant int Sqlite3_ruby_authorizer(void*,int,const char*,const char*,const char*,const char*);
+%constant void Sqlite3_ruby_trace(void*,const char*);
+%constant void Sqlite3_ruby_function_step(sqlite3_context* ctx,int n,
+  sqlite3_value** args);
+%constant void Sqlite3_ruby_function_final(sqlite3_context* ctx);
+
+const char *sqlite3_libversion(void);
+int sqlite3_close(sqlite3*);
+
+sqlite_int64 sqlite3_last_insert_rowid(sqlite3*);
+
+int sqlite3_changes(sqlite3*);
+int sqlite3_total_changes(sqlite3*);
+void sqlite3_interrupt(sqlite3*);
+
+int sqlite3_complete(const char*);
+int sqlite3_complete16(const void *str);
+
+int sqlite3_busy_handler(sqlite3*, int(*)(void*,int), void*);
+int sqlite3_busy_timeout(sqlite3*,int);
+int sqlite3_set_authorizer(sqlite3*, int(*)(void*,int,const char*,const char*,const char*,const char*), void*);
+int sqlite3_trace(sqlite3*, void(*)(void*,const char*), void*);
+
+int sqlite3_open(const char *filename, sqlite3 **);
+int sqlite3_open16(const void *filename, sqlite3 **);
+
+int sqlite3_errcode(sqlite3*);
+const char *sqlite3_errmsg(sqlite3*);
+const void *sqlite3_errmsg16(sqlite3*);
+
+int sqlite3_prepare(sqlite3*,const char* sql,int,sqlite3_stmt**,const char**);
+int sqlite3_prepare16(sqlite3*,const void* sql,int,sqlite3_stmt**,const void**);
+
+int sqlite3_bind_blob(sqlite3_stmt*,int,const void *blob,int,void(*free)(void*));
+int sqlite3_bind_double(sqlite3_stmt*,int,double);
+int sqlite3_bind_int(sqlite3_stmt*,int,int);
+int sqlite3_bind_int64(sqlite3_stmt*,int,sqlite_int64);
+int sqlite3_bind_null(sqlite3_stmt*,int);
+int sqlite3_bind_text(sqlite3_stmt*,int,const char*text,int,void(*free)(void*));
+int sqlite3_bind_text16(sqlite3_stmt*,int,const void*utf16,int,void(*free)(void*));
+
+int sqlite3_bind_parameter_count(sqlite3_stmt*);
+const char *sqlite3_bind_parameter_name(sqlite3_stmt*,int);
+int sqlite3_bind_parameter_index(sqlite3_stmt*,const char*);
+
+int sqlite3_column_count(sqlite3_stmt*);
+const char *sqlite3_column_name(sqlite3_stmt*,int);
+const void *sqlite3_column_name16(sqlite3_stmt*,int);
+const char *sqlite3_column_decltype(sqlite3_stmt*,int);
+const void *sqlite3_column_decltype16(sqlite3_stmt*,int);
+
+int sqlite3_step(sqlite3_stmt*);
+
+int sqlite3_data_count(sqlite3_stmt*);
+
+const BLOB *sqlite3_column_blob(sqlite3_stmt*,int);
+int sqlite3_column_bytes(sqlite3_stmt*,int);
+int sqlite3_column_bytes16(sqlite3_stmt*,int);
+double sqlite3_column_double(sqlite3_stmt*,int);
+double sqlite3_column_int(sqlite3_stmt*,int);
+sqlite_int64 sqlite3_column_int64(sqlite3_stmt*,int);
+const char *sqlite3_column_text(sqlite3_stmt*,int);
+const void *sqlite3_column_text16(sqlite3_stmt*,int);
+int sqlite3_column_type(sqlite3_stmt*,int);
+
+int sqlite3_finalize(sqlite3_stmt*);
+int sqlite3_reset(sqlite3_stmt*);
+
+int sqlite3_create_function(sqlite3*,const char*str,int,int,void*,void(*func)(sqlite3_context*,int,sqlite3_value**),void(*step)(sqlite3_context*,int,sqlite3_value**),void(*final)(sqlite3_context*));
+
+int sqlite3_create_function16(sqlite3*,const void*str,int,int,void*,void(*func)(sqlite3_context*,int,sqlite3_value**),void(*step)(sqlite3_context*,int,sqlite3_value**),void(*final)(sqlite3_context*));
+
+int sqlite3_aggregate_count(sqlite3_context*);
+
+const VALBLOB *sqlite3_value_blob(sqlite3_value*);
+int sqlite3_value_bytes(sqlite3_value*);
+int sqlite3_value_bytes16(sqlite3_value*);
+double sqlite3_value_double(sqlite3_value*);
+int sqlite3_value_int(sqlite3_value*);
+sqlite_int64 sqlite3_value_int64(sqlite3_value*);
+const char *sqlite3_value_text(sqlite3_value*);
+const void *sqlite3_value_text16(sqlite3_value*);
+const void *sqlite3_value_text16le(sqlite3_value*);
+const void *sqlite3_value_text16be(sqlite3_value*);
+int sqlite3_value_type(sqlite3_value*);
+
+void sqlite3_result_blob(sqlite3_context*,const void *blob,int,void(*free)(void*));
+void sqlite3_result_double(sqlite3_context*,double);
+void sqlite3_result_error(sqlite3_context*,const char *text,int);
+void sqlite3_result_error16(sqlite3_context*,const void *blob,int);
+void sqlite3_result_int(sqlite3_context*,int);
+void sqlite3_result_int64(sqlite3_context*,sqlite_int64);
+void sqlite3_result_text(sqlite3_context*,const char* text,int,void(*free)(void*));
+void sqlite3_result_text16(sqlite3_context*,const void* utf16,int,void(*free)(void*));
+void sqlite3_result_text16le(sqlite3_context*,const void* utf16,int,void(*free)(void*));
+void sqlite3_result_text16be(sqlite3_context*,const void* utf16,int,void(*free)(void*));
+void sqlite3_result_value(sqlite3_context*,sqlite3_value*);
+
+VALUE *sqlite3_aggregate_context(sqlite3_context*,int data_size);