/*jslint-disable*/

/*

shRawLibFetch

{

"fetchList": [

{

"comment": true,

"url": "https://github.com/sqlite/sqlite/blob/version-3.36.0/LICENSE.md"

},

{

"url": "https://github.com/sqlite/sqlite/blob/version-3.36.0/ext/misc/carray.c"

},

{

"url": "https://github.com/sqlite/sqlite/blob/version-3.36.0/ext/misc/compress.c"

},

{

"url": "https://github.com/sqlite/sqlite/blob/version-3.36.0/ext/misc/noop.c"

},

{

"url": "https://github.com/sqlite/sqlite/blob/version-3.36.0/ext/misc/regexp.c"

},

{

"url": "https://github.com/sqlite/sqlite/blob/version-3.36.0/ext/misc/templatevtab.c"

},

{

"url": "https://github.com/sqlite/sqlite/tree/version-3.36.0/contrib/download/extension-functions.c/download/extension-functions.c",

"url2": "https://www.sqlite.org/contrib/download/extension-functions.c/download/extension-functions.c?get=25"

}

],

"replaceList": [

{

"aa": "SQLITE_EXTENSION_INIT",

"bb": "// $&",

"flags": "g"

}

]

}

- /\\* math.h *\\/

- { "acos", 1, 0, SQLITE_UTF8, 0, acosFunc },

- { "asin", 1, 0, SQLITE_UTF8, 0, asinFunc },

- { "atan", 1, 0, SQLITE_UTF8, 0, atanFunc },

- { "atn2", 2, 0, SQLITE_UTF8, 0, atn2Func },

- /\\* XXX alias *\\/

- { "atan2", 2, 0, SQLITE_UTF8, 0, atn2Func },

- { "acosh", 1, 0, SQLITE_UTF8, 0, acoshFunc },

- { "asinh", 1, 0, SQLITE_UTF8, 0, asinhFunc },

- { "atanh", 1, 0, SQLITE_UTF8, 0, atanhFunc },

-

- { "difference", 2, 0, SQLITE_UTF8, 0, differenceFunc},

- { "degrees", 1, 0, SQLITE_UTF8, 0, rad2degFunc },

- { "radians", 1, 0, SQLITE_UTF8, 0, deg2radFunc },

-

- { "cos", 1, 0, SQLITE_UTF8, 0, cosFunc },

- { "sin", 1, 0, SQLITE_UTF8, 0, sinFunc },

- { "tan", 1, 0, SQLITE_UTF8, 0, tanFunc },

- { "cot", 1, 0, SQLITE_UTF8, 0, cotFunc },

- { "cosh", 1, 0, SQLITE_UTF8, 0, coshFunc },

- { "sinh", 1, 0, SQLITE_UTF8, 0, sinhFunc },

- { "tanh", 1, 0, SQLITE_UTF8, 0, tanhFunc },

- { "coth", 1, 0, SQLITE_UTF8, 0, cothFunc },

-

- { "exp", 1, 0, SQLITE_UTF8, 0, expFunc },

- { "log", 1, 0, SQLITE_UTF8, 0, logFunc },

- { "log10", 1, 0, SQLITE_UTF8, 0, log10Func },

- { "power", 2, 0, SQLITE_UTF8, 0, powerFunc },

- { "sign", 1, 0, SQLITE_UTF8, 0, signFunc },

- { "sqrt", 1, 0, SQLITE_UTF8, 0, sqrtFunc },

- { "square", 1, 0, SQLITE_UTF8, 0, squareFunc },

-

- { "ceil", 1, 0, SQLITE_UTF8, 0, ceilFunc },

- { "floor", 1, 0, SQLITE_UTF8, 0, floorFunc },

-

- { "pi", 0, 0, SQLITE_UTF8, 1, piFunc },

+ /\\* math.h *\\/

+// hack-sqlite

+ { "atn2", 2, 0, SQLITE_UTF8, 0, atn2Func },

+ { "cot", 1, 0, SQLITE_UTF8, 0, cotFunc },

+ { "coth", 1, 0, SQLITE_UTF8, 0, cothFunc },

+ { "difference", 2, 0, SQLITE_UTF8, 0, differenceFunc},

+ { "sign", 1, 0, SQLITE_UTF8, 0, signFunc },

+ { "square", 1, 0, SQLITE_UTF8, 0, squareFunc },

-#include "sqlite3ext.h"

+#include "sqlite3ext.h"

+// hack-sqlite

+static const sqlite3_api_routines *sqlite3_api;

-int sqlite3_extension_init(

- sqlite3 *db, char **pzErrMsg, const sqlite3_api_routines *pApi){

- // SQLITE_EXTENSION_INIT2(pApi);

+// hack-sqlite

+int sqlite3_sqlmath_init(sqlite3*, char**, const sqlite3_api_routines*);

+int sqlite3_extension_functions_init(

+ sqlite3 *db, char **pzErrMsg, const sqlite3_api_routines *pApi){

+ // SQLITE_EXTENSION_INIT2(pApi);

+ sqlite3_api=pApi;

+ sqlite3_carray_init(db, pzErrMsg, pApi);

+ sqlite3_compress_init(db, pzErrMsg, pApi);

+ sqlite3_noop_init(db, pzErrMsg, pApi);

+ sqlite3_regexp_init(db, pzErrMsg, pApi);

+ sqlite3_sqlmath_init(db, pzErrMsg, pApi);

+ sqlite3_templatevtab_init(db, pzErrMsg, pApi);

*/

