should be it

external/duckdb/tools/sqlite3_api_wrapper/sqlite3/CMakeLists.txt

@@ -0,0 +1,13 @@
+# this directory contains some of the original code from SQLite mainly helper
+# functions that we don't really care about replacing ourselves
+
+add_definitions(-DUSE_DUCKDB_SHELL_WRAPPER)
+set(SQLITE_FILES printf.c strglob.c)
+if(WIN32)
+  set(SQLITE_FILES ${SQLITE_FILES} os_win.c)
+endif()
+
+add_library(sqlite3_api_wrapper_sqlite3 OBJECT ${SQLITE_FILES})
+set(ALL_OBJECT_FILES
+    ${ALL_OBJECT_FILES} $<TARGET_OBJECTS:sqlite3_api_wrapper_sqlite3>
+    PARENT_SCOPE)

external/duckdb/tools/sqlite3_api_wrapper/sqlite3/os_win.c

@@ -0,0 +1,245 @@
+/*
+** 2004 May 22
+**
+** The author disclaims copyright to this source code.  In place of
+** a legal notice, here is a blessing:
+**
+**    May you do good and not evil.
+**    May you find forgiveness for yourself and forgive others.
+**    May you share freely, never taking more than you give.
+**
+******************************************************************************
+**
+** This file contains code that is specific to Windows.
+*/
+
+#if defined(_WIN32) || defined(WIN32)
+#include "stripped_sqlite_int.h"
+#include <windows.h>
+#define SQLITE_OMIT_AUTOINIT
+
+/*
+** Allocate and zero memory.
+*/
+void *sqlite3MallocZero(u64 n) {
+	void *p = sqlite3Malloc(n);
+	if (p) {
+		memset(p, 0, (size_t)n);
+	}
+	return p;
+}
+
+#define osMultiByteToWideChar MultiByteToWideChar
+
+#define osWideCharToMultiByte WideCharToMultiByte
+
+/*
+** Convert a UTF-8 string to Microsoft Unicode.
+**
+** Space to hold the returned string is obtained from sqlite3_malloc().
+*/
+static LPWSTR winUtf8ToUnicode(const char *zText){
+  int nChar;
+  LPWSTR zWideText;
+
+  nChar = osMultiByteToWideChar(CP_UTF8, 0, zText, -1, NULL, 0);
+  if( nChar==0 ){
+    return 0;
+  }
+  zWideText = (LPWSTR) sqlite3MallocZero( nChar*sizeof(WCHAR) );
+  if( zWideText==0 ){
+    return 0;
+  }
+  nChar = osMultiByteToWideChar(CP_UTF8, 0, zText, -1, zWideText,
+                                nChar);
+  if( nChar==0 ){
+    sqlite3_free(zWideText);
+    zWideText = 0;
+  }
+  return zWideText;
+}
+
+/*
+** Convert a Microsoft Unicode string to UTF-8.
+**
+** Space to hold the returned string is obtained from sqlite3_malloc().
+*/
+static char *winUnicodeToUtf8(LPCWSTR zWideText){
+  int nByte;
+  char *zText;
+
+  nByte = osWideCharToMultiByte(CP_UTF8, 0, zWideText, -1, 0, 0, 0, 0);
+  if( nByte == 0 ){
+    return 0;
+  }
+  zText = (char*) sqlite3MallocZero( nByte );
+  if( zText==0 ){
+    return 0;
+  }
+  nByte = osWideCharToMultiByte(CP_UTF8, 0, zWideText, -1, zText, nByte,
+                                0, 0);
+  if( nByte == 0 ){
+    sqlite3_free(zText);
+    zText = 0;
+  }
+  return zText;
+}
+
+/*
+** Convert an ANSI string to Microsoft Unicode, using the ANSI or OEM
+** code page.
+**
+** Space to hold the returned string is obtained from sqlite3_malloc().
+*/
+static LPWSTR winMbcsToUnicode(const char *zText, int useAnsi){
+  int nByte;
+  LPWSTR zMbcsText;
+  int codepage = useAnsi ? CP_ACP : CP_OEMCP;
+
+  nByte = osMultiByteToWideChar(codepage, 0, zText, -1, NULL,
+                                0)*sizeof(WCHAR);
+  if( nByte==0 ){
+    return 0;
+  }
+  zMbcsText = (LPWSTR) sqlite3MallocZero( nByte*sizeof(WCHAR) );
+  if( zMbcsText==0 ){
+    return 0;
+  }
+  nByte = osMultiByteToWideChar(codepage, 0, zText, -1, zMbcsText,
+                                nByte);
+  if( nByte==0 ){
+    sqlite3_free(zMbcsText);
+    zMbcsText = 0;
+  }
+  return zMbcsText;
+}
+
+/*
+** Convert a Microsoft Unicode string to a multi-byte character string,
+** using the ANSI or OEM code page.
+**
+** Space to hold the returned string is obtained from sqlite3_malloc().
+*/
+static char *winUnicodeToMbcs(LPCWSTR zWideText, int useAnsi){
+  int nByte;
+  char *zText;
+  int codepage = useAnsi ? CP_ACP : CP_OEMCP;
+
+  nByte = osWideCharToMultiByte(codepage, 0, zWideText, -1, 0, 0, 0, 0);
+  if( nByte == 0 ){
+    return 0;
+  }
+  zText = (char*) sqlite3MallocZero( nByte );
+  if( zText==0 ){
+    return 0;
+  }
+  nByte = osWideCharToMultiByte(codepage, 0, zWideText, -1, zText,
+                                nByte, 0, 0);
+  if( nByte == 0 ){
+    sqlite3_free(zText);
+    zText = 0;
+  }
+  return zText;
+}
+
+/*
+** Convert a multi-byte character string to UTF-8.
+**
+** Space to hold the returned string is obtained from sqlite3_malloc().
+*/
+static char *winMbcsToUtf8(const char *zText, int useAnsi){
+  char *zTextUtf8;
+  LPWSTR zTmpWide;
+
+  zTmpWide = winMbcsToUnicode(zText, useAnsi);
+  if( zTmpWide==0 ){
+    return 0;
+  }
+  zTextUtf8 = winUnicodeToUtf8(zTmpWide);
+  sqlite3_free(zTmpWide);
+  return zTextUtf8;
+}
+
+/*
+** Convert a UTF-8 string to a multi-byte character string.
+**
+** Space to hold the returned string is obtained from sqlite3_malloc().
+*/
+static char *winUtf8ToMbcs(const char *zText, int useAnsi){
+  char *zTextMbcs;
+  LPWSTR zTmpWide;
+
+  zTmpWide = winUtf8ToUnicode(zText);
+  if( zTmpWide==0 ){
+    return 0;
+  }
+  zTextMbcs = winUnicodeToMbcs(zTmpWide, useAnsi);
+  sqlite3_free(zTmpWide);
+  return zTextMbcs;
+}
+
+/*
+** This is a public wrapper for the winUtf8ToUnicode() function.
+*/
+LPWSTR sqlite3_win32_utf8_to_unicode(const char *zText){
+#ifdef SQLITE_ENABLE_API_ARMOR
+  if( !zText ){
+    (void)SQLITE_MISUSE_BKPT;
+    return 0;
+  }
+#endif
+#ifndef SQLITE_OMIT_AUTOINIT
+  if( sqlite3_initialize() ) return 0;
+#endif
+  return winUtf8ToUnicode(zText);
+}
+
+/*
+** This is a public wrapper for the winUnicodeToUtf8() function.
+*/
+char *sqlite3_win32_unicode_to_utf8(LPCWSTR zWideText){
+#ifdef SQLITE_ENABLE_API_ARMOR
+  if( !zWideText ){
+    (void)SQLITE_MISUSE_BKPT;
+    return 0;
+  }
+#endif
+#ifndef SQLITE_OMIT_AUTOINIT
+  if( sqlite3_initialize() ) return 0;
+#endif
+  return winUnicodeToUtf8(zWideText);
+}
+
+/*
+** This is a public wrapper for the winMbcsToUtf8() function.
+*/
+char *sqlite3_win32_mbcs_to_utf8_v2(const char *zText, int useAnsi){
+#ifdef SQLITE_ENABLE_API_ARMOR
+  if( !zText ){
+    (void)SQLITE_MISUSE_BKPT;
+    return 0;
+  }
+#endif
+#ifndef SQLITE_OMIT_AUTOINIT
+  if( sqlite3_initialize() ) return 0;
+#endif
+  return winMbcsToUtf8(zText, useAnsi);
+}
+
+/*
+** This is a public wrapper for the winUtf8ToMbcs() function.
+*/
+char *sqlite3_win32_utf8_to_mbcs_v2(const char *zText, int useAnsi){
+#ifdef SQLITE_ENABLE_API_ARMOR
+  if( !zText ){
+    (void)SQLITE_MISUSE_BKPT;
+    return 0;
+  }
+#endif
+#ifndef SQLITE_OMIT_AUTOINIT
+  if( sqlite3_initialize() ) return 0;
+#endif
+  return winUtf8ToMbcs(zText, useAnsi);
+}
+
+#endif /* SQLITE_OS_WIN */

