koffi 2.2.0 → 2.2.2-beta.1

package/vendor/sqlite3/wasm/common/SqliteTestUtil.js

@@ -0,0 +1,236 @@
+/*
+  2022-05-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 bootstrapping code used by various test scripts
+  which live in this file's directory.
+*/
+'use strict';
+(function(self){
+  /* querySelectorAll() proxy */
+  const EAll = function(/*[element=document,] cssSelector*/){
+    return (arguments.length>1 ? arguments[0] : document)
+      .querySelectorAll(arguments[arguments.length-1]);
+  };
+  /* querySelector() proxy */
+  const E = function(/*[element=document,] cssSelector*/){
+    return (arguments.length>1 ? arguments[0] : document)
+      .querySelector(arguments[arguments.length-1]);
+  };
+
+  /**
+     Helpers for writing sqlite3-specific tests.
+  */
+  self.SqliteTestUtil = {
+    /** Running total of the number of tests run via
+        this API. */
+    counter: 0,
+    /**
+       If expr is a function, it is called and its result
+       is returned, coerced to a bool, else expr, coerced to
+       a bool, is returned.
+    */
+    toBool: function(expr){
+      return (expr instanceof Function) ? !!expr() : !!expr;
+    },
+    /** abort() if expr is false. If expr is a function, it
+        is called and its result is evaluated.
+    */
+    assert: function f(expr, msg){
+      if(!f._){
+        f._ = ('undefined'===typeof abort
+               ? (msg)=>{throw new Error(msg)}
+               : abort);
+      }
+      ++this.counter;
+      if(!this.toBool(expr)){
+        f._(msg || "Assertion failed.");
+      }
+      return this;
+    },
+    /** Identical to assert() but throws instead of calling
+        abort(). */
+    affirm: function(expr, msg){
+      ++this.counter;
+      if(!this.toBool(expr)) throw new Error(msg || "Affirmation failed.");
+      return this;
+    },
+    /** Calls f() and squelches any exception it throws. If it
+        does not throw, this function throws. */
+    mustThrow: function(f, msg){
+      ++this.counter;
+      let err;
+      try{ f(); } catch(e){err=e;}
+      if(!err) throw new Error(msg || "Expected exception.");
+      return this;
+    },
+    /**
+       Works like mustThrow() but expects filter to be a regex,
+       function, or string to match/filter the resulting exception
+       against. If f() does not throw, this test fails and an Error is
+       thrown. If filter is a regex, the test passes if
+       filter.test(error.message) passes. If it's a function, the test
+       passes if filter(error) returns truthy. If it's a string, the
+       test passes if the filter matches the exception message
+       precisely. In all other cases the test fails, throwing an
+       Error.
+
+       If it throws, msg is used as the error report unless it's falsy,
+       in which case a default is used.
+    */
+    mustThrowMatching: function(f, filter, msg){
+      ++this.counter;
+      let err;
+      try{ f(); } catch(e){err=e;}
+      if(!err) throw new Error(msg || "Expected exception.");
+      let pass = false;
+      if(filter instanceof RegExp) pass = filter.test(err.message);
+      else if(filter instanceof Function) pass = filter(err);
+      else if('string' === typeof filter) pass = (err.message === filter);
+      if(!pass){
+        throw new Error(msg || ("Filter rejected this exception: "+err.message));
+      }
+      return this;
+    },
+    /** Throws if expr is truthy or expr is a function and expr()
+        returns truthy. */
+    throwIf: function(expr, msg){
+      ++this.counter;
+      if(this.toBool(expr)) throw new Error(msg || "throwIf() failed");
+      return this;
+    },
+    /** Throws if expr is falsy or expr is a function and expr()
+        returns falsy. */
+    throwUnless: function(expr, msg){
+      ++this.counter;
+      if(!this.toBool(expr)) throw new Error(msg || "throwUnless() failed");
+      return this;
+    },
+
+    /**
+       Parses window.location.search-style string into an object
+       containing key/value pairs of URL arguments (already
+       urldecoded). The object is created using Object.create(null),
+       so contains only parsed-out properties and has no prototype
+       (and thus no inherited properties).
+
+       If the str argument is not passed (arguments.length==0) then
+       window.location.search.substring(1) is used by default. If
+       neither str is passed in nor window exists then false is returned.
+
+       On success it returns an Object containing the key/value pairs
+       parsed from the string. Keys which have no value are treated
+       has having the boolean true value.
+
+       Pedantic licensing note: this code has appeared in other source
+       trees, but was originally written by the same person who pasted
+       it into those trees.
+    */
+    processUrlArgs: function(str) {
+      if( 0 === arguments.length ) {
+        if( ('undefined' === typeof window) ||
+            !window.location ||
+            !window.location.search )  return false;
+        else str = (''+window.location.search).substring(1);
+      }
+      if( ! str ) return false;
+      str = (''+str).split(/#/,2)[0]; // remove #... to avoid it being added as part of the last value.
+      const args = Object.create(null);
+      const sp = str.split(/&+/);
+      const rx = /^([^=]+)(=(.+))?/;
+      var i, m;
+      for( i in sp ) {
+        m = rx.exec( sp[i] );
+        if( ! m ) continue;
+        args[decodeURIComponent(m[1])] = (m[3] ? decodeURIComponent(m[3]) : true);
+      }
+      return args;
+    }
+  };
+
+  
+  /**
+     This is a module object for use with the emscripten-installed
+     sqlite3InitModule() factory function.
+  */
+  self.sqlite3TestModule = {
+    /**
+       Array of functions to call after Emscripten has initialized the
+       wasm module. Each gets passed the Emscripten module object
+       (which is _this_ object).
+    */
+    postRun: [
+      /* function(theModule){...} */
+    ],
+    //onRuntimeInitialized: function(){},
+    /* Proxy for C-side stdout output. */
+    print: (...args)=>{console.log(...args)},
+    /* Proxy for C-side stderr output. */
+    printErr: (...args)=>{console.error(...args)},
+    /**
+       Called by the Emscripten module init bits to report loading
+       progress. It gets passed an empty argument when loading is done
+       (after onRuntimeInitialized() and any this.postRun callbacks
+       have been run).
+    */
+    setStatus: function f(text){
+      if(!f.last){
+        f.last = { text: '', step: 0 };
+        f.ui = {
+          status: E('#module-status'),
+          progress: E('#module-progress'),
+          spinner: E('#module-spinner')
+        };
+      }
+      if(text === f.last.text) return;
+      f.last.text = text;
+      if(f.ui.progress){
+        f.ui.progress.value = f.last.step;
+        f.ui.progress.max = f.last.step + 1;
+      }
+      ++f.last.step;
+      if(text) {
+        f.ui.status.classList.remove('hidden');
+        f.ui.status.innerText = text;
+      }else{
+        if(f.ui.progress){
+          f.ui.progress.remove();
+          f.ui.spinner.remove();
+          delete f.ui.progress;
+          delete f.ui.spinner;
+        }
+        f.ui.status.classList.add('hidden');
+      }
+    },
+    /**
+       Config options used by the Emscripten-dependent initialization
+       which happens via this.initSqlite3(). This object gets
+       (indirectly) passed to sqlite3ApiBootstrap() to configure the
+       sqlite3 API.
+    */
+    sqlite3ApiConfig: {
+      wasmfsOpfsDir: "/opfs"
+    },
+    /**
+       Intended to be called by apps which need to call the
+       Emscripten-installed sqlite3InitModule() routine. This function
+       temporarily installs this.sqlite3ApiConfig into the self
+       object, calls it sqlite3InitModule(), and removes
+       self.sqlite3ApiConfig after initialization is done. Returns the
+       promise from sqlite3InitModule(), and the next then() handler
+       will get the sqlite3 API object as its argument.
+    */
+    initSqlite3: function(){
+      self.sqlite3ApiConfig = this.sqlite3ApiConfig;
+      return self.sqlite3InitModule(this).finally(()=>delete self.sqlite3ApiConfig);
+    }
+  };
+})(self/*window or worker*/);

package/vendor/sqlite3/wasm/common/emscripten.css

@@ -0,0 +1,24 @@
+/* emcscript-related styling, used during the module load/intialization processes... */
+.emscripten { padding-right: 0; margin-left: auto; margin-right: auto; display: block; }
+div.emscripten { text-align: center; }
+div.emscripten_border { border: 1px solid black; }
+#module-spinner { overflow: visible; }
+#module-spinner > * {
+    margin-top: 1em;
+}
+.spinner {
+    height: 50px;
+    width: 50px;
+    margin: 0px auto;
+    animation: rotation 0.8s linear infinite;
+    border-left: 10px solid rgb(0,150,240);
+    border-right: 10px solid rgb(0,150,240);
+    border-bottom: 10px solid rgb(0,150,240);
+    border-top: 10px solid rgb(100,0,200);
+    border-radius: 100%;
+    background-color: rgb(200,100,250);
+}
+@keyframes rotation {
+    from {transform: rotate(0deg);}
+    to {transform: rotate(360deg);}
+}