/*

repo https://github.com/sqlite/sqlite/tree/version-3.36.0

committed 2021-06-18T18:36:39Z

*/

/*

file https://github.com/sqlite/sqlite/blob/version-3.36.0/LICENSE.md

*/

/*

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.

*/

/*

file https://github.com/sqlite/sqlite/blob/version-3.36.0/ext/misc/carray.c

*/

/*

** 2016-06-29

**

** 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 demonstrates how to create a table-valued-function that

** returns the values in a C-language array.

** Examples:

**

** SELECT * FROM carray($ptr,5)

**

** The query above returns 5 integers contained in a C-language array

** at the address $ptr. $ptr is a pointer to the array of integers.

** The pointer value must be assigned to $ptr using the

** sqlite3_bind_pointer() interface with a pointer type of "carray".

** For example:

**

** static int aX[] = { 53, 9, 17, 2231, 4, 99 };

** int i = sqlite3_bind_parameter_index(pStmt, "$ptr");

** sqlite3_bind_pointer(pStmt, i, aX, "carray", 0);

**

** There is an optional third parameter to determine the datatype of

** the C-language array. Allowed values of the third parameter are

** 'int32', 'int64', 'double', 'char*'. Example:

**

** SELECT * FROM carray($ptr,10,'char*');

**

** The default value of the third parameter is 'int32'.

**

** HOW IT WORKS

**

** The carray "function" is really a virtual table with the

** following schema:

**

** CREATE TABLE carray(

** value,

** pointer HIDDEN,

** count HIDDEN,

** ctype TEXT HIDDEN

** );

**

** If the hidden columns "pointer" and "count" are unconstrained, then

** the virtual table has no rows. Otherwise, the virtual table interprets

** the integer value of "pointer" as a pointer to the array and "count"

** as the number of elements in the array. The virtual table steps through

** the array, element by element.

*/

#include "sqlite3ext.h"

// hack-sqlite

static const sqlite3_api_routines *sqlite3_api;

// SQLITE_EXTENSION_INIT1

#include <assert.h>

#include <string.h>

/* Allowed values for the mFlags parameter to sqlite3_carray_bind().

** Must exactly match the definitions in carray.h.

*/

#define CARRAY_INT32 0 /* Data is 32-bit signed integers */

#define CARRAY_INT64 1 /* Data is 64-bit signed integers */

#define CARRAY_DOUBLE 2 /* Data is doubles */

#define CARRAY_TEXT 3 /* Data is char* */

#ifndef SQLITE_OMIT_VIRTUALTABLE

/*

** Names of allowed datatypes

*/

static const char *azType[] = { "int32", "int64", "double", "char*" };

/*

** Structure used to hold the sqlite3_carray_bind() information

*/

typedef struct carray_bind carray_bind;

struct carray_bind {

void *aData; /* The data */

int nData; /* Number of elements */

int mFlags; /* Control flags */

void (*xDel)(void*); /* Destructor for aData */

};

/* carray_cursor is a subclass of sqlite3_vtab_cursor which will

** serve as the underlying representation of a cursor that scans

** over rows of the result

*/

