added lsqlite3 full source

3rdparty/lsqlite3/.travis.yml

@@ -0,0 +1,51 @@
+#
+# LuaDist Travis-CI Hook
+#
+
+# We assume C build environments
+language: C
+
+# Try using multiple Lua Implementations
+env:
+  - TOOL="gcc"                  # Use native compiler (GCC usually)
+  - TOOL="clang"                # Use clang
+  - TOOL="i686-w64-mingw32"     # 32bit MinGW
+  - TOOL="x86_64-w64-mingw32"   # 64bit MinGW
+  - TOOL="arm-linux-gnueabihf"  # ARM hard-float (hf), linux
+
+# Crosscompile builds may fail
+matrix:
+  allow_failures:
+    - env: TOOL="i686-w64-mingw32"
+    - env: TOOL="x86_64-w64-mingw32"
+    - env: TOOL="arm-linux-gnueabihf"
+
+# Install dependencies
+install:
+  - git clone git://github.com/LuaDist/Tools.git ~/_tools
+  - ~/_tools/travis/travis install
+
+# Bootstap
+before_script:
+  - ~/_tools/travis/travis bootstrap
+
+# Build the module
+script:
+  - ~/_tools/travis/travis build
+
+# Execute additional tests or commands
+after_script:
+  - ~/_tools/travis/travis test
+
+# Only watch the master branch
+branches:
+  only:
+    - master
+
+# Notify the LuaDist Dev group if needed
+notifications:
+  recipients:
+    - luadist-dev@googlegroups.com
+  email:
+    on_success: change
+    on_failure: always

3rdparty/lsqlite3/CMakeLists.txt

@@ -0,0 +1,21 @@
+# Copyright (C) 2007-2012 LuaDist.
+# Created by Peter Kapec
+# Redistribution and use of this file is allowed according to the terms of the MIT license.
+# For details see the COPYRIGHT file distributed with LuaDist.
+# Please note that the package source code is licensed under its own license.
+
+project ( lsqlite3 C )
+cmake_minimum_required ( VERSION 2.8 )
+include ( cmake/dist.cmake )
+include ( lua )
+
+# Find SQLite3
+find_package ( SQLite3 REQUIRED )
+include_directories ( ${SQLITE3_INCLUDE_DIRS} )
+
+# Create lsqlite module
+install_lua_module ( lsqlite3 lsqlite3.c lsqlite3.def LINK ${SQLITE3_LIBRARIES} )
+install_data ( HISTORY README )
+install_doc( doc/ )
+install_test ( lunit.lua test.lua tests-sqlite3.lua )
+install_example ( examples/ )

3rdparty/lsqlite3/HISTORY

@@ -0,0 +1,133 @@
+2007-August-15 e
+
+Version "0.6-devel"
+
+Since the "0.5-devel" release of this Lua library...
+
+Tested with SQLite 3.4.2
+
+Added some documentation.
+
+Thanks to Thomas Lauer...
+
+Moved line 525 ("luaL_checktype(L, 2, LUA_TTABLE);")
+below the declarations to eliminate non-gcc compiler errors.
+
+Added create-collation, and associated test case.
+
+-=-
+
+2006-October-02 e
+
+Since the "0.1-devel" release of this Lua library...
+- updated for Lua 5.1
+- provide automatic re-preparation of queries after schema changes
+- made prepared statements with bindings work with for-loops
+- added some compatibility names
+- added many test cases, and ported Mike Roth's tests and examples
+
+-=-
+
+Below is a header comment from the 2004 "0.1" version of the library...
+
+/************************************************************************
+$Id: lsqlite3.c,v 1.3 2004/09/05 17:50:32 tngd Exp $
+
+To consider:
+------------
+
+EXPERIMENTAL APIs
+
+* sqlite3_progress_handler (implemented)
+* sqlite3_commit_hook
+
+TODO?
+
+* sqlite3_create_collation
+
+Changes:
+04-09-2004
+----------
+    * changed second return value of db:compile to be the rest of the
+    sql statement that was not processed instead of the number of
+    characters of sql not processed (situation in case of success).
+    * progress callback register function parameter order changed.
+    number of opcodes is given before the callback now.
+
+29-08-2004 e
+------------
+    * added version() (now supported in sqlite 3.0.5)
+    * added db:errmsg db:errcode db:total_changes
+    * rename vm:get_column to vm:get_value
+    * merge in Tiago's v1.11 change in dbvm_tostring
+
+23-06-2004 e
+------------
+    * heavily revised for SQLite3 C API
+    * row values now returned as native type (not always text)
+    * added db:nrows (named rows)
+    * added vm:bind_blob
+    * added vm:get_column
+    * removed encode_binary decode_binary (no longer needed or supported)
+    * removed version encoding error_string (unsupported in v 3.0.1 -- soon?)
+
+09-04-2004
+----------
+    * renamed db:rows to db:urows
+    * renamed db:prows to db:rows
+
+    * added vm:get_unames()
+    * added vm:get_utypes()
+    * added vm:get_uvalues()
+
+08-04-2004
+----------
+    * changed db:encoding() and db:version() to use sqlite_libencoding() and
+    sqlite_libversion()
+
+    * added vm:columns()
+    * added vm:get_named_types()
+    * added vm:get_named_values()
+
+    * added db:prows - like db:rows but returns a table with the column values
+    instead of returning multiple columns seperatly on each iteration
+
+    * added compatibility functions idata,iname,itype,data,type
+
+    * added luaopen_sqlite_module. allow the library to be loaded without
+    setting a global variable. does the same as luaopen_sqlite, but does not
+    set the global name "sqlite".
+
+    * vm:bind now also returns an error string in case of error
+
+31-03-2004 - 01-04-2004
+-----------------------
+    * changed most of the internals. now using references (luaL_ref) in
+    most of the places
+
+    * make the virtual machine interface seperate from the database
+    handle. db:compile now returns a vm handle
+
+    * added db:rows [for ... in db:rows(...) do ... end]
+
+    * added db:close_vm
+
+    * added sqlite.encode_binary and sqlite.decode_binary
+
+    * attempt to do a strict checking on the return type of the user
+    defined functions returned values
+
+18-01-2004
+----------
+    * add check on sql function callback to ensure there is enough stack
+    space to pass column values as parameters
+
+03-12-2003
+----------
+    * callback functions now have to return boolean values to abort or
+    continue operation instead of a zero or non-zero value
+
+06-12-2003
+----------
+    * make version member of sqlite table a function instead of a string
+************************************************************************/

3rdparty/lsqlite3/Makefile

@@ -0,0 +1,106 @@
+# makefile for lsqlite3 library for Lua
+
+ifneq "$(shell pkg-config --version)" ""
+  # automagic setup (OS X fink, Linux apt-get, ..)
+  #
+  LUAINC= $(shell pkg-config --cflags lua)
+  LUALIB= $(shell pkg-config --libs lua)
+  LUAEXE= lua
+  # Now, we actually want to _not_ push in stuff to the distro Lua CMOD directory,
+  # way better to play within /usr/local/lib/lua/5.1/
+  #LUACMOD= $(shell pkg-config --variable=INSTALL_CMOD lua)
+  LUACMOD= /usr/local/lib/lua/5.1/
+  #
+  SQLITE3INC= $(shell pkg-config --cflags sqlite3)
+  SQLITE3LIB= $(shell pkg-config --libs sqlite3)
+else
+  # manual setup (change these to reflect your Lua installation)
+  #
+  BASE= /usr/local
+  LUAINC= -I$(BASE)/include
+  LUAEXE= $(BASE)/bin/lua.exe
+#  LUALIB= -L$(BASE)/lib -llua51
+#  LUACMOD= $(BASE)/lib/lua/5.1/
+#  Windows' LUA_CDIR and LUALIB are both the same as the Lua executable's directory...
+  LUALIB= -L$(BASE)/bin -llua51
+  LUACMOD= $(BASE)/bin
+  #
+  SQLITE3INC= -I$(BASE)/include
+  SQLITE3LIB= -L$(BASE)/bin -lsqlite3
+  #
+  POD2HTML= perl -x -S doc/pod2html.pl
+endif
+
+TMP=./tmp
+DISTDIR=./archive
+
+# OS detection
+#
+SHFLAGS=-shared
+UNAME= $(shell uname)
+ifeq "$(UNAME)" "Linux"
+  _SO=so
+  SHFLAGS= -fPIC
+endif
+ifneq "" "$(findstring BSD,$(UNAME))"
+  _SO=so
+endif
+ifeq "$(UNAME)" "Darwin"
+  _SO=bundle
+  SHFLAGS= -bundle
+endif
+ifneq "" "$(findstring msys,$(OSTYPE))"		# 'msys'
+  _SO=dll
+endif
+
+ifndef _SO
+  $(error $(UNAME))
+  $(error Unknown OS)
+endif
+
+# no need to change anything below here - HAH!
+CFLAGS= $(INCS) $(DEFS) $(WARN) -O2 $(SHFLAGS)
+WARN= -Wall #-ansi -pedantic -Wall
+INCS= $(LUAINC) $(SQLITE3INC)
+LIBS= $(LUALIB) $(SQLITE3LIB)
+
+MYNAME= sqlite3
+MYLIB= l$(MYNAME)
+
+VER=$(shell svnversion -c . | sed 's/.*://')
+TARFILE = $(DISTDIR)/$(MYLIB)-$(VER).tar.gz
+
+OBJS= $(MYLIB).o
+T= $(MYLIB).$(_SO)
+
+all: $T
+
+test: $T
+	$(LUAEXE) test.lua
+	$(LUAEXE) tests-sqlite3.lua
+
+$T:	$(OBJS)
+	$(CC) $(SHFLAGS) -o $@ $(OBJS) $(LIBS)
+
+install:
+	cp $T $(LUACMOD)
+
+clean:
+	rm -f $(OBJS) $T core core.* a.out test.db
+
+html:
+	$(POD2HTML) --title="LuaSQLite 3" --infile=doc/lsqlite3.pod --outfile=doc/lsqlite3.html
+
+dist:	html
+	echo 'Exporting...'
+	mkdir -p $(TMP)
+	mkdir -p $(DISTDIR)
+	svn export -r HEAD . $(TMP)/$(MYLIB)-$(VER)
+	mkdir -p $(TMP)/$(MYLIB)-$(VER)/doc
+	cp -p doc/lsqlite3.html $(TMP)/$(MYLIB)-$(VER)/doc
+	echo 'Compressing...'
+	tar -zcf $(TARFILE) -C $(TMP) $(MYLIB)-$(VER)
+	rm -fr $(TMP)/$(MYLIB)-$(VER)
+	echo 'Done.'
+
+.PHONY: all test clean dist install

3rdparty/lsqlite3/README

@@ -0,0 +1,8 @@
+
+LuaSQLite 3 provides a means to manipulate SQLite3 
+databases directly from lua using Lua 5.
+
+To use this library you need SQLite3 library.
+You can get it from http://www.sqlite.org/
+
+Lua 5 is available from http://www.lua.org/

3rdparty/lsqlite3/cmake/FindLua.cmake

@@ -0,0 +1,118 @@
+# Locate Lua library
+# This module defines
+#  LUA_EXECUTABLE, if found
+#  LUA_FOUND, if false, do not try to link to Lua 
+#  LUA_LIBRARIES
+#  LUA_INCLUDE_DIR, where to find lua.h
+#  LUA_VERSION_STRING, the version of Lua found (since CMake 2.8.8)
+#
+# Note that the expected include convention is
+#  #include "lua.h"
+# and not
+#  #include <lua/lua.h>
+# This is because, the lua location is not standardized and may exist
+# in locations other than lua/
+
+#=============================================================================
+# Copyright 2007-2009 Kitware, Inc.
+# Modified to support Lua 5.2 by LuaDist 2012
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+#  License text for the above reference.)
+#
+# The required version of Lua can be specified using the
+# standard syntax, e.g. FIND_PACKAGE(Lua 5.1)
+# Otherwise the module will search for any available Lua implementation
+
+# Always search for non-versioned lua first (recommended)
+SET(_POSSIBLE_LUA_INCLUDE include include/lua)
+SET(_POSSIBLE_LUA_EXECUTABLE lua)
+SET(_POSSIBLE_LUA_LIBRARY lua)
+
+# Determine possible naming suffixes (there is no standard for this)
+IF(Lua_FIND_VERSION_MAJOR AND Lua_FIND_VERSION_MINOR)
+  SET(_POSSIBLE_SUFFIXES "${Lua_FIND_VERSION_MAJOR}${Lua_FIND_VERSION_MINOR}" "${Lua_FIND_VERSION_MAJOR}.${Lua_FIND_VERSION_MINOR}" "-${Lua_FIND_VERSION_MAJOR}.${Lua_FIND_VERSION_MINOR}")
+ELSE(Lua_FIND_VERSION_MAJOR AND Lua_FIND_VERSION_MINOR)
+  SET(_POSSIBLE_SUFFIXES "52" "5.2" "-5.2" "51" "5.1" "-5.1")
+ENDIF(Lua_FIND_VERSION_MAJOR AND Lua_FIND_VERSION_MINOR)
+
+# Set up possible search names and locations
+FOREACH(_SUFFIX ${_POSSIBLE_SUFFIXES})
+  LIST(APPEND _POSSIBLE_LUA_INCLUDE "include/lua${_SUFFIX}")
+  LIST(APPEND _POSSIBLE_LUA_EXECUTABLE "lua${_SUFFIX}")
+  LIST(APPEND _POSSIBLE_LUA_LIBRARY "lua${_SUFFIX}")
+ENDFOREACH(_SUFFIX)
+
+# Find the lua executable
+FIND_PROGRAM(LUA_EXECUTABLE
+  NAMES ${_POSSIBLE_LUA_EXECUTABLE}
+)
+
+# Find the lua header
+FIND_PATH(LUA_INCLUDE_DIR lua.h
+  HINTS
+  $ENV{LUA_DIR}
+  PATH_SUFFIXES ${_POSSIBLE_LUA_INCLUDE}
+  PATHS
+  ~/Library/Frameworks
+  /Library/Frameworks
+  /usr/local
+  /usr
+  /sw # Fink
+  /opt/local # DarwinPorts
+  /opt/csw # Blastwave
+  /opt
+)
+
+# Find the lua library
+FIND_LIBRARY(LUA_LIBRARY 
+  NAMES ${_POSSIBLE_LUA_LIBRARY}
+  HINTS
+  $ENV{LUA_DIR}
+  PATH_SUFFIXES lib64 lib
+  PATHS
+  ~/Library/Frameworks
+  /Library/Frameworks
+  /usr/local
+  /usr
+  /sw
+  /opt/local
+  /opt/csw
+  /opt
+)
+
+IF(LUA_LIBRARY)
+  # include the math library for Unix
+  IF(UNIX AND NOT APPLE)
+    FIND_LIBRARY(LUA_MATH_LIBRARY m)
+    SET( LUA_LIBRARIES "${LUA_LIBRARY};${LUA_MATH_LIBRARY}" CACHE STRING "Lua Libraries")
+  # For Windows and Mac, don't need to explicitly include the math library
+  ELSE(UNIX AND NOT APPLE)
+    SET( LUA_LIBRARIES "${LUA_LIBRARY}" CACHE STRING "Lua Libraries")
+  ENDIF(UNIX AND NOT APPLE)
+ENDIF(LUA_LIBRARY)
+
+# Determine Lua version
+IF(LUA_INCLUDE_DIR AND EXISTS "${LUA_INCLUDE_DIR}/lua.h")
+  FILE(STRINGS "${LUA_INCLUDE_DIR}/lua.h" lua_version_str REGEX "^#define[ \t]+LUA_RELEASE[ \t]+\"Lua .+\"")
+
+  STRING(REGEX REPLACE "^#define[ \t]+LUA_RELEASE[ \t]+\"Lua ([^\"]+)\".*" "\\1" LUA_VERSION_STRING "${lua_version_str}")
+  UNSET(lua_version_str)
+ENDIF()
+
+INCLUDE(FindPackageHandleStandardArgs)
+# handle the QUIETLY and REQUIRED arguments and set LUA_FOUND to TRUE if 
+# all listed variables are TRUE
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(Lua
+                                  REQUIRED_VARS LUA_LIBRARIES LUA_INCLUDE_DIR
+                                  VERSION_VAR LUA_VERSION_STRING)
+
+MARK_AS_ADVANCED(LUA_INCLUDE_DIR LUA_LIBRARIES LUA_LIBRARY LUA_MATH_LIBRARY LUA_EXECUTABLE)
+

3rdparty/lsqlite3/cmake/FindSQLite3.cmake

@@ -0,0 +1,37 @@
+# Copyright (C) 2007-2009 LuaDist.
+# Created by Peter Kapec <kapecp@gmail.com>
+# Redistribution and use of this file is allowed according to the terms of the MIT license.
+# For details see the COPYRIGHT file distributed with LuaDist.
+#	Note:
+#		Searching headers and libraries is very simple and is NOT as powerful as scripts
+#		distributed with CMake, because LuaDist defines directories to search for.
+#		Everyone is encouraged to contact the author with improvements. Maybe this file
+#		becomes part of CMake distribution sometimes.
+
+# - Find sqlite3
+# Find the native SQLITE3 headers and libraries.
+#
+# SQLITE3_INCLUDE_DIRS	- where to find sqlite3.h, etc.
+# SQLITE3_LIBRARIES	- List of libraries when using sqlite.
+# SQLITE3_FOUND	- True if sqlite found.
+
+# Look for the header file.
+FIND_PATH(SQLITE3_INCLUDE_DIR NAMES sqlite3.h)
+
+# Look for the library.
+FIND_LIBRARY(SQLITE3_LIBRARY NAMES sqlite3 libsqlite3 sqlite libsqlite)
+
+# Handle the QUIETLY and REQUIRED arguments and set SQLITE3_FOUND to TRUE if all listed variables are TRUE.
+INCLUDE(FindPackageHandleStandardArgs)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(SQLITE3 DEFAULT_MSG SQLITE3_LIBRARY SQLITE3_INCLUDE_DIR)
+
+# Copy the results to the output variables.
+IF(SQLITE3_FOUND)
+	SET(SQLITE3_LIBRARIES ${SQLITE3_LIBRARY})
+	SET(SQLITE3_INCLUDE_DIRS ${SQLITE3_INCLUDE_DIR})
+ELSE(SQLITE3_FOUND)
+	SET(SQLITE3_LIBRARIES)
+	SET(SQLITE3_INCLUDE_DIRS)
+ENDIF(SQLITE3_FOUND)
+
+MARK_AS_ADVANCED(SQLITE3_INCLUDE_DIRS SQLITE3_LIBRARIES)

3rdparty/lsqlite3/cmake/dist.cmake