package/vendor/sqlite3/wasm/common/testing.css

@@ -0,0 +1,63 @@
+body {
+  display: flex;
+  flex-direction: column;
+  flex-wrap: wrap;
+}
+textarea {
+    font-family: monospace;
+}
+header {
+    font-size: 130%;
+    font-weight: bold;
+}
+.hidden, .initially-hidden {
+    position: absolute !important;
+    opacity: 0 !important;
+    pointer-events: none !important;
+    display: none !important;
+}
+fieldset.options {
+    font-size: 75%;
+}
+fieldset > legend {
+    padding: 0 0.5em;
+}
+span.labeled-input {
+    padding: 0.25em;
+    margin: 0.25em 0.5em;
+    border-radius: 0.25em;
+    white-space: nowrap;
+    background: #0002;
+}
+.center { text-align: center; }
+.error {
+    color: red;
+    background-color: yellow;
+}
+.strong { font-weight: 700 }
+.warning { color: firebrick; }
+.green { color: darkgreen; }
+.tests-pass { background-color: green; color: white }
+.tests-fail { background-color: red; color: yellow }
+.faded { opacity: 0.5; }
+.group-start { color: blue; }
+.group-end { color: blue; }
+.input-wrapper {
+  white-space: nowrap;
+  display: flex;
+  align-items: center;
+}
+#test-output {
+  border: 1px inset;
+  border-radius: 0.25em;
+  padding: 0.25em;
+  /*max-height: 30em;*/
+  overflow: auto;
+  white-space: break-spaces;
+  display: flex; flex-direction: column;
+  font-family: monospace;
+}
+#test-output.reverse {
+  flex-direction: column-reverse;
+}
+label[for] { cursor: pointer }