typedef struct carray_cursor carray_cursor;

struct carray_cursor {

sqlite3_vtab_cursor base; /* Base class - must be first */

sqlite3_int64 iRowid; /* The rowid */

void *pPtr; /* Pointer to the array of values */

sqlite3_int64 iCnt; /* Number of integers in the array */

unsigned char eType; /* One of the CARRAY_type values */

};

/*

** The carrayConnect() method is invoked to create a new

** carray_vtab that describes the carray virtual table.

**

** Think of this routine as the constructor for carray_vtab objects.

**

** All this routine needs to do is:

**

** (1) Allocate the carray_vtab object and initialize all fields.

**

** (2) Tell SQLite (via the sqlite3_declare_vtab() interface) what the

** result set of queries against carray will look like.

*/

static int carrayConnect(

sqlite3 *db,

void *pAux,

int argc, const char *const*argv,

sqlite3_vtab **ppVtab,

char **pzErr

){

sqlite3_vtab *pNew;

int rc;

/* Column numbers */

#define CARRAY_COLUMN_VALUE 0

#define CARRAY_COLUMN_POINTER 1

#define CARRAY_COLUMN_COUNT 2

#define CARRAY_COLUMN_CTYPE 3

rc = sqlite3_declare_vtab(db,

"CREATE TABLE x(value,pointer hidden,count hidden,ctype hidden)");

if( rc==SQLITE_OK ){

pNew = *ppVtab = sqlite3_malloc( sizeof(*pNew) );

if( pNew==0 ) return SQLITE_NOMEM;

memset(pNew, 0, sizeof(*pNew));

}

return rc;

}

/*

** This method is the destructor for carray_cursor objects.

*/

static int carrayDisconnect(sqlite3_vtab *pVtab){

sqlite3_free(pVtab);

return SQLITE_OK;

}

/*

** Constructor for a new carray_cursor object.

*/

static int carrayOpen(sqlite3_vtab *p, sqlite3_vtab_cursor **ppCursor){

carray_cursor *pCur;

pCur = sqlite3_malloc( sizeof(*pCur) );

if( pCur==0 ) return SQLITE_NOMEM;

memset(pCur, 0, sizeof(*pCur));

*ppCursor = &pCur->base;

return SQLITE_OK;

}

/*

** Destructor for a carray_cursor.

*/

static int carrayClose(sqlite3_vtab_cursor *cur){

sqlite3_free(cur);

return SQLITE_OK;

}

/*

** Advance a carray_cursor to its next row of output.

*/

static int carrayNext(sqlite3_vtab_cursor *cur){

carray_cursor *pCur = (carray_cursor*)cur;

pCur->iRowid++;

return SQLITE_OK;

}

/*

** Return values of columns for the row at which the carray_cursor

** is currently pointing.

*/

static int carrayColumn(

sqlite3_vtab_cursor *cur, /* The cursor */

sqlite3_context *ctx, /* First argument to sqlite3_result_...() */

int i /* Which column to return */

){

carray_cursor *pCur = (carray_cursor*)cur;

sqlite3_int64 x = 0;

switch( i ){

case CARRAY_COLUMN_POINTER: return SQLITE_OK;

case CARRAY_COLUMN_COUNT: x = pCur->iCnt; break;

case CARRAY_COLUMN_CTYPE: {

sqlite3_result_text(ctx, azType[pCur->eType], -1, SQLITE_STATIC);

return SQLITE_OK;

}

default: {

switch( pCur->eType ){

case CARRAY_INT32: {

int *p = (int*)pCur->pPtr;

sqlite3_result_int(ctx, p[pCur->iRowid-1]);

return SQLITE_OK;

}

case CARRAY_INT64: {

sqlite3_int64 *p = (sqlite3_int64*)pCur->pPtr;

sqlite3_result_int64(ctx, p[pCur->iRowid-1]);

return SQLITE_OK;

}

case CARRAY_DOUBLE: {

double *p = (double*)pCur->pPtr;

sqlite3_result_double(ctx, p[pCur->iRowid-1]);

return SQLITE_OK;

}

case CARRAY_TEXT: {

const char **p = (const char**)pCur->pPtr;

sqlite3_result_text(ctx, p[pCur->iRowid-1], -1, SQLITE_TRANSIENT);

return SQLITE_OK;

}

}

}

}

sqlite3_result_int64(ctx, x);

return SQLITE_OK;

}