@@ -0,0 +1,321 @@
+# LuaDist CMake utility library.
+# Provides sane project defaults and macros common to LuaDist CMake builds.
+# 
+# Copyright (C) 2007-2012 LuaDist.
+# by David Manura, Peter Drahoš
+# Redistribution and use of this file is allowed according to the terms of the MIT license.
+# For details see the COPYRIGHT file distributed with LuaDist.
+# Please note that the package source code is licensed under its own license.
+
+## Extract information from dist.info
+if ( NOT EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/dist.info )
+  message ( FATAL_ERROR
+    "Missing dist.info file (${CMAKE_CURRENT_SOURCE_DIR}/dist.info)." )
+endif ()
+file ( READ ${CMAKE_CURRENT_SOURCE_DIR}/dist.info DIST_INFO )
+if ( "${DIST_INFO}" STREQUAL "" )
+  message ( FATAL_ERROR "Failed to load dist.info." )
+endif ()
+# Reads field `name` from dist.info string `DIST_INFO` into variable `var`.
+macro ( _parse_dist_field name var )
+  string ( REGEX REPLACE ".*${name}[ \t]?=[ \t]?[\"']([^\"']+)[\"'].*" "\\1"
+           ${var} "${DIST_INFO}" )
+  if ( ${var} STREQUAL DIST_INFO )
+    message ( FATAL_ERROR "Failed to extract \"${var}\" from dist.info" )
+  endif ()
+endmacro ()
+#
+_parse_dist_field ( name DIST_NAME )
+_parse_dist_field ( version DIST_VERSION )
+_parse_dist_field ( license DIST_LICENSE )
+_parse_dist_field ( author DIST_AUTHOR )
+_parse_dist_field ( maintainer DIST_MAINTAINER )
+_parse_dist_field ( url DIST_URL )
+_parse_dist_field ( desc DIST_DESC )
+message ( "DIST_NAME: ${DIST_NAME}")
+message ( "DIST_VERSION: ${DIST_VERSION}")
+message ( "DIST_LICENSE: ${DIST_LICENSE}")
+message ( "DIST_AUTHOR: ${DIST_AUTHOR}")
+message ( "DIST_MAINTAINER: ${DIST_MAINTAINER}")
+message ( "DIST_URL: ${DIST_URL}")
+message ( "DIST_DESC: ${DIST_DESC}")
+string ( REGEX REPLACE ".*depends[ \t]?=[ \t]?[\"']([^\"']+)[\"'].*" "\\1"
+         DIST_DEPENDS ${DIST_INFO} )
+if ( DIST_DEPENDS STREQUAL DIST_INFO )
+  set ( DIST_DEPENDS "" )
+endif ()
+message ( "DIST_DEPENDS: ${DIST_DEPENDS}")
+## 2DO: Parse DIST_DEPENDS and try to install Dependencies with automatically using externalproject_add
+
+
+## INSTALL DEFAULTS (Relative to CMAKE_INSTALL_PREFIX)
+# Primary paths
+set ( INSTALL_BIN bin CACHE PATH "Where to install binaries to." )
+set ( INSTALL_LIB lib CACHE PATH "Where to install libraries to." )
+set ( INSTALL_INC include CACHE PATH "Where to install headers to." )
+set ( INSTALL_ETC etc CACHE PATH "Where to store configuration files" )
+set ( INSTALL_SHARE share CACHE PATH "Directory for shared data." )
+
+# Secondary paths
+option ( INSTALL_VERSION
+      "Install runtime libraries and executables with version information." OFF)
+set ( INSTALL_DATA ${INSTALL_SHARE}/${DIST_NAME} CACHE PATH
+      "Directory the package can store documentation, tests or other data in.")  
+set ( INSTALL_DOC  ${INSTALL_DATA}/doc CACHE PATH
+      "Recommended directory to install documentation into.")
+set ( INSTALL_EXAMPLE ${INSTALL_DATA}/example CACHE PATH
+      "Recommended directory to install examples into.")
+set ( INSTALL_TEST ${INSTALL_DATA}/test CACHE PATH
+      "Recommended directory to install tests into.")
+set ( INSTALL_FOO  ${INSTALL_DATA}/etc CACHE PATH
+      "Where to install additional files")
+
+# Tweaks and other defaults
+# Setting CMAKE to use loose block and search for find modules in source directory
+set ( CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS true )
+set ( CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake" ${CMAKE_MODULE_PATH} )
+option ( BUILD_SHARED_LIBS "Build shared libraries" ON )
+
+# In MSVC, prevent warnings that can occur when using standard libraries.
+if ( MSVC )
+  add_definitions ( -D_CRT_SECURE_NO_WARNINGS )
+endif ()
+
+# RPath and relative linking
+option ( USE_RPATH "Use relative linking." ON)
+if ( USE_RPATH )
+  string ( REGEX REPLACE "[^!/]+" ".." UP_DIR ${INSTALL_BIN} )
+  set ( CMAKE_SKIP_BUILD_RPATH FALSE CACHE STRING "" FORCE )
+  set ( CMAKE_BUILD_WITH_INSTALL_RPATH FALSE CACHE STRING "" FORCE )
+  set ( CMAKE_INSTALL_RPATH $ORIGIN/${UP_DIR}/${INSTALL_LIB}
+        CACHE STRING "" FORCE )
+  set ( CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE CACHE STRING "" FORCE )
+  set ( CMAKE_INSTALL_NAME_DIR @executable_path/${UP_DIR}/${INSTALL_LIB}
+        CACHE STRING "" FORCE )
+endif ()
+
+## MACROS
+# Parser macro
+macro ( parse_arguments prefix arg_names option_names)
+  set ( DEFAULT_ARGS )
+  foreach ( arg_name ${arg_names} )
+    set ( ${prefix}_${arg_name} )
+  endforeach ()
+  foreach ( option ${option_names} )
+    set ( ${prefix}_${option} FALSE )
+  endforeach ()
+
+  set ( current_arg_name DEFAULT_ARGS )
+  set ( current_arg_list )
+  foreach ( arg ${ARGN} )            
+    set ( larg_names ${arg_names} )    
+    list ( FIND larg_names "${arg}" is_arg_name )                   
+    if ( is_arg_name GREATER -1 )
+      set ( ${prefix}_${current_arg_name} ${current_arg_list} )
+      set ( current_arg_name ${arg} )
+      set ( current_arg_list )
+    else ()
+      set ( loption_names ${option_names} )    
+      list ( FIND loption_names "${arg}" is_option )            
+      if ( is_option GREATER -1 )
+        set ( ${prefix}_${arg} TRUE )
+      else ()
+        set ( current_arg_list ${current_arg_list} ${arg} )
+      endif ()
+    endif ()
+  endforeach ()
+  set ( ${prefix}_${current_arg_name} ${current_arg_list} )
+endmacro ()
+
+
+# install_executable ( executable_targets )
+# Installs any executables generated using "add_executable".
+# USE: install_executable ( lua )
+# NOTE: subdirectories are NOT supported
+set ( CPACK_COMPONENT_RUNTIME_DISPLAY_NAME "${DIST_NAME} Runtime" )
+set ( CPACK_COMPONENT_RUNTIME_DESCRIPTION
+      "Executables and runtime libraries. Installed into ${INSTALL_BIN}." )
+macro ( install_executable )
+  foreach ( _file ${ARGN} )
+    if ( INSTALL_VERSION )
+      set_target_properties ( ${_file} PROPERTIES VERSION ${DIST_VERSION}
+                              SOVERSION ${DIST_VERSION} )
+    endif ()
+    install ( TARGETS ${_file} RUNTIME DESTINATION ${INSTALL_BIN}
+              COMPONENT Runtime )
+  endforeach()
+endmacro ()
+
+# install_library ( library_targets )
+# Installs any libraries generated using "add_library" into apropriate places.
+# USE: install_library ( libexpat )
+# NOTE: subdirectories are NOT supported
+set ( CPACK_COMPONENT_LIBRARY_DISPLAY_NAME "${DIST_NAME} Development Libraries" )
+set ( CPACK_COMPONENT_LIBRARY_DESCRIPTION
+  "Static and import libraries needed for development. Installed into ${INSTALL_LIB} or ${INSTALL_BIN}." )
+macro ( install_library )
+  foreach ( _file ${ARGN} )
+    if ( INSTALL_VERSION )
+      set_target_properties ( ${_file} PROPERTIES VERSION ${DIST_VERSION}
+                              SOVERSION ${DIST_VERSION} )
+    endif ()
+    install ( TARGETS ${_file}
+              RUNTIME DESTINATION ${INSTALL_BIN} COMPONENT Runtime
+              LIBRARY DESTINATION ${INSTALL_LIB} COMPONENT Runtime 
+              ARCHIVE DESTINATION ${INSTALL_LIB} COMPONENT Library )
+  endforeach()
+endmacro ()
+
+# helper function for various install_* functions, for PATTERN/REGEX args.
+macro ( _complete_install_args )
+  if ( NOT("${_ARG_PATTERN}" STREQUAL "") )
+    set ( _ARG_PATTERN PATTERN ${_ARG_PATTERN} )
+  endif ()
+  if ( NOT("${_ARG_REGEX}" STREQUAL "") )
+    set ( _ARG_REGEX REGEX ${_ARG_REGEX} )
+  endif ()
+endmacro ()
+
+# install_header ( files/directories [INTO destination] )
+# Install a directories or files into header destination.
+# USE: install_header ( lua.h luaconf.h ) or install_header ( GL )
+# USE: install_header ( mylib.h INTO mylib )
+# For directories, supports optional PATTERN/REGEX arguments like install().
+set ( CPACK_COMPONENT_HEADER_DISPLAY_NAME "${DIST_NAME} Development Headers" )
+set ( CPACK_COMPONENT_HEADER_DESCRIPTION
+      "Headers needed for development. Installed into ${INSTALL_INC}." )
+macro ( install_header )
+  parse_arguments ( _ARG "INTO;PATTERN;REGEX" "" ${ARGN} )
+  _complete_install_args()
+  foreach ( _file ${_ARG_DEFAULT_ARGS} )
+    if ( IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/${_file}" )
+      install ( DIRECTORY ${_file} DESTINATION ${INSTALL_INC}/${_ARG_INTO}
+                COMPONENT Header ${_ARG_PATTERN} ${_ARG_REGEX} )
+    else ()
+      install ( FILES ${_file} DESTINATION ${INSTALL_INC}/${_ARG_INTO}
+                COMPONENT Header )
+    endif ()
+  endforeach()
+endmacro ()
+
+# install_data ( files/directories [INTO destination] )
+# This installs additional data files or directories.
+# USE: install_data ( extra data.dat )
+# USE: install_data ( image1.png image2.png INTO images )
+# For directories, supports optional PATTERN/REGEX arguments like install().
+set ( CPACK_COMPONENT_DATA_DISPLAY_NAME "${DIST_NAME} Data" )
+set ( CPACK_COMPONENT_DATA_DESCRIPTION
+      "Application data. Installed into ${INSTALL_DATA}." )
+macro ( install_data )
+  parse_arguments ( _ARG "INTO;PATTERN;REGEX" "" ${ARGN} )
+  _complete_install_args()
+  foreach ( _file ${_ARG_DEFAULT_ARGS} )
+    if ( IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/${_file}" )
+      install ( DIRECTORY ${_file}
+                DESTINATION ${INSTALL_DATA}/${_ARG_INTO}
+                COMPONENT Data ${_ARG_PATTERN} ${_ARG_REGEX} )
+    else ()
+      install ( FILES ${_file} DESTINATION ${INSTALL_DATA}/${_ARG_INTO}
+                COMPONENT Data )
+    endif ()
+  endforeach()
+endmacro ()
+
+# INSTALL_DOC ( files/directories [INTO destination] )
+# This installs documentation content
+# USE: install_doc ( doc/ doc.pdf )
+# USE: install_doc ( index.html INTO html )
+# For directories, supports optional PATTERN/REGEX arguments like install().
+set ( CPACK_COMPONENT_DOCUMENTATION_DISPLAY_NAME "${DIST_NAME} Documentation" )
+set ( CPACK_COMPONENT_DOCUMENTATION_DESCRIPTION
+      "Application documentation. Installed into ${INSTALL_DOC}." )
+macro ( install_doc )
+  parse_arguments ( _ARG "INTO;PATTERN;REGEX" "" ${ARGN} )
+  _complete_install_args()
+  foreach ( _file ${_ARG_DEFAULT_ARGS} )
+    if ( IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/${_file}" )
+      install ( DIRECTORY ${_file} DESTINATION ${INSTALL_DOC}/${_ARG_INTO}
+                COMPONENT Documentation ${_ARG_PATTERN} ${_ARG_REGEX} )
+    else ()
+      install ( FILES ${_file} DESTINATION ${INSTALL_DOC}/${_ARG_INTO}
+                COMPONENT Documentation )
+    endif ()
+  endforeach()
+endmacro ()
+
+# install_example ( files/directories [INTO destination]  )
+# This installs additional examples
+# USE: install_example ( examples/ exampleA )
+# USE: install_example ( super_example super_data INTO super)
+# For directories, supports optional PATTERN/REGEX argument like install().
+set ( CPACK_COMPONENT_EXAMPLE_DISPLAY_NAME "${DIST_NAME} Examples" )
+set ( CPACK_COMPONENT_EXAMPLE_DESCRIPTION
+    "Examples and their associated data. Installed into ${INSTALL_EXAMPLE}." )
+macro ( install_example )
+  parse_arguments ( _ARG "INTO;PATTERN;REGEX" "" ${ARGN} )
+  _complete_install_args()
+  foreach ( _file ${_ARG_DEFAULT_ARGS} )
+    if ( IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/${_file}" )
+      install ( DIRECTORY ${_file} DESTINATION ${INSTALL_EXAMPLE}/${_ARG_INTO}
+                COMPONENT Example ${_ARG_PATTERN} ${_ARG_REGEX} )
+    else ()
+      install ( FILES ${_file} DESTINATION ${INSTALL_EXAMPLE}/${_ARG_INTO}
+                COMPONENT Example )
+    endif ()
+  endforeach()
+endmacro ()
+
+# install_test ( files/directories [INTO destination] )
+# This installs tests and test files, DOES NOT EXECUTE TESTS
+# USE: install_test ( my_test data.sql )
+# USE: install_test ( feature_x_test INTO x )
+# For directories, supports optional PATTERN/REGEX argument like install().
+set ( CPACK_COMPONENT_TEST_DISPLAY_NAME "${DIST_NAME} Tests" )
+set ( CPACK_COMPONENT_TEST_DESCRIPTION
+      "Tests and associated data. Installed into ${INSTALL_TEST}." )
+macro ( install_test )
+  parse_arguments ( _ARG "INTO;PATTERN;REGEX" "" ${ARGN} )
+  _complete_install_args()
+  foreach ( _file ${_ARG_DEFAULT_ARGS} )
+    if ( IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/${_file}" )
+      install ( DIRECTORY ${_file} DESTINATION ${INSTALL_TEST}/${_ARG_INTO}
+                COMPONENT Test ${_ARG_PATTERN} ${_ARG_REGEX} )
+    else ()
+      install ( FILES ${_file} DESTINATION ${INSTALL_TEST}/${_ARG_INTO}
+                COMPONENT Test )
+    endif ()
+  endforeach()
+endmacro ()
+
+# install_foo ( files/directories [INTO destination] )
+# This installs optional or otherwise unneeded content
+# USE: install_foo ( etc/ example.doc )
+# USE: install_foo ( icon.png logo.png INTO icons)
+# For directories, supports optional PATTERN/REGEX argument like install().
+set ( CPACK_COMPONENT_OTHER_DISPLAY_NAME "${DIST_NAME} Unspecified Content" )
+set ( CPACK_COMPONENT_OTHER_DESCRIPTION
+      "Other unspecified content. Installed into ${INSTALL_FOO}." )
+macro ( install_foo )
+  parse_arguments ( _ARG "INTO;PATTERN;REGEX" "" ${ARGN} )
+  _complete_install_args()
+  foreach ( _file ${_ARG_DEFAULT_ARGS} )
+    if ( IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/${_file}" )
+      install ( DIRECTORY ${_file} DESTINATION ${INSTALL_FOO}/${_ARG_INTO}
+                COMPONENT Other ${_ARG_PATTERN} ${_ARG_REGEX} )
+    else ()
+      install ( FILES ${_file} DESTINATION ${INSTALL_FOO}/${_ARG_INTO}
+                COMPONENT Other )
+    endif ()
+  endforeach()
+endmacro ()
+
+## CTest defaults
+
+## CPack defaults
+set ( CPACK_GENERATOR "ZIP" )
+set ( CPACK_STRIP_FILES TRUE )
+set ( CPACK_PACKAGE_NAME "${DIST_NAME}" )
+set ( CPACK_PACKAGE_VERSION "${DIST_VERSION}")
+set ( CPACK_PACKAGE_VENDOR "LuaDist" )
+set ( CPACK_COMPONENTS_ALL Runtime Library Header Data Documentation Example Other )
+include ( CPack )

3rdparty/lsqlite3/cmake/lua.cmake

@@ -0,0 +1,293 @@
+# LuaDist CMake utility library for Lua.
+# 
+# Copyright (C) 2007-2012 LuaDist.
+# by David Manura, Peter Drahos
+# Redistribution and use of this file is allowed according to the terms of the MIT license.
+# For details see the COPYRIGHT file distributed with LuaDist.
+# Please note that the package source code is licensed under its own license.
+
+set ( INSTALL_LMOD ${INSTALL_LIB}/lua
+      CACHE PATH "Directory to install Lua modules." )
+set ( INSTALL_CMOD ${INSTALL_LIB}/lua
+      CACHE PATH "Directory to install Lua binary modules." )
+
+option ( SKIP_LUA_WRAPPER
+         "Do not build and install Lua executable wrappers." OFF)
+
+# List of (Lua module name, file path) pairs.
+# Used internally by add_lua_test.  Built by add_lua_module.
+set ( _lua_modules )
+
+# utility function: appends path `path` to path `basepath`, properly
+# handling cases when `path` may be relative or absolute.
+macro ( _append_path basepath path result )
+  if ( IS_ABSOLUTE "${path}" )
+    set ( ${result} "${path}" )
+  else ()
+    set ( ${result} "${basepath}/${path}" )
+  endif ()
+endmacro ()
+
+# install_lua_executable ( target source )
+# Automatically generate a binary if srlua package is available
+# The application or its source will be placed into /bin 
+# If the application source did not have .lua suffix then it will be added
+# USE: lua_executable ( sputnik src/sputnik.lua )
+macro ( install_lua_executable _name _source )
+  get_filename_component ( _source_name ${_source} NAME_WE )
+  # Find srlua and glue
+  find_program( SRLUA_EXECUTABLE NAMES srlua )
+  find_program( GLUE_EXECUTABLE NAMES glue )
+  # Executable output
+  set ( _exe ${CMAKE_CURRENT_BINARY_DIR}/${_name}${CMAKE_EXECUTABLE_SUFFIX} )
+  if ( NOT SKIP_LUA_WRAPPER AND SRLUA_EXECUTABLE AND GLUE_EXECUTABLE )
+    # Generate binary gluing the lua code to srlua, this is a robuust approach for most systems
+    add_custom_command(
+      OUTPUT ${_exe}
+      COMMAND ${GLUE_EXECUTABLE} 
+      ARGS ${SRLUA_EXECUTABLE} ${_source} ${_exe}
+      DEPENDS ${_source}
+      WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+      VERBATIM
+    )
+    # Make sure we have a target associated with the binary
+    add_custom_target(${_name} ALL
+        DEPENDS ${_exe}
+    )
+    # Install with run permissions
+    install ( PROGRAMS ${_exe} DESTINATION ${INSTALL_BIN} COMPONENT Runtime)
+	# Also install source as optional resurce
+	install ( FILES ${_source} DESTINATION ${INSTALL_FOO} COMPONENT Other )
+  else()
+    # Install into bin as is but without the lua suffix, we assume the executable uses UNIX shebang/hash-bang magic
+    install ( PROGRAMS ${_source} DESTINATION ${INSTALL_BIN}
+            RENAME ${_source_name}
+            COMPONENT Runtime
+    )
+  endif()
+endmacro ()
+
+macro ( _lua_module_helper is_install _name ) 
+  parse_arguments ( _MODULE "LINK;ALL_IN_ONE" "" ${ARGN} )
+  # _target is CMake-compatible target name for module (e.g. socket_core).
+  # _module is relative path of target (e.g. socket/core),
+  #   without extension (e.g. .lua/.so/.dll).
+  # _MODULE_SRC is list of module source files (e.g. .lua and .c files).
+  # _MODULE_NAMES is list of module names (e.g. socket.core).
+  if ( _MODULE_ALL_IN_ONE )
+    string ( REGEX REPLACE "\\..*" "" _target "${_name}" )
+    string ( REGEX REPLACE "\\..*" "" _module "${_name}" )
+    set ( _target "${_target}_all_in_one")
+    set ( _MODULE_SRC ${_MODULE_ALL_IN_ONE} )
+    set ( _MODULE_NAMES ${_name} ${_MODULE_DEFAULT_ARGS} )
+  else ()
+    string ( REPLACE "." "_" _target "${_name}" )
+    string ( REPLACE "." "/" _module "${_name}" )
+    set ( _MODULE_SRC ${_MODULE_DEFAULT_ARGS} )
+    set ( _MODULE_NAMES ${_name} )
+  endif ()
+  if ( NOT _MODULE_SRC )
+    message ( FATAL_ERROR "no module sources specified" )
+  endif ()
+  list ( GET _MODULE_SRC 0 _first_source )
+  
+  get_filename_component ( _ext ${_first_source} EXT )
+  if ( _ext STREQUAL ".lua" )  # Lua source module
+    list ( LENGTH _MODULE_SRC _len )
+    if ( _len GREATER 1 )
+      message ( FATAL_ERROR "more than one source file specified" )
+    endif ()
+  
+    set ( _module "${_module}.lua" )
+
+    get_filename_component ( _module_dir ${_module} PATH )
+    get_filename_component ( _module_filename ${_module} NAME )
+    _append_path ( "${CMAKE_CURRENT_SOURCE_DIR}" "${_first_source}" _module_path )
+    list ( APPEND _lua_modules "${_name}" "${_module_path}" )
+
+    if ( ${is_install} )
+      install ( FILES ${_first_source} DESTINATION ${INSTALL_LMOD}/${_module_dir}
+                RENAME ${_module_filename} 
+                COMPONENT Runtime
+      )
+    endif ()
+  else ()  # Lua C binary module
+    enable_language ( C )
+    find_package ( Lua REQUIRED )
+    include_directories ( ${LUA_INCLUDE_DIR} )
+
+    set ( _module "${_module}${CMAKE_SHARED_MODULE_SUFFIX}" )
+
+    get_filename_component ( _module_dir ${_module} PATH )
+    get_filename_component ( _module_filenamebase ${_module} NAME_WE )
+    foreach ( _thisname ${_MODULE_NAMES} )
+      list ( APPEND _lua_modules "${_thisname}"
+             "${CMAKE_CURRENT_BINARY_DIR}/\${CMAKE_CFG_INTDIR}/${_module}" )
+    endforeach ()
+   
+    add_library( ${_target} MODULE ${_MODULE_SRC})
+    target_link_libraries ( ${_target} ${LUA_LIBRARY} ${_MODULE_LINK} )
+    set_target_properties ( ${_target} PROPERTIES LIBRARY_OUTPUT_DIRECTORY
+                "${_module_dir}" PREFIX "" OUTPUT_NAME "${_module_filenamebase}" )
+    if ( ${is_install} )
+      install ( TARGETS ${_target} DESTINATION ${INSTALL_CMOD}/${_module_dir} COMPONENT Runtime)
+    endif ()
+  endif ()
+endmacro ()
+
+# add_lua_module
+# Builds a Lua source module into a destination locatable by Lua
+# require syntax.
+# Binary modules are also supported where this function takes sources and
+# libraries to compile separated by LINK keyword.
+# USE: add_lua_module ( socket.http src/http.lua )
+# USE2: add_lua_module ( mime.core src/mime.c )
+# USE3: add_lua_module ( socket.core ${SRC_SOCKET} LINK ${LIB_SOCKET} )
+# USE4: add_lua_module ( ssl.context ssl.core ALL_IN_ONE src/context.c src/ssl.c )
+#   This form builds an "all-in-one" module (e.g. ssl.so or ssl.dll containing
+#   both modules ssl.context and ssl.core).  The CMake target name will be
+#   ssl_all_in_one.
+# Also sets variable _module_path (relative path where module typically
+# would be installed).
+macro ( add_lua_module )
+  _lua_module_helper ( 0 ${ARGN} )
+endmacro ()
+
+
+# install_lua_module
+# This is the same as `add_lua_module` but also installs the module.
+# USE: install_lua_module ( socket.http src/http.lua )
+# USE2: install_lua_module ( mime.core src/mime.c )
+# USE3: install_lua_module ( socket.core ${SRC_SOCKET} LINK ${LIB_SOCKET} )
+macro ( install_lua_module )
+  _lua_module_helper ( 1 ${ARGN} )
+endmacro ()
+
+# Builds string representing Lua table mapping Lua modules names to file
+# paths.  Used internally.
+macro ( _make_module_table _outvar )
+  set ( ${_outvar} )
+  list ( LENGTH _lua_modules _n )
+  if ( ${_n} GREATER 0 ) # avoids cmake complaint
+  foreach ( _i RANGE 1 ${_n} 2 )
+    list ( GET _lua_modules ${_i} _path )
+    math ( EXPR _ii ${_i}-1 )
+    list ( GET _lua_modules ${_ii} _name )
+    set ( ${_outvar} "${_table}  ['${_name}'] = '${_path}'\;\n")
+  endforeach ()
+  endif ()
+  set ( ${_outvar}
+"local modules = {
+${_table}}" )
+endmacro ()
+
+# add_lua_test ( _testfile [ WORKING_DIRECTORY _working_dir ] )
+# Runs Lua script `_testfile` under CTest tester.
+# Optional named argument `WORKING_DIRECTORY` is current working directory to
+# run test under (defaults to ${CMAKE_CURRENT_BINARY_DIR}).
+# Both paths, if relative, are relative to ${CMAKE_CURRENT_SOURCE_DIR}.
+# Any modules previously defined with install_lua_module are automatically
+# preloaded (via package.preload) prior to running the test script.
+# Under LuaDist, set test=true in config.lua to enable testing.
+# USE: add_lua_test ( test/test1.lua [args...] [WORKING_DIRECTORY dir])
+macro ( add_lua_test _testfile )
+  if ( NOT SKIP_TESTING )
+    parse_arguments ( _ARG "WORKING_DIRECTORY" "" ${ARGN} )
+    include ( CTest )
+    find_program ( LUA NAMES lua lua.bat )
+    get_filename_component ( TESTFILEABS ${_testfile} ABSOLUTE )
+    get_filename_component ( TESTFILENAME ${_testfile} NAME )
+    get_filename_component ( TESTFILEBASE ${_testfile} NAME_WE )
+
+    # Write wrapper script.
+    # Note: One simple way to allow the script to find modules is
+    # to just put them in package.preload.
+    set ( TESTWRAPPER ${CMAKE_CURRENT_BINARY_DIR}/${TESTFILENAME} )
+    _make_module_table ( _table )
+    set ( TESTWRAPPERSOURCE
+"local CMAKE_CFG_INTDIR = ... or '.'
+${_table}
+local function preload_modules(modules)
+  for name, path in pairs(modules) do
+    if path:match'%.lua' then
+      package.preload[name] = assert(loadfile(path))
+    else
+      local name = name:gsub('.*%-', '') -- remove any hyphen prefix
+      local symbol = 'luaopen_' .. name:gsub('%.', '_')
+          --improve: generalize to support all-in-one loader?
+      local path = path:gsub('%$%{CMAKE_CFG_INTDIR%}', CMAKE_CFG_INTDIR)
+      package.preload[name] = assert(package.loadlib(path, symbol))
+    end
+  end
+end
+preload_modules(modules)
+arg[0] = '${TESTFILEABS}'
+table.remove(arg, 1)
+return assert(loadfile '${TESTFILEABS}')(unpack(arg))
+"    )
+    if ( _ARG_WORKING_DIRECTORY )
+      get_filename_component (
+         TESTCURRENTDIRABS ${_ARG_WORKING_DIRECTORY} ABSOLUTE )
+      # note: CMake 2.6 (unlike 2.8) lacks WORKING_DIRECTORY parameter.
+      set ( _pre ${CMAKE_COMMAND} -E chdir "${TESTCURRENTDIRABS}" )
+    endif ()
+    file ( WRITE ${TESTWRAPPER} ${TESTWRAPPERSOURCE})
+    add_test ( NAME ${TESTFILEBASE} COMMAND ${_pre} ${LUA}
+               ${TESTWRAPPER} "${CMAKE_CFG_INTDIR}"
+               ${_ARG_DEFAULT_ARGS} )
+  endif ()
+  # see also http://gdcm.svn.sourceforge.net/viewvc/gdcm/Sandbox/CMakeModules/UsePythonTest.cmake
+  # Note: ${CMAKE_CFG_INTDIR} is a command-line argument to allow proper
+  # expansion by the native build tool.
+endmacro ()
+
+
+# Converts Lua source file `_source` to binary string embedded in C source
+# file `_target`.  Optionally compiles Lua source to byte code (not available
+# under LuaJIT2, which doesn't have a bytecode loader).  Additionally, Lua
+# versions of bin2c [1] and luac [2] may be passed respectively as additional
+# arguments.
+#
+# [1] http://lua-users.org/wiki/BinToCee
+# [2] http://lua-users.org/wiki/LuaCompilerInLua
+function ( add_lua_bin2c _target _source )
+  find_program ( LUA NAMES lua lua.bat )
+  execute_process ( COMMAND ${LUA} -e "string.dump(function()end)"
+                    RESULT_VARIABLE _LUA_DUMP_RESULT ERROR_QUIET )
+  if ( NOT ${_LUA_DUMP_RESULT} )
+    SET ( HAVE_LUA_DUMP true )
+  endif ()
+  message ( "-- string.dump=${HAVE_LUA_DUMP}" )
+
+  if ( ARGV2 )
+    get_filename_component ( BIN2C ${ARGV2} ABSOLUTE )
+    set ( BIN2C ${LUA} ${BIN2C} )
+  else ()
+    find_program ( BIN2C NAMES bin2c bin2c.bat )
+  endif ()
+  if ( HAVE_LUA_DUMP )
+    if ( ARGV3 )
+      get_filename_component ( LUAC ${ARGV3} ABSOLUTE )
+      set ( LUAC ${LUA} ${LUAC} )
+    else ()
+      find_program ( LUAC NAMES luac luac.bat )
+    endif ()
+  endif ( HAVE_LUA_DUMP )
+  message ( "-- bin2c=${BIN2C}" )
+  message ( "-- luac=${LUAC}" )
+
+  get_filename_component ( SOURCEABS ${_source} ABSOLUTE )
+  if ( HAVE_LUA_DUMP )
+    get_filename_component ( SOURCEBASE ${_source} NAME_WE )
+    add_custom_command (
+      OUTPUT  ${_target} DEPENDS ${_source}
+      COMMAND ${LUAC} -o ${CMAKE_CURRENT_BINARY_DIR}/${SOURCEBASE}.lo
+              ${SOURCEABS}
+      COMMAND ${BIN2C} ${CMAKE_CURRENT_BINARY_DIR}/${SOURCEBASE}.lo
+              ">${_target}" )
+  else ()
+    add_custom_command (
+      OUTPUT  ${_target} DEPENDS ${SOURCEABS}
+      COMMAND ${BIN2C} ${_source} ">${_target}" )
+  endif ()
+endfunction()

3rdparty/lsqlite3/dist.info

@@ -0,0 +1,15 @@
+--- This dist file is part of LuaDist project
+
+name = "lsqlite3"
+version = "0.6devel"
+
+desc = "LuaSQLite 3 is a thin wrapper around the public domain SQLite3 database engine."
+author = "Tiago Dionizio, Doug Currie"
+license = "MIT"
+url = "http://luaforge.net/projects/luasqlite/"
+maintainer = "Peter Kapec"
+
+depends = {
+	"lua ~> 5.1",
+	"libsqlite3 >=3.5"
+}

3rdparty/lsqlite3/doc/lsqlite3.html

@@ -0,0 +1,893 @@
+<HTML>
+<HEAD>
+<TITLE>LuaSQLite 3</TITLE>
+<LINK REV="made" HREF="mailto:unknown@du216771.users">
+</HEAD>
+
+<BODY>
+
+<A NAME="__index__"></A>
+<!-- INDEX BEGIN -->
+
+<UL>
+
+	<LI><A HREF="#name">NAME</A></LI>
+	<LI><A HREF="#overview">OVERVIEW</A></LI>
+	<LI><A HREF="#download">DOWNLOAD</A></LI>
+	<LI><A HREF="#installation">INSTALLATION</A></LI>
+	<LI><A HREF="#examples">EXAMPLES</A></LI>
+	<LI><A HREF="#verification tests">VERIFICATION TESTS</A></LI>
+	<LI><A HREF="#reference">REFERENCE</A></LI>
+	<LI><A HREF="#sqlite3 functions">SQLite3 functions</A></LI>
+	<UL>
+
+		<LI><A HREF="#sqlite3.complete">sqlite3.complete</A></LI>
+		<LI><A HREF="#sqlite3.open">sqlite3.open</A></LI>
+		<LI><A HREF="#sqlite3.open_memory">sqlite3.open_memory</A></LI>
+		<LI><A HREF="#sqlite3.temp_directory">sqlite3.temp_directory</A></LI>
+		<LI><A HREF="#sqlite3.version">sqlite3.version</A></LI>
+	</UL>
+
+	<LI><A HREF="#database methods">Database methods</A></LI>
+	<UL>
+
+		<LI><A HREF="#db:busy_handler">db:busy_handler</A></LI>
+		<LI><A HREF="#db:busy_timeout">db:busy_timeout</A></LI>
+		<LI><A HREF="#db:changes">db:changes</A></LI>
+		<LI><A HREF="#db:close">db:close</A></LI>
+		<LI><A HREF="#db:close_vm">db:close_vm</A></LI>
+		<LI><A HREF="#db:create_aggregate">db:create_aggregate</A></LI>
+		<LI><A HREF="#db:create_collation">db:create_collation</A></LI>
+		<LI><A HREF="#db:create_function">db:create_function</A></LI>
+		<LI><A HREF="#db:errcode">db:errcode</A></LI>
+		<LI><A HREF="#db:errmsg">db:errmsg</A></LI>
+		<LI><A HREF="#db:exec">db:exec</A></LI>
+		<LI><A HREF="#db:interrupt">db:interrupt</A></LI>
+		<LI><A HREF="#db:isopen">db:isopen</A></LI>
+		<LI><A HREF="#db:last_insert_rowid">db:last_insert_rowid</A></LI>
+		<LI><A HREF="#db:nrows">db:nrows</A></LI>
+		<LI><A HREF="#db:prepare">db:prepare</A></LI>
+		<LI><A HREF="#db:progress_handler">db:progress_handler</A></LI>
+		<LI><A HREF="#db:rows">db:rows</A></LI>
+		<LI><A HREF="#db:total_changes">db:total_changes</A></LI>
+		<LI><A HREF="#db:trace">db:trace</A></LI>
+		<LI><A HREF="#db:urows">db:urows</A></LI>
+	</UL>
+
+	<LI><A HREF="#methods for prepared statements">Methods for prepared statements</A></LI>
+	<UL>
+
+		<LI><A HREF="#stmt:bind">stmt:bind</A></LI>
+		<LI><A HREF="#stmt:bind_blob">stmt:bind_blob</A></LI>
+		<LI><A HREF="#stmt:bind_names">stmt:bind_names</A></LI>
+		<LI><A HREF="#stmt:bind_parameter_count">stmt:bind_parameter_count</A></LI>
+		<LI><A HREF="#stmt:bind_parameter_name">stmt:bind_parameter_name</A></LI>
+		<LI><A HREF="#stmt:bind_values">stmt:bind_values</A></LI>
+		<LI><A HREF="#stmt:columns">stmt:columns</A></LI>
+		<LI><A HREF="#stmt:finalize">stmt:finalize</A></LI>
+		<LI><A HREF="#stmt:get_name">stmt:get_name</A></LI>
+		<LI><A HREF="#stmt:get_named_types">stmt:get_named_types</A></LI>
+		<LI><A HREF="#stmt:get_named_values">stmt:get_named_values</A></LI>
+		<LI><A HREF="#stmt:get_names">stmt:get_names</A></LI>
+		<LI><A HREF="#stmt:get_type">stmt:get_type</A></LI>
+		<LI><A HREF="#stmt:get_types">stmt:get_types</A></LI>
+		<LI><A HREF="#stmt:get_unames">stmt:get_unames</A></LI>
+		<LI><A HREF="#stmt:get_utypes">stmt:get_utypes</A></LI>
+		<LI><A HREF="#stmt:get_uvalues">stmt:get_uvalues</A></LI>
+		<LI><A HREF="#stmt:get_value">stmt:get_value</A></LI>
+		<LI><A HREF="#stmt:get_values">stmt:get_values</A></LI>
+		<LI><A HREF="#stmt:isopen">stmt:isopen</A></LI>
+		<LI><A HREF="#stmt:nrows">stmt:nrows</A></LI>
+		<LI><A HREF="#stmt:reset">stmt:reset</A></LI>
+		<LI><A HREF="#stmt:rows">stmt:rows</A></LI>
+		<LI><A HREF="#stmt:step">stmt:step</A></LI>
+		<LI><A HREF="#stmt:urows">stmt:urows</A></LI>
+	</UL>
+
+	<LI><A HREF="#methods for callback contexts">Methods for callback contexts</A></LI>
+	<UL>
+
+		<LI><A HREF="#context:aggregate_count">context:aggregate_count</A></LI>
+		<LI><A HREF="#context:get_aggregate_data">context:get_aggregate_data</A></LI>
+		<LI><A HREF="#context:set_aggregate_data">context:set_aggregate_data</A></LI>
+		<LI><A HREF="#context:result">context:result</A></LI>
+		<LI><A HREF="#context:result_null">context:result_null</A></LI>
+		<LI><A HREF="#context:result_number">context:result_number</A></LI>
+		<LI><A HREF="#context:result_int">context:result_int</A></LI>
+		<LI><A HREF="#context:result_text">context:result_text</A></LI>
+		<LI><A HREF="#context:result_blob">context:result_blob</A></LI>
+		<LI><A HREF="#context:result_error">context:result_error</A></LI>
+		<LI><A HREF="#context:user_data">context:user_data</A></LI>
+	</UL>
+
+	<LI><A HREF="#numerical error and result codes">Numerical error and result codes</A></LI>
+	<LI><A HREF="#version">VERSION</A></LI>
+	<LI><A HREF="#credits">CREDITS</A></LI>
+	<LI><A HREF="#license">LICENSE</A></LI>
+</UL>
+<!-- INDEX END -->
+
+<HR>
+<P>
+<HR>
+<H1><A NAME="name">NAME</A></H1>
+<P><STRONG>LuaSQLite 3</STRONG> - a Lua 5.1 wrapper for the SQLite3 library</P>
+<P>
+<HR>
+<H1><A NAME="overview">OVERVIEW</A></H1>
+<P><STRONG>LuaSQLite 3</STRONG> is a thin wrapper around the public domain SQLite3
+database engine.</P>
+<P>The <CODE>lsqlite3</CODE> module supports the creation and manipulation of 
+SQLite3 databases. After a <CODE>require('lsqlite3')</CODE> the exported 
+functions are called with prefix <CODE>sqlite3</CODE>. However, most sqlite3 
+functions are called via an object-oriented interface to either 
+database or SQL statement objects; see below for details.</P>
+<P>This documentation does not attempt to describe how SQLite3 itself
+works, it just describes the Lua binding and the available functions.
+For more information about the SQL features supported by SQLite3 and
+details about the syntax of SQL statements and queries, please see the
+<STRONG>SQLite3 documentation</STRONG> <A HREF="http://www.sqlite.org/">http://www.sqlite.org/</A>. Using some of the
+advanced features (how to use callbacks, for instance) will require 
+some familiarity with the SQLite3 API.</P>
+<P>
+<HR>
+<H1><A NAME="download">DOWNLOAD</A></H1>
+<P><STRONG>LuaSQLite 3</STRONG> source code can be downloaded from its 
+LuaForge (<A HREF="http://luaforge.net/projects/luasqlite/">http://luaforge.net/projects/luasqlite/</A>) page.</P>
+<P>You will also need to build or obtain an SQLite3 loadable library 
+(DLL or .so). See <A HREF="http://www.sqlite.org/">http://www.sqlite.org/</A> for obtaining SQLite3 
+source code or downloading a binary SQLite3 library.</P>
+<P>
+<HR>
+<H1><A NAME="installation">INSTALLATION</A></H1>
+<P>A <EM>Makefile</EM> is provided; it assumes an SQLite3 library is already
+installed.</P>
+<P>
+<HR>
+<H1><A NAME="examples">EXAMPLES</A></H1>
+<P>The distribution contains an <EM>examples</EM> directory. The unit tests
+also show some example use.</P>
+<P>
+<HR>
+<H1><A NAME="verification tests">VERIFICATION TESTS</A></H1>
+<P>The distribution contains some units tests using Michael Roth's
+<CODE>lunit</CODE> (which is also included). Some of the tests were also derived 
+from Michael's <STRONG>lua-sqlite3</STRONG> module, and more unit tests added by 
+Doug Currie.</P>
+<P>The distribution also contains some functional tests by Tiago.</P>
+<P>This version of <CODE>lsqlite3</CODE> was tested with SQLite 3.4.2.</P>
+<P>
+<HR>
+<H1><A NAME="reference">REFERENCE</A></H1>
+<P>
+<HR>
+<H1><A NAME="sqlite3 functions">SQLite3 functions</A></H1>
+<P>
+<H2><A NAME="sqlite3.complete">sqlite3.complete</A></H2>
+<PRE>
+        sqlite3.complete(sql)</PRE>
+<P>Returns true if the string <CODE>sql</CODE> comprises one or more complete SQL
+statements and false otherwise.</P>
+<P>
+<H2><A NAME="sqlite3.open">sqlite3.open</A></H2>
+<PRE>
+        sqlite3.open(filename)</PRE>
+<P>Opens (or creates if it does not exist) an SQLite database with name
+<CODE>filename</CODE> and returns its handle as userdata (the returned object 
+should be used for all further method calls in connection with this 
+specific database, see <A HREF="#database methods">Database methods</A>). Example:</P>
+<PRE>
+        myDB=sqlite3.open('MyDatabase.sqlite3')  -- open
+        -- do some database calls...
+        myDB:close()  -- close</PRE>
+<P>In case of an error, the function returns nil, an error code and an
+error message.</P>
+<P>
+<H2><A NAME="sqlite3.open_memory">sqlite3.open_memory</A></H2>
+<PRE>
+        sqlite3.open_memory()</PRE>
+<P>Opens an SQLite database <STRONG>in memory</STRONG> and returns its handle as
+userdata. In case of an error, the function returns nil, an error code
+and an error message. (In-memory databases are volatile as they are
+never stored on disk.)</P>
+<P>
+<H2><A NAME="sqlite3.temp_directory">sqlite3.temp_directory</A></H2>
+<PRE>
+        sqlite3.temp_directory([temp])</PRE>
+<P>Sets or queries the directory used by SQLite for temporary files. If
+string <CODE>temp</CODE> is a directory name or nil, the temporary directory is 
+set accordingly and the old value is returned. If <CODE>temp</CODE> is missing, 
+the function simply returns the current temporary directory.</P>
+<P>
+<H2><A NAME="sqlite3.version">sqlite3.version</A></H2>
+<PRE>
+        sqlite3.version()</PRE>
+<P>Returns a string with SQLite version information, in the form 'x.y[.z]'.</P>
+<P>
+<HR>
+<H1><A NAME="database methods">Database methods</A></H1>
+<P>After opening a database with <A HREF="#sqlite3.open"><CODE>sqlite3.open()</CODE></A> or 
+<A HREF="#sqlite3.open_memory"><CODE>sqlite3.open_memory()</CODE></A>
+the returned database object should be used for all further method calls
+in connection with that database. An open database object supports the
+following methods.</P>
+<P>
+<H2><A NAME="db:busy_handler">db:busy_handler</A></H2>
+<PRE>
+        db:busy_handler([func[,udata]])</PRE>
+<P>Sets or removes a busy handler for a database. <CODE>func</CODE> is either a Lua
+function that implements the busy handler or nil to remove a previously
+set handler. This function returns nothing.</P>
+<P>The handler function is called with two parameters: <CODE>udata</CODE> and the 
+number of (re-)tries for a pending transaction. It should return nil, 
+false or 0 if the transaction is to be aborted. All other values will 
+result in another attempt to perform the transaction. (See the SQLite
+documentation for important hints about writing busy handlers.)</P>
+<P>
+<H2><A NAME="db:busy_timeout">db:busy_timeout</A></H2>
+<PRE>
+        db:busy_timeout(t)</PRE>
+<P>Sets a busy handler that waits for <CODE>t</CODE> milliseconds if a transaction 
+cannot proceed. Calling this function will remove any busy handler set 
+by <A HREF="#db:busy_handler"><CODE>db:busy_handler()</CODE></A>; calling it with an argument 
+less than or equal to 0 will turn off all busy handlers.</P>
+<P>
+<H2><A NAME="db:changes">db:changes</A></H2>
+<PRE>
+        db:changes()</PRE>
+<P>This function returns the number of database rows that were changed (or
+inserted or deleted) by the most recent SQL statement. Only changes that
+are directly specified by INSERT, UPDATE, or DELETE statements are
+counted. Auxiliary changes caused by triggers are not counted. Use
+<A HREF="#db:total_changes"><CODE>db:total_changes()</CODE></A> to find the total number of 
+changes.</P>
+<P>
+<H2><A NAME="db:close">db:close</A></H2>
+<PRE>
+        db:close()</PRE>
+<P>Closes a database. All SQL statements prepared using 
+<A HREF="#db:prepare"><CODE>db:prepare()</CODE></A> should
+have been finalized before this function is called. The function returns
+<CODE>sqlite3.OK</CODE> on success or else a numerical error code (see the list of
+<A HREF="#numerical error and result codes">Numerical error and result codes</A>).</P>
+<P>
+<H2><A NAME="db:close_vm">db:close_vm</A></H2>
+<PRE>
+        db:close_vm(temponly)</PRE>
+<P>Finalizes all statements that have not been explicitly finalized. If
+<CODE>temponly</CODE> is true, only internal, temporary statements are finalized.
+This function returns nothing.</P>
+<P>
+<H2><A NAME="db:create_aggregate">db:create_aggregate</A></H2>
+<PRE>
+        db:create_aggregate(name,nargs,step,final)</PRE>
+<P>This function creates an aggregate callback function. Aggregates perform
+an operation over all rows in a query. <CODE>name</CODE> is a string with the name 
+of the aggregate function as given in an SQL statement; <CODE>nargs</CODE> is the 
+number of arguments this call will provide. <CODE>step</CODE> is the actual Lua 
+function that gets called once for every row; it should accept a function 
+context (see <A HREF="#methods for callback contexts">Methods for callback contexts</A>) plus the same number of
+parameters as given in <CODE>nargs</CODE>. <CODE>final</CODE> is a function that is called 
+once after all rows have been processed; it receives one argument, the
+function context.</P>
+<P>The function context can be used inside the two callback functions to
+communicate with SQLite3. Here is a simple example:</P>
+<PRE>
+        db:exec[=[
+          CREATE TABLE numbers(num1,num2);
+          INSERT INTO numbers VALUES(1,11);
+          INSERT INTO numbers VALUES(2,22);
+          INSERT INTO numbers VALUES(3,33);
+        ]=]
+        local num_sum=0
+        local function oneRow(context,num)  -- add one column in all rows
+          num_sum=num_sum+num
+        end
+        local function afterLast(context)   -- return sum after last row has been processed
+          context:result_number(num_sum)
+          num_sum=0
+        end
+        db:create_aggregate(&quot;do_the_sums&quot;,1,oneRow,afterLast)
+        for sum in db:urows('SELECT do_the_sums(num1) FROM numbers') do print(&quot;Sum of col 1:&quot;,sum) end
+        for sum in db:urows('SELECT do_the_sums(num2) FROM numbers') do print(&quot;Sum of col 2:&quot;,sum) end</PRE>
+<P>This prints:</P>
+<PRE>
+        Sum of col 1:   6
+        Sum of col 2:   66</PRE>
+<P>
+<H2><A NAME="db:create_collation">db:create_collation</A></H2>
+<PRE>
+        db:create_collation(name,func)</PRE>
+<P>This creates a collation callback. A collation callback is used to
+establish a collation order, mostly for string comparisons and sorting
+purposes. <CODE>name</CODE> is a string with the name of the collation to be created;
+<CODE>func</CODE> is a function that accepts two string arguments, compares them 
+and returns 0 if both strings are identical, -1 if the first argument is
+lower in the collation order than the second and 1 if the first argument
+is higher in the collation order than the second. A simple example:</P>
+<PRE>
+        local function collate(s1,s2)
+          s1=s1:lower()
+          s2=s2:lower()
+          if s1==s2 then return 0
+          elseif s1&lt;s2 then return -1
+          else return 1 end
+        end
+        db:exec[=[
+          CREATE TABLE test(id INTEGER PRIMARY KEY,content COLLATE CINSENS);
+          INSERT INTO test VALUES(NULL,'hello world');
+          INSERT INTO test VALUES(NULL,'Buenos dias');
+          INSERT INTO test VALUES(NULL,'HELLO WORLD');
+        ]=]
+        db:create_collation('CINSENS',collate)
+        for row in db:nrows('SELECT * FROM test') do print(row.id,row.content) end</PRE>
+<P>
+<H2><A NAME="db:create_function">db:create_function</A></H2>
+<PRE>
+        db:create_function(name,nargs,func)</PRE>
+<P>This function creates a callback function. Callback function are called
+by SQLite3 once for every row in a query. <CODE>name</CODE> is a string with the 
+name of the callback function as given in an SQL statement; <CODE>nargs</CODE> is 
+the number of arguments this call will provide. <CODE>func</CODE> is the actual Lua
+function that gets called once for every row; it should accept a
+function context (see <A HREF="#methods for callback contexts">Methods for callback contexts</A>) plus the same
+number of parameters as given in nargs. Here is an example:</P>
+<PRE>
+        db:exec'CREATE TABLE test(col1,col2,col3)'
+        db:exec'INSERT INTO test VALUES(1,2,4)'
+        db:exec'INSERT INTO test VALUES(2,4,9)'
+        db:exec'INSERT INTO test VALUES(3,6,16)'
+        db:create_function('sum_cols',3,function(ctx,a,b,c)
+          ctx:result_number(a+b+c)
+        end))
+        for col1,col2,col3,sum in db:urows('SELECT *,sum_cols(col1,col2,col3) FROM test') do
+          util.printf('%2i+%2i+%2i=%2i\n',col1,col2,col3,sum)
+        end</PRE>
+<P>
+<H2><A NAME="db:errcode">db:errcode</A></H2>
+<PRE>
+        db:errcode()
+        db:error_code()</PRE>
+<P>Returns the numerical result code (or extended result code) for the most
+recent failed call associated with database db. See
+<A HREF="#numerical error and result codes">Numerical error and result codes</A> for details.</P>
+<P>
+<H2><A NAME="db:errmsg">db:errmsg</A></H2>
+<PRE>
+        db:errmsg()
+        db:error_message()</PRE>
+<P>Returns a string that contains an error message for the most recent
+failed call associated with database db.</P>
+<P>
+<H2><A NAME="db:exec">db:exec</A></H2>
+<PRE>
+        db:exec(sql[,func[,udata]])
+        db:execute(sql[,func[,udata]])</PRE>
+<P>Compiles and executes the SQL <CODE>statement(s)</CODE> given in string <CODE>sql</CODE>. The
+statements are simply executed one after the other and not stored. The
+function returns <CODE>sqlite3.OK</CODE> on success or else a numerical error code
+(see <A HREF="#numerical error and result codes">Numerical error and result codes</A>).</P>
+<P>If one or more of the SQL statements are queries, then the callback
+function specified in <CODE>func</CODE> is invoked once for each row of the query
+result (if <CODE>func</CODE> is nil, no callback is invoked). The callback receives
+four arguments: <CODE>udata</CODE> (the third parameter of the <CODE>db:exec()</CODE> call), 
+the number of columns in the row, a table with the column values and 
+another table with the column names. The callback function should return 
+0. If the callback returns a non-zero value then the query is aborted, 
+all subsequent SQL statements are skipped and <CODE>db:exec()</CODE> returns
+<CODE>sqlite3.ABORT</CODE>. Here is a simple example:</P>
+<PRE>
+        sql=[=[
+          CREATE TABLE numbers(num1,num2,str);
+          INSERT INTO numbers VALUES(1,11,&quot;ABC&quot;);
+          INSERT INTO numbers VALUES(2,22,&quot;DEF&quot;);
+          INSERT INTO numbers VALUES(3,33,&quot;UVW&quot;);
+          INSERT INTO numbers VALUES(4,44,&quot;XYZ&quot;);
+          SELECT * FROM numbers;
+        ]=]
+        function showrow(udata,cols,values,names)
+          assert(udata=='test_udata')
+          print('exec:')
+          for i=1,cols do print('',names[i],values[i]) end
+          return 0
+        end
+        db:exec(sql,showrow,'test_udata')</PRE>
+<P>
+<H2><A NAME="db:interrupt">db:interrupt</A></H2>
+<PRE>
+        db:interrupt()</PRE>
+<P>This function causes any pending database operation to abort and return
+at the next opportunity. This function returns nothing.</P>
+<P>
+<H2><A NAME="db:isopen">db:isopen</A></H2>
+<PRE>
+        db:isopen()</PRE>
+<P>Returns true if database db is open, false otherwise.</P>
+<P>
+<H2><A NAME="db:last_insert_rowid">db:last_insert_rowid</A></H2>
+<PRE>
+        db:last_insert_rowid()</PRE>
+<P>This function returns the rowid of the most recent INSERT into the
+database. If no inserts have ever occurred, 0 is returned. (Each row in
+an SQLite table has a unique 64-bit signed integer key called the
+'rowid'. This id is always available as an undeclared column named
+ROWID, OID, or _ROWID_. If the table has a column of type INTEGER
+PRIMARY KEY then that column is another alias for the rowid.)</P>
+<P>If an INSERT occurs within a trigger, then the rowid of the inserted row
+is returned as long as the trigger is running. Once the trigger
+terminates, the value returned reverts to the last value inserted before
+the trigger fired.</P>
+<P>
+<H2><A NAME="db:nrows">db:nrows</A></H2>
+<PRE>
+        db:nrows(sql)</PRE>
+<P>Creates an iterator that returns the successive rows selected by the SQL
+statement given in string <CODE>sql</CODE>. Each call to the iterator returns a 
+table in which the named fields correspond to the columns in the database.
+Here is an example:</P>
+<PRE>
+        db:exec[=[
+          CREATE TABLE numbers(num1,num2);
+          INSERT INTO numbers VALUES(1,11);
+          INSERT INTO numbers VALUES(2,22);
+          INSERT INTO numbers VALUES(3,33);
+        ]=]
+        for a in db:nrows('SELECT * FROM numbers') do table.print(a) end</PRE>
+<P>This script prints:</P>
+<PRE>
+        num2: 11
+        num1: 1
+        num2: 22
+        num1: 2
+        num2: 33
+        num1: 3</PRE>
+<P>
+<H2><A NAME="db:prepare">db:prepare</A></H2>
+<PRE>
+        db:prepare(sql)</PRE>
+<P>This function compiles the SQL statement in string <CODE>sql</CODE> into an internal
+representation and returns this as userdata. The returned object should
+be used for all further method calls in connection with this specific
+SQL statement (see <A HREF="#methods for prepared statements">Methods for prepared statements</A>).</P>
+<P>
+<H2><A NAME="db:progress_handler">db:progress_handler</A></H2>
+<PRE>
+        db:progress_handler(n,func,udata)</PRE>
+<P>This function installs a callback function <CODE>func</CODE> that is invoked
+periodically during long-running calls to <A HREF="#db:exec"><CODE>db:exec()</CODE></A>
+or <A HREF="#stmt:step"><CODE>stmt:step()</CODE></A>. The
+progress callback is invoked once for every <CODE>n</CODE> internal operations, 
+where <CODE>n</CODE> is the first argument to this function. <CODE>udata</CODE> is passed to 
+the progress callback function each time it is invoked. If a call to
+<CODE>db:exec()</CODE> or <CODE>stmt:step()</CODE> results in fewer than <CODE>n</CODE> operations 
+being executed, then the progress callback is never invoked. Only a 
+single progress callback function may be registered for each opened 
+database and a call to this function will overwrite any previously set 
+callback function. To remove the progress callback altogether, pass nil 
+as the second argument.</P>
+<P>If the progress callback returns a result other than 0, then the current
+query is immediately terminated, any database changes are rolled back
+and the containing <CODE>db:exec()</CODE> or <CODE>stmt:step()</CODE> call returns
+<CODE>sqlite3.INTERRUPT</CODE>. This feature can be used to cancel long-running
+queries.</P>
+<P>
+<H2><A NAME="db:rows">db:rows</A></H2>
+<PRE>
+        db:rows(sql)</PRE>
+<P>Creates an iterator that returns the successive rows selected by the SQL
+statement given in string <CODE>sql</CODE>. Each call to the iterator returns a table
+in which the numerical indices 1 to n correspond to the selected columns
+1 to n in the database. Here is an example:</P>
+<PRE>
+        db:exec[=[
+          CREATE TABLE numbers(num1,num2);
+          INSERT INTO numbers VALUES(1,11);
+          INSERT INTO numbers VALUES(2,22);
+          INSERT INTO numbers VALUES(3,33);
+        ]=]
+        for a in db:rows('SELECT * FROM numbers') do table.print(a) end</PRE>
+<P>This script prints:</P>
+<PRE>
+        1: 1
+        2: 11
+        1: 2
+        2: 22
+        1: 3
+        2: 33</PRE>
+<P>
+<H2><A NAME="db:total_changes">db:total_changes</A></H2>
+<PRE>
+        db:total_changes()</PRE>
+<P>This function returns the number of database rows that have been
+modified by INSERT, UPDATE or DELETE statements since the database was
+opened. This includes UPDATE, INSERT and DELETE statements executed as
+part of trigger programs. All changes are counted as soon as the
+statement that produces them is completed by calling either 
+<A HREF="#stmt:reset"><CODE>stmt:reset()</CODE></A> or <A HREF="#stmt:finalize"><CODE>stmt:finalize()</CODE></A>.</P>
+<P>
+<H2><A NAME="db:trace">db:trace</A></H2>
+<PRE>
+        db:trace(func,udata)</PRE>
+<P>This function installs a trace callback handler. <CODE>func</CODE> is a Lua
+function that is called by SQLite3 just before the evaluation of an SQL
+statement. This callback receives two arguments: the first is the 
+<CODE>udata</CODE> argument used when the callback was installed; the second is a 
+string with the SQL statement about to be executed.</P>
+<P>
+<H2><A NAME="db:urows">db:urows</A></H2>
+<PRE>
+        db:urows(sql)</PRE>
+<P>Creates an iterator that returns the successive rows selected by the SQL
+statement given in string <CODE>sql</CODE>. Each call to the iterator returns the
+values that correspond to the columns in the currently selected row.
+Here is an example:</P>
+<PRE>
+        db:exec[=[
+          CREATE TABLE numbers(num1,num2);
+          INSERT INTO numbers VALUES(1,11);
+          INSERT INTO numbers VALUES(2,22);
+          INSERT INTO numbers VALUES(3,33);
+        ]=]
+        for num1,num2 in db:urows('SELECT * FROM numbers') do print(num1,num2) end</PRE>
+<P>This script prints:</P>
+<PRE>
+        1       11
+        2       22
+        3       33</PRE>
+<P>
+<HR>
+<H1><A NAME="methods for prepared statements">Methods for prepared statements</A></H1>
+<P>After creating a prepared statement with <A HREF="#db:prepare"><CODE>db:prepare()</CODE></A> 
+the returned statement object should be used for all further calls in 
+connection with that statement. Statement objects support the following 
+methods.</P>
+<P>
+<H2><A NAME="stmt:bind">stmt:bind</A></H2>
+<PRE>
+        stmt:bind(n[,value])</PRE>
+<P>Binds value to statement parameter <CODE>n</CODE>. If the type of value is string 
+or number, it is bound as text or double, respectively. If <CODE>value</CODE> is a
+boolean or nil or missing, any previous binding is removed. The function
+returns <CODE>sqlite3.OK</CODE> on success or else a numerical error code (see
+<A HREF="#numerical error and result codes">Numerical error and result codes</A>).</P>
+<P>
+<H2><A NAME="stmt:bind_blob">stmt:bind_blob</A></H2>
+<PRE>
+        stmt:bind_blob(n,blob)</PRE>
+<P>Binds string <CODE>blob</CODE> (which can be a binary string) as a blob to 
+statement parameter <CODE>n</CODE>. The function returns <CODE>sqlite3.OK</CODE> on success 
+or else a numerical error code (see <A HREF="#numerical error and result codes">Numerical error and result codes</A>).</P>
+<P>
+<H2><A NAME="stmt:bind_names">stmt:bind_names</A></H2>
+<PRE>
+        stmt:bind_names(nametable)</PRE>
+<P>Binds the values in <CODE>nametable</CODE> to statement parameters. If the 
+statement parameters are named (i.e., of the form ``:AAA'' or ``$AAA'') 
+then this function looks for appropriately named fields in <CODE>nametable</CODE>; 
+if the statement parameters are
+not named, it looks for numerical fields 1 to the number of statement
+parameters. The function returns <CODE>sqlite3.OK</CODE> on success or else a
+numerical error code (see <A HREF="#numerical error and result codes">Numerical error and result codes</A>).</P>
+<P>
+<H2><A NAME="stmt:bind_parameter_count">stmt:bind_parameter_count</A></H2>
+<PRE>
+        stmt:bind_parameter_count()</PRE>
+<P>Returns the largest statement parameter index in prepared statement 
+<CODE>stmt</CODE>. When the statement parameters are of the forms ``:AAA'' or ``?'', 
+then they are assigned sequentially increasing numbers beginning with 
+one, so the value returned is the number of parameters. However if the 
+same statement parameter name is used multiple times, each occurrence 
+is given the same number, so the value returned is the number of unique 
+statement parameter names.</P>
+<P>If statement parameters of the form ``?NNN'' are used (where NNN is an 
+integer) then there might be gaps in the numbering and the value 
+returned by this interface is the index of the statement parameter with 
+the largest index value.</P>
+<P>
+<H2><A NAME="stmt:bind_parameter_name">stmt:bind_parameter_name</A></H2>
+<PRE>
+        stmt:bind_parameter_name(n)</PRE>
+<P>Returns the name of the <CODE>n</CODE>-th parameter in prepared statement <CODE>stmt</CODE>. 
+Statement parameters of the form ``:AAA'' or ``@AAA'' or ``$VVV'' have a name 
+which  is the string ``:AAA'' or ``@AAA'' or ``$VVV''. In other words, the 
+initial ``:'' or ``$'' or ``@'' is included as part of the name. Parameters 
+of the form ``?'' or ``?NNN'' have no name. The first bound parameter has 
+an index of 1.
+If the value <CODE>n</CODE> is out of range or if the <CODE>n</CODE>-th parameter is
+nameless, then nil is returned. The function returns <CODE>sqlite3.OK</CODE> on
+success or else a numerical error code (see
+<A HREF="#numerical error and result codes">Numerical error and result codes</A>)</P>
+<P>
+<H2><A NAME="stmt:bind_values">stmt:bind_values</A></H2>
+<PRE>
+        stmt:bind_values(value1,value2,...,valueN)</PRE>
+<P>Binds the given values to statement parameters. The function returns
+<CODE>sqlite3.OK</CODE> on success or else a numerical error code (see
+<A HREF="#numerical error and result codes">Numerical error and result codes</A>).</P>
+<P>
+<H2><A NAME="stmt:columns">stmt:columns</A></H2>
+<PRE>
+        stmt:columns()</PRE>
+<P>Returns the number of columns in the result set returned by statement
+stmt or 0 if the statement does not return data (for example an UPDATE).</P>
+<P>
+<H2><A NAME="stmt:finalize">stmt:finalize</A></H2>
+<PRE>
+        stmt:finalize()</PRE>
+<P>This function frees prepared statement stmt. If the statement was
+executed successfully, or not executed at all, then <CODE>sqlite3.OK</CODE> is
+returned. If execution of the statement failed then an error code is
+returned.</P>
+<P>
+<H2><A NAME="stmt:get_name">stmt:get_name</A></H2>
+<PRE>
+        stmt:get_name(n)</PRE>
+<P>Returns the name of column <CODE>n</CODE> in the result set of statement stmt. (The
+left-most column is number 0.)</P>
+<P>
+<H2><A NAME="stmt:get_named_types">stmt:get_named_types</A></H2>
+<PRE>
+        stmt:get_named_types()</PRE>
+<P>Returns a table with the names and types of all columns in the result
+set of statement stmt.</P>
+<P>
+<H2><A NAME="stmt:get_named_values">stmt:get_named_values</A></H2>
+<PRE>
+        stmt:get_named_values()</PRE>
+<P>This function returns a table with names and values of all columns in
+the current result row of a query.</P>
+<P>
+<H2><A NAME="stmt:get_names">stmt:get_names</A></H2>
+<PRE>
+        stmt:get_names()</PRE>
+<P>This function returns an array with the names of all columns in the
+result set returned by statement stmt.</P>
+<P>
+<H2><A NAME="stmt:get_type">stmt:get_type</A></H2>
+<PRE>
+        stmt:get_type(n)</PRE>
+<P>Returns the type of column <CODE>n</CODE> in the result set of statement stmt. (The
+left-most column is number 0.)</P>
+<P>
+<H2><A NAME="stmt:get_types">stmt:get_types</A></H2>
+<PRE>
+        stmt:get_types()</PRE>
+<P>This function returns an array with the types of all columns in the
+result set returned by statement stmt.</P>
+<P>
+<H2><A NAME="stmt:get_unames">stmt:get_unames</A></H2>
+<PRE>
+        stmt:get_unames()</PRE>
+<P>This function returns a list with the names of all columns in the result
+set returned by statement stmt.</P>
+<P>
+<H2><A NAME="stmt:get_utypes">stmt:get_utypes</A></H2>
+<PRE>
+        stmt:get_utypes()</PRE>
+<P>This function returns a list with the types of all columns in the result
+set returned by statement stmt.</P>
+<P>
+<H2><A NAME="stmt:get_uvalues">stmt:get_uvalues</A></H2>
+<PRE>
+        stmt:get_uvalues()</PRE>
+<P>This function returns a list with the values of all columns in the
+current result row of a query.</P>
+<P>
+<H2><A NAME="stmt:get_value">stmt:get_value</A></H2>
+<PRE>
+        stmt:get_value(n)</PRE>
+<P>Returns the value of column <CODE>n</CODE> in the result set of statement stmt. (The
+left-most column is number 0.)</P>
+<P>
+<H2><A NAME="stmt:get_values">stmt:get_values</A></H2>
+<PRE>
+        stmt:get_values()</PRE>
+<P>This function returns an array with the values of all columns in the
+result set returned by statement stmt.</P>
+<P>
+<H2><A NAME="stmt:isopen">stmt:isopen</A></H2>
+<PRE>
+        stmt:isopen()</PRE>
+<P>Returns true if stmt has not yet been finalized, false otherwise.</P>
+<P>
+<H2><A NAME="stmt:nrows">stmt:nrows</A></H2>
+<PRE>
+        stmt:nrows()</PRE>
+<P>Returns an function that iterates over the names and values of the
+result set of statement <CODE>stmt</CODE>. Each iteration returns a table with the
+names and values for the current row.
+This is the prepared statement equivalent of <A HREF="#db:nrows"><CODE>db:nrows()</CODE></A>.</P>
+<P>
+<H2><A NAME="stmt:reset">stmt:reset</A></H2>
+<PRE>
+        stmt:reset()</PRE>
+<P>This function resets SQL statement <CODE>stmt</CODE>, so that it is ready to be
+re-executed. Any statement variables that had values bound to them using
+the <CODE>stmt:bind*()</CODE> functions retain their values.</P>
+<P>
+<H2><A NAME="stmt:rows">stmt:rows</A></H2>
+<PRE>
+        stmt:rows()</PRE>
+<P>Returns an function that iterates over the values of the result set of
+statement stmt. Each iteration returns an array with the values for the
+current row.
+This is the prepared statement equivalent of <A HREF="#db:rows"><CODE>db:rows()</CODE></A>.</P>
+<P>
+<H2><A NAME="stmt:step">stmt:step</A></H2>
+<PRE>
+        stmt:step()</PRE>
+<P>This function must be called to evaluate the (next iteration of the)
+prepared statement stmt. It will return one of the following values:</P>
+<UL>
+<LI>
+<CODE>sqlite3.BUSY</CODE>: the engine was unable to acquire the locks needed. If the
+statement is a COMMIT or occurs outside of an explicit transaction, then
+you can retry the statement. If the statement is not a COMMIT and occurs
+within a explicit transaction then you should rollback the transaction
+before continuing.
+<P></P>
+<LI>
+<CODE>sqlite3.DONE</CODE>: the statement has finished executing successfully.
+<A HREF="#stmt:step"><CODE>stmt:step()</CODE></A> should not be called again on this statement 
+without first calling <A HREF="#stmt:reset"><CODE>stmt:reset()</CODE></A> to reset the virtual 
+machine back to the initial state.
+<P></P>
+<LI>
+<CODE>sqlite3.ROW</CODE>: this is returned each time a new row of data is ready for
+processing by the caller. The values may be accessed using the column
+access functions. <A HREF="#stmt:step"><CODE>stmt:step()</CODE></A> can be called again to 
+retrieve the next row of data.
+<P></P>
+<LI>
+<CODE>sqlite3.ERROR</CODE>: a run-time error (such as a constraint violation) has
+occurred. <A HREF="#stmt:step"><CODE>stmt:step()</CODE></A> should not be called again. More 
+information may be found by calling <A HREF="#db:errmsg"><CODE>db:errmsg()</CODE></A>. A more 
+specific error 
+code (can be obtained by calling <A HREF="#stmt:reset"><CODE>stmt:reset()</CODE></A>.
+<P></P>
+<LI>
+<CODE>sqlite3.MISUSE</CODE>: the function was called inappropriately, perhaps 
+because the statement has already been finalized or a previous call to
+<A HREF="#stmt:step"><CODE>stmt:step()</CODE></A> has returned <CODE>sqlite3.ERROR</CODE> or 
+<CODE>sqlite3.DONE</CODE>.
+<P></P></UL>
+<P>
+<H2><A NAME="stmt:urows">stmt:urows</A></H2>
+<PRE>
+        stmt:urows()</PRE>
+<P>Returns an function that iterates over the values of the result set of
+statement stmt. Each iteration returns the values for the current row.
+This is the prepared statement equivalent of <A HREF="#db:urows"><CODE>db:urows()</CODE></A>.</P>
+<P>
+<HR>
+<H1><A NAME="methods for callback contexts">Methods for callback contexts</A></H1>
+<P>A callback context is available as a parameter inside the callback
+functions <A HREF="#db:create_aggregate"><CODE>db:create_aggregate()</CODE></A> and 
+<A HREF="#db:create_function"><CODE>db:create_function()</CODE></A>. It can be used
+to get further information about the state of a query.</P>
+<P>
+<H2><A NAME="context:aggregate_count">context:aggregate_count</A></H2>
+<PRE>
+        context:aggregate_count()</PRE>
+<P>Returns the number of calls to the aggregate step function.</P>
+<P>
+<H2><A NAME="context:get_aggregate_data">context:get_aggregate_data</A></H2>
+<PRE>
+        context:get_aggregate_data()</PRE>
+<P>Returns the user-definable data field for callback funtions.</P>
+<P>
+<H2><A NAME="context:set_aggregate_data">context:set_aggregate_data</A></H2>
+<PRE>
+        context:set_aggregate_data(udata)</PRE>
+<P>Set the user-definable data field for callback funtions to <CODE>udata</CODE>.</P>
+<P>
+<H2><A NAME="context:result">context:result</A></H2>
+<PRE>
+        context:result(res)</PRE>
+<P>This function sets the result of a callback function to res. The type of
+the result depends on the type of res and is either a number or a string
+or nil. All other values will raise an error message.</P>
+<P>
+<H2><A NAME="context:result_null">context:result_null</A></H2>
+<PRE>
+        context:result_null()</PRE>
+<P>This function sets the result of a callback function to nil. It returns
+nothing.</P>
+<P>
+<H2><A NAME="context:result_number">context:result_number</A></H2>
+<PRE>
+        context:result_number(number)
+        context:result_double(number)</PRE>
+<P>This function sets the result of a callback function to the value
+<CODE>number</CODE>. It returns nothing.</P>
+<P>
+<H2><A NAME="context:result_int">context:result_int</A></H2>
+<PRE>
+        context:result_int(number)</PRE>
+<P>This function sets the result of a callback function to the integer
+value in <CODE>number</CODE>. It returns nothing.</P>
+<P>
+<H2><A NAME="context:result_text">context:result_text</A></H2>
+<PRE>
+        context:result_text(str)</PRE>
+<P>This function sets the result of a callback function to the string in
+<CODE>str</CODE>. It returns nothing.</P>
+<P>
+<H2><A NAME="context:result_blob">context:result_blob</A></H2>
+<PRE>
+        context:result_blob(blob)</PRE>
+<P>This function sets the result of a callback function to the binary
+string in <CODE>blob</CODE>. It returns nothing.</P>
+<P>
+<H2><A NAME="context:result_error">context:result_error</A></H2>
+<PRE>
+        context:result_error(err)</PRE>
+<P>This function sets the result of a callback function to the error value
+in <CODE>err</CODE>. It returns nothing.</P>
+<P>
+<H2><A NAME="context:user_data">context:user_data</A></H2>
+<PRE>
+        context:user_data()</PRE>
+<P>Returns the userdata parameter given in the call to install the callback
+function (see <A HREF="#db:create_aggregate"><CODE>db:create_aggregate()</CODE></A> and 
+<A HREF="#db:create_function"><CODE>db:create_function()</CODE></A> for details).</P>
+<P>
+<HR>
+<H1><A NAME="numerical error and result codes">Numerical error and result codes</A></H1>
+<P>The following constants are defined by module sqlite3:</P>
+<PRE>
+        OK: 0          ERROR: 1       INTERNAL: 2    PERM: 3        ABORT: 4
+        BUSY: 5        LOCKED: 6      NOMEM: 7       READONLY: 8    INTERRUPT: 9
+        IOERR: 10      CORRUPT: 11    NOTFOUND: 12   FULL: 13       CANTOPEN: 14
+        PROTOCOL: 15   EMPTY: 16      SCHEMA: 17     TOOBIG: 18     CONSTRAINT: 19
+        MISMATCH: 20   MISUSE: 21     NOLFS: 22      FORMAT: 24     RANGE: 25
+        NOTADB: 26     ROW: 100       DONE: 101</PRE>
+<P>For details about their exact meaning please see the <STRONG>SQLite3
+documentation</STRONG> <A HREF="http://www.sqlite.org/">http://www.sqlite.org/</A>.</P>
+<P>
+<HR>
+<H1><A NAME="version">VERSION</A></H1>
+<P>This is <CODE>lsqlite3</CODE> subversion 6, also known as ``devel-0.6''.</P>
+<P>
+<HR>
+<H1><A NAME="credits">CREDITS</A></H1>
+<P><CODE>lsqlite3</CODE> was developed by Tiago Dionizio and Doug Currie with 
+contributions from Thomas Lauer and Michael Roth.</P>
+<P>This documentation is based on the ``(very) preliminary'' documents
+for the Idle-SQLite3 database module. Thanks to Thomas Lauer for
+making it available.</P>
+<P>
+<HR>
+<H1><A NAME="license">LICENSE</A></H1>
+<PRE>
+    /************************************************************************
+    * lsqlite3                                                              *
+    * Copyright (C) 2002-2007 Tiago Dionizio, Doug Currie                   *
+    * All rights reserved.                                                  *
+    * Author    : Tiago Dionizio &lt;tiago.dionizio@ist.utl.pt&gt;                *
+    * Author    : Doug Currie &lt;doug.currie@alum.mit.edu&gt;                    *
+    * Library   : lsqlite3 - a SQLite 3 database binding for Lua 5          *
+    *                                                                       *
+    * Permission is hereby granted, free of charge, to any person obtaining *
+    * a copy of this software and associated documentation files (the       *
+    * &quot;Software&quot;), to deal in the Software without restriction, including   *
+    * without limitation the rights to use, copy, modify, merge, publish,   *
+    * distribute, sublicense, and/or sell copies of the Software, and to    *
+    * permit persons to whom the Software is furnished to do so, subject to *
+    * the following conditions:                                             *
+    *                                                                       *
+    * The above copyright notice and this permission notice shall be        *
+    * included in all copies or substantial portions of the Software.       *
+    *                                                                       *
+    * THE SOFTWARE IS PROVIDED &quot;AS IS&quot;, WITHOUT WARRANTY OF ANY KIND,       *
+    * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    *
+    * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*
+    * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  *
+    * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  *
+    * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     *
+    * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                *
+    ************************************************************************/</PRE>
+
+</BODY>
+
+</HTML>

3rdparty/lsqlite3/doc/lsqlite3.pod

@@ -0,0 +1,866 @@
+=pod
+
+=head1 NAME
+
+B<LuaSQLite 3> - a Lua 5.1 wrapper for the SQLite3 library
+
+=head1 OVERVIEW
+
+B<LuaSQLite 3> is a thin wrapper around the public domain SQLite3
+database engine. 
+
+The C<lsqlite3> module supports the creation and manipulation of 
+SQLite3 databases. After a C<require('lsqlite3')> the exported 
+functions are called with prefix C<sqlite3>. However, most sqlite3 
+functions are called via an object-oriented interface to either 
+database or SQL statement objects; see below for details.
+
+This documentation does not attempt to describe how SQLite3 itself
+works, it just describes the Lua binding and the available functions.
+For more information about the SQL features supported by SQLite3 and
+details about the syntax of SQL statements and queries, please see the
+B<SQLite3 documentation> L<http://www.sqlite.org/>. Using some of the
+advanced features (how to use callbacks, for instance) will require 
+some familiarity with the SQLite3 API.
+
+=head1 DOWNLOAD
+
+B<LuaSQLite 3> source code can be downloaded from its 
+LuaForge (L<http://luaforge.net/projects/luasqlite/>) page.
+
+You will also need to build or obtain an SQLite3 loadable library 
+(DLL or .so). See L<http://www.sqlite.org/> for obtaining SQLite3 
+source code or downloading a binary SQLite3 library.
+
+=head1 INSTALLATION
+
+A I<Makefile> is provided; it assumes an SQLite3 library is already
+installed. 
+
+=head1 EXAMPLES
+
+The distribution contains an I<examples> directory. The unit tests
+also show some example use.
+
+=head1 VERIFICATION TESTS
+
+The distribution contains some units tests using Michael Roth's
+C<lunit> (which is also included). Some of the tests were also derived 
+from Michael's B<lua-sqlite3> module, and more unit tests added by 
+Doug Currie.
+
+The distribution also contains some functional tests by Tiago.
+
+This version of C<lsqlite3> was tested with SQLite 3.4.2.
+
+=head1 REFERENCE
+
+=head1 SQLite3 functions
+
+=head2 sqlite3.complete
+
+	sqlite3.complete(sql)
+
+Returns true if the string C<sql> comprises one or more complete SQL
+statements and false otherwise.
+
+=head2 sqlite3.open
+
+	sqlite3.open(filename)
+
+Opens (or creates if it does not exist) an SQLite database with name
+C<filename> and returns its handle as userdata (the returned object 
+should be used for all further method calls in connection with this 
+specific database, see L</Database methods>). Example:
+
+	myDB=sqlite3.open('MyDatabase.sqlite3')  -- open
+	-- do some database calls...
+	myDB:close()  -- close
+
+In case of an error, the function returns nil, an error code and an
+error message.
+
+=head2 sqlite3.open_memory
+
+	sqlite3.open_memory()
+
+Opens an SQLite database B<in memory> and returns its handle as
+userdata. In case of an error, the function returns nil, an error code
+and an error message. (In-memory databases are volatile as they are
+never stored on disk.)
+
+=head2 sqlite3.temp_directory
+
+	sqlite3.temp_directory([temp])
+
+Sets or queries the directory used by SQLite for temporary files. If
+string C<temp> is a directory name or nil, the temporary directory is 
+set accordingly and the old value is returned. If C<temp> is missing, 
+the function simply returns the current temporary directory.
+
+=head2 sqlite3.version
+
+	sqlite3.version()
+
+Returns a string with SQLite version information, in the form 'x.y[.z]'.
+
+=head1 Database methods
+
+After opening a database with L<C<sqlite3.open()>|/sqlite3.open> or 
+L<C<sqlite3.open_memory()>|/sqlite3.open_memory>
+the returned database object should be used for all further method calls
+in connection with that database. An open database object supports the
+following methods.
+
+=head2 db:busy_handler
+
+	db:busy_handler([func[,udata]])
+
+Sets or removes a busy handler for a database. C<func> is either a Lua
+function that implements the busy handler or nil to remove a previously
+set handler. This function returns nothing.
+
+The handler function is called with two parameters: C<udata> and the 
+number of (re-)tries for a pending transaction. It should return nil, 
+false or 0 if the transaction is to be aborted. All other values will 
+result in another attempt to perform the transaction. (See the SQLite
+documentation for important hints about writing busy handlers.)
+
+=head2 db:busy_timeout
+
+	db:busy_timeout(t)
+
+Sets a busy handler that waits for C<t> milliseconds if a transaction 
+cannot proceed. Calling this function will remove any busy handler set 
+by L<C<db:busy_handler()>|/db:busy_handler>; calling it with an argument 
+less than or equal to 0 will turn off all busy handlers.
+
+=head2 db:changes
+
+	db:changes()
+
+This function returns the number of database rows that were changed (or
+inserted or deleted) by the most recent SQL statement. Only changes that
+are directly specified by INSERT, UPDATE, or DELETE statements are
+counted. Auxiliary changes caused by triggers are not counted. Use
+L<C<db:total_changes()>|/db:total_changes> to find the total number of 
+changes.
+
+=head2 db:close
+
+	db:close()
+
+Closes a database. All SQL statements prepared using 
+L<C<db:prepare()>|/db:prepare> should
+have been finalized before this function is called. The function returns
+C<sqlite3.OK> on success or else a numerical error code (see the list of
+L</Numerical error and result codes>).
+
+=head2 db:close_vm
+
+	db:close_vm(temponly)
+
+Finalizes all statements that have not been explicitly finalized. If
+C<temponly> is true, only internal, temporary statements are finalized.
+This function returns nothing.
+
+=head2 db:create_aggregate
+
+	db:create_aggregate(name,nargs,step,final)
+
+This function creates an aggregate callback function. Aggregates perform
+an operation over all rows in a query. C<name> is a string with the name 
+of the aggregate function as given in an SQL statement; C<nargs> is the 
+number of arguments this call will provide. C<step> is the actual Lua 
+function that gets called once for every row; it should accept a function 
+context (see L</Methods for callback contexts>) plus the same number of
+parameters as given in C<nargs>. C<final> is a function that is called 
+once after all rows have been processed; it receives one argument, the
+function context.
+
+The function context can be used inside the two callback functions to
+communicate with SQLite3. Here is a simple example:
+
+	db:exec[=[
+	  CREATE TABLE numbers(num1,num2);
+	  INSERT INTO numbers VALUES(1,11);
+	  INSERT INTO numbers VALUES(2,22);
+	  INSERT INTO numbers VALUES(3,33);
+	]=]
+	local num_sum=0
+	local function oneRow(context,num)  -- add one column in all rows
+	  num_sum=num_sum+num
+	end
+	local function afterLast(context)   -- return sum after last row has been processed
+	  context:result_number(num_sum)
+	  num_sum=0
+	end
+	db:create_aggregate("do_the_sums",1,oneRow,afterLast)
+	for sum in db:urows('SELECT do_the_sums(num1) FROM numbers') do print("Sum of col 1:",sum) end
+	for sum in db:urows('SELECT do_the_sums(num2) FROM numbers') do print("Sum of col 2:",sum) end
+
+This prints:
+
+	Sum of col 1:   6
+	Sum of col 2:   66
+
+=head2 db:create_collation
+
+	db:create_collation(name,func)
+
+This creates a collation callback. A collation callback is used to
+establish a collation order, mostly for string comparisons and sorting
+purposes. C<name> is a string with the name of the collation to be created;
+C<func> is a function that accepts two string arguments, compares them 
+and returns 0 if both strings are identical, -1 if the first argument is
+lower in the collation order than the second and 1 if the first argument
+is higher in the collation order than the second. A simple example:
+
+	local function collate(s1,s2)
+	  s1=s1:lower()
+	  s2=s2:lower()
+	  if s1==s2 then return 0
+	  elseif s1<s2 then return -1
+	  else return 1 end
+	end
+	db:exec[=[
+	  CREATE TABLE test(id INTEGER PRIMARY KEY,content COLLATE CINSENS);
+	  INSERT INTO test VALUES(NULL,'hello world');
+	  INSERT INTO test VALUES(NULL,'Buenos dias');
+	  INSERT INTO test VALUES(NULL,'HELLO WORLD');
+	]=]
+	db:create_collation('CINSENS',collate)
+	for row in db:nrows('SELECT * FROM test') do print(row.id,row.content) end
+
+=head2 db:create_function
+
+	db:create_function(name,nargs,func)
+
+This function creates a callback function. Callback function are called
+by SQLite3 once for every row in a query. C<name> is a string with the 
+name of the callback function as given in an SQL statement; C<nargs> is 
+the number of arguments this call will provide. C<func> is the actual Lua
+function that gets called once for every row; it should accept a
+function context (see L</Methods for callback contexts>) plus the same
+number of parameters as given in nargs. Here is an example:
+
+	db:exec'CREATE TABLE test(col1,col2,col3)'
+	db:exec'INSERT INTO test VALUES(1,2,4)'
+	db:exec'INSERT INTO test VALUES(2,4,9)'
+	db:exec'INSERT INTO test VALUES(3,6,16)'
+	db:create_function('sum_cols',3,function(ctx,a,b,c)
+	  ctx:result_number(a+b+c)
+	end))
+	for col1,col2,col3,sum in db:urows('SELECT *,sum_cols(col1,col2,col3) FROM test') do
+	  util.printf('%2i+%2i+%2i=%2i\n',col1,col2,col3,sum)
+	end
+
+=head2 db:errcode
+
+	db:errcode()
+	db:error_code()
+
+Returns the numerical result code (or extended result code) for the most
+recent failed call associated with database db. See
+L</Numerical error and result codes> for details.
+
+=head2 db:errmsg
+
+	db:errmsg()
+	db:error_message()
+
+Returns a string that contains an error message for the most recent
+failed call associated with database db.
+
+=head2 db:exec
+
+	db:exec(sql[,func[,udata]])
+	db:execute(sql[,func[,udata]])
+
+Compiles and executes the SQL statement(s) given in string C<sql>. The
+statements are simply executed one after the other and not stored. The
+function returns C<sqlite3.OK> on success or else a numerical error code
+(see L</Numerical error and result codes>).
+
+If one or more of the SQL statements are queries, then the callback
+function specified in C<func> is invoked once for each row of the query
+result (if C<func> is nil, no callback is invoked). The callback receives
+four arguments: C<udata> (the third parameter of the C<db:exec()> call), 
+the number of columns in the row, a table with the column values and 
+another table with the column names. The callback function should return 
+0. If the callback returns a non-zero value then the query is aborted, 
+all subsequent SQL statements are skipped and C<db:exec()> returns
+C<sqlite3.ABORT>. Here is a simple example:
+
+	sql=[=[
+	  CREATE TABLE numbers(num1,num2,str);
+	  INSERT INTO numbers VALUES(1,11,"ABC");
+	  INSERT INTO numbers VALUES(2,22,"DEF");
+	  INSERT INTO numbers VALUES(3,33,"UVW");
+	  INSERT INTO numbers VALUES(4,44,"XYZ");
+	  SELECT * FROM numbers;
+	]=]
+	function showrow(udata,cols,values,names)
+	  assert(udata=='test_udata')
+	  print('exec:')
+	  for i=1,cols do print('',names[i],values[i]) end
+	  return 0
+	end
+	db:exec(sql,showrow,'test_udata')
+
+=head2 db:interrupt
+
+	db:interrupt()
+
+This function causes any pending database operation to abort and return
+at the next opportunity. This function returns nothing.
+
+=head2 db:isopen
+
+	db:isopen()
+
+Returns true if database db is open, false otherwise.
+
+=head2 db:last_insert_rowid
+
+	db:last_insert_rowid()
+
+This function returns the rowid of the most recent INSERT into the
+database. If no inserts have ever occurred, 0 is returned. (Each row in
+an SQLite table has a unique 64-bit signed integer key called the
+'rowid'. This id is always available as an undeclared column named
+ROWID, OID, or _ROWID_. If the table has a column of type INTEGER
+PRIMARY KEY then that column is another alias for the rowid.)
+
+If an INSERT occurs within a trigger, then the rowid of the inserted row
+is returned as long as the trigger is running. Once the trigger
+terminates, the value returned reverts to the last value inserted before
+the trigger fired.
+
+=head2 db:nrows
+
+	db:nrows(sql)
+
+Creates an iterator that returns the successive rows selected by the SQL
+statement given in string C<sql>. Each call to the iterator returns a 
+table in which the named fields correspond to the columns in the database.
+Here is an example:
+
+	db:exec[=[
+	  CREATE TABLE numbers(num1,num2);
+	  INSERT INTO numbers VALUES(1,11);
+	  INSERT INTO numbers VALUES(2,22);
+	  INSERT INTO numbers VALUES(3,33);
+	]=]
+	for a in db:nrows('SELECT * FROM numbers') do table.print(a) end
+
+This script prints:
+
+	num2: 11
+	num1: 1
+	num2: 22
+	num1: 2
+	num2: 33
+	num1: 3
+
+=head2 db:prepare
+
+	db:prepare(sql)
+
+This function compiles the SQL statement in string C<sql> into an internal
+representation and returns this as userdata. The returned object should
+be used for all further method calls in connection with this specific
+SQL statement (see L</Methods for prepared statements>).
+
+=head2 db:progress_handler
+
+	db:progress_handler(n,func,udata)
+
+This function installs a callback function C<func> that is invoked
+periodically during long-running calls to L<C<db:exec()>|/db:exec>
+or L<C<stmt:step()>|/stmt:step>. The
+progress callback is invoked once for every C<n> internal operations, 
+where C<n> is the first argument to this function. C<udata> is passed to 
+the progress callback function each time it is invoked. If a call to
+C<db:exec()> or C<stmt:step()> results in fewer than C<n> operations 
+being executed, then the progress callback is never invoked. Only a 
+single progress callback function may be registered for each opened 
+database and a call to this function will overwrite any previously set 
+callback function. To remove the progress callback altogether, pass nil 
+as the second argument.
+
+If the progress callback returns a result other than 0, then the current
+query is immediately terminated, any database changes are rolled back
+and the containing C<db:exec()> or C<stmt:step()> call returns
+C<sqlite3.INTERRUPT>. This feature can be used to cancel long-running
+queries.
+
+=head2 db:rows
+
+	db:rows(sql)
+
+Creates an iterator that returns the successive rows selected by the SQL
+statement given in string C<sql>. Each call to the iterator returns a table
+in which the numerical indices 1 to n correspond to the selected columns
+1 to n in the database. Here is an example:
+
+	db:exec[=[
+	  CREATE TABLE numbers(num1,num2);
+	  INSERT INTO numbers VALUES(1,11);
+	  INSERT INTO numbers VALUES(2,22);
+	  INSERT INTO numbers VALUES(3,33);
+	]=]
+	for a in db:rows('SELECT * FROM numbers') do table.print(a) end
+
+This script prints:
+
+	1: 1
+	2: 11
+	1: 2
+	2: 22
+	1: 3
+	2: 33
+
+=head2 db:total_changes
+
+	db:total_changes()
+
+This function returns the number of database rows that have been
+modified by INSERT, UPDATE or DELETE statements since the database was
+opened. This includes UPDATE, INSERT and DELETE statements executed as
+part of trigger programs. All changes are counted as soon as the
+statement that produces them is completed by calling either 
+L<C<stmt:reset()>|/stmt:reset> or L<C<stmt:finalize()>|/stmt:finalize>.
+
+=head2 db:trace
+
+	db:trace(func,udata)
+
+This function installs a trace callback handler. C<func> is a Lua
+function that is called by SQLite3 just before the evaluation of an SQL
+statement. This callback receives two arguments: the first is the 
+C<udata> argument used when the callback was installed; the second is a 
+string with the SQL statement about to be executed.
+
+=head2 db:urows
+
+	db:urows(sql)
+
+Creates an iterator that returns the successive rows selected by the SQL
+statement given in string C<sql>. Each call to the iterator returns the
+values that correspond to the columns in the currently selected row.
+Here is an example:
+
+	db:exec[=[
+	  CREATE TABLE numbers(num1,num2);
+	  INSERT INTO numbers VALUES(1,11);
+	  INSERT INTO numbers VALUES(2,22);
+	  INSERT INTO numbers VALUES(3,33);
+	]=]
+	for num1,num2 in db:urows('SELECT * FROM numbers') do print(num1,num2) end
+
+This script prints:
+
+	1       11
+	2       22
+	3       33
+
+=head1 Methods for prepared statements
+
+After creating a prepared statement with L<C<db:prepare()>|/db:prepare> 
+the returned statement object should be used for all further calls in 
+connection with that statement. Statement objects support the following 
+methods.
+
+=head2 stmt:bind
+
+	stmt:bind(n[,value])
+
+Binds value to statement parameter C<n>. If the type of value is string 
+or number, it is bound as text or double, respectively. If C<value> is a
+boolean or nil or missing, any previous binding is removed. The function
+returns C<sqlite3.OK> on success or else a numerical error code (see
+L</Numerical error and result codes>).
+
+=head2 stmt:bind_blob
+
+	stmt:bind_blob(n,blob)
+
+Binds string C<blob> (which can be a binary string) as a blob to 
+statement parameter C<n>. The function returns C<sqlite3.OK> on success 
+or else a numerical error code (see L</Numerical error and result codes>).
+
+=head2 stmt:bind_names
+
+	stmt:bind_names(nametable)
+
+Binds the values in C<nametable> to statement parameters. If the 
+statement parameters are named (i.e., of the form ":AAA" or "$AAA") 
+then this function looks for appropriately named fields in C<nametable>; 
+if the statement parameters are
+not named, it looks for numerical fields 1 to the number of statement
+parameters. The function returns C<sqlite3.OK> on success or else a
+numerical error code (see L</Numerical error and result codes>).
+
+=head2 stmt:bind_parameter_count
+
+	stmt:bind_parameter_count()
+
+Returns the largest statement parameter index in prepared statement 
+C<stmt>. When the statement parameters are of the forms ":AAA" or "?", 
+then they are assigned sequentially increasing numbers beginning with 
+one, so the value returned is the number of parameters. However if the 
+same statement parameter name is used multiple times, each occurrence 
+is given the same number, so the value returned is the number of unique 
+statement parameter names.
+
+If statement parameters of the form "?NNN" are used (where NNN is an 
+integer) then there might be gaps in the numbering and the value 
+returned by this interface is the index of the statement parameter with 
+the largest index value.
+
+=head2 stmt:bind_parameter_name
+
+	stmt:bind_parameter_name(n)
+
+Returns the name of the C<n>-th parameter in prepared statement C<stmt>. 
+Statement parameters of the form ":AAA" or "@AAA" or "$VVV" have a name 
+which  is the string ":AAA" or "@AAA" or "$VVV". In other words, the 
+initial ":" or "$" or "@" is included as part of the name. Parameters 
+of the form "?" or "?NNN" have no name. The first bound parameter has 
+an index of 1.
+If the value C<n> is out of range or if the C<n>-th parameter is
+nameless, then nil is returned. The function returns C<sqlite3.OK> on
+success or else a numerical error code (see
+L</Numerical error and result codes>)
+
+=head2 stmt:bind_values
+
+	stmt:bind_values(value1,value2,...,valueN)
+
+Binds the given values to statement parameters. The function returns
+C<sqlite3.OK> on success or else a numerical error code (see
+L</Numerical error and result codes>).
+
+=head2 stmt:columns
+
+	stmt:columns()
+
+Returns the number of columns in the result set returned by statement
+stmt or 0 if the statement does not return data (for example an UPDATE).
+
+=head2 stmt:finalize
+
+	stmt:finalize()
+
+This function frees prepared statement stmt. If the statement was
+executed successfully, or not executed at all, then C<sqlite3.OK> is
+returned. If execution of the statement failed then an error code is
+returned.
+
+=head2 stmt:get_name
+
+	stmt:get_name(n)
+
+Returns the name of column C<n> in the result set of statement stmt. (The
+left-most column is number 0.)
+
+=head2 stmt:get_named_types
+
+	stmt:get_named_types()
+
+Returns a table with the names and types of all columns in the result
+set of statement stmt.
+
+=head2 stmt:get_named_values
+
+	stmt:get_named_values()
+
+This function returns a table with names and values of all columns in
+the current result row of a query.
+
+=head2 stmt:get_names
+
+	stmt:get_names()
+
+This function returns an array with the names of all columns in the
+result set returned by statement stmt.
+
+=head2 stmt:get_type
+
+	stmt:get_type(n)
+
+Returns the type of column C<n> in the result set of statement stmt. (The
+left-most column is number 0.)
+
+=head2 stmt:get_types
+
+	stmt:get_types()
+
+This function returns an array with the types of all columns in the
+result set returned by statement stmt.
+
+=head2 stmt:get_unames
+
+	stmt:get_unames()
+
+This function returns a list with the names of all columns in the result
+set returned by statement stmt.
+
+=head2 stmt:get_utypes
+
+	stmt:get_utypes()
+
+This function returns a list with the types of all columns in the result
+set returned by statement stmt.
+
+=head2 stmt:get_uvalues
+
+	stmt:get_uvalues()
+
+This function returns a list with the values of all columns in the
+current result row of a query.
+
+=head2 stmt:get_value
+
+	stmt:get_value(n)
+
+Returns the value of column C<n> in the result set of statement stmt. (The
+left-most column is number 0.)
+
+=head2 stmt:get_values
+
+	stmt:get_values()
+
+This function returns an array with the values of all columns in the
+result set returned by statement stmt.
+
+=head2 stmt:isopen
+
+	stmt:isopen()
+
+Returns true if stmt has not yet been finalized, false otherwise.
+
+=head2 stmt:nrows
+
+	stmt:nrows()
+
+Returns an function that iterates over the names and values of the
+result set of statement C<stmt>. Each iteration returns a table with the
+names and values for the current row.
+This is the prepared statement equivalent of L<C<db:nrows()>|/db:nrows>.
+
+=head2 stmt:reset
+
+	stmt:reset()
+
+This function resets SQL statement C<stmt>, so that it is ready to be
+re-executed. Any statement variables that had values bound to them using
+the C<stmt:bind*()> functions retain their values.
+
+=head2 stmt:rows
+
+	stmt:rows()
+
+Returns an function that iterates over the values of the result set of
+statement stmt. Each iteration returns an array with the values for the
+current row.
+This is the prepared statement equivalent of L<C<db:rows()>|/db:rows>.
+
+=head2 stmt:step
+
+	stmt:step()
+
+This function must be called to evaluate the (next iteration of the)
+prepared statement stmt. It will return one of the following values:
+
+=over 4
+
+=item *
+
+C<sqlite3.BUSY>: the engine was unable to acquire the locks needed. If the
+statement is a COMMIT or occurs outside of an explicit transaction, then
+you can retry the statement. If the statement is not a COMMIT and occurs
+within a explicit transaction then you should rollback the transaction
+before continuing.
+
+=item *
+
+C<sqlite3.DONE>: the statement has finished executing successfully.
+L<C<stmt:step()>|/stmt:step> should not be called again on this statement 
+without first calling L<C<stmt:reset()>|/stmt:reset> to reset the virtual 
+machine back to the initial state.
+
+=item *
+
+C<sqlite3.ROW>: this is returned each time a new row of data is ready for
+processing by the caller. The values may be accessed using the column
+access functions. L<C<stmt:step()>|/stmt:step> can be called again to 
+retrieve the next row of data.
+
+=item *
+
+C<sqlite3.ERROR>: a run-time error (such as a constraint violation) has
+occurred. L<C<stmt:step()>|/stmt:step> should not be called again. More 
+information may be found by calling L<C<db:errmsg()>|/db:errmsg>. A more 
+specific error 
+code (can be obtained by calling L<C<stmt:reset()>|/stmt:reset>.
+
+=item *
+
+C<sqlite3.MISUSE>: the function was called inappropriately, perhaps 
+because the statement has already been finalized or a previous call to
+L<C<stmt:step()>|/stmt:step> has returned C<sqlite3.ERROR> or 
+C<sqlite3.DONE>.
+
+=back
+
+=head2 stmt:urows
+
+	stmt:urows()
+
+Returns an function that iterates over the values of the result set of
+statement stmt. Each iteration returns the values for the current row.
+This is the prepared statement equivalent of L<C<db:urows()>|/db:urows>.
+
+=head1 Methods for callback contexts
+
+A callback context is available as a parameter inside the callback
+functions L<C<db:create_aggregate()>|/db:create_aggregate> and 
+L<C<db:create_function()>|/db:create_function>. It can be used
+to get further information about the state of a query.
+
+=head2 context:aggregate_count
+
+	context:aggregate_count()
+
+Returns the number of calls to the aggregate step function.
+
+=head2 context:get_aggregate_data
+
+	context:get_aggregate_data()
+
+Returns the user-definable data field for callback funtions.
+
+=head2 context:set_aggregate_data
+
+	context:set_aggregate_data(udata)
+
+Set the user-definable data field for callback funtions to C<udata>.
+
+=head2 context:result
+
+	context:result(res)
+
+This function sets the result of a callback function to res. The type of
+the result depends on the type of res and is either a number or a string
+or nil. All other values will raise an error message.
+
+=head2 context:result_null
+
+	context:result_null()
+
+This function sets the result of a callback function to nil. It returns
+nothing.
+
+=head2 context:result_number
+
+	context:result_number(number)
+	context:result_double(number)
+
+This function sets the result of a callback function to the value
+C<number>. It returns nothing.
+
+=head2 context:result_int
+
+	context:result_int(number)
+
+This function sets the result of a callback function to the integer
+value in C<number>. It returns nothing.
+
+=head2 context:result_text
+
+	context:result_text(str)
+
+This function sets the result of a callback function to the string in
+C<str>. It returns nothing.
+
+=head2 context:result_blob
+
+	context:result_blob(blob)
+
+This function sets the result of a callback function to the binary
+string in C<blob>. It returns nothing.
+
+=head2 context:result_error
+
+	context:result_error(err)
+
+This function sets the result of a callback function to the error value
+in C<err>. It returns nothing.
+
+=head2 context:user_data
+
+	context:user_data()
+
+Returns the userdata parameter given in the call to install the callback
+function (see L<C<db:create_aggregate()>|/db:create_aggregate> and 
+L<C<db:create_function()>|/db:create_function> for details).
+
+=head1 Numerical error and result codes
+
+The following constants are defined by module sqlite3:
+
+	OK: 0          ERROR: 1       INTERNAL: 2    PERM: 3        ABORT: 4
+	BUSY: 5        LOCKED: 6      NOMEM: 7       READONLY: 8    INTERRUPT: 9
+	IOERR: 10      CORRUPT: 11    NOTFOUND: 12   FULL: 13       CANTOPEN: 14
+	PROTOCOL: 15   EMPTY: 16      SCHEMA: 17     TOOBIG: 18     CONSTRAINT: 19
+	MISMATCH: 20   MISUSE: 21     NOLFS: 22      FORMAT: 24     RANGE: 25
+	NOTADB: 26     ROW: 100       DONE: 101
+
+For details about their exact meaning please see the B<SQLite3
+documentation> L<http://www.sqlite.org/>.
+
+=head1 VERSION
+
+This is C<lsqlite3> subversion 6, also known as "devel-0.6".
+
+=head1 CREDITS
+
+C<lsqlite3> was developed by Tiago Dionizio and Doug Currie with 
+contributions from Thomas Lauer and Michael Roth.
+
+This documentation is based on the "(very) preliminary" documents
+for the Idle-SQLite3 database module. Thanks to Thomas Lauer for
+making it available.
+
+=head1 LICENSE
+
+    /************************************************************************
+    * lsqlite3                                                              *
+    * Copyright (C) 2002-2007 Tiago Dionizio, Doug Currie                   *
+    * All rights reserved.                                                  *
+    * Author    : Tiago Dionizio <tiago.dionizio@ist.utl.pt>                *
+    * Author    : Doug Currie <doug.currie@alum.mit.edu>                    *
+    * Library   : lsqlite3 - a SQLite 3 database binding for Lua 5          *
+    *                                                                       *
+    * Permission is hereby granted, free of charge, to any person obtaining *
+    * a copy of this software and associated documentation files (the       *
+    * "Software"), to deal in the Software without restriction, including   *
+    * without limitation the rights to use, copy, modify, merge, publish,   *
+    * distribute, sublicense, and/or sell copies of the Software, and to    *
+    * permit persons to whom the Software is furnished to do so, subject to *
+    * the following conditions:                                             *
+    *                                                                       *
+    * The above copyright notice and this permission notice shall be        *
+    * included in all copies or substantial portions of the Software.       *
+    *                                                                       *
+    * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       *
+    * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    *
+    * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*
+    * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  *
+    * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  *
+    * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     *
+    * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                *
+    ************************************************************************/
+

3rdparty/lsqlite3/doc/pod2html.pl

@@ -0,0 +1,7 @@
+#!perl
+
+use Pod::Html;
+
+pod2html @ARGV;
+
+__END__

3rdparty/lsqlite3/examples/aggregate.lua

@@ -0,0 +1,35 @@
+
+require("lsqlite3")
+
+local db = sqlite3.open_memory()
+
+assert( db:exec "CREATE TABLE test (col1, col2)" )
+assert( db:exec "INSERT INTO test VALUES (1, 2)" )
+assert( db:exec "INSERT INTO test VALUES (2, 4)" )
+assert( db:exec "INSERT INTO test VALUES (3, 6)" )
+assert( db:exec "INSERT INTO test VALUES (4, 8)" )
+assert( db:exec "INSERT INTO test VALUES (5, 10)" )
+
+do
+
+  local square_error_sum = 0
+
+  local function step(ctx, a, b)
+    local error        = a - b
+    local square_error = error * error
+    square_error_sum   = square_error_sum + square_error
+  end
+
+  local function final(ctx)
+    ctx:result_number( square_error_sum / ctx:aggregate_count() )
+  end
+
+  assert( db:create_aggregate("my_stats", 2, step, final) )
+
+end
+
+--for a,b in db:urows("SELECT col1, col2 FROM test")
+--do print("a b: ", a, b) end
+
+for my_stats in db:urows("SELECT my_stats(col1, col2) FROM test")
+do print("my_stats:", my_stats) end

3rdparty/lsqlite3/examples/function.lua

@@ -0,0 +1,21 @@
+
+require("lsqlite3")
+
+
+local db = sqlite3.open_memory()
+
+assert( db:exec "CREATE TABLE test (col1, col2)" )
+assert( db:exec "INSERT INTO test VALUES (1, 2)" )
+assert( db:exec "INSERT INTO test VALUES (2, 4)" )
+assert( db:exec "INSERT INTO test VALUES (3, 6)" )
+assert( db:exec "INSERT INTO test VALUES (4, 8)" )
+assert( db:exec "INSERT INTO test VALUES (5, 10)" )
+
+assert( db:create_function("my_sum", 2, function(ctx, a, b)
+  ctx:result_number( a + b )
+end))
+
+
+for col1, col2, sum in db:urows("SELECT *, my_sum(col1, col2) FROM test") do
+  print(col1, col2, sum)
+end

3rdparty/lsqlite3/examples/order.lua

@@ -0,0 +1,122 @@
+
+require("lsqlite3")
+
+local db = assert( sqlite3:open_memory() )
+
+assert( db:exec[[
+
+  CREATE TABLE customer (
+    id		INTEGER PRIMARY KEY, 
+    name	VARCHAR(40)
+  );
+
+  CREATE TABLE invoice (
+    id		INTEGER PRIMARY KEY,
+    customer	INTEGER NOT NULL,
+    title	VARCHAR(80) NOT NULL,
+    article1	VARCHAR(40) NOT NULL,
+    price1	REAL NOT NULL,
+    article2	VARCHAR(40),
+    price2	REAL
+  );
+
+  CREATE TABLE invoice_overflow (
+    id		INTEGER PRIMARY KEY,
+    invoice	INTEGER NOT NULL,
+    article	VARCHAR(40) NOT NULL,
+    price	REAL NOT NULL
+  );
+
+  INSERT INTO customer VALUES(
+    1, "Michael" );
+
+  INSERT INTO invoice VALUES(
+    1, 1, "Computer parts", "harddisc", 89.90, "floppy", 9.99 );
+
+  INSERT INTO customer VALUES(
+    2, "John" );
+
+  INSERT INTO invoice VALUES(
+    2, 2, "Somme food", "apples", 2.79, "pears", 5.99 );
+
+  INSERT INTO invoice_overflow VALUES(
+    NULL, 2, "grapes", 6.34 );
+
+  INSERT INTO invoice_overflow VALUES(
+    NULL, 2, "strawberries", 4.12 );
+
+  INSERT INTO invoice_overflow VALUES(
+    NULL, 2, "tomatoes", 6.17 );
+
+  INSERT INTO invoice VALUES(
+    3, 2, "A new car", "Cybercar XL-1000", 65000.00, NULL, NULL );
+
+]] )
+
+
+local function customer_name(id)
+  local stmt = db:prepare("SELECT name FROM customer WHERE id = ?")
+  stmt:bind_values(id)
+  stmt:step()
+  local r = stmt:get_uvalues()
+  stmt:finalize()
+  return r
+end
+
+
+local function all_invoices()
+  return db:nrows("SELECT id, customer, title FROM invoice")
+end
+
+
+local function all_articles(invoice)
+
+  local function iterator()
+    local stmt, row
+
+    -- Get the articles that are contained in the invoice table itself.
+    stmt = db:prepare("SELECT article1, price1, article2, price2 FROM invoice WHERE id = ?")
+    stmt:bind_values(invoice)
+    stmt:step()
+    row = stmt:get_named_values()
+
+    -- Every Invoice has at least one article.
+    coroutine.yield(row.article1, row.price1)
+
+    -- Maybe the Invoice has a second article?
+    if row.article2 then
+
+      -- Yes, there is a second article, so return it.
+      coroutine.yield(row.article2, row.price2)
+
+      -- When there was an second article, maybe there are even
+      -- more articles in the overflow table? We will see...
+
+      stmt = db:prepare("SELECT article, price FROM invoice_overflow WHERE invoice = ? ORDER BY id")
+      stmt:bind_values(invoice)
+      
+      for row in stmt:nrows() do
+        coroutine.yield(row.article, row.price)
+      end
+    end
+  end
+
+  return coroutine.wrap(iterator)
+end
+
+
+for invoice in all_invoices() do
+  local id    = invoice.id
+  local name  = customer_name(invoice.customer)
+  local title = invoice.title
+
+  print()
+  print("Invoice #"..id..", "..name..": '"..title.."'")
+  print("----------------------------------------")
+
+  for article, price in all_articles(id) do
+    print( string.format("%20s  %8.2f", article, price) )
+  end
+
+  print()
+end

3rdparty/lsqlite3/examples/simple.lua

@@ -0,0 +1,16 @@
+
+require("lsqlite3")
+
+local db = sqlite3.open_memory()
+
+db:exec[[
+  CREATE TABLE test (id INTEGER PRIMARY KEY, content);
+
+  INSERT INTO test VALUES (NULL, 'Hello World');
+  INSERT INTO test VALUES (NULL, 'Hello Lua');
+  INSERT INTO test VALUES (NULL, 'Hello Sqlite3')
+]]
+
+for row in db:nrows("SELECT * FROM test") do
+  print(row.id, row.content)
+end

3rdparty/lsqlite3/examples/smart.lua

@@ -0,0 +1,22 @@
+
+require("lsqlite3")
+
+local db = sqlite3.open_memory()
+
+db:exec[[ CREATE TABLE test (id INTEGER PRIMARY KEY, content) ]]
+
+local stmt = db:prepare[[ INSERT INTO test VALUES (:key, :value) ]]
+
+stmt:bind_names{  key = 1,  value = "Hello World"    }
+stmt:step()
+stmt:reset()
+stmt:bind_names{  key = 2,  value = "Hello Lua"      }
+stmt:step()
+stmt:reset()
+stmt:bind_names{  key = 3,  value = "Hello Sqlite3"  }
+stmt:step()
+stmt:finalize()
+
+for row in db:nrows("SELECT * FROM test") do
+  print(row.id, row.content)
+end

3rdparty/lsqlite3/examples/statement.lua

@@ -0,0 +1,39 @@
+
+require("lsqlite3")
+
+local db = sqlite3.open_memory()
+
+db:exec[[
+  CREATE TABLE test (
+    id        INTEGER PRIMARY KEY,
+    content   VARCHAR
+  );
+]]
+
+local insert_stmt = assert( db:prepare("INSERT INTO test VALUES (NULL, ?)") )
+
+local function insert(data)
+  insert_stmt:bind_values(data)
+  insert_stmt:step()
+  insert_stmt:reset()
+end
+
+local select_stmt = assert( db:prepare("SELECT * FROM test") )
+
+local function select()
+  for row in select_stmt:nrows() do
+    print(row.id, row.content)
+  end
+end
+
+insert("Hello World")
+print("First:")
+select()
+
+insert("Hello Lua")
+print("Second:")
+select()
+
+insert("Hello Sqlite3")
+print("Third:")
+select()

3rdparty/lsqlite3/examples/tracing.lua

@@ -0,0 +1,20 @@
+
+require("lsqlite3")
+
+local db = sqlite3.open_memory()
+
+db:trace( function(ud, sql)
+  print("Sqlite Trace:", sql)
+end )
+
+db:exec[[
+  CREATE TABLE test ( id INTEGER PRIMARY KEY, content VARCHAR );
+
+  INSERT INTO test VALUES (NULL, 'Hello World');
+  INSERT INTO test VALUES (NULL, 'Hello Lua');
+  INSERT INTO test VALUES (NULL, 'Hello Sqlite3');
+]]
+
+for row in db:rows("SELECT * FROM test") do
+  -- NOP
+end

3rdparty/lsqlite3/lsqlite3.def

@@ -0,0 +1,2 @@
+EXPORTS
+luaopen_lsqlite3

3rdparty/lsqlite3/lunit.lua

@@ -0,0 +1,693 @@
+
+--[[--------------------------------------------------------------------------
+
+    This file is part of lunit 0.4pre (alpha).
+
+    For Details about lunit look at: http://www.nessie.de/mroth/lunit/
+
+    Author: Michael Roth <mroth@nessie.de>
+
+    Copyright (c) 2004 Michael Roth <mroth@nessie.de>
+
+    Permission is hereby granted, free of charge, to any person 
+    obtaining a copy of this software and associated documentation
+    files (the "Software"), to deal in the Software without restriction,
+    including without limitation the rights to use, copy, modify, merge,
+    publish, distribute, sublicense, and/or sell copies of the Software,
+    and to permit persons to whom the Software is furnished to do so,
+    subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be 
+    included in all copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+    IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+    CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+    TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+    SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+--]]--------------------------------------------------------------------------
+
+
+
+
+-----------------------
+-- Intialize package --
+-----------------------
+
+local P = { }
+lunit = P
+
+-- Import
+local type = type
+local print = print
+local ipairs = ipairs
+local pairs = pairs
+local string = string
+local table = table
+local pcall = pcall
+local xpcall = xpcall
+local traceback = debug.traceback
+local error = error
+local setmetatable = setmetatable
+local rawset = rawset
+local orig_assert = assert
+local getfenv = getfenv
+local setfenv = setfenv
+local tostring = tostring
+
+
+-- Start package scope
+setfenv(1, P)
+
+
+
+
+--------------------------------
+-- Private data and functions --
+--------------------------------
+
+local run_testcase
+local do_assert, check_msg
+local stats = { }
+local testcases = { }
+local stats_inc, tc_mt
+
+
+
+
+--------------------------
+-- Type check functions --
+--------------------------
+
+function is_nil(x)
+  return type(x) == "nil"
+end
+
+function is_boolean(x)
+  return type(x) == "boolean"
+end
+
+function is_number(x)
+  return type(x) == "number"
+end
+
+function is_string(x)
+  return type(x) == "string"
+end
+
+function is_table(x)
+  return type(x) == "table"
+end
+
+function is_function(x)
+  return type(x) == "function"
+end
+
+function is_thread(x)
+  return type(x) == "thread"
+end
+
+function is_userdata(x)
+  return type(x) == "userdata"
+end
+
+
+
+
+----------------------
+-- Assert functions --
+----------------------
+
+function assert(assertion, msg)
+  stats_inc("assertions")
+  check_msg("assert", msg)
+  do_assert(not not assertion, "assertion failed (was: "..tostring(assertion)..")", msg)		-- (convert assertion to bool)
+  return assertion
+end
+
+
+function assert_fail(msg)
+  stats_inc("assertions")
+  check_msg("assert_fail", msg)
+  do_assert(false, "failure", msg)
+end
+
+
+function assert_true(actual, msg)
+  stats_inc("assertions")
+  check_msg("assert_true", msg)
+  do_assert(is_boolean(actual), "true expected but was a "..type(actual), msg)
+  do_assert(actual == true, "true expected but was false", msg)
+  return actual
+end
+
+
+function assert_false(actual, msg)
+  stats_inc("assertions")
+  check_msg("assert_false", msg)
+  do_assert(is_boolean(actual), "false expected but was a "..type(actual), msg)
+  do_assert(actual == false, "false expected but was true", msg)
+  return actual
+end
+
+
+function assert_equal(expected, actual, msg)
+  stats_inc("assertions")
+  check_msg("assert_equal", msg)
+  do_assert(expected == actual, "expected '"..tostring(expected).."' but was '"..tostring(actual).."'", msg)
+  return actual
+end
+
+
+function assert_not_equal(unexpected, actual, msg)
+  stats_inc("assertions")
+  check_msg("assert_not_equal", msg)
+  do_assert(unexpected ~= actual, "'"..tostring(expected).."' not expected but was one", msg)
+  return actual
+end
+
+
+function assert_match(pattern, actual, msg)
+  stats_inc("assertions")
+  check_msg("assert_match", msg)
+  do_assert(is_string(pattern), "assert_match expects the pattern as a string")
+  do_assert(is_string(actual), "expected a string to match pattern '"..pattern.."' but was a '"..type(actual).."'", msg)
+  do_assert(not not string.find(actual, pattern), "expected '"..actual.."' to match pattern '"..pattern.."' but doesn't", msg)
+  return actual
+end
+
+
+function assert_not_match(pattern, actual, msg)
+  stats_inc("assertions")
+  check_msg("assert_not_match", msg)
+  do_assert(is_string(actual), "expected a string to not match pattern '"..pattern.."' but was a '"..type(actual).."'", msg)
+  do_assert(string.find(actual, pattern) == nil, "expected '"..actual.."' to not match pattern '"..pattern.."' but it does", msg)
+  return actual
+end
+
+
+function assert_nil(actual, msg)
+  stats_inc("assertions")
+  check_msg("assert_nil", msg)
+  do_assert(is_nil(actual), "nil expected but was a "..type(actual), msg)
+  return actual
+end
+
+
+function assert_not_nil(actual, msg)
+  stats_inc("assertions")
+  check_msg("assert_not_nil", msg)
+  do_assert(not is_nil(actual), "nil not expected but was one", msg)
+  return actual
+end
+
+
+function assert_boolean(actual, msg)
+  stats_inc("assertions")
+  check_msg("assert_boolean", msg)
+  do_assert(is_boolean(actual), "boolean expected but was a "..type(actual), msg)
+  return actual
+end
+
+
+function assert_not_boolean(actual, msg)
+  stats_inc("assertions")
+  check_msg("assert_not_boolean", msg)
+  do_assert(not is_boolean(actual), "boolean not expected but was one", msg)
+  return actual
+end
+
+
+function assert_number(actual, msg)
+  stats_inc("assertions")
+  check_msg("assert_number", msg)
+  do_assert(is_number(actual), "number expected but was a "..type(actual), msg)
+  return actual
+end
+
+
+function assert_not_number(actual, msg)
+  stats_inc("assertions")
+  check_msg("assert_not_number", msg)
+  do_assert(not is_number(actual), "number not expected but was one", msg)
+  return actual
+end
+
+
+function assert_string(actual, msg)
+  stats_inc("assertions")
+  check_msg("assert_string", msg)
+  do_assert(is_string(actual), "string expected but was a "..type(actual), msg)
+  return actual
+end
+
+
+function assert_not_string(actual, msg)
+  stats_inc("assertions")
+  check_msg("assert_not_string", msg)
+  do_assert(not is_string(actual), "string not expected but was one", msg)
+  return actual
+end
+
+
+function assert_table(actual, msg)
+  stats_inc("assertions")
+  check_msg("assert_table", msg)
+  do_assert(is_table(actual), "table expected but was a "..type(actual), msg)
+  return actual
+end
+
+
+function assert_not_table(actual, msg)
+  stats_inc("assertions")
+  check_msg("assert_not_table", msg)
+  do_assert(not is_table(actual), "table not expected but was one", msg)
+  return actual
+end
+
+
+function assert_function(actual, msg)
+  stats_inc("assertions")
+  check_msg("assert_function", msg)
+  do_assert(is_function(actual), "function expected but was a "..type(actual), msg)
+  return actual
+end
+
+
+function assert_not_function(actual, msg)
+  stats_inc("assertions")
+  check_msg("assert_not_function", msg)
+  do_assert(not is_function(actual), "function not expected but was one", msg)
+  return actual
+end
+
+
+function assert_thread(actual, msg)
+  stats_inc("assertions")
+  check_msg("assert_thread", msg)
+  do_assert(is_thread(actual), "thread expected but was a "..type(actual), msg)
+  return actual
+end
+
+
+function assert_not_thread(actual, msg)
+  stats_inc("assertions")
+  check_msg("assert_not_thread", msg)
+  do_assert(not is_thread(actual), "thread not expected but was one", msg)
+  return actual
+end
+
+
+function assert_userdata(actual, msg)
+  stats_inc("assertions")
+  check_msg("assert_userdata", msg)
+  do_assert(is_userdata(actual), "userdata expected but was a "..type(actual), msg)
+  return actual
+end
+
+
+function assert_not_userdata(actual, msg)
+  stats_inc("assertions")
+  check_msg("assert_not_userdata", msg)
+  do_assert(not is_userdata(actual), "userdata not expected but was one", msg)
+  return actual
+end
+
+
+function assert_error(msg, func)
+  stats_inc("assertions")
+  if is_nil(func) then func, msg = msg, nil end
+  check_msg("assert_error", msg)
+  do_assert(is_function(func), "assert_error expects a function as the last argument but it was a "..type(func))
+  local ok, errmsg = pcall(func)
+  do_assert(ok == false, "error expected but no error occurred", msg)
+end
+
+
+function assert_pass(msg, func)
+  stats_inc("assertions")
+  if is_nil(func) then func, msg = msg, nil end
+  check_msg("assert_pass", msg)
+  do_assert(is_function(func), "assert_pass expects a function as the last argument but it was a "..type(func))
+  local ok, errmsg = pcall(func)
+  if not ok then do_assert(ok == true, "no error expected but error was: "..errmsg, msg) end
+end
+
+
+
+
+-----------------------------------------------------------
+-- Assert implementation that assumes it was called from --
+-- lunit code which was called directly from user code.  --
+-----------------------------------------------------------
+
+function do_assert(assertion, base_msg, user_msg)
+  orig_assert(is_boolean(assertion))
+  orig_assert(is_string(base_msg))
+  orig_assert(is_string(user_msg) or is_nil(user_msg))
+  if not assertion then
+    if user_msg then
+      error(base_msg..": "..user_msg, 3)
+    else
+      error(base_msg.."!", 3)
+    end
+  end
+end
+
+-------------------------------------------
+-- Checks the msg argument in assert_xxx --
+-------------------------------------------
+
+function check_msg(name, msg)
+  orig_assert(is_string(name))
+  if not (is_nil(msg) or is_string(msg)) then
+    error("lunit."..name.."() expects the optional message as a string but it was a "..type(msg).."!" ,3)
+  end
+end
+
+
+
+
+-------------------------------------
+-- Creates a new TestCase 'Object' --
+-------------------------------------
+
+function TestCase(name)
+  do_assert(is_string(name), "lunit.TestCase() needs a string as an argument")
+  local tc = {
+    __lunit_name = name;
+    __lunit_setup = nil;
+    __lunit_tests = { };
+    __lunit_teardown = nil;
+  }
+  setmetatable(tc, tc_mt)
+  table.insert(testcases, tc)
+  return tc
+end
+
+tc_mt = {
+  __newindex = function(tc, key, value)
+    rawset(tc, key, value)
+    if is_string(key) and is_function(value) then
+      local name = string.lower(key)
+      if string.find(name, "^test") or string.find(name, "test$") then
+        table.insert(tc.__lunit_tests, key)
+      elseif name == "setup" then
+        tc.__lunit_setup = value
+      elseif name == "teardown" then
+        tc.__lunit_teardown = value
+      end
+    end
+  end
+}
+
+
+
+-----------------------------------------
+-- Wrap Functions in a TestCase object --
+-----------------------------------------
+
+function wrap(name, ...)
+  if is_function(name) then
+    table.insert({...}, 1, name)
+    name = "Anonymous Testcase"
+  end
+  
+  local tc = TestCase(name)
+  for index, test in ipairs({...}) do
+    tc["Test #"..index] = test
+  end
+  return tc
+end
+
+
+
+
+
+
+----------------------------------
+-- Runs the complete Test Suite --
+----------------------------------
+
+function run()
+  
+  ---------------------------
+  -- Initialize statistics --
+  ---------------------------
+  
+  stats.testcases = 0	-- Total number of Test Cases
+  stats.tests = 0	-- Total number of all Tests in all Test Cases
+  stats.run = 0		-- Number of Tests run
+  stats.notrun = 0	-- Number of Tests not run
+  stats.failed = 0	-- Number of Tests failed
+  stats.warnings = 0	-- Number of Warnings (teardown)
+  stats.errors = 0	-- Number of Errors (setup)
+  stats.passed = 0	-- Number of Test passed
+  stats.assertions = 0	-- Number of all assertions made in all Test in all Test Cases
+  
+  --------------------------------
+  -- Count Test Cases and Tests --
+  --------------------------------
+  
+  stats.testcases = table.getn(testcases)
+  
+  for _, tc in ipairs(testcases) do
+    stats_inc("tests" , table.getn(tc.__lunit_tests))
+  end
+  
+  ------------------
+  -- Print Header --
+  ------------------
+  
+  print()
+  print("#### Test Suite with "..stats.tests.." Tests in "..stats.testcases.." Test Cases loaded.")
+  
+  ------------------------
+  -- Run all Test Cases --
+  ------------------------
+  
+  for _, tc in ipairs(testcases) do
+    run_testcase(tc)
+  end
+  
+  ------------------
+  -- Print Footer --
+  ------------------
+  
+  print()
+  print("#### Test Suite finished.")
+  
+  local msg_assertions = stats.assertions.." Assertions checked. "
+  local msg_passed     = stats.passed == stats.tests and "All Tests passed" or  stats.passed.." Tests passed"
+  local msg_failed     = stats.failed > 0 and ", "..stats.failed.." failed" or ""
+  local msg_run	       = stats.notrun > 0 and ", "..stats.notrun.." not run" or ""
+  local msg_warn       = stats.warnings > 0 and ", "..stats.warnings.." warnings" or ""
+  
+  print()
+  print(msg_assertions..msg_passed..msg_failed..msg_run..msg_warn.."!")
+  
+  -----------------
+  -- Return code --
+  -----------------
+  
+  if stats.passed == stats.tests then
+    return 0
+  else
+    return 1
+  end
+end
+
+
+
+
+-----------------------------
+-- Runs a single Test Case --
+-----------------------------
+
+function run_testcase(tc)
+  
+  orig_assert(is_table(tc))
+  orig_assert(is_table(tc.__lunit_tests))
+  orig_assert(is_string(tc.__lunit_name))
+  orig_assert(is_nil(tc.__lunit_setup) or is_function(tc.__lunit_setup))
+  orig_assert(is_nil(tc.__lunit_teardown) or is_function(tc.__lunit_teardown))
+  
+  ----------------------------------
+  -- Protected call to a function --
+  ----------------------------------
+  
+  local function call(errprefix, func)
+    orig_assert(is_string(errprefix))
+    orig_assert(is_function(func))
+    local ok, errmsg = xpcall(function() func(tc) end, traceback)
+    if not ok then
+      print()
+      print(errprefix..": "..errmsg)
+    end
+    return ok
+  end
+  
+  ------------------------------------
+  -- Calls setup() on the Test Case --
+  ------------------------------------
+  
+  local function setup(testname)
+    if tc.__lunit_setup then 
+      return call("ERROR: "..testname..": setup() failed", tc.__lunit_setup)
+    else
+      return true
+    end
+  end
+  
+  ------------------------------------------
+  -- Calls a single Test on the Test Case --
+  ------------------------------------------
+  
+  local function run(testname)
+    orig_assert(is_string(testname))
+    orig_assert(is_function(tc[testname]))
+    local ok = call("FAIL: "..testname, tc[testname])
+    if not ok then
+      stats_inc("failed")
+    else
+      stats_inc("passed")
+    end
+    return ok
+  end
+  
+  ---------------------------------------
+  -- Calls teardown() on the Test Case --
+  ---------------------------------------
+  
+  local function teardown(testname)
+     if tc.__lunit_teardown then
+       if not call("WARNING: "..testname..": teardown() failed", tc.__lunit_teardown) then
+         stats_inc("warnings")
+       end
+     end
+  end
+  
+  ---------------------------------
+  -- Run all Tests on a TestCase --
+  ---------------------------------
+  
+  print()
+  print("#### Running '"..tc.__lunit_name.."' ("..table.getn(tc.__lunit_tests).." Tests)...")
+  
+  for _, testname in ipairs(tc.__lunit_tests) do
+    if setup(testname) then
+      run(testname)
+      stats_inc("run")
+      teardown(testname)
+    else
+      print("WARN: Skipping '"..testname.."'...")
+      stats_inc("notrun")
+    end
+  end
+  
+end
+
+
+
+
+---------------------
+-- Import function --
+---------------------
+
+function import(name)
+  
+  do_assert(is_string(name), "lunit.import() expects a single string as argument")
+  
+  local user_env = getfenv(2)
+  
+  --------------------------------------------------
+  -- Installs a specific function in the user env --
+  --------------------------------------------------
+  
+  local function install(funcname)
+    user_env[funcname] = P[funcname]
+  end
+  
+  
+  ----------------------------------------------------------
+  -- Install functions matching a pattern in the user env --
+  ----------------------------------------------------------
+  
+  local function install_pattern(pattern)
+    for funcname, _ in pairs(P) do
+      if string.find(funcname, pattern) then
+        install(funcname)
+      end
+    end
+  end
+  
+  ------------------------------------------------------------
+  -- Installs assert() and all assert_xxx() in the user env --
+  ------------------------------------------------------------
+  
+  local function install_asserts()
+    install_pattern("^assert.*")
+  end
+  
+  -------------------------------------------
+  -- Installs all is_xxx() in the user env --
+  -------------------------------------------
+  
+  local function install_tests()
+    install_pattern("^is_.+")
+  end
+  
+  if name == "asserts" or name == "assertions" then
+    install_asserts()
+  elseif name == "tests" or name == "checks" then
+    install_tests()
+  elseif name == "all" then
+    install_asserts()
+    install_tests()
+    install("TestCase")
+  elseif string.find(name, "^assert.*") and P[name] then
+    install(name)
+  elseif string.find(name, "^is_.+") and P[name] then
+    install(name)
+  elseif name == "TestCase" then
+    install("TestCase")
+  else
+    error("luniit.import(): invalid function '"..name.."' to import", 2)
+  end
+end
+
+
+
+
+--------------------------------------------------
+-- Installs a private environment on the caller --
+--------------------------------------------------
+
+function setprivfenv()
+  local new_env = { }
+  local new_env_mt = { __index = getfenv(2) }
+  setmetatable(new_env, new_env_mt)
+  setfenv(2, new_env)
+end
+
+
+
+
+--------------------------------------------------
+-- Increments a counter in the statistics table --  
+--------------------------------------------------
+
+function stats_inc(varname, value)
+  orig_assert(is_table(stats))
+  orig_assert(is_string(varname))
+  orig_assert(is_nil(value) or is_number(value))
+  if not stats[varname] then return end
+  stats[varname] = stats[varname] + (value or 1)
+end
+
+
+
+

3rdparty/lsqlite3/test.lua

@@ -0,0 +1,153 @@
+require("lsqlite3")
+
+local width = 78
+local function line(pref, suff)
+    pref = pref or ''
+    suff = suff or ''
+    local len = width - 2 - string.len(pref) - string.len(suff)
+    print(pref .. string.rep('-', len) .. suff)
+end
+
+local db, vm
+local assert_, assert = assert, function (test)
+    if (not test) then
+        error(db:errmsg(), 2)
+    end
+end
+
+line(sqlite3.version())
+
+os.remove('test.db')
+db = sqlite3.open('test.db')
+
+line(nil, 'db:exec')
+db:exec('CREATE TABLE t(a, b)')
+
+line(nil, 'prepare')
+vm = db:prepare('insert into t values(?, :bork)')
+assert(vm, db:errmsg())
+assert(vm:bind_parameter_count() == 2)
+assert(vm:bind_values(2, 4) == sqlite3.OK)
+assert(vm:step() == sqlite3.DONE)
+assert(vm:reset() == sqlite3.OK)
+assert(vm:bind_names{ 'pork', bork = 'nono' } == sqlite3.OK)
+assert(vm:step() == sqlite3.DONE)
+assert(vm:reset() == sqlite3.OK)
+assert(vm:bind_names{ bork = 'sisi' } == sqlite3.OK)
+assert(vm:step() == sqlite3.DONE)
+assert(vm:reset() == sqlite3.OK)
+assert(vm:bind_names{ 1 } == sqlite3.OK)
+assert(vm:step() == sqlite3.DONE)
+assert(vm:finalize() == sqlite3.OK)
+
+line("select * from t", 'db:exec')
+
+assert(db:exec('select * from t', function (ud, ncols, values, names)
+    --table.setn(values, 2)
+    print(unpack(values))
+    return sqlite3.OK
+end) == sqlite3.OK)
+
+line("select * from t", 'db:prepare')
+
+vm = db:prepare('select * from t')
+assert(vm, db:errmsg())
+print(vm:get_unames())
+while (vm:step() == sqlite3.ROW) do
+    print(vm:get_uvalues())
+end
+assert(vm:finalize() == sqlite3.OK)
+
+
+
+line('udf', 'scalar')
+
+local function do_query(sql)
+    local r
+    local vm = db:prepare(sql)
+    assert(vm, db:errmsg())
+    print('====================================')
+    print(vm:get_unames())
+    print('------------------------------------')
+    r = vm:step()
+    while (r == sqlite3.ROW) do
+        print(vm:get_uvalues())
+        r = vm:step()
+    end
+    assert(r == sqlite3.DONE)
+    assert(vm:finalize() == sqlite3.OK)
+    print('====================================')
+end
+
+local function udf1_scalar(ctx, v)
+    local ud = ctx:user_data()
+    ud.r = (ud.r or '') .. tostring(v)
+    ctx:result_text(ud.r)
+end
+
+db:create_function('udf1', 1, udf1_scalar, { })
+do_query('select udf1(a) from t')
+
+
+line('udf', 'aggregate')
+
+local function udf2_aggregate(ctx, ...)
+    local ud = ctx:get_aggregate_data()
+    if (not ud) then
+        ud = {}
+        ctx:set_aggregate_data(ud)
+    end
+    ud.r = (ud.r or 0) + 2
+end
+
+local function udf2_aggregate_finalize(ctx, v)
+    local ud = ctx:get_aggregate_data()
+    ctx:result_number(ud and ud.r or 0)
+end
+
+db:create_aggregate('udf2', 1, udf2_aggregate, udf2_aggregate_finalize, { })
+do_query('select udf2(a) from t')
+
+if (true) then
+    line(nil, '100 insert exec')
+    db:exec('delete from t')
+    local t = os.time()
+    for i = 1, 100 do
+        db:exec('insert into t values('..i..', '..(i * 2 * -1^i)..')')
+    end
+    print('elapsed: '..(os.time() - t))
+    do_query('select count(*) from t')
+
+    line(nil, '100000 insert exec T')
+    db:exec('delete from t')
+    local t = os.time()
+    db:exec('begin')
+    for i = 1, 100000 do
+        db:exec('insert into t values('..i..', '..(i * 2 * -1^i)..')')
+    end
+    db:exec('commit')
+    print('elapsed: '..(os.time() - t))
+    do_query('select count(*) from t')
+
+    line(nil, '100000 insert prepare/bind T')
+    db:exec('delete from t')
+    local t = os.time()
+    local vm = db:prepare('insert into t values(?, ?)')
+    db:exec('begin')
+    for i = 1, 100000 do
+        vm:bind_values(i, i * 2 * -1^i)
+        vm:step()
+        vm:reset()
+    end
+    vm:finalize()
+    db:exec('commit')
+    print('elapsed: '..(os.time() - t))
+    do_query('select count(*) from t')
+
+end
+
+line(nil, "db:close")
+
+assert(db:close() == sqlite3.OK)
+
+line(sqlite3.version())

3rdparty/lsqlite3/tests-sqlite3.lua

@@ -0,0 +1,587 @@
+
+--[[--------------------------------------------------------------------------
+
+    Author: Michael Roth <mroth@nessie.de>
+
+    Copyright (c) 2004, 2005 Michael Roth <mroth@nessie.de>
+
+    Permission is hereby granted, free of charge, to any person 
+    obtaining a copy of this software and associated documentation
+    files (the "Software"), to deal in the Software without restriction,
+    including without limitation the rights to use, copy, modify, merge,
+    publish, distribute, sublicense, and/or sell copies of the Software,
+    and to permit persons to whom the Software is furnished to do so,
+    subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be 
+    included in all copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+    IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+    CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+    TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+    SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+--]]--------------------------------------------------------------------------
+
+
+require "lsqlite3"
+
+require "lunit"
+
+lunit.setprivfenv()
+lunit.import "assertions"
+lunit.import "checks"
+
+
+
+
+
+
+-------------------------------
+-- Basic open and close test --
+-------------------------------
+
+lunit.wrap("open_memory", function()
+  local db = assert_userdata( sqlite3.open_memory() )
+  assert( db:close() )
+end)
+
+lunit.wrap("open", function()
+  local filename = "/tmp/__lua-sqlite3-20040906135849." .. os.time()
+  local db = assert_userdata( sqlite3.open(filename) )
+  assert( db:close() )
+  os.remove(filename)
+end)
+
+
+
+-------------------------------------
+-- Presence of db member functions --
+-------------------------------------
+
+local db_funcs = lunit.TestCase("Database Member Functions")
+
+function db_funcs:setup()
+  self.db = assert( sqlite3.open_memory() )
+end
+
+function db_funcs:teardown()
+  assert( self.db:close() )
+end
+
+function db_funcs:test()
+  local db = self.db
+  assert_function( db.close )
+  assert_function( db.exec )
+--e  assert_function( db.irows )
+  assert_function( db.rows )
+--e  assert_function( db.cols )
+--e  assert_function( db.first_irow )
+--e  assert_function( db.first_row )
+--e  assert_function( db.first_cols )
+  assert_function( db.prepare )
+  assert_function( db.interrupt )
+  assert_function( db.last_insert_rowid )
+  assert_function( db.changes )
+  assert_function( db.total_changes )
+end
+
+
+
+---------------------------------------
+-- Presence of stmt member functions --
+---------------------------------------
+
+local stmt_funcs = lunit.TestCase("Statement Member Functions")
+
+function stmt_funcs:setup()
+  self.db = assert( sqlite3.open_memory() )
+  self.stmt = assert( self.db:prepare("CREATE TABLE test (id, content)") )
+end
+
+function stmt_funcs:teardown()
+--e-  assert( self.stmt:close() )
+  assert( self.stmt:finalize() ) --e+
+  assert( self.db:close() )
+end
+
+function stmt_funcs:test()
+  local stmt = self.stmt
+--e  assert_function( stmt.close )
+  assert_function( stmt.reset )
+--e  assert_function( stmt.exec )
+  assert_function( stmt.bind )
+--e  assert_function( stmt.irows )
+--e  assert_function( stmt.rows )
+--e  assert_function( stmt.cols )
+--e  assert_function( stmt.first_irow )
+--e  assert_function( stmt.first_row )
+--e  assert_function( stmt.first_cols )
+--e  assert_function( stmt.column_names )
+--e  assert_function( stmt.column_decltypes )
+--e  assert_function( stmt.column_count )
+--e +
+  assert_function( stmt.isopen )
+  assert_function( stmt.step )
+  assert_function( stmt.reset )
+  assert_function( stmt.finalize )
+  assert_function( stmt.columns )
+  assert_function( stmt.bind )
+  assert_function( stmt.bind_values )
+  assert_function( stmt.bind_names )
+  assert_function( stmt.bind_blob )
+  assert_function( stmt.bind_parameter_count )
+  assert_function( stmt.bind_parameter_name )
+  assert_function( stmt.get_value )
+  assert_function( stmt.get_values )
+  assert_function( stmt.get_name )
+  assert_function( stmt.get_names )
+  assert_function( stmt.get_type )
+  assert_function( stmt.get_types )
+  assert_function( stmt.get_uvalues )
+  assert_function( stmt.get_unames )
+  assert_function( stmt.get_utypes )
+  assert_function( stmt.get_named_values )
+  assert_function( stmt.get_named_types )
+  assert_function( stmt.idata )
+  assert_function( stmt.inames )
+  assert_function( stmt.itypes )
+  assert_function( stmt.data )
+  assert_function( stmt.type )
+--e +
+end
+
+
+
+------------------
+-- Tests basics --
+------------------
+
+local basics = lunit.TestCase("Basics")
+
+function basics:setup()
+  self.db = assert_userdata( sqlite3.open_memory() )
+end
+
+function basics:teardown()
+  assert_number( self.db:close() )
+end
+
+function basics:create_table()
+  assert_number( self.db:exec("CREATE TABLE test (id, name)") )
+end
+
+function basics:drop_table()
+  assert_number( self.db:exec("DROP TABLE test") )
+end
+
+function basics:insert(id, name)
+  assert_number( self.db:exec("INSERT INTO test VALUES ("..id..", '"..name.."')") )
+end
+
+function basics:update(id, name)
+  assert_number( self.db:exec("UPDATE test SET name = '"..name.."' WHERE id = "..id) )
+end
+
+function basics:test_create_drop()
+  self:create_table()
+  self:drop_table()
+end
+
+function basics:test_multi_create_drop()
+  self:create_table()
+  self:drop_table()
+  self:create_table()
+  self:drop_table()
+end
+
+function basics:test_insert()
+  self:create_table()
+  self:insert(1, "Hello World")
+  self:insert(2, "Hello Lua")
+  self:insert(3, "Hello sqlite3")
+end
+
+function basics:test_update()
+  self:create_table()
+  self:insert(1, "Hello Home")
+  self:insert(2, "Hello Lua")
+  self:update(1, "Hello World")
+end
+
+
+---------------------------------
+-- Statement Column Info Tests --
+---------------------------------
+
+lunit.wrap("Column Info Test", function()
+  local db = assert_userdata( sqlite3.open_memory() )
+  assert_number( db:exec("CREATE TABLE test (id INTEGER, name TEXT)") )
+  local stmt = assert_userdata( db:prepare("SELECT * FROM test") )
+  
+  assert_equal(2, stmt:columns(), "Wrong number of columns." )
+  
+  local names = assert_table( stmt:get_names() )
+  assert_equal(2, #(names), "Wrong number of names.")
+  assert_equal("id", names[1] )
+  assert_equal("name", names[2] )
+  
+  local types = assert_table( stmt:get_types() )
+  assert_equal(2, #(types), "Wrong number of declaration types.")
+  assert_equal("INTEGER", types[1] )
+  assert_equal("TEXT", types[2] )
+  
+  assert_equal( sqlite3.OK, stmt:finalize() )
+  assert_equal( sqlite3.OK, db:close() )
+end)
+
+
+
+---------------------
+-- Statement Tests --
+---------------------
+
+st = lunit.TestCase("Statement Tests")
+
+function st:setup()
+  self.db = assert( sqlite3.open_memory() )
+  assert_equal( sqlite3.OK, self.db:exec("CREATE TABLE test (id, name)") )
+  assert_equal( sqlite3.OK, self.db:exec("INSERT INTO test VALUES (1, 'Hello World')") )
+  assert_equal( sqlite3.OK, self.db:exec("INSERT INTO test VALUES (2, 'Hello Lua')") )
+  assert_equal( sqlite3.OK, self.db:exec("INSERT INTO test VALUES (3, 'Hello sqlite3')") )
+end
+
+function st:teardown()
+  assert_equal( sqlite3.OK, self.db:close() )
+end
+
+function st:check_content(expected)
+  local stmt = assert( self.db:prepare("SELECT * FROM test ORDER BY id") )
+  local i = 0
+  for row in stmt:rows() do
+    i = i + 1
+    assert( i <= #(expected), "Too many rows." )
+    assert_equal(2, #(row), "Two result column expected.")
+    assert_equal(i, row[1], "Wrong 'id'.")
+    assert_equal(expected[i], row[2], "Wrong 'name'.")
+  end
+  assert_equal( #(expected), i, "Too few rows." )
+  assert_number( stmt:finalize() )
+end
+
+function st:test_setup()
+  assert_pass(function() self:check_content{ "Hello World", "Hello Lua", "Hello sqlite3" } end)
+  assert_error(function() self:check_content{ "Hello World", "Hello Lua" } end)
+  assert_error(function() self:check_content{ "Hello World", "Hello Lua", "Hello sqlite3", "To much" } end)
+  assert_error(function() self:check_content{ "Hello World", "Hello Lua", "Wrong" } end)
+  assert_error(function() self:check_content{ "Hello World", "Wrong", "Hello sqlite3" } end)
+  assert_error(function() self:check_content{ "Wrong", "Hello Lua", "Hello sqlite3" } end)
+end
+
+function st:test_questionmark_args()
+  local stmt = assert_userdata( self.db:prepare("INSERT INTO test VALUES (?, ?)")  )
+  assert_number( stmt:bind_values(0, "Test") )
+  assert_error(function() stmt:bind_values("To few") end)
+  assert_error(function() stmt:bind_values(0, "Test", "To many") end)
+end
+
+function st:test_questionmark()
+  local stmt = assert_userdata( self.db:prepare("INSERT INTO test VALUES (?, ?)")  )
+  assert_number( stmt:bind_values(4, "Good morning") )
+  assert_number( stmt:step() )
+  assert_number( stmt:reset() )
+  self:check_content{ "Hello World", "Hello Lua", "Hello sqlite3", "Good morning" }
+  assert_number( stmt:bind_values(5, "Foo Bar") )
+  assert_number( stmt:step() )
+  assert_number( stmt:reset() )
+  self:check_content{ "Hello World", "Hello Lua", "Hello sqlite3", "Good morning", "Foo Bar" }
+  assert_number( stmt:finalize() )
+end
+
+--[===[
+function st:test_questionmark_multi()
+  local stmt = assert_userdata( self.db:prepare([[
+    INSERT INTO test VALUES (?, ?); INSERT INTO test VALUES (?, ?) ]]))
+  assert( stmt:bind_values(5, "Foo Bar", 4, "Good morning") )
+  assert_number( stmt:step() )
+  assert_number( stmt:reset() )
+  self:check_content{ "Hello World", "Hello Lua", "Hello sqlite3", "Good morning", "Foo Bar" }
+  assert_number( stmt:finalize() )
+end
+]===]
+
+function st:test_identifiers()
+  local stmt = assert_userdata( self.db:prepare("INSERT INTO test VALUES (:id, :name)")  )
+  assert_number( stmt:bind_values(4, "Good morning") )
+  assert_number( stmt:step() )
+  assert_number( stmt:reset() )
+  self:check_content{ "Hello World", "Hello Lua", "Hello sqlite3", "Good morning" }
+  assert_number( stmt:bind_values(5, "Foo Bar") )
+  assert_number( stmt:step() )
+  assert_number( stmt:reset() )
+  self:check_content{ "Hello World", "Hello Lua", "Hello sqlite3", "Good morning", "Foo Bar" }
+  assert_number( stmt:finalize() )
+end
+
+--[===[
+function st:test_identifiers_multi()
+  local stmt = assert_table( self.db:prepare([[
+    INSERT INTO test VALUES (:id1, :name1); INSERT INTO test VALUES (:id2, :name2) ]]))
+  assert( stmt:bind_values(5, "Foo Bar", 4, "Good morning") )
+  assert( stmt:exec() )
+  self:check_content{ "Hello World", "Hello Lua", "Hello sqlite3", "Good morning", "Foo Bar" }
+end
+]===]
+
+function st:test_identifiers_names()
+  --local stmt = assert_userdata( self.db:prepare({"name", "id"}, "INSERT INTO test VALUES (:id, $name)")  )
+  local stmt = assert_userdata( self.db:prepare("INSERT INTO test VALUES (:id, $name)")  )
+  assert_number( stmt:bind_names({name="Good morning", id=4}) )
+  assert_number( stmt:step() )
+  assert_number( stmt:reset() )
+  self:check_content{ "Hello World", "Hello Lua", "Hello sqlite3", "Good morning" }
+  assert_number( stmt:bind_names({name="Foo Bar", id=5}) )
+  assert_number( stmt:step() )
+  assert_number( stmt:reset() )
+  self:check_content{ "Hello World", "Hello Lua", "Hello sqlite3", "Good morning", "Foo Bar" }
+  assert_number( stmt:finalize() )
+end
+
+--[===[
+function st:test_identifiers_multi_names()
+  local stmt = assert_table( self.db:prepare( {"name", "id1", "id2"},[[
+    INSERT INTO test VALUES (:id1, $name); INSERT INTO test VALUES ($id2, :name) ]]))
+  assert( stmt:bind_values("Hoho", 4, 5) )
+  assert( stmt:exec() )
+  self:check_content{ "Hello World", "Hello Lua", "Hello sqlite3", "Hoho", "Hoho" }
+end
+]===]
+
+function st:test_colon_identifiers_names()
+  local stmt = assert_userdata( self.db:prepare("INSERT INTO test VALUES (:id, :name)")  )
+  assert_number( stmt:bind_names({name="Good morning", id=4}) )
+  assert_number( stmt:step() )
+  assert_number( stmt:reset() )
+  self:check_content{ "Hello World", "Hello Lua", "Hello sqlite3", "Good morning" }
+  assert_number( stmt:bind_names({name="Foo Bar", id=5}) )
+  assert_number( stmt:step() )
+  assert_number( stmt:reset() )
+  self:check_content{ "Hello World", "Hello Lua", "Hello sqlite3", "Good morning", "Foo Bar" }
+  assert_number( stmt:finalize() )
+end
+
+--[===[
+function st:test_colon_identifiers_multi_names()
+  local stmt = assert_table( self.db:prepare( {":name", ":id1", ":id2"},[[
+    INSERT INTO test VALUES (:id1, $name); INSERT INTO test VALUES ($id2, :name) ]]))
+  assert( stmt:bind_values("Hoho", 4, 5) )
+  assert( stmt:exec() )
+  self:check_content{ "Hello World", "Hello Lua", "Hello sqlite3", "Hoho", "Hoho" }
+end
+
+
+function st:test_dollar_identifiers_names()
+  local stmt = assert_table( self.db:prepare({"$name", "$id"}, "INSERT INTO test VALUES (:id, $name)")  )
+  assert_table( stmt:bind_values("Good morning", 4) )
+  assert_table( stmt:exec() )
+  self:check_content{ "Hello World", "Hello Lua", "Hello sqlite3", "Good morning" }
+  assert_table( stmt:bind_values("Foo Bar", 5) )
+  assert_table( stmt:exec() )
+  self:check_content{ "Hello World", "Hello Lua", "Hello sqlite3", "Good morning", "Foo Bar" }
+end
+
+function st:test_dollar_identifiers_multi_names()
+  local stmt = assert_table( self.db:prepare( {"$name", "$id1", "$id2"},[[
+    INSERT INTO test VALUES (:id1, $name); INSERT INTO test VALUES ($id2, :name) ]]))
+  assert( stmt:bind_values("Hoho", 4, 5) )
+  assert( stmt:exec() )
+  self:check_content{ "Hello World", "Hello Lua", "Hello sqlite3", "Hoho", "Hoho" }
+end
+]===]
+
+function st:test_bind_by_names()
+  local stmt = assert_userdata( self.db:prepare("INSERT INTO test VALUES (:id, :name)")  )
+  local args = { }
+  args.id = 5
+  args.name = "Hello girls"
+  assert( stmt:bind_names(args) )
+  assert_number( stmt:step() )
+  assert_number( stmt:reset() )
+  args.id = 4
+  args.name = "Hello boys"
+  assert( stmt:bind_names(args) )
+  assert_number( stmt:step() )
+  assert_number( stmt:reset() )
+  self:check_content{ "Hello World", "Hello Lua", "Hello sqlite3",  "Hello boys", "Hello girls" }
+  assert_number( stmt:finalize() )
+end
+
+
+
+--------------------------------
+-- Tests binding of arguments --
+--------------------------------
+
+b = lunit.TestCase("Binding Tests")
+
+function b:setup()
+  self.db = assert( sqlite3.open_memory() )
+  assert_number( self.db:exec("CREATE TABLE test (id, name, u, v, w, x, y, z)") )
+end
+
+function b:teardown()
+  assert_number( self.db:close() )
+end
+
+function b:test_auto_parameter_names()
+  local stmt = assert_userdata( self.db:prepare("INSERT INTO test VALUES(:a, $b, :a2, :b2, $a, :b, $a3, $b3)") )
+  local parameters = assert_number( stmt:bind_parameter_count() )
+  assert_equal( 8, parameters )
+  assert_equal( ":a", stmt:bind_parameter_name(1) )
+  assert_equal( "$b", stmt:bind_parameter_name(2) )
+  assert_equal( ":a2", stmt:bind_parameter_name(3) )
+  assert_equal( ":b2", stmt:bind_parameter_name(4) )
+  assert_equal( "$a", stmt:bind_parameter_name(5) )
+  assert_equal( ":b", stmt:bind_parameter_name(6) )
+  assert_equal( "$a3", stmt:bind_parameter_name(7) )
+  assert_equal( "$b3", stmt:bind_parameter_name(8) )
+end
+
+function b:test_auto_parameter_names()
+  local stmt = assert_userdata( self.db:prepare("INSERT INTO test VALUES($a, $b, $a2, $b2, $a, $b, $a3, $b3)") )
+  local parameters = assert_number( stmt:bind_parameter_count() )
+  assert_equal( 6, parameters )
+  assert_equal( "$a", stmt:bind_parameter_name(1) )
+  assert_equal( "$b", stmt:bind_parameter_name(2) )
+  assert_equal( "$a2", stmt:bind_parameter_name(3) )
+  assert_equal( "$b2", stmt:bind_parameter_name(4) )
+  assert_equal( "$a3", stmt:bind_parameter_name(5) )
+  assert_equal( "$b3", stmt:bind_parameter_name(6) )
+end
+
+function b:test_no_parameter_names_1()
+  local stmt = assert_userdata( self.db:prepare([[ SELECT * FROM test ]]))
+  local parameters = assert_number( stmt:bind_parameter_count() )
+  assert_equal( 0, (parameters) )
+end
+
+function b:test_no_parameter_names_2()
+  local stmt = assert_userdata( self.db:prepare([[ INSERT INTO test VALUES(?, ?, ?, ?, ?, ?, ?, ?) ]]))
+  local parameters = assert_number( stmt:bind_parameter_count() )
+  assert_equal( 8, (parameters) )
+  assert_nil( stmt:bind_parameter_name(1) )
+end
+
+
+
+
+
+
+
+--------------------------------------------
+-- Tests loop break and statement reusage --
+--------------------------------------------
+
+
+
+----------------------------
+-- Test for bugs reported --
+----------------------------
+
+bug = lunit.TestCase("Bug-Report Tests")
+
+function bug:setup()
+  self.db = assert( sqlite3.open_memory() )
+end
+
+function bug:teardown()
+  assert_number( self.db:close() )
+end
+
+--[===[
+function bug:test_1()
+  self.db:exec("CREATE TABLE test (id INTEGER PRIMARY KEY, value TEXT)")
+  
+  local query = assert_userdata( self.db:prepare("SELECT id FROM test WHERE value=?") )
+  
+  assert_table ( query:bind_values("1") )
+  assert_nil   ( query:first_cols() )
+  assert_table ( query:bind_values("2") )
+  assert_nil   ( query:first_cols() )
+end
+]===]
+
+function bug:test_nils()   -- appeared in lua-5.1 (holes in arrays)
+  local function check(arg1, arg2, arg3, arg4, arg5)
+    assert_equal(1, arg1)
+    assert_equal(2, arg2)
+    assert_nil(arg3)
+    assert_equal(4, arg4)
+    assert_nil(arg5)
+  end
+  
+  self.db:create_function("test_nils", 5, function(arg1, arg2, arg3, arg4, arg5)
+    check(arg1, arg2, arg3, arg4, arg5)
+  end, {})
+  
+  assert_number( self.db:exec([[ SELECT test_nils(1, 2, NULL, 4, NULL) ]]) )
+  
+  for arg1, arg2, arg3, arg4, arg5 in self.db:urows([[ SELECT 1, 2, NULL, 4, NULL ]])
+  do check(arg1, arg2, arg3, arg4, arg5) 
+  end
+  
+  for row in self.db:rows([[ SELECT 1, 2, NULL, 4, NULL ]])
+  do assert_table( row ) 
+     check(row[1], row[2], row[3], row[4], row[5])
+  end
+end
+
+----------------------------
+-- Test for collation fun --
+----------------------------
+
+colla = lunit.TestCase("Collation Tests")
+
+function colla:setup()
+    local function collate(s1,s2)
+        -- if p then print("collation callback: ",s1,s2) end
+        s1=s1:lower()
+        s2=s2:lower()
+        if s1==s2 then return 0
+        elseif s1<s2 then return -1
+        else return 1 end
+    end
+    self.db = assert( sqlite3.open_memory() )
+    assert_nil(self.db:create_collation('CINSENS',collate))
+    self.db:exec[[
+      CREATE TABLE test(id INTEGER PRIMARY KEY,content COLLATE CINSENS);
+      INSERT INTO test VALUES(NULL,'hello world');
+      INSERT INTO test VALUES(NULL,'Buenos dias');
+      INSERT INTO test VALUES(NULL,'HELLO WORLD');
+      INSERT INTO test VALUES(NULL,'Guten Tag');
+      INSERT INTO test VALUES(NULL,'HeLlO WoRlD');
+      INSERT INTO test VALUES(NULL,'Bye for now');
+    ]]
+end
+
+function colla:teardown()
+  assert_number( self.db:close() )
+end
+
+function colla:test()
+    --for row in db:nrows('SELECT * FROM test') do
+    --  print(row.id,row.content)
+    --end
+    local n = 0
+    for row in self.db:nrows('SELECT * FROM test WHERE content="hElLo wOrLd"') do
+      -- print(row.id,row.content)
+      assert_equal (row.content:lower(), "hello world")
+      n = n + 1
+    end
+    assert_equal (n, 3)
+end
+
+lunit.run()

src/lib/lib.mak

@@ -513,7 +513,7 @@ LUAOBJS = \
 	$(LIBOBJ)/lua/ltablib.o \
 	$(LIBOBJ)/lua/loadlib.o \
 	$(LIBOBJ)/lua/linit.o \
-	$(LIBOBJ)/lua/lib/lsqlite3.o \
+	$(LIBOBJ)/lua/lsqlite3/lsqlite3.o \
 
 $(OBJ)/liblua.a: $(LUAOBJS)
 
@@ -530,6 +530,10 @@ $(LIBOBJ)/lua/%.o: $(LIBSRC)/lua/%.c | $(OSPREBUILD)
 	@echo Compiling $<...
 	$(CC) $(CDEFS) $(CCOMFLAGS) $(CONLYFLAGS) -DLUA_COMPAT_ALL $(LUA_FLAGS) -c $< -o $@
 
+$(LIBOBJ)/lua/lsqlite3/%.o: $(3RDPARTY)/lsqlite3/%.c | $(OSPREBUILD)
+	@echo Compiling $<...
+	$(CC) $(CDEFS) $(CCOMFLAGS) $(CONLYFLAGS) -DLUA_COMPAT_ALL $(LUA_FLAGS) -c $< -o $@
+
 #-------------------------------------------------
 # web library objects
 #-------------------------------------------------

src/lib/lua/lib/lualibs.h

@@ -1,8 +0,0 @@
-#ifndef LUALIBS_H
-#define LUALIBS_H
-
-extern "C" {
-	int luaopen_lsqlite3(lua_State *L);
-}
-
-#endif //LUALIBS_H