package/vendor/sqlite3/wasm/demo-123-worker.html

@@ -0,0 +1,44 @@
+<!doctype html>
+<html lang="en-us">
+  <head>
+    <meta charset="utf-8">
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+    <link rel="shortcut icon" href="data:image/x-icon;," type="image/x-icon">
+    <title>Hello, sqlite3</title>
+    <style>
+      .warning, .error {color: red}
+      .error {background-color: yellow}
+      body {
+          display: flex;
+          flex-direction: column;
+          font-family: monospace;
+          white-space: break-spaces;
+      }
+    </style>
+  </head>
+  <body>
+    <h1>1-2-sqlite3 worker demo</h1>
+    <script>(function(){
+      const logHtml = function(cssClass,...args){
+        const ln = document.createElement('div');
+        if(cssClass) ln.classList.add(cssClass);
+        ln.append(document.createTextNode(args.join(' ')));
+        document.body.append(ln);
+      };
+      const w = new Worker("demo-123.js?sqlite3.dir=jswasm"
+                           /* Note the URL argument on that name. See
+                              the notes in demo-123.js (search for
+                              "importScripts") for why we need
+                              that. */);
+      w.onmessage = function({data}){
+        switch(data.type){
+            case 'log':
+              logHtml(data.payload.cssClass, ...data.payload.args);
+              break;
+            default:
+              logHtml('error',"Unhandled message:",data.type);
+        };
+      };
+    })();</script>
+  </body>
+</html>

package/vendor/sqlite3/wasm/demo-123.html

@@ -0,0 +1,24 @@
+<!doctype html>
+<html lang="en-us">
+  <head>
+    <meta charset="utf-8">
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+    <link rel="shortcut icon" href="data:image/x-icon;," type="image/x-icon">
+    <title>Hello, sqlite3</title>
+    <style>
+      .warning, .error {color: red}
+      .error {background-color: yellow}
+      body {
+          display: flex;
+          flex-direction: column;
+          font-family: monospace;
+          white-space: break-spaces;
+      }
+    </style>
+  </head>
+  <body>
+    <h1>1-2-sqlite3 demo</h1>
+    <script src="jswasm/sqlite3.js"></script>
+    <script src="demo-123.js"></script>
+  </body>
+</html>

package/vendor/sqlite3/wasm/demo-123.js