/*

** Return the rowid for the current row. In this implementation, the

** rowid is the same as the output value.

*/

static int carrayRowid(sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid){

carray_cursor *pCur = (carray_cursor*)cur;

*pRowid = pCur->iRowid;

return SQLITE_OK;

}

/*

** Return TRUE if the cursor has been moved off of the last

** row of output.

*/

static int carrayEof(sqlite3_vtab_cursor *cur){

carray_cursor *pCur = (carray_cursor*)cur;

return pCur->iRowid>pCur->iCnt;

}

/*

** This method is called to "rewind" the carray_cursor object back

** to the first row of output.

*/

static int carrayFilter(

sqlite3_vtab_cursor *pVtabCursor,

int idxNum, const char *idxStr,

int argc, sqlite3_value **argv

){

carray_cursor *pCur = (carray_cursor *)pVtabCursor;

pCur->pPtr = 0;

pCur->iCnt = 0;

switch( idxNum ){

case 1: {

carray_bind *pBind = sqlite3_value_pointer(argv[0], "carray-bind");

if( pBind==0 ) break;

pCur->pPtr = pBind->aData;

pCur->iCnt = pBind->nData;

pCur->eType = pBind->mFlags & 0x03;

break;

}

case 2:

case 3: {

pCur->pPtr = sqlite3_value_pointer(argv[0], "carray");

pCur->iCnt = pCur->pPtr ? sqlite3_value_int64(argv[1]) : 0;

if( idxNum<3 ){

pCur->eType = CARRAY_INT32;

}else{

unsigned char i;

const char *zType = (const char*)sqlite3_value_text(argv[2]);

for(i=0; i<sizeof(azType)/sizeof(azType[0]); i++){

if( sqlite3_stricmp(zType, azType[i])==0 ) break;

}

if( i>=sizeof(azType)/sizeof(azType[0]) ){

pVtabCursor->pVtab->zErrMsg = sqlite3_mprintf(

"unknown datatype: %Q", zType);

return SQLITE_ERROR;

}else{

pCur->eType = i;

}

}

break;

}

}

pCur->iRowid = 1;

return SQLITE_OK;

}

/*

** SQLite will invoke this method one or more times while planning a query

** that uses the carray virtual table. This routine needs to create

** a query plan for each invocation and compute an estimated cost for that

** plan.

**

** In this implementation idxNum is used to represent the

** query plan. idxStr is unused.

**

** idxNum is:

**

** 1 If only the pointer= constraint exists. In this case, the

** parameter must be bound using sqlite3_carray_bind().

**

** 2 if the pointer= and count= constraints exist.

**

** 3 if the ctype= constraint also exists.

**

** idxNum is 0 otherwise and carray becomes an empty table.

*/

static int carrayBestIndex(

sqlite3_vtab *tab,

sqlite3_index_info *pIdxInfo

){

int i; /* Loop over constraints */

int ptrIdx = -1; /* Index of the pointer= constraint, or -1 if none */

int cntIdx = -1; /* Index of the count= constraint, or -1 if none */

int ctypeIdx = -1; /* Index of the ctype= constraint, or -1 if none */

const struct sqlite3_index_constraint *pConstraint;

pConstraint = pIdxInfo->aConstraint;

for(i=0; i<pIdxInfo->nConstraint; i++, pConstraint++){

if( pConstraint->usable==0 ) continue;

if( pConstraint->op!=SQLITE_INDEX_CONSTRAINT_EQ ) continue;

switch( pConstraint->iColumn ){

case CARRAY_COLUMN_POINTER:

ptrIdx = i;

break;

case CARRAY_COLUMN_COUNT:

cntIdx = i;

break;

case CARRAY_COLUMN_CTYPE:

ctypeIdx = i;

break;

}

}

if( ptrIdx>=0 ){

pIdxInfo->aConstraintUsage[ptrIdx].argvIndex = 1;

pIdxInfo->aConstraintUsage[ptrIdx].omit = 1;

pIdxInfo->estimatedCost = (double)1;

pIdxInfo->estimatedRows = 100;

pIdxInfo->idxNum = 1;

if( cntIdx>=0 ){

pIdxInfo->aConstraintUsage[cntIdx].argvIndex = 2;

pIdxInfo->aConstraintUsage[cntIdx].omit = 1;

pIdxInfo->idxNum = 2;

if( ctypeIdx>=0 ){

pIdxInfo->aConstraintUsage[ctypeIdx].argvIndex = 3;

pIdxInfo->aConstraintUsage[ctypeIdx].omit = 1;

pIdxInfo->idxNum = 3;

}

}

}else{

pIdxInfo->estimatedCost = (double)2147483647;

pIdxInfo->estimatedRows = 2147483647;

pIdxInfo->idxNum = 0;

}

return SQLITE_OK;

}

