source: trunk/m4/sqlite.m4 @ 704

# Copyright (C) 2005-2008 David Carter <arm4@arm4.org>
#  
# This file is free software; as a special exception the author gives
# unlimited permission to copy and/or distribute it, with or without 
# modifications, as long as this notice is preserved.
# 
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY, to the extent permitted by law; without even the
# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

# Macros to check the version for the Sqlite library, and to set whatever link flags are appropriate

AC_DEFUN([__ARM4_SQLITE_CHECK_CLEAR_BINDINGS],
[
  AC_MSG_CHECKING(for sqlite3_clear_bindings)
  SQLITE_LIBS="$1"
  ac_save_LIBS="$LIBS"
  LIBS="$LIBS $SQLITE_LIBS"
  no_clear_bindings=""
  AC_LINK_IFELSE([
#include <sqlite3.h>
#include <stdlib.h>

main ()
{
        sqlite3_stmt *statement_ptr;
        sqlite3_clear_bindings(statement_ptr);
}
], ,[no_clear_bindings="yes"])
  LIBS="$ac_save_libs"
  if test "x$no_clear_bindings" == "x" ; then
    AC_DEFINE(HAVE_SQLITE_CLEAR_BINDINGS, 1,
      [Defines wether the Sqlite function sqlite3_clear_bindings is supported by this library version])
    AC_MSG_RESULT(yes)
  else
    AC_MSG_RESULT(no)
  fi
])

AC_DEFUN([__ARM4_SQLITE_CHECK_PREPARE_V2],
[
  AC_MSG_CHECKING(for sqlite3_prepare_v2)
  SQLITE_LIBS="$1"
  ac_save_LIBS="$LIBS"
  LIBS="$LIBS $SQLITE_LIBS"
  no_prepare_v2=""
  AC_LINK_IFELSE([
#include <sqlite3.h>
#include <stdlib.h>

main ()
{
        sqlite3 *db_ptr;
        sqlite3_stmt *statement_ptr;
        sqlite3_prepare_v2(db_ptr, "test", 4, &statement_ptr, NULL);
}
], ,[no_prepare_v2="yes"])
  LIBS="$ac_save_libs"
  if test "x$no_prepare_v2" == "x" ; then
    AC_DEFINE(HAVE_SQLITE_PREPARE_V2, 1,
      [Defines wether the Sqlite function sqlite3_prepare_v2 is supported by this library version])
    AC_MSG_RESULT(yes)
  else
    AC_MSG_RESULT(no)
  fi
])

AC_DEFUN([__ARM4_SQLITE_CHECK_OPEN_V2],
[
  AC_MSG_CHECKING(for sqlite3_open_v2)
  SQLITE_LIBS="$1"
  ac_save_LIBS="$LIBS"
  LIBS="$LIBS $SQLITE_LIBS"
  no_open_v2=""
  AC_LINK_IFELSE([
#include <sqlite3.h>
#include <stdlib.h>

main ()
{
        sqlite3 *db_ptr;
        sqlite3_open_v2 ("dummy", &db_ptr, SQLITE_OPEN_READONLY, NULL);
}
], ,[no_open_v2="yes"])
  LIBS="$ac_save_libs"
  if test "x$no_open_v2" == "x" ; then
    AC_DEFINE(HAVE_SQLITE_OPEN_V2, 1,
      [Defines wether the Sqlite function sqlite3_open_v2 is supported by this library version])
    AC_MSG_RESULT(yes)
  else
    AC_MSG_RESULT(no)
  fi
])

AC_DEFUN([__ARM4_SQLITE_CHECKLINK],
[
  SQLITE_LIBS="$1"
  ac_save_LIBS="$LIBS"
  LIBS="$LIBS $SQLITE_LIBS"
  AC_LINK_IFELSE([
#include <sqlite3.h>

main ()
{
        sqlite3_close (0);
}
], ,[SQLITE_LIBS=""])
  LIBS="$ac_save_libs"
  AC_SUBST(SQLITE_LIBS)
])