external/duckdb/tools/sqlite3_api_wrapper/sqlite3/strglob.c

@@ -0,0 +1,262 @@
+#include "stripped_sqlite_int.h"
+#include <ctype.h>
+
+#define sqlite3Toupper(x) toupper((unsigned char)(x))
+#define sqlite3Tolower(x) tolower((unsigned char)(x))
+
+/*
+** This lookup table is used to help decode the first byte of
+** a multi-byte UTF8 character.
+*/
+static const unsigned char sqlite3Utf8Trans1[] = {
+    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
+    0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
+    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
+    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x00, 0x01, 0x02, 0x03, 0x00, 0x01, 0x00, 0x00,
+};
+
+u32 sqlite3Utf8Read(const unsigned char **pz /* Pointer to string from which to read char */
+) {
+	unsigned int c;
+
+	/* Same as READ_UTF8() above but without the zTerm parameter.
+	** For this routine, we assume the UTF8 string is always zero-terminated.
+	*/
+	c = *((*pz)++);
+	if (c >= 0xc0) {
+		c = sqlite3Utf8Trans1[c - 0xc0];
+		while ((*(*pz) & 0xc0) == 0x80) {
+			c = (c << 6) + (0x3f & *((*pz)++));
+		}
+		if (c < 0x80 || (c & 0xFFFFF800) == 0xD800 || (c & 0xFFFFFFFE) == 0xFFFE) {
+			c = 0xFFFD;
+		}
+	}
+	return c;
+}
+
+/*
+** A structure defining how to do GLOB-style comparisons.
+*/
+struct compareInfo {
+	u8 matchAll; /* "*" or "%" */
+	u8 matchOne; /* "?" or "_" */
+	u8 matchSet; /* "[" or 0 */
+	u8 noCase;   /* true to ignore case differences */
+};
+
+/*
+** For LIKE and GLOB matching on EBCDIC machines, assume that every
+** character is exactly one byte in size.  Also, provde the Utf8Read()
+** macro for fast reading of the next character in the common case where
+** the next character is ASCII.
+*/
+#define Utf8Read(A) (A[0] < 0x80 ? *(A++) : sqlite3Utf8Read(&A))
+
+static const struct compareInfo globInfo = {'*', '?', '[', 0};
+/* The correct SQL-92 behavior is for the LIKE operator to ignore
+** case.  Thus  'a' LIKE 'A' would be true. */
+static const struct compareInfo likeInfoNorm = {'%', '_', 0, 1};
+/* If SQLITE_CASE_SENSITIVE_LIKE is defined, then the LIKE operator
+** is case sensitive causing 'a' LIKE 'A' to be false */
+// static const struct compareInfo likeInfoAlt = { '%', '_',   0, 0 };
+
+/*
+** Possible error returns from patternMatch()
+*/
+#define SQLITE_MATCH           0
+#define SQLITE_NOMATCH         1
+#define SQLITE_NOWILDCARDMATCH 2
+
+/*
+** Compare two UTF-8 strings for equality where the first string is
+** a GLOB or LIKE expression.  Return values:
+**
+**    SQLITE_MATCH:            Match
+**    SQLITE_NOMATCH:          No match
+**    SQLITE_NOWILDCARDMATCH:  No match in spite of having * or % wildcards.
+**
+** Globbing rules:
+**
+**      '*'       Matches any sequence of zero or more characters.
+**
+**      '?'       Matches exactly one character.
+**
+**     [...]      Matches one character from the enclosed list of
+**                characters.
+**
+**     [^...]     Matches one character not in the enclosed list.
+**
+** With the [...] and [^...] matching, a ']' character can be included
+** in the list by making it the first character after '[' or '^'.  A
+** range of characters can be specified using '-'.  Example:
+** "[a-z]" matches any single lower-case letter.  To match a '-', make
+** it the last character in the list.
+**
+** Like matching rules:
+**
+**      '%'       Matches any sequence of zero or more characters
+**
+***     '_'       Matches any one character
+**
+**      Ec        Where E is the "esc" character and c is any other
+**                character, including '%', '_', and esc, match exactly c.
+**
+** The comments within this routine usually assume glob matching.
+**
+** This routine is usually quick, but can be N**2 in the worst case.
+*/
+static int patternCompare(const u8 *zPattern,              /* The glob pattern */
+                          const u8 *zString,               /* The string to compare against the glob */
+                          const struct compareInfo *pInfo, /* Information about how to do the compare */
+                          uint32_t matchOther              /* The escape char (LIKE) or '[' (GLOB) */
+) {
+	uint32_t c, c2;                      /* Next pattern and input string chars */
+	uint32_t matchOne = pInfo->matchOne; /* "?" or "_" */
+	uint32_t matchAll = pInfo->matchAll; /* "*" or "%" */
+	u8 noCase = pInfo->noCase;           /* True if uppercase==lowercase */
+	const u8 *zEscaped = 0;              /* One past the last escaped input char */
+
+	while ((c = Utf8Read(zPattern)) != 0) {
+		if (c == matchAll) { /* Match "*" */
+			/* Skip over multiple "*" characters in the pattern.  If there
+			** are also "?" characters, skip those as well, but consume a
+			** single character of the input string for each "?" skipped */
+			while ((c = Utf8Read(zPattern)) == matchAll || c == matchOne) {
+				if (c == matchOne && sqlite3Utf8Read(&zString) == 0) {
+					return SQLITE_NOWILDCARDMATCH;
+				}
+			}
+			if (c == 0) {
+				return SQLITE_MATCH; /* "*" at the end of the pattern matches */
+			} else if (c == matchOther) {
+				if (pInfo->matchSet == 0) {
+					c = sqlite3Utf8Read(&zPattern);
+					if (c == 0)
+						return SQLITE_NOWILDCARDMATCH;
+				} else {
+					/* "[...]" immediately follows the "*".  We have to do a slow
+					** recursive search in this case, but it is an unusual case. */
+					assert(matchOther < 0x80); /* '[' is a single-byte character */
+					while (*zString) {
+						int bMatch = patternCompare(&zPattern[-1], zString, pInfo, matchOther);
+						if (bMatch != SQLITE_NOMATCH)
+							return bMatch;
+						SQLITE_SKIP_UTF8(zString);
+					}
+					return SQLITE_NOWILDCARDMATCH;
+				}
+			}
+
+			/* At this point variable c contains the first character of the
+			** pattern string past the "*".  Search in the input string for the
+			** first matching character and recursively continue the match from
+			** that point.
+			**
+			** For a case-insensitive search, set variable cx to be the same as
+			** c but in the other case and search the input string for either
+			** c or cx.
+			*/
+			if (c <= 0x80) {
+				char zStop[3];
+				int bMatch;
+				if (noCase) {
+					zStop[0] = sqlite3Toupper(c);
+					zStop[1] = sqlite3Tolower(c);
+					zStop[2] = 0;
+				} else {
+					zStop[0] = c;
+					zStop[1] = 0;
+				}
+				while (1) {
+					zString += strcspn((const char *)zString, zStop);
+					if (zString[0] == 0)
+						break;
+					zString++;
+					bMatch = patternCompare(zPattern, zString, pInfo, matchOther);
+					if (bMatch != SQLITE_NOMATCH)
+						return bMatch;
+				}
+			} else {
+				int bMatch;
+				while ((c2 = Utf8Read(zString)) != 0) {
+					if (c2 != c)
+						continue;
+					bMatch = patternCompare(zPattern, zString, pInfo, matchOther);
+					if (bMatch != SQLITE_NOMATCH)
+						return bMatch;
+				}
+			}
+			return SQLITE_NOWILDCARDMATCH;
+		}
+		if (c == matchOther) {
+			if (pInfo->matchSet == 0) {
+				c = sqlite3Utf8Read(&zPattern);
+				if (c == 0)
+					return SQLITE_NOMATCH;
+				zEscaped = zPattern;
+			} else {
+				uint32_t prior_c = 0;
+				int seen = 0;
+				int invert = 0;
+				c = sqlite3Utf8Read(&zString);
+				if (c == 0)
+					return SQLITE_NOMATCH;
+				c2 = sqlite3Utf8Read(&zPattern);
+				if (c2 == '^') {
+					invert = 1;
+					c2 = sqlite3Utf8Read(&zPattern);
+				}
+				if (c2 == ']') {
+					if (c == ']')
+						seen = 1;
+					c2 = sqlite3Utf8Read(&zPattern);
+				}
+				while (c2 && c2 != ']') {
+					if (c2 == '-' && zPattern[0] != ']' && zPattern[0] != 0 && prior_c > 0) {
+						c2 = sqlite3Utf8Read(&zPattern);
+						if (c >= prior_c && c <= c2)
+							seen = 1;
+						prior_c = 0;
+					} else {
+						if (c == c2) {
+							seen = 1;
+						}
+						prior_c = c2;
+					}
+					c2 = sqlite3Utf8Read(&zPattern);
+				}
+				if (c2 == 0 || (seen ^ invert) == 0) {
+					return SQLITE_NOMATCH;
+				}
+				continue;
+			}
+		}
+		c2 = Utf8Read(zString);
+		if (c == c2)
+			continue;
+		if (noCase && sqlite3Tolower(c) == sqlite3Tolower(c2) && c < 0x80 && c2 < 0x80) {
+			continue;
+		}
+		if (c == matchOne && zPattern != zEscaped && c2 != 0)
+			continue;
+		return SQLITE_NOMATCH;
+	}
+	return *zString == 0 ? SQLITE_MATCH : SQLITE_NOMATCH;
+}
+
+/*
+** The sqlite3_strglob() interface.  Return 0 on a match (like strcmp()) and
+** non-zero if there is no match.
+*/
+int sqlite3_strglob(const char *zGlobPattern, const char *zString) {
+	return patternCompare((u8 *)zGlobPattern, (u8 *)zString, &globInfo, '[');
+}
+
+/*
+** The sqlite3_strlike() interface.  Return 0 on a match and non-zero for
+** a miss - like strcmp().
+*/
+int sqlite3_strlike(const char *zPattern, const char *zStr, unsigned int esc) {
+	return patternCompare((u8 *)zPattern, (u8 *)zStr, &likeInfoNorm, esc);
+}