/*

** This following structure defines all the methods for the

** carray virtual table.

*/

static sqlite3_module carrayModule = {

0, /* iVersion */

0, /* xCreate */

carrayConnect, /* xConnect */

carrayBestIndex, /* xBestIndex */

carrayDisconnect, /* xDisconnect */

0, /* xDestroy */

carrayOpen, /* xOpen - open a cursor */

carrayClose, /* xClose - close a cursor */

carrayFilter, /* xFilter - configure scan constraints */

carrayNext, /* xNext - advance a cursor */

carrayEof, /* xEof - check for end of scan */

carrayColumn, /* xColumn - read data */

carrayRowid, /* xRowid - read data */

0, /* xUpdate */

0, /* xBegin */

0, /* xSync */

0, /* xCommit */

0, /* xRollback */

0, /* xFindMethod */

0, /* xRename */

};

/*

** Destructor for the carray_bind object

*/

static void carrayBindDel(void *pPtr){

carray_bind *p = (carray_bind*)pPtr;

if( p->xDel!=SQLITE_STATIC ){

p->xDel(p->aData);

}

sqlite3_free(p);

}

/*

** Invoke this interface in order to bind to the single-argument

** version of CARRAY().

*/

#ifdef _WIN32

__declspec(dllexport)

#endif

int sqlite3_carray_bind(

sqlite3_stmt *pStmt,

int idx,

void *aData,

int nData,

int mFlags,

void (*xDestroy)(void*)

){

carray_bind *pNew;

int i;

pNew = sqlite3_malloc64(sizeof(*pNew));

if( pNew==0 ){

if( xDestroy!=SQLITE_STATIC && xDestroy!=SQLITE_TRANSIENT ){

xDestroy(aData);

}

return SQLITE_NOMEM;

}

pNew->nData = nData;

pNew->mFlags = mFlags;

if( xDestroy==SQLITE_TRANSIENT ){

sqlite3_int64 sz = nData;

switch( mFlags & 0x03 ){

case CARRAY_INT32: sz *= 4; break;

case CARRAY_INT64: sz *= 8; break;

case CARRAY_DOUBLE: sz *= 8; break;

case CARRAY_TEXT: sz *= sizeof(char*); break;

}

if( (mFlags & 0x03)==CARRAY_TEXT ){

for(i=0; i<nData; i++){

const char *z = ((char**)aData)[i];

if( z ) sz += strlen(z) + 1;

}

}

pNew->aData = sqlite3_malloc64( sz );

if( pNew->aData==0 ){

sqlite3_free(pNew);

return SQLITE_NOMEM;

}

if( (mFlags & 0x03)==CARRAY_TEXT ){

char **az = (char**)pNew->aData;

char *z = (char*)&az[nData];

for(i=0; i<nData; i++){

const char *zData = ((char**)aData)[i];

sqlite3_int64 n;

if( zData==0 ){

az[i] = 0;

continue;

}

az[i] = z;

n = strlen(zData);

memcpy(z, zData, n+1);

z += n+1;

}

}else{

memcpy(pNew->aData, aData, sz*nData);

}

pNew->xDel = sqlite3_free;

}else{

pNew->aData = aData;

pNew->xDel = xDestroy;

}

return sqlite3_bind_pointer(pStmt, idx, pNew, "carray-bind", carrayBindDel);

}

/*

** For testing purpose in the TCL test harness, we need a method for

** setting the pointer value. The inttoptr(X) SQL function accomplishes

** this. Tcl script will bind an integer to X and the inttoptr() SQL

** function will use sqlite3_result_pointer() to convert that integer into

** a pointer.

**

** This is for testing on TCL only.

*/