AC_DEFUN([__ARM4_SQLITE_CHECK_VERSION],
[
  min_sqlite_version=ifelse([$1], ,3.3,$1)
  sqlite="$2"
  sqlite_path="$3"

  if test "x$sqlite_path" = x ; then
    AC_PATH_PROG(SQLITE_STAT, $sqlite, no,)
  else
    AC_PATH_PROG(SQLITE_STAT, $sqlite, no, [$sqlite_path])
  fi
  no_sqlite=""
  if test "$SQLITE_STAT" = "no" ; then
    no_sqlite=yes
    AC_MSG_ERROR([unable to find $sqlite program $sqlite_path])
  else
    AC_MSG_CHECKING(for sqlite - version >= $min_sqlite_version)
    sqlite_major_version=`$SQLITE_STAT -version | \
         sed 's/^[[A-Za-z :]]*\([[0-9]]*\)\.\{0,1\}\([[0-9]]*\)\.\{0,1\}\([[0-9]]*\).*/\1/'`
    if test "x${sqlite_major_version}" = "x" ; then
       sqlite_major_version=0
    fi

    sqlite_minor_version=`$SQLITE_STAT -version | \
         sed 's/^[[A-Za-z :]]*\([[0-9]]*\)\.\{0,1\}\([[0-9]]*\)\.\{0,1\}\([[0-9]]*\).*/\2/'`
    if test "x${sqlite_minor_version}" = "x" ; then
       sqlite_minor_version=0
    fi

    sqlite_micro_version=`$SQLITE_STAT -version | \
         sed 's/^[[A-Za-z :]]*\([[0-9]]*\)\.\{0,1\}\([[0-9]]*\)\.\{0,1\}\([[0-9]]*\).*/\3/'`
    if test "x${sqlite_micro_version}" = "x" ; then
       sqlite_micro_version=0
    fi

    enable_sqlitetest=yes
    if test "x$enable_sqlitetest" = "xyes" ; then
      rm -f conf.sqlitetest
      AC_RUN_IFELSE([
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char* my_strdup (const char *str);

char*
my_strdup (const char *str)
{
  char *new_str;
  
  if (str)
    {
      new_str = (char *)malloc ((strlen (str) + 1) * sizeof(char));
      strcpy (new_str, str);
    }
  else
    new_str = NULL;
  
  return new_str;
}

int main (void)
{
  int major = 0, minor = 0, micro = 0;
  int n;
  char *tmp_version;

  system ("touch conf.sqlitetest");

  /* HP/UX 9 (%@#!) writes to sscanf strings */
  tmp_version = my_strdup("$min_sqlite_version");

  n = sscanf(tmp_version, "%d.%d.%d", &major, &minor, &micro) ;

  if (n != 2 && n != 3) {
     printf("%s, bad version string\n", "$min_sqlite_version");
     exit(1);
   }

   if (($sqlite_major_version > major) ||
      (($sqlite_major_version == major) && ($sqlite_minor_version > minor)) ||
      (($sqlite_major_version == major) && ($sqlite_minor_version == minor) && ($sqlite_micro_version >= micro)))
    {
      exit(0);
    }
  else
    {
      printf("\n*** 'sqlite3 -version' returned %d.%d.%d, but the minimum version\n", $sqlite_major_version, $sqlite_minor_version, $sqlite_micro_version);
      printf("*** of sqlite3 required is %d.%d.%d. If sqlite3 is correct, then it is\n", major, minor, micro);
      printf("*** best to upgrade to the required version.\n");
      exit(1);
    }
}

],, no_sqlite=yes,[echo $ac_n "cross compiling; assumed OK... $ac_c"])
    fi
  fi
  if test "x$no_sqlite" = x ; then
    AC_MSG_RESULT(yes)
  else
    AC_MSG_ERROR([sqlite version $min_sqlite_version or greater is required])
  fi
])

