cordova-sqlite-evmax-build-free 0.0.4 → 0.0.5

package/spec/www/spec/sqlite-version-test.js

@@ -104,7 +104,7 @@ var mytests = function() {
               expect(rs).toBeDefined();
               expect(rs.rows).toBeDefined();
               expect(rs.rows.length).toBe(1);
-              expect(rs.rows.item(0).myResult).toBe('3.37.2');
+              expect(rs.rows.item(0).myResult).toBe('3.38.5');
 
               // Close (plugin only) & finish:
               (isWebSql) ? done() : db.close(done, done);

package/src/android/io/sqlc/SQLitePlugin.java

@@ -410,7 +410,7 @@ public class SQLitePlugin extends CordovaPlugin {
         @Override
         void closeDatabaseNow() {
             try {
-                if (mydbhandle > 0) EVNDKDriver.sqlc_db_close(mydbhandle);
+                if (mydbhandle != EVNDKDriver.SQLC_NULL_HANDLE) EVNDKDriver.sqlc_db_close(mydbhandle);
             } catch (Exception e) {
                 Log.e(SQLitePlugin.class.getSimpleName(), "couldn't close database, ignoring", e);
             }
@@ -423,8 +423,11 @@ public class SQLitePlugin extends CordovaPlugin {
         void bugWorkaround() { }
 
         /* ** NOT USED in this plugin version:
-        String flatBatchJSON(...) {
-            // ...
+        String flatBatchJSON(String batch_json, int ll) {
+            long ch = EVNDKDriver.sqlc_evcore_db_new_qc(mydbhandle);
+            String jr = EVNDKDriver.sqlc_evcore_qc_execute(ch, batch_json, ll);
+            EVNDKDriver.sqlc_evcore_qc_finalize(ch);
+            return jr;
         }
         // ** */
     }

package/src/deps/common/libb64-core/README.md

@@ -0,0 +1,31 @@
+libb64: Base64 C Routines
+=========================
+
+From projects:
+
+- <https://github.com/gorb314/libb64>
+- <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 in cencode.c by default
+- Flatter include statements to make iOS build easier
+
+Other versions:
+---------------
+
+- <https://github.com/gorb314/libb64>
+- <https://github.com/libb64/libb64>

package/src/deps/common/libb64-core/cdecode.c

@@ -0,0 +1,93 @@
+/*
+cdecoder.c - c source to a base64 decoding 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 "cdecode.h"
+
+int base64_decode_value(char value_in)
+{
+	static const char decoding[] = {62,-1,-1,-1,63,52,53,54,55,56,57,58,59,60,61,-1,-1,-1,-2,-1,-1,-1,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,-1,-1,-1,-1,-1,-1,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51};
+	static const char decoding_size = sizeof(decoding);
+	value_in -= 43;
+	if (value_in < 0 || value_in >= decoding_size) return -1;
+	return decoding[(int)value_in];
+}
+
+void base64_init_decodestate(base64_decodestate* state_in)
+{
+	state_in->step = step_a;
+	state_in->plainchar = 0;
+}
+
+int base64_decode_block(const char* code_in, const int length_in, char* plaintext_out, base64_decodestate* state_in)
+{
+	const char* codechar = code_in;
+	char* plainchar = plaintext_out;
+	int value;
+	char fragment;
+
+	*plainchar = state_in->plainchar;
+
+	switch (state_in->step)
+	{
+		while (1)
+		{
+	case step_a:
+			do {
+				if (codechar == code_in+length_in)
+				{
+					state_in->step = step_a;
+					state_in->plainchar = *plainchar;
+					return plainchar - plaintext_out;
+				}
+				value = base64_decode_value(*codechar++);
+				fragment = (char)value;
+			} while (value < 0);
+			*plainchar    = (fragment & 0x03f) << 2;
+	case step_b:
+			do {
+				if (codechar == code_in+length_in)
+				{
+					state_in->step = step_b;
+					state_in->plainchar = *plainchar;
+					return plainchar - plaintext_out;
+				}
+				value = base64_decode_value(*codechar++);
+				fragment = (char)value;
+			} while (value < 0);
+			*plainchar++ |= (fragment & 0x030) >> 4;
+			*plainchar    = (fragment & 0x00f) << 4;
+	case step_c:
+			do {
+				if (codechar == code_in+length_in)
+				{
+					state_in->step = step_c;
+					state_in->plainchar = *plainchar;
+					return plainchar - plaintext_out;
+				}
+				value = base64_decode_value(*codechar++);
+				fragment = (char)value;
+			} while (value < 0);
+			*plainchar++ |= (fragment & 0x03c) >> 2;
+			*plainchar    = (fragment & 0x003) << 6;
+	case step_d:
+			do {
+				if (codechar == code_in+length_in)
+				{
+					state_in->step = step_d;
+					state_in->plainchar = *plainchar;
+					return plainchar - plaintext_out;
+				}
+				value = base64_decode_value(*codechar++);
+				fragment = (char)value;
+			} while (value < 0);
+			*plainchar++   |= (fragment & 0x03f);
+		}
+	}
+	/* control should not reach here */
+	return plainchar - plaintext_out;
+}
+

package/src/deps/common/libb64-core/cdecode.h

@@ -0,0 +1,29 @@
+/*
+cdecode.h - c header for a base64 decoding 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_CDECODE_H
+#define BASE64_CDECODE_H
+
+typedef enum
+{
+	step_a, step_b, step_c, step_d
+} base64_decodestep;
+
+typedef struct
+{
+	base64_decodestep step;
+	char plainchar;
+} base64_decodestate;
+
+void base64_init_decodestate(base64_decodestate* state_in);
+
+int base64_decode_value(char value_in);
+
+int base64_decode_block(const char* code_in, const int length_in, char* plaintext_out, base64_decodestate* state_in);
+
+#endif /* BASE64_CDECODE_H */
+

package/src/deps/common/sqlite3-base64/README.md

@@ -1,15 +1,18 @@
 # sqlite3-base64
 
-Add BASE64 encoding function to sqlite3.
+Add base-64 encoding & decoding functions to SQLite3:
+
+- `BASE64`
+- `BLOBFROMBASE64`
 
 **LICENSE:** UNLICENSE (public domain) ref: <http://unlicense.org/>
 
 ## External dependencies
 
-- `cencode.h`, `cencode.c` from <http://libb64.sourceforge.net/> (public domain)
+- `cencode.h`, `cencode.c`, `cdecode.h`, `cdecode.c` from <https://github.com/gorb314/libb64> or a fork such as <https://github.com/brodybits/libb64-core> (public domain)
 - `sqlite3.h`
 
-**NOTE:** `cencode.h` must be in the build path.
+**NOTE:** `cencode.h` and `cdecode.h` must be in the build path.
 
 ## Sample usage
 
@@ -24,4 +27,15 @@ Then the following SQL:
 SELECT BASE64(X'010203')
 ```
 
-returns the following value: `AQID`
+returns the following value _ending with a newline (`\n`)_:
+```
+AQID
+```
+
+And the following SQL:
+
+```sql
+SELECT HEX(BLOBFROMBASE64('AQID'))
+```
+
+returns the following value: `010203`

package/src/deps/common/sqlite3-base64/sqlite3_base64.c

@@ -2,6 +2,8 @@
 
 #include "cencode.h"
 
+#include "cdecode.h"
+
 #include <string.h>
 #include <stdint.h>
 
@@ -11,7 +13,7 @@ void sqlite3_base64(sqlite3_context * context, int argc, sqlite3_value ** argv)
     sqlite3_result_null(context);
   } else {
     // THANKS FOR GUIDANCE:
-    // http://www.sqlite.org/cgi/src/artifact/43916c1d8e6da5d1
+    // https://www.sqlite.org/cgi/src/artifact/43916c1d8e6da5d1
     // (src/func.c:hexFunc)
     sqlite3_value * first = argv[0];
 
@@ -33,7 +35,40 @@ void sqlite3_base64(sqlite3_context * context, int argc, sqlite3_value ** argv)
   }
 }
 
+static
+void sqlite3_blobfrombase64(
+  sqlite3_context * context,
+  int argc,
+  sqlite3_value ** argv
+) {
+  // Base64 value is WANTED in TEXT format
+  // It *may* be possible to get Base64 from INTEGER, does not seem interesting.
+  if (argc < 1 || sqlite3_value_type(argv[0]) != SQLITE_TEXT) {
+    sqlite3_result_null(context);
+  } else {
+    // get the info
+    sqlite3_value * first = argv[0];
+    const uint8_t * base64 = sqlite3_value_text(first);
+
+    const int base64_length = sqlite3_value_bytes(first);
+
+    // overestimating length needed is **much** better than underestimating !!
+    const uint8_t * blob = sqlite3_malloc(base64_length);
+
+    base64_decodestate ds;
+    base64_init_decodestate(&ds);
+
+    {
+      const int len = base64_decode_block(base64, base64_length, blob, &ds);
+
+      sqlite3_result_blob(context, blob, 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_create_function_v2(db, "BASE64", 1, SQLITE_ANY | SQLITE_DETERMINISTIC, NULL, sqlite3_base64, NULL, NULL, NULL);
+  sqlite3_create_function_v2(db, "BLOBFROMBASE64", 1, SQLITE_ANY | SQLITE_DETERMINISTIC, NULL, sqlite3_blobfrombase64, NULL, NULL, NULL);
+  return 0;
 }