#ifdef SQLITE_TEST

static void inttoptrFunc(

sqlite3_context *context,

int argc,

sqlite3_value **argv

){

void *p;

sqlite3_int64 i64;

i64 = sqlite3_value_int64(argv[0]);

if( sizeof(i64)==sizeof(p) ){

memcpy(&p, &i64, sizeof(p));

}else{

int i32 = i64 & 0xffffffff;

memcpy(&p, &i32, sizeof(p));

}

sqlite3_result_pointer(context, p, "carray", 0);

}

#endif /* SQLITE_TEST */

#endif /* SQLITE_OMIT_VIRTUALTABLE */

#ifdef _WIN32

__declspec(dllexport)

#endif

int sqlite3_carray_init(

sqlite3 *db,

char **pzErrMsg,

const sqlite3_api_routines *pApi

){

int rc = SQLITE_OK;

// SQLITE_EXTENSION_INIT2(pApi);

#ifndef SQLITE_OMIT_VIRTUALTABLE

rc = sqlite3_create_module(db, "carray", &carrayModule, 0);

#ifdef SQLITE_TEST

if( rc==SQLITE_OK ){

rc = sqlite3_create_function(db, "inttoptr", 1, SQLITE_UTF8, 0,

inttoptrFunc, 0, 0);

}

#endif /* SQLITE_TEST */

#endif /* SQLITE_OMIT_VIRTUALTABLE */

return rc;

}

/*

file https://github.com/sqlite/sqlite/blob/version-3.36.0/ext/misc/compress.c

*/

/*

** 2014-06-13

**

** 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 SQLite extension implements SQL compression functions

** compress() and uncompress() using ZLIB.

*/

#include "sqlite3ext.h"

// SQLITE_EXTENSION_INIT1

#include <zlib.h>

/*

** Implementation of the "compress(X)" SQL function. The input X is

** compressed using zLib and the output is returned.

**

** The output is a BLOB that begins with a variable-length integer that

** is the input size in bytes (the size of X before compression). The

** variable-length integer is implemented as 1 to 5 bytes. There are

** seven bits per integer stored in the lower seven bits of each byte.

** More significant bits occur first. The most significant bit (0x80)

** is a flag to indicate the end of the integer.

**

** This function, SQLAR, and ZIP all use the same "deflate" compression

** algorithm, but each is subtly different:

**

** * ZIP uses raw deflate.

**

** * SQLAR uses the "zlib format" which is raw deflate with a two-byte

** algorithm-identification header and a four-byte checksum at the end.

**

** * This utility uses the "zlib format" like SQLAR, but adds the variable-

** length integer uncompressed size value at the beginning.

**

** This function might be extended in the future to support compression

** formats other than deflate, by providing a different algorithm-id

** mark following the variable-length integer size parameter.

*/

static void compressFunc(

sqlite3_context *context,

int argc,

sqlite3_value **argv

){

const unsigned char *pIn;

unsigned char *pOut;

unsigned int nIn;

unsigned long int nOut;

unsigned char x[8];

int rc;

int i, j;

pIn = sqlite3_value_blob(argv[0]);

nIn = sqlite3_value_bytes(argv[0]);

nOut = 13 + nIn + (nIn+999)/1000;

pOut = sqlite3_malloc( nOut+5 );

for(i=4; i>=0; i--){

x[i] = (nIn >> (7*(4-i)))&0x7f;

}

for(i=0; i<4 && x[i]==0; i++){}

for(j=0; i<=4; i++, j++) pOut[j] = x[i];

pOut[j-1] |= 0x80;

rc = compress(&pOut[j], &nOut, pIn, nIn);

if( rc==Z_OK ){

sqlite3_result_blob(context, pOut, nOut+j, sqlite3_free);

}else{

sqlite3_free(pOut);

}

}

/*

** Implementation of the "uncompress(X)" SQL function. The argument X

** is a blob which was obtained from compress(Y). The output will be

** the value Y.

*/

