Include libb64-encode, sqlite3-base64, sqlite3-regexp-cached source

needed for BASE64 & REGEXP features on iOS/macOS/Windows

(cordova-sqlite-evcore-free-dependencies 0.8.1)

README.md

@@ -7,14 +7,13 @@ LICENSE: GPL v3 (http://www.gnu.org/licenses/gpl.txt) or commercial license opti
 Contains source and library (shared object) code built from:
 - [litehelpers / Android-sqlite-evcore-native-driver-free](https://github.com/litehelpers/Android-sqlite-evcore-native-driver-free) - GPL v3 or commercial license options
 - [SQLite (sqlite.org)](https://sqlite.org/) - public domain
-
-Also included in Android JAR build:
 - [brodybits / sqlite3-regexp-cached](https://github.com/brodybits/sqlite3-regexp-cached) (based on <http://git.altlinux.org/people/at/packages/?p=sqlite3-pcre.git> by Alexey Tourbin, public domain)
 - [brodybits / sqlite3-base64](https://github.com/brodybits/sqlite3-base64) (Unlicense, public domain)
 - [brodybits / libb64-encode](https://github.com/brodybits/libb64-encode) (based on <http://libb64.sourceforge.net/> by Chris Venter, public domain)
 
 This project provides the following dependencies needed to build Cordova SQLite evcore plugin versions:
 - `sqlite3.h`, `sqlite3.c` - SQLite `3.15.2` amalgamation needed to build iOS and Windows versions
+- [libb64-encode](https://github.com/brodybits/libb64-encode), [sqlite3-base64](https://github.com/brodybits/sqlite3-base64), and [sqlite3-regexp-cached](https://github.com/brodybits/sqlite3-regexp-cached) source for iOS/macOS/Windows platform versions
 - `evcore-native-driver.jar` - Android-sqlite-evcore-native-driver-free NDK JAR built with SQLite `3.15.2` amalgamation, with the following option flags:
    - `-DSQLITE_TEMP_STORE=2`
    - `-DSQLITE_THREADSAFE=2`

libb64-encode/LICENSE

@@ -0,0 +1,29 @@
+Copyright-Only Dedication (based on United States law) 
+or Public Domain Certification
+
+The person or persons who have associated work with this document (the
+"Dedicator" or "Certifier") hereby either (a) certifies that, to the best of
+his knowledge, the work of authorship identified is in the public domain of the
+country from which the work is published, or (b) hereby dedicates whatever
+copyright the dedicators holds in the work of authorship identified below (the
+"Work") to the public domain. A certifier, moreover, dedicates any copyright
+interest he may have in the associated work, and for these purposes, is
+described as a "dedicator" below.
+
+A certifier has taken reasonable steps to verify the copyright status of this
+work. Certifier recognizes that his good faith efforts may not shield him from
+liability if in fact the work certified is not in the public domain.
+
+Dedicator makes this dedication for the benefit of the public at large and to
+the detriment of the Dedicator's heirs and successors. Dedicator intends this
+dedication to be an overt act of relinquishment in perpetuity of all present
+and future rights under copyright law, whether vested or contingent, in the
+Work. Dedicator understands that such relinquishment of all rights includes
+the relinquishment of all rights to enforce (by lawsuit or otherwise) those
+copyrights in the Work.
+
+Dedicator recognizes that, once placed in the public domain, the Work may be
+freely reproduced, distributed, transmitted, used, modified, built upon, or
+otherwise exploited by anyone for any purpose, commercial or non-commercial,
+and in any way, including by methods that have not yet been invented or
+conceived.

libb64-encode/README.md

@@ -0,0 +1,27 @@
+libb64: Base64 Encoding C Routine
+=================================
+
+From project: <http://libb64.sourceforge.net/> (latest CVS source from <http://libb64.cvs.sourceforge.net/viewvc/libb64/>)
+
+LICENSE:
+--------
+
+Public domain
+
+Authors:
+--------
+
+- Chris Venter ([@gorb314](https://github.com/gorb314))
+- Christopher J. Brody ([@brodybits](https://github.com/brodybits))
+
+Major changes:
+--------------
+
+- Use macro instead of function to encode each value
+- Line breaks disabled by default
+- Include fixed for iOS build
+
+Other versions:
+---------------
+
+- <https://github.com/libb64/libb64>

libb64-encode/cencode.c

@@ -0,0 +1,116 @@
+/*
+cencoder.c - c source to a base64 encoding algorithm implementation
+
+This is part of the libb64 project, and has been placed in the public domain.
+For details, see http://sourceforge.net/projects/libb64
+*/
+
+#include "cencode.h"
+
+#ifdef B64_ENCODE_LINE_BREAKS
+const int CHARS_PER_LINE = 72;
+#endif
+
+static const char * ENCODING_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+#define ENCODE_VALUE(value) (((value) < 0 || (value) > 63) ? '=' : (ENCODING_CHARS[(int)(value)]))
+
+void base64_init_encodestate(base64_encodestate* state_in)
+{
+	state_in->step = step_A;
+	state_in->result = 0;
+	state_in->stepcount = 0;
+}
+
+char base64_encode_value(char value_in)
+{
+	return ENCODE_VALUE(value_in);
+}
+
+int base64_encode_block(const char* plaintext_in, int length_in, char* code_out, base64_encodestate* state_in)
+{
+	const char* plainchar = plaintext_in;
+	const char* const plaintextend = plaintext_in + length_in;
+	char* codechar = code_out;
+	char result;
+	char fragment;
+
+	result = state_in->result;
+
+	switch (state_in->step)
+	{
+		while (1)
+		{
+	case step_A:
+			if (plainchar == plaintextend)
+			{
+				state_in->result = result;
+				state_in->step = step_A;
+				return codechar - code_out;
+			}
+			fragment = *plainchar++;
+			result = (fragment & 0x0fc) >> 2;
+			*codechar++ = ENCODE_VALUE(result);
+			result = (fragment & 0x003) << 4;
+	case step_B:
+			if (plainchar == plaintextend)
+			{
+				state_in->result = result;
+				state_in->step = step_B;
+				return codechar - code_out;
+			}
+			fragment = *plainchar++;
+			result |= (fragment & 0x0f0) >> 4;
+			*codechar++ = ENCODE_VALUE(result);
+			result = (fragment & 0x00f) << 2;
+	case step_C:
+			if (plainchar == plaintextend)
+			{
+				state_in->result = result;
+				state_in->step = step_C;
+				return codechar - code_out;
+			}
+			fragment = *plainchar++;
+			result |= (fragment & 0x0c0) >> 6;
+			*codechar++ = ENCODE_VALUE(result);
+			result  = (fragment & 0x03f) >> 0;
+			*codechar++ = ENCODE_VALUE(result);
+
+			++(state_in->stepcount);
+#ifdef B64_ENCODE_LINE_BREAKS
+			if (state_in->stepcount == CHARS_PER_LINE/4)
+			{
+				*codechar++ = '\n';
+				state_in->stepcount = 0;
+			}
+#endif
+		}
+	}
+	/* control should not reach here */
+	return codechar - code_out;
+}
+
+int base64_encode_blockend(char* code_out, base64_encodestate* state_in)
+{
+	char* codechar = code_out;
+
+	switch (state_in->step)
+	{
+	case step_B:
+		*codechar++ = ENCODE_VALUE(state_in->result);
+		*codechar++ = '=';
+		*codechar++ = '=';
+		break;
+	case step_C:
+		*codechar++ = ENCODE_VALUE(state_in->result);
+		*codechar++ = '=';
+		break;
+	case step_A:
+		break;
+	}
+#ifdef B64_ENCODE_LINE_BREAKS
+	*codechar++ = '\n';
+#endif
+
+	return codechar - code_out;
+}

libb64-encode/cencode.h

@@ -0,0 +1,64 @@
+/*
+
+cencode.h - c header for a base64 encoding algorithm
+
+
+
+This is part of the libb64 project, and has been placed in the public domain.
+
+For details, see http://sourceforge.net/projects/libb64
+
+*/
+
+
+
+#ifndef BASE64_CENCODE_H
+
+#define BASE64_CENCODE_H
+
+
+
+typedef enum
+
+{
+
+	step_A, step_B, step_C
+
+} base64_encodestep;
+
+
+
+typedef struct
+
+{
+
+	base64_encodestep step;
+
+	char result;
+
+	int stepcount;
+
+} base64_encodestate;
+
+
+
+void base64_init_encodestate(base64_encodestate* state_in);
+
+
+
+char base64_encode_value(char value_in);
+
+
+
+int base64_encode_block(const char* plaintext_in, int length_in, char* code_out, base64_encodestate* state_in);
+
+
+
+int base64_encode_blockend(char* code_out, base64_encodestate* state_in);
+
+
+
+#endif /* BASE64_CENCODE_H */
+
+
+

package.json

@@ -1,6 +1,6 @@
 {
   "name": "cordova-sqlite-evcore-free-dependencies",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "description": "Cordova sqlite evcore free dependencies",
   "main": "404.js",
   "scripts": {

sqlite3-base64/README.md

@@ -0,0 +1,27 @@
+# sqlite3-base64
+
+Add BASE64 encoding function to sqlite3.
+
+**LICENSE:** UNLICENSE (public domain) ref: <http://unlicense.org/>
+
+## External dependencies
+
+- `cencode.h`, `cencode.c` from <http://libb64.sourceforge.net/> (public domain)
+- `sqlite3.h`
+
+**NOTE:** `cencode.h` must be in the build path.
+
+## Sample usage
+
+After opening sqlite3 database:
+
+```c
+sqlite3_base64_init(db);
+```
+
+Then the following SQL:
+```sql
+SELECT BASE64(X'010203')
+```
+
+returns the following value: `AQID`

sqlite3-base64/sqlite3_base64.c

@@ -0,0 +1,39 @@
+#include "sqlite3_base64.h"
+
+#include "cencode.h"
+
+#include <string.h>
+#include <stdint.h>
+
+static
+void sqlite3_base64(sqlite3_context * context, int argc, sqlite3_value ** argv) {
+  if (argc < 1) {
+    sqlite3_result_null(context);
+  } else {
+    // THANKS FOR GUIDANCE:
+    // http://www.sqlite.org/cgi/src/artifact/43916c1d8e6da5d1
+    // (src/func.c:hexFunc)
+    sqlite3_value * first = argv[0];
+
+    const uint8_t * blob = sqlite3_value_blob(first);
+
+    const int blen = sqlite3_value_bytes(first);
+
+    char * b64 = sqlite3_malloc(blen*2);
+
+    base64_encodestate es;
+    base64_init_encodestate(&es);
+
+    {
+      const int len1 = base64_encode_block(blob, blen, b64, &es);
+      const int len = len1 + base64_encode_blockend(b64 + len1, &es);
+
+      sqlite3_result_text(context, b64, len, sqlite3_free);
+    }
+  }
+}
+
+int sqlite3_base64_init(sqlite3 * db)
+{
+    return sqlite3_create_function_v2(db, "BASE64", 1, SQLITE_ANY | SQLITE_DETERMINISTIC, NULL, sqlite3_base64, NULL, NULL, NULL);
+}

sqlite3-base64/sqlite3_base64.h

@@ -0,0 +1,11 @@
+#include "sqlite3.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int sqlite3_base64_init(sqlite3 * db);
+
+#ifdef __cplusplus
+}
+#endif

sqlite3-regexp-cached/LICENSE

@@ -0,0 +1,9 @@
+Adapted by Christopher J. Brody <[email protected]>.
+
+Based on sqlite3-pcre:
+Written by Alexey Tourbin <[email protected]>.
+
+The author has dedicated the code to the public domain.  Anyone is free
+to copy, modify, publish, use, compile, sell, or distribute the original
+code, either in source code form or as a compiled binary, for any purpose,
+commercial or non-commercial, and by any means.

sqlite3-regexp-cached/README.md

@@ -0,0 +1,26 @@
+# sqlite3-regexp-cached
+
+Provide REGEXP function for SQLite3 with regex caching, using BSD REGEX functions.
+
+Default cache size: 16
+
+`SQLITE3_REGEXP_CACHE_SIZE` may be defined to change the regex cache size.
+
+Based on: <http://git.altlinux.org/people/at/packages/?p=sqlite3-pcre.git>
+
+Sample usage (opening database):
+```c
+sqlite3 * db;
+int rc;
+const char * err;
+
+rc = sqlite3_open_v2("my.db", &db, SQLITE_OPEN_CREATE, NULL);
+
+if (rc == 0) {
+    rc = sqlite3_regexp_init(db, &err);
+}
+```
+
+**LICENSE:** public domain
+
+Other GitHub version of sqlite3-pcre: <https://github.com/ralight/sqlite3-pcre>