@@ -0,0 +1,289 @@
+/*
+  2022-09-19
+
+  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.
+
+  ***********************************************************************
+
+  A basic demonstration of the SQLite3 "OO#1" API.
+*/
+'use strict';
+(function(){
+  /**
+     Set up our output channel differently depending
+     on whether we are running in a worker thread or
+     the main (UI) thread.
+  */
+  let logHtml;
+  if(self.window === self /* UI thread */){
+    console.log("Running demo from main UI thread.");
+    logHtml = function(cssClass,...args){
+      const ln = document.createElement('div');
+      if(cssClass) ln.classList.add(cssClass);
+      ln.append(document.createTextNode(args.join(' ')));
+      document.body.append(ln);
+    };
+  }else{ /* Worker thread */
+    console.log("Running demo from Worker thread.");
+    logHtml = function(cssClass,...args){
+      postMessage({
+        type:'log',
+        payload:{cssClass, args}
+      });
+    };
+  }
+  const log = (...args)=>logHtml('',...args);
+  const warn = (...args)=>logHtml('warning',...args);
+  const error = (...args)=>logHtml('error',...args);
+
+  const demo1 = function(sqlite3){
+    const capi = sqlite3.capi/*C-style API*/,
+          oo = sqlite3.oo1/*high-level OO API*/;
+    log("sqlite3 version",capi.sqlite3_libversion(), capi.sqlite3_sourceid());
+    const db = new oo.DB("/mydb.sqlite3",'ct');
+    log("transient db =",db.filename);
+    /**
+       Never(!) rely on garbage collection to clean up DBs and
+       (especially) prepared statements. Always wrap their lifetimes
+       in a try/finally construct, as demonstrated below. By and
+       large, client code can entirely avoid lifetime-related
+       complications of prepared statement objects by using the
+       DB.exec() method for SQL execution.
+    */
+    try {
+      log("Create a table...");
+      db.exec("CREATE TABLE IF NOT EXISTS t(a,b)");
+      //Equivalent:
+      db.exec({
+        sql:"CREATE TABLE IF NOT EXISTS t(a,b)"
+        // ... numerous other options ... 
+      });
+      // SQL can be either a string or a byte array
+      // or an array of strings which get concatenated
+      // together as-is (so be sure to end each statement
+      // with a semicolon).
+
+      log("Insert some data using exec()...");
+      let i;
+      for( i = 20; i <= 25; ++i ){
+        db.exec({
+          sql: "insert into t(a,b) values (?,?)",
+          // bind by parameter index...
+          bind: [i, i*2]
+        });
+        db.exec({
+          sql: "insert into t(a,b) values ($a,$b)",
+          // bind by parameter name...
+          bind: {$a: i * 10, $b: i * 20}
+        });
+      }    
+
+      log("Insert using a prepared statement...");
+      let q = db.prepare([
+        // SQL may be a string or array of strings
+        // (concatenated w/o separators).
+        "insert into t(a,b) ",
+        "values(?,?)"
+      ]);
+      try {
+        for( i = 100; i < 103; ++i ){
+          q.bind( [i, i*2] ).step();
+          q.reset();
+        }
+        // Equivalent...
+        for( i = 103; i <= 105; ++i ){
+          q.bind(1, i).bind(2, i*2).stepReset();
+        }
+      }finally{
+        q.finalize();
+      }
+
+      log("Query data with exec() using rowMode 'array'...");
+      db.exec({
+        sql: "select a from t order by a limit 3",
+        rowMode: 'array', // 'array' (default), 'object', or 'stmt'
+        callback: function(row){
+          log("row ",++this.counter,"=",row);
+        }.bind({counter: 0})
+      });
+
+      log("Query data with exec() using rowMode 'object'...");
+      db.exec({
+        sql: "select a as aa, b as bb from t order by aa limit 3",
+        rowMode: 'object',
+        callback: function(row){
+          log("row ",++this.counter,"=",JSON.stringify(row));
+        }.bind({counter: 0})
+      });
+
+      log("Query data with exec() using rowMode 'stmt'...");
+      db.exec({
+        sql: "select a from t order by a limit 3",
+        rowMode: 'stmt',
+        callback: function(row){
+          log("row ",++this.counter,"get(0) =",row.get(0));
+        }.bind({counter: 0})
+      });
+
+      log("Query data with exec() using rowMode INTEGER (result column index)...");
+      db.exec({
+        sql: "select a, b from t order by a limit 3",
+        rowMode: 1, // === result column 1
+        callback: function(row){
+          log("row ",++this.counter,"b =",row);
+        }.bind({counter: 0})
+      });
+
+      log("Query data with exec() using rowMode $COLNAME (result column name)...");
+      db.exec({
+        sql: "select a a, b from t order by a limit 3",
+        rowMode: '$a',
+        callback: function(value){
+          log("row ",++this.counter,"a =",value);
+        }.bind({counter: 0})
+      });
+
+      log("Query data with exec() without a callback...");
+      let resultRows = [];
+      db.exec({
+        sql: "select a, b from t order by a limit 3",
+        rowMode: 'object',
+        resultRows: resultRows
+      });
+      log("Result rows:",JSON.stringify(resultRows,undefined,2));
+
+      log("Create a scalar UDF...");
+      db.createFunction({
+        name: 'twice',
+        xFunc: function(pCx, arg){ // note the call arg count
+          return arg + arg;
+        }
+      });
+      log("Run scalar UDF and collect result column names...");
+      let columnNames = [];
+      db.exec({
+        sql: "select a, twice(a), twice(''||a) from t order by a desc limit 3",
+        columnNames: columnNames,
+        rowMode: 'stmt',
+        callback: function(row){
+          log("a =",row.get(0), "twice(a) =", row.get(1),
+              "twice(''||a) =",row.get(2));
+        }
+      });
+      log("Result column names:",columnNames);
+
+      try{
+        log("The following use of the twice() UDF will",
+            "fail because of incorrect arg count...");
+        db.exec("select twice(1,2,3)");
+      }catch(e){
+        warn("Got expected exception:",e.message);
+      }
+
+      try {
+        db.transaction( function(D) {
+          D.exec("delete from t");
+          log("In transaction: count(*) from t =",db.selectValue("select count(*) from t"));
+          throw new sqlite3.SQLite3Error("Demonstrating transaction() rollback");
+        });
+      }catch(e){
+        if(e instanceof sqlite3.SQLite3Error){
+          log("Got expected exception from db.transaction():",e.message);
+          log("count(*) from t =",db.selectValue("select count(*) from t"));
+        }else{
+          throw e;
+        }
+      }
+
+      try {
+        db.savepoint( function(D) {
+          D.exec("delete from t");
+          log("In savepoint: count(*) from t =",db.selectValue("select count(*) from t"));
+          D.savepoint(function(DD){
+            const rows = [];
+            DD.exec({
+              sql: ["insert into t(a,b) values(99,100);",
+                    "select count(*) from t"],
+              rowMode: 0,
+              resultRows: rows
+            });
+            log("In nested savepoint. Row count =",rows[0]);
+            throw new sqlite3.SQLite3Error("Demonstrating nested savepoint() rollback");
+          })
+        });
+      }catch(e){
+        if(e instanceof sqlite3.SQLite3Error){
+          log("Got expected exception from nested db.savepoint():",e.message);
+          log("count(*) from t =",db.selectValue("select count(*) from t"));
+        }else{
+          throw e;
+        }
+      }
+    }finally{
+      db.close();
+    }
+
+    log("That's all, folks!");
+
+    /**
+       Some of the features of the OO API not demonstrated above...
+
+       - get change count (total or statement-local, 32- or 64-bit)
+       - get a DB's file name
+    
+       Misc. Stmt features:
+
+       - Various forms of bind() 
+       - clearBindings()
+       - reset()
+       - Various forms of step()
+       - Variants of get() for explicit type treatment/conversion,
+         e.g. getInt(), getFloat(), getBlob(), getJSON()
+       - getColumnName(ndx), getColumnNames()
+       - getParamIndex(name)
+    */
+  }/*demo1()*/;
+
+  log("Loading and initializing sqlite3 module...");
+  if(self.window!==self) /*worker thread*/{
+    /*
+      If sqlite3.js is in a directory other than this script, in order
+      to get sqlite3.js to resolve sqlite3.wasm properly, we have to
+      explicitly tell it where sqlite3.js is being loaded from. We do
+      that by passing the `sqlite3.dir=theDirName` URL argument to
+      _this_ script. That URL argument will be seen by the JS/WASM
+      loader and it will adjust the sqlite3.wasm path accordingly. If
+      sqlite3.js/.wasm are in the same directory as this script then
+      that's not needed.
+
+      URL arguments passed as part of the filename via importScripts()
+      are simply lost, and such scripts see the self.location of
+      _this_ script.
+    */
+    let sqlite3Js = 'sqlite3.js';
+    const urlParams = new URL(self.location.href).searchParams;
+    if(urlParams.has('sqlite3.dir')){
+      sqlite3Js = urlParams.get('sqlite3.dir') + '/' + sqlite3Js;
+    }
+    importScripts(sqlite3Js);
+  }
+  self.sqlite3InitModule({
+    // We can redirect any stdout/stderr from the module
+    // like so...
+    print: log,
+    printErr: error
+  }).then(function(sqlite3){
+    //console.log('sqlite3 =',sqlite3);
+    log("Done initializing. Running demo...");
+    try {
+      demo1(sqlite3);
+    }catch(e){
+      error("Exception:",e.message);
+    }
+  });
+})();