static void uncompressFunc(

sqlite3_context *context,

int argc,

sqlite3_value **argv

){

const unsigned char *pIn;

unsigned char *pOut;

unsigned int nIn;

unsigned long int nOut;

int rc;

int i;

pIn = sqlite3_value_blob(argv[0]);

nIn = sqlite3_value_bytes(argv[0]);

nOut = 0;

for(i=0; i<nIn && i<5; i++){

nOut = (nOut<<7) | (pIn[i]&0x7f);

if( (pIn[i]&0x80)!=0 ){ i++; break; }

}

pOut = sqlite3_malloc( nOut+1 );

rc = uncompress(pOut, &nOut, &pIn[i], nIn-i);

if( rc==Z_OK ){

sqlite3_result_blob(context, pOut, nOut, sqlite3_free);

}else{

sqlite3_free(pOut);

}

}

#ifdef _WIN32

__declspec(dllexport)

#endif

int sqlite3_compress_init(

sqlite3 *db,

char **pzErrMsg,

const sqlite3_api_routines *pApi

){

int rc = SQLITE_OK;

// SQLITE_EXTENSION_INIT2(pApi);

(void)pzErrMsg; /* Unused parameter */

rc = sqlite3_create_function(db, "compress", 1,

SQLITE_UTF8 | SQLITE_INNOCUOUS,

0, compressFunc, 0, 0);

if( rc==SQLITE_OK ){

rc = sqlite3_create_function(db, "uncompress", 1,

SQLITE_UTF8 | SQLITE_INNOCUOUS | SQLITE_DETERMINISTIC,

0, uncompressFunc, 0, 0);

}

return rc;

}

/*

file https://github.com/sqlite/sqlite/blob/version-3.36.0/ext/misc/noop.c

*/

/*

** 2020-01-08

**

** 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 SQLite extension implements a noop() function used for testing.

**

** Variants:

**

** noop(X) The default. Deterministic.

** noop_i(X) Deterministic and innocuous.

** noop_do(X) Deterministic and direct-only.

** noop_nd(X) Non-deterministic.

*/

#include "sqlite3ext.h"

// SQLITE_EXTENSION_INIT1

#include <assert.h>

#include <string.h>

/*

** Implementation of the noop() function.

**

** The function returns its argument, unchanged.

*/

static void noopfunc(

sqlite3_context *context,

int argc,

sqlite3_value **argv

){

assert( argc==1 );

sqlite3_result_value(context, argv[0]);

}

#ifdef _WIN32

__declspec(dllexport)

#endif

int sqlite3_noop_init(

sqlite3 *db,

char **pzErrMsg,

const sqlite3_api_routines *pApi

){

int rc = SQLITE_OK;

// SQLITE_EXTENSION_INIT2(pApi);

(void)pzErrMsg; /* Unused parameter */

rc = sqlite3_create_function(db, "noop", 1,

SQLITE_UTF8 | SQLITE_DETERMINISTIC,

0, noopfunc, 0, 0);

if( rc ) return rc;

rc = sqlite3_create_function(db, "noop_i", 1,

SQLITE_UTF8 | SQLITE_DETERMINISTIC | SQLITE_INNOCUOUS,

0, noopfunc, 0, 0);

if( rc ) return rc;

rc = sqlite3_create_function(db, "noop_do", 1,

SQLITE_UTF8 | SQLITE_DETERMINISTIC | SQLITE_DIRECTONLY,

0, noopfunc, 0, 0);

if( rc ) return rc;

rc = sqlite3_create_function(db, "noop_nd", 1,

SQLITE_UTF8,

0, noopfunc, 0, 0);

return rc;

}

/*

file https://github.com/sqlite/sqlite/blob/version-3.36.0/ext/misc/regexp.c

*/