AC_DEFUN([ARM4_VERSION_SQLITE],
[
  min_sqlite_version=ifelse([$1], ,3.3,$1)

  sqlite_found="no"
  sqlite_root=""
  AC_MSG_CHECKING(for sqlite root)
  AC_ARG_WITH(sqlite,
  [  --with-sqlite=PATH      path to the sqlite root],
  [
    if test "$withval" = "no" || test "$withval" = "yes"; then
      AC_MSG_ERROR([--with-sqlite requires the path to the sqlite root to be provided])
    fi

    if test -d "$withval" > /dev/null 2>&1 ; then
      sqlite_found="yes"
      sqlite_root="$withval"
    fi

    dnl if --with-sqlite is used, it is a fatal error for its argument
    dnl to be invalid
    if test "$sqlite_found" != "yes"; then
      AC_MSG_ERROR([the --with-sqlite parameter is incorrect. It must specify the path to the sqlite root.])
    fi
  ],[
    sqlite_found="yes"
        sqlite_root="/usr"
  ])
  AC_MSG_RESULT($sqlite_root)

  if test "$sqlite_found" = "yes"; then
    if test "x$sqlite_root" = "x" ; then
      AC_CHECK_HEADERS([sqlite3.h],,[AC_MSG_ERROR(unable to find sqlite header file)],)
      __ARM4_SQLITE_CHECK_VERSION([$min_sqlite_version], [sqlite3])
      AC_MSG_CHECKING(for sqlite flags)
      __ARM4_SQLITE_CHECKLINK([-lsqlite3])
      if test "x$SQLITE_LIBS" = "x" ; then
        __ARM4_SQLITE_CHECKLINK([-lsqlite3 -lrt])
      fi
      AC_MSG_RESULT($SQLITE_LIBS)
    else
      CPPFLAGS="-I$sqlite_root/include $CPPFLAGS"
      AC_CHECK_HEADERS([sqlite3.h],,[AC_MSG_ERROR(unable to find sqlite header file)],)
      __ARM4_SQLITE_CHECK_VERSION([$min_sqlite_version], [sqlite3], [$sqlite_root/bin])
      AC_MSG_CHECKING(for sqlite flags)
      __ARM4_SQLITE_CHECKLINK([-L$sqlite_root/lib -lsqlite3])
      if test "x$SQLITE_LIBS" = "x" ; then
        __ARM4_SQLITE_CHECKLINK([-L$sqlite_root/lib -lsqlite3 -lrt])
      fi
      AC_MSG_RESULT($SQLITE_LIBS)
    fi
    if test "x$SQLITE_LIBS" = "x" ; then
      AC_MSG_ERROR([unable to link $sqlite])
    fi
  fi
])

AC_DEFUN([ARM4_CHECK_SQLITE],
[
  min_sqlite_version=ifelse([$1], ,3.3,$1)

  AC_MSG_CHECKING(for Sqlite)
  AC_ARG_ENABLE(sqlite,
  [  --enable-sqlite         enable Sqlite database back end],
  [case "${enableval}" in
     yes) sqlite=yes ;;
     no)  sqlite=no ;;
     *) AC_MSG_ERROR([bad value ${enableval} for --enable-sqlite]) ;;
   esac],
  [sqlite=no])
  AC_MSG_RESULT($sqlite)
  AM_CONDITIONAL([BUILD_SQLITE], [test "$sqlite" = "yes" ])
  if test "$sqlite" = "yes" ; then
    ARM4_VERSION_SQLITE([$min_sqlite_version])
    AC_DEFINE(HAVE_SQLITE, 1,
      [Define wether the Sqlite back end is implemented on this platform])
    __ARM4_SQLITE_CHECK_OPEN_V2([$SQLITE_LIBS])
    __ARM4_SQLITE_CHECK_PREPARE_V2([$SQLITE_LIBS])
    __ARM4_SQLITE_CHECK_CLEAR_BINDINGS([$SQLITE_LIBS])
  fi
])