external/duckdb/tools/sqlite3_api_wrapper/sqlite3/stripped_sqlite_int.h

@@ -0,0 +1,58 @@
+#ifndef __STRIPPED_SQLITE_INT__
+#define __STRIPPED_SQLITE_INT__
+
+#define LONGDOUBLE_TYPE long double
+#include <stdint.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+typedef uint8_t u8;
+typedef uint32_t u32;
+typedef int64_t i64;
+typedef uint64_t u64;
+
+typedef int64_t sqlite3_int64;
+typedef uint64_t sqlite_uint64;
+typedef uint64_t sqlite3_uint64;
+
+#ifdef USE_DUCKDB_SHELL_WRAPPER
+#include "duckdb_shell_wrapper.h"
+void *sqlite3_realloc64(void *ptr, sqlite3_uint64 n);
+void *sqlite3_free(void *ptr);
+#else
+#define sqlite3_realloc64 realloc
+#define sqlite3_free      free
+#endif
+
+#define sqlite3Malloc malloc
+#define sqlite3IsNaN  isnan
+
+#define ArraySize(X)   ((int)(sizeof(X) / sizeof(X[0])))
+#define LARGEST_INT64  (0xffffffff | (((i64)0x7fffffff) << 32))
+#define SMALLEST_INT64 (((i64)-1) - LARGEST_INT64)
+
+#include <assert.h>
+
+#define SQLITE_SKIP_UTF8(zIn)                                                                                          \
+	{                                                                                                                  \
+		if ((*(zIn++)) >= 0xc0) {                                                                                      \
+			while ((*zIn & 0xc0) == 0x80) {                                                                            \
+				zIn++;                                                                                                 \
+			}                                                                                                          \
+		}                                                                                                              \
+	}
+
+#ifndef MAX
+#define MAX(A, B) ((A) > (B) ? (A) : (B))
+#endif
+#ifndef MIN
+#define MIN(A, B) ((A) < (B) ? (A) : (B))
+#endif
+
+#ifndef SQLITE_MAX_LENGTH
+#define SQLITE_MAX_LENGTH 1000000000
+#endif
+
+#endif