/*

** 2012-11-13

**

** 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.

**

******************************************************************************

**

** The code in this file implements a compact but reasonably

** efficient regular-expression matcher for posix extended regular

** expressions against UTF8 text.

**

** This file is an SQLite extension. It registers a single function

** named "regexp(A,B)" where A is the regular expression and B is the

** string to be matched. By registering this function, SQLite will also

** then implement the "B regexp A" operator. Note that with the function

** the regular expression comes first, but with the operator it comes

** second.

**

** The following regular expression syntax is supported:

**

** X* zero or more occurrences of X

** X+ one or more occurrences of X

** X? zero or one occurrences of X

** X{p,q} between p and q occurrences of X

** (X) match X

** X|Y X or Y

** ^X X occurring at the beginning of the string

** X$ X occurring at the end of the string

** . Match any single character

** \c Character c where c is one of \{}()[]|*+?.

** \c C-language escapes for c in afnrtv. ex: \t or \n

** \uXXXX Where XXXX is exactly 4 hex digits, unicode value XXXX

** \xXX Where XX is exactly 2 hex digits, unicode value XX

** [abc] Any single character from the set abc

** [^abc] Any single character not in the set abc

** [a-z] Any single character in the range a-z

** [^a-z] Any single character not in the range a-z

** \b Word boundary

** \w Word character. [A-Za-z0-9_]

** \W Non-word character

** \d Digit

** \D Non-digit

** \s Whitespace character

** \S Non-whitespace character

**

** A nondeterministic finite automaton (NFA) is used for matching, so the

** performance is bounded by O(N*M) where N is the size of the regular

** expression and M is the size of the input string. The matcher never

** exhibits exponential behavior. Note that the X{p,q} operator expands

** to p copies of X following by q-p copies of X? and that the size of the

** regular expression in the O(N*M) performance bound is computed after

** this expansion.

*/

#include <string.h>

#include <stdlib.h>

#include "sqlite3ext.h"

// SQLITE_EXTENSION_INIT1

/*

** The following #defines change the names of some functions implemented in

** this file to prevent name collisions with C-library functions of the

** same name.

*/

#define re_match sqlite3re_match

#define re_compile sqlite3re_compile

#define re_free sqlite3re_free

/* The end-of-input character */

#define RE_EOF 0 /* End of input */

/* The NFA is implemented as sequence of opcodes taken from the following

** set. Each opcode has a single integer argument.

*/

#define RE_OP_MATCH 1 /* Match the one character in the argument */

#define RE_OP_ANY 2 /* Match any one character. (Implements ".") */

#define RE_OP_ANYSTAR 3 /* Special optimized version of .* */

#define RE_OP_FORK 4 /* Continue to both next and opcode at iArg */

#define RE_OP_GOTO 5 /* Jump to opcode at iArg */

#define RE_OP_ACCEPT 6 /* Halt and indicate a successful match */

#define RE_OP_CC_INC 7 /* Beginning of a [...] character class */

#define RE_OP_CC_EXC 8 /* Beginning of a [^...] character class */

#define RE_OP_CC_VALUE 9 /* Single value in a character class */

#define RE_OP_CC_RANGE 10 /* Range of values in a character class */

#define RE_OP_WORD 11 /* Perl word character [A-Za-z0-9_] */

#define RE_OP_NOTWORD 12 /* Not a perl word character */

#define RE_OP_DIGIT 13 /* digit: [0-9] */

#define RE_OP_NOTDIGIT 14 /* Not a digit */

#define RE_OP_SPACE 15 /* space: [ \t\n\r\v\f] */

#define RE_OP_NOTSPACE 16 /* Not a digit */

#define RE_OP_BOUNDARY 17 /* Boundary between word and non-word */

/* Each opcode is a "state" in the NFA */

typedef unsigned short ReStateNumber;

/* Because this is an NFA and not a DFA, multiple states can be active at

** once. An instance of the following object records all active states in

** the NFA. The implementation is optimized for the common case where the

** number of actives states is small.

*/

typedef struct ReStateSet {

unsigned nState; /* Number of current states */

ReStateNumber *aState; /* Current states */

} ReStateSet;

/* An input string read one character at a time.

*/

typedef struct ReInput ReInput;

struct ReInput {

const unsigned char *z; /* All text */

int i; /* Next byte to read */

int mx; /* EOF when i>=mx */

};

/* A compiled NFA (or an NFA that is in the process of being compiled) is

** an instance of the following object.

*/

typedef struct ReCompiled ReCompiled;

struct ReCompiled {

ReInput sIn; /* Regular expression text */

const char *zErr; /* Error message to return */

char *aOp; /* Operators for the virtual machine */

int *aArg; /* Arguments to each operator */

unsigned (*xNextChar)(ReInput*); /* Next character function */

unsigned char zInit[12]; /* Initial text to match */

int nInit; /* Number of characters in zInit */

unsigned nState; /* Number of entries in aOp[] and aArg[] */

unsigned nAlloc; /* Slots allocated for aOp[] and aArg[] */

};

/* Add a state to the given state set if it is not already there */

static void re_add_state(ReStateSet *pSet, int newState){