/*

** 2001 September 15

**

** 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 to implement the "sqlite" command line

** utility for accessing SQLite databases.

*/

#if (defined(_WIN32) || defined(WIN32)) && !defined(_CRT_SECURE_NO_WARNINGS)

/* This needs to come before any includes for MSVC compiler */

#define _CRT_SECURE_NO_WARNINGS

#endif

typedef unsigned int u32;

typedef unsigned short int u16;

/*

** Optionally #include a user-defined header, whereby compilation options

** may be set prior to where they take effect, but after platform setup.

** If SQLITE_CUSTOM_INCLUDE=? is defined, its value names the #include

** file. Note that this macro has a like effect on sqlite3.c compilation.

*/

# define SHELL_STRINGIFY_(f) #f

# define SHELL_STRINGIFY(f) SHELL_STRINGIFY_(f)

#ifdef SQLITE_CUSTOM_INCLUDE

# include SHELL_STRINGIFY(SQLITE_CUSTOM_INCLUDE)

#endif

/*

** Determine if we are dealing with WinRT, which provides only a subset of

** the full Win32 API.

*/

#if !defined(SQLITE_OS_WINRT)

# define SQLITE_OS_WINRT 0

#endif

/*

** If SQLITE_SHELL_FIDDLE is defined then the shell is modified

** somewhat for use as a WASM module in a web browser. This flag

** should only be used when building the "fiddle" web application, as

** the browser-mode build has much different user input requirements

** and this build mode rewires the user input subsystem to account for

** that.

*/

/*

** Warning pragmas copied from msvc.h in the core.

*/

#if defined(_MSC_VER)

#pragma warning(disable : 4054)

#pragma warning(disable : 4055)

#pragma warning(disable : 4100)

#pragma warning(disable : 4127)

#pragma warning(disable : 4130)

#pragma warning(disable : 4152)

#pragma warning(disable : 4189)

#pragma warning(disable : 4206)

#pragma warning(disable : 4210)

#pragma warning(disable : 4232)

#pragma warning(disable : 4244)

#pragma warning(disable : 4305)

#pragma warning(disable : 4306)

#pragma warning(disable : 4702)

#pragma warning(disable : 4706)

#endif /* defined(_MSC_VER) */

/*

** No support for loadable extensions in VxWorks.

*/

#if (defined(__RTP__) || defined(_WRS_KERNEL)) && !SQLITE_OMIT_LOAD_EXTENSION

# define SQLITE_OMIT_LOAD_EXTENSION 1

#endif

/*

** Enable large-file support for fopen() and friends on unix.

*/

#ifndef SQLITE_DISABLE_LFS

# define _LARGE_FILE 1

# ifndef _FILE_OFFSET_BITS

# define _FILE_OFFSET_BITS 64

# endif

# define _LARGEFILE_SOURCE 1

#endif

#if defined(SQLITE_SHELL_FIDDLE) && !defined(_POSIX_SOURCE)

/*

** emcc requires _POSIX_SOURCE (or one of several similar defines)

** to expose strdup().

*/

# define _POSIX_SOURCE

#endif

#include <stdlib.h>

#include <string.h>

#include <stdio.h>

#include <assert.h>

#include <math.h>

#include "sqlite3.h"

typedef sqlite3_int64 i64;

typedef sqlite3_uint64 u64;

typedef unsigned char u8;

#include <ctype.h>

#include <stdarg.h>

#if !defined(_WIN32) && !defined(WIN32)

# include <signal.h>

# if !defined(__RTP__) && !defined(_WRS_KERNEL) && !defined(SQLITE_WASI)

# include <pwd.h>

# endif

#endif

#if (!defined(_WIN32) && !defined(WIN32)) || defined(__MINGW32__)

# include <unistd.h>

# include <dirent.h>

# define GETPID getpid

# if defined(__MINGW32__)

# define DIRENT dirent

# ifndef S_ISLNK

# define S_ISLNK(mode) (0)

# endif

# endif

#else

# define GETPID (int)GetCurrentProcessId

#endif

#include <sys/types.h>

#include <sys/stat.h>

#if HAVE_READLINE

# include <readline/readline.h>

# include <readline/history.h>

#endif

#if HAVE_EDITLINE

# include <editline/readline.h>

#endif

#if HAVE_EDITLINE || HAVE_READLINE

# define shell_add_history(X) add_history(X)

# define shell_read_history(X) read_history(X)

# define shell_write_history(X) write_history(X)

# define shell_stifle_history(X) stifle_history(X)

# define shell_readline(X) readline(X)

#elif HAVE_LINENOISE

# include "linenoise.h"

# define shell_add_history(X) linenoiseHistoryAdd(X)

# define shell_read_history(X) linenoiseHistoryLoad(X)

# define shell_write_history(X) linenoiseHistorySave(X)

# define shell_stifle_history(X) linenoiseHistorySetMaxLen(X)

# define shell_readline(X) linenoise(X)

#else

# define shell_read_history(X)

# define shell_write_history(X)

# define shell_stifle_history(X)

# define SHELL_USE_LOCAL_GETLINE 1

#endif

#ifndef deliberate_fall_through

/* Quiet some compilers about some of our intentional code. */

# if defined(GCC_VERSION) && GCC_VERSION>=7000000

# define deliberate_fall_through __attribute__((fallthrough));

# else

# define deliberate_fall_through

# endif

#endif

#if defined(_WIN32) || defined(WIN32)

# if SQLITE_OS_WINRT

# define SQLITE_OMIT_POPEN 1

# else

# include <io.h>

# include <fcntl.h>

# define isatty(h) _isatty(h)

# ifndef access

# define access(f,m) _access((f),(m))

# endif

# ifndef unlink

# define unlink _unlink

# endif

# ifndef strdup

# define strdup _strdup

# endif

# undef pclose

# define pclose _pclose

# endif

#else

/* Make sure isatty() has a prototype. */

extern int isatty(int);

# if !defined(__RTP__) && !defined(_WRS_KERNEL) && !defined(SQLITE_WASI)

/* popen and pclose are not C89 functions and so are

** sometimes omitted from the <stdio.h> header */

extern FILE *popen(const char*,const char*);

extern int pclose(FILE*);

# else

# define SQLITE_OMIT_POPEN 1

# endif

#endif

#if defined(_WIN32_WCE)

/* Windows CE (arm-wince-mingw32ce-gcc) does not provide isatty()

* thus we always assume that we have a console. That can be

* overridden with the -batch command line option.

*/

#define isatty(x) 1

#endif

/* ctype macros that work with signed characters */

#define IsSpace(X) isspace((unsigned char)X)

#define IsDigit(X) isdigit((unsigned char)X)

#define ToLower(X) (char)tolower((unsigned char)X)

#if defined(_WIN32) || defined(WIN32)

#if SQLITE_OS_WINRT

#include <intrin.h>

#endif

#undef WIN32_LEAN_AND_MEAN

#define WIN32_LEAN_AND_MEAN

#include <windows.h>

/* string conversion routines only needed on Win32 */

extern char *sqlite3_win32_unicode_to_utf8(LPCWSTR);

extern LPWSTR sqlite3_win32_utf8_to_unicode(const char *zText);

#endif

INCLUDE ../ext/misc/sqlite3_stdio.h

INCLUDE ../ext/misc/sqlite3_stdio.c

/* Use console I/O package as a direct INCLUDE. */

#define SQLITE_INTERNAL_LINKAGE static

#ifdef SQLITE_SHELL_FIDDLE

/* Deselect most features from the console I/O package for Fiddle. */

# define SQLITE_CIO_NO_REDIRECT

# define SQLITE_CIO_NO_CLASSIFY

# define SQLITE_CIO_NO_TRANSLATE

# define SQLITE_CIO_NO_SETMODE

# define SQLITE_CIO_NO_FLUSH

#endif

#define eputz(z) sqlite3_fputs(z,stderr)

#define sputz(fp,z) sqlite3_fputs(z,fp)

/* True if the timer is enabled */

static int enableTimer = 0;

/* A version of strcmp() that works with NULL values */

static int cli_strcmp(const char *a, const char *b){

if( a==0 ) a = "";

if( b==0 ) b = "";

return strcmp(a,b);

}

static int cli_strncmp(const char *a, const char *b, size_t n){

if( a==0 ) a = "";

if( b==0 ) b = "";

return strncmp(a,b,n);

}

/* Return the current wall-clock time */

static sqlite3_int64 timeOfDay(void){

static sqlite3_vfs *clockVfs = 0;

sqlite3_int64 t;

if( clockVfs==0 ) clockVfs = sqlite3_vfs_find(0);

if( clockVfs==0 ) return 0; /* Never actually happens */

if( clockVfs->iVersion>=2 && clockVfs->xCurrentTimeInt64!=0 ){

clockVfs->xCurrentTimeInt64(clockVfs, &t);

}else{

double r;

clockVfs->xCurrentTime(clockVfs, &r);

t = (sqlite3_int64)(r*86400000.0);

}

return t;

}

#if !defined(_WIN32) && !defined(WIN32) && !defined(__minux)

#include <sys/time.h>

#include <sys/resource.h>

/* VxWorks does not support getrusage() as far as we can determine */

#if defined(_WRS_KERNEL) || defined(__RTP__)

struct rusage {

struct timeval ru_utime; /* user CPU time used */

struct timeval ru_stime; /* system CPU time used */

};

#define getrusage(A,B) memset(B,0,sizeof(*B))

#endif

/* Saved resource information for the beginning of an operation */

static struct rusage sBegin; /* CPU time at start */

static sqlite3_int64 iBegin; /* Wall-clock time at start */

/*

** Begin timing an operation

*/

static void beginTimer(void){

if( enableTimer ){

getrusage(RUSAGE_SELF, &sBegin);

iBegin = timeOfDay();

}

}

/* Return the difference of two time_structs in seconds */

static double timeDiff(struct timeval *pStart, struct timeval *pEnd){

return (pEnd->tv_usec - pStart->tv_usec)*0.000001 +

(double)(pEnd->tv_sec - pStart->tv_sec);

}

/*

** Print the timing results.

*/

static void endTimer(FILE *out){

if( enableTimer ){

sqlite3_int64 iEnd = timeOfDay();

struct rusage sEnd;

getrusage(RUSAGE_SELF, &sEnd);

sqlite3_fprintf(out, "Run Time: real %.3f user %f sys %f\n",

(iEnd - iBegin)*0.001,

timeDiff(&sBegin.ru_utime, &sEnd.ru_utime),

timeDiff(&sBegin.ru_stime, &sEnd.ru_stime));

}

}

#define BEGIN_TIMER beginTimer()

#define END_TIMER(X) endTimer(X)

#define HAS_TIMER 1

#elif (defined(_WIN32) || defined(WIN32))

/* Saved resource information for the beginning of an operation */

static HANDLE hProcess;

static FILETIME ftKernelBegin;

static FILETIME ftUserBegin;

static sqlite3_int64 ftWallBegin;

typedef BOOL (WINAPI *GETPROCTIMES)(HANDLE, LPFILETIME, LPFILETIME,

LPFILETIME, LPFILETIME);

static GETPROCTIMES getProcessTimesAddr = NULL;

/*

** Check to see if we have timer support. Return 1 if necessary

** support found (or found previously).

*/

static int hasTimer(void){

if( getProcessTimesAddr ){

return 1;

} else {

#if !SQLITE_OS_WINRT

/* GetProcessTimes() isn't supported in WIN95 and some other Windows

** versions. See if the version we are running on has it, and if it

** does, save off a pointer to it and the current process handle.

*/

hProcess = GetCurrentProcess();

if( hProcess ){

HINSTANCE hinstLib = LoadLibrary(TEXT("Kernel32.dll"));

if( NULL != hinstLib ){

getProcessTimesAddr =

(GETPROCTIMES) GetProcAddress(hinstLib, "GetProcessTimes");

if( NULL != getProcessTimesAddr ){

return 1;

}

FreeLibrary(hinstLib);

}

}

#endif

}

return 0;

}

/*

** Begin timing an operation

*/

static void beginTimer(void){

if( enableTimer && getProcessTimesAddr ){

FILETIME ftCreation, ftExit;

getProcessTimesAddr(hProcess,&ftCreation,&ftExit,

&ftKernelBegin,&ftUserBegin);

ftWallBegin = timeOfDay();

}

}

/* Return the difference of two FILETIME structs in seconds */

static double timeDiff(FILETIME *pStart, FILETIME *pEnd){

sqlite_int64 i64Start = *((sqlite_int64 *) pStart);

sqlite_int64 i64End = *((sqlite_int64 *) pEnd);

return (double) ((i64End - i64Start) / 10000000.0);

}

/*

** Print the timing results.

*/

static void endTimer(FILE *out){

if( enableTimer && getProcessTimesAddr){

FILETIME ftCreation, ftExit, ftKernelEnd, ftUserEnd;

sqlite3_int64 ftWallEnd = timeOfDay();

getProcessTimesAddr(hProcess,&ftCreation,&ftExit,&ftKernelEnd,&ftUserEnd);

sqlite3_fprintf(out, "Run Time: real %.3f user %f sys %f\n",

(ftWallEnd - ftWallBegin)*0.001,

timeDiff(&ftUserBegin, &ftUserEnd),

timeDiff(&ftKernelBegin, &ftKernelEnd));

}

}

#define BEGIN_TIMER beginTimer()

#define END_TIMER(X) endTimer(X)

#define HAS_TIMER hasTimer()

#else

#define BEGIN_TIMER

#define END_TIMER(X) /*no-op*/

#define HAS_TIMER 0

#endif

/*

** Used to prevent warnings about unused parameters

*/

#define UNUSED_PARAMETER(x) (void)(x)

/*

** Number of elements in an array

*/

#define ArraySize(X) (int)(sizeof(X)/sizeof(X[0]))

/*

** If the following flag is set, then command execution stops

** at an error if we are not interactive.

*/

static int bail_on_error = 0;

/*

** Treat stdin as an interactive input if the following variable

** is true. Otherwise, assume stdin is connected to a file or pipe.

*/

static int stdin_is_interactive = 1;

/*

** On Windows systems we need to know if standard output is a console

** in order to show that UTF-16 translation is done in the sign-on

** banner. The following variable is true if it is the console.

*/

static int stdout_is_console = 1;

/*

** The following is the open SQLite database. We make a pointer

** to this database a static variable so that it can be accessed

** by the SIGINT handler to interrupt database processing.

*/

static sqlite3 *globalDb = 0;

/*

** True if an interrupt (Control-C) has been received.

*/

static volatile int seenInterrupt = 0;

/*

** This is the name of our program. It is set in main(), used

** in a number of other places, mostly for error messages.

*/

static char *Argv0;

/*

** Prompt strings. Initialized in main. Settable with

** .prompt main continue

*/

#define PROMPT_LEN_MAX 20

/* First line prompt. default: "sqlite> " */

static char mainPrompt[PROMPT_LEN_MAX];

/* Continuation prompt. default: " ...> " */

static char continuePrompt[PROMPT_LEN_MAX];

/* This is variant of the standard-library strncpy() routine with the

** one change that the destination string is always zero-terminated, even

** if there is no zero-terminator in the first n-1 characters of the source

** string.

*/

static char *shell_strncpy(char *dest, const char *src, size_t n){

size_t i;

for(i=0; i<n-1 && src[i]!=0; i++) dest[i] = src[i];

dest[i] = 0;

return dest;

}

/*

** strcpy() workalike to squelch an unwarranted link-time warning

** from OpenBSD.

*/

static void shell_strcpy(char *dest, const char *src){

while( (*(dest++) = *(src++))!=0 ){}

}

/*

** Optionally disable dynamic continuation prompt.

** Unless disabled, the continuation prompt shows open SQL lexemes if any,

** or open parentheses level if non-zero, or continuation prompt as set.

** This facility interacts with the scanner and process_input() where the

** below 5 macros are used.

*/

#ifdef SQLITE_OMIT_DYNAPROMPT

# define CONTINUATION_PROMPT continuePrompt

# define CONTINUE_PROMPT_RESET

# define CONTINUE_PROMPT_AWAITS(p,s)

# define CONTINUE_PROMPT_AWAITC(p,c)

# define CONTINUE_PAREN_INCR(p,n)

# define CONTINUE_PROMPT_PSTATE 0

typedef void *t_NoDynaPrompt;

# define SCAN_TRACKER_REFTYPE t_NoDynaPrompt

#else

# define CONTINUATION_PROMPT dynamicContinuePrompt()

# define CONTINUE_PROMPT_RESET \

do {setLexemeOpen(&dynPrompt,0,0); trackParenLevel(&dynPrompt,0);} while(0)

# define CONTINUE_PROMPT_AWAITS(p,s) \

if(p && stdin_is_interactive) setLexemeOpen(p, s, 0)

# define CONTINUE_PROMPT_AWAITC(p,c) \

if(p && stdin_is_interactive) setLexemeOpen(p, 0, c)

# define CONTINUE_PAREN_INCR(p,n) \

if(p && stdin_is_interactive) (trackParenLevel(p,n))

# define CONTINUE_PROMPT_PSTATE (&dynPrompt)

typedef struct DynaPrompt *t_DynaPromptRef;

# define SCAN_TRACKER_REFTYPE t_DynaPromptRef

static struct DynaPrompt {

char dynamicPrompt[PROMPT_LEN_MAX];

char acAwait[2];

int inParenLevel;

char *zScannerAwaits;

} dynPrompt = { {0}, {0}, 0, 0 };

/* Record parenthesis nesting level change, or force level to 0. */

static void trackParenLevel(struct DynaPrompt *p, int ni){

p->inParenLevel += ni;

if( ni==0 ) p->inParenLevel = 0;

p->zScannerAwaits = 0;

}

/* Record that a lexeme is opened, or closed with args==0. */

static void setLexemeOpen(struct DynaPrompt *p, char *s, char c){

if( s!=0 || c==0 ){

p->zScannerAwaits = s;

p->acAwait[0] = 0;

}else{

p->acAwait[0] = c;

p->zScannerAwaits = p->acAwait;

}

}

/* Upon demand, derive the continuation prompt to display. */

static char *dynamicContinuePrompt(void){

if( continuePrompt[0]==0

|| (dynPrompt.zScannerAwaits==0 && dynPrompt.inParenLevel == 0) ){

return continuePrompt;

}else{

if( dynPrompt.zScannerAwaits ){

size_t ncp = strlen(continuePrompt);

size_t ndp = strlen(dynPrompt.zScannerAwaits);

if( ndp > ncp-3 ) return continuePrompt;

shell_strcpy(dynPrompt.dynamicPrompt, dynPrompt.zScannerAwaits);

while( ndp<3 ) dynPrompt.dynamicPrompt[ndp++] = ' ';

shell_strncpy(dynPrompt.dynamicPrompt+3, continuePrompt+3,

PROMPT_LEN_MAX-4);

}else{

if( dynPrompt.inParenLevel>9 ){

shell_strncpy(dynPrompt.dynamicPrompt, "(..", 4);

}else if( dynPrompt.inParenLevel<0 ){

shell_strncpy(dynPrompt.dynamicPrompt, ")x!", 4);

}else{

shell_strncpy(dynPrompt.dynamicPrompt, "(x.", 4);

dynPrompt.dynamicPrompt[2] = (char)('0'+dynPrompt.inParenLevel);

}

shell_strncpy(dynPrompt.dynamicPrompt+3, continuePrompt+3,

PROMPT_LEN_MAX-4);

}

}

return dynPrompt.dynamicPrompt;

}

#endif /* !defined(SQLITE_OMIT_DYNAPROMPT) */

/* Indicate out-of-memory and exit. */

static void shell_out_of_memory(void){

eputz("Error: out of memory\n");

exit(1);

}

/* Check a pointer to see if it is NULL. If it is NULL, exit with an

** out-of-memory error.

*/

static void shell_check_oom(const void *p){

if( p==0 ) shell_out_of_memory();

}

/*

** Write I/O traces to the following stream.

*/

#ifdef SQLITE_ENABLE_IOTRACE

static FILE *iotrace = 0;

#endif

/*

** This routine works like printf in that its first argument is a

** format string and subsequent arguments are values to be substituted

** in place of % fields. The result of formatting this string

** is written to iotrace.

*/

#ifdef SQLITE_ENABLE_IOTRACE

static void SQLITE_CDECL iotracePrintf(const char *zFormat, ...){

va_list ap;

char *z;

if( iotrace==0 ) return;

va_start(ap, zFormat);

z = sqlite3_vmprintf(zFormat, ap);

va_end(ap);

sqlite3_fprintf(iotrace, "%s", z);

sqlite3_free(z);

}

#endif

/* Lookup table to estimate the number of columns consumed by a Unicode

** character.

*/

static const struct {

unsigned char w; /* Width of the character in columns */

int iFirst; /* First character in a span having this width */

} aUWidth[] = {

/* {1, 0x00000}, */

{0, 0x00300}, {1, 0x00370}, {0, 0x00483}, {1, 0x00487}, {0, 0x00488},

{1, 0x0048a}, {0, 0x00591}, {1, 0x005be}, {0, 0x005bf}, {1, 0x005c0},

{0, 0x005c1}, {1, 0x005c3}, {0, 0x005c4}, {1, 0x005c6}, {0, 0x005c7},

{1, 0x005c8}, {0, 0x00600}, {1, 0x00604}, {0, 0x00610}, {1, 0x00616},

{0, 0x0064b}, {1, 0x0065f}, {0, 0x00670}, {1, 0x00671}, {0, 0x006d6},

{1, 0x006e5}, {0, 0x006e7}, {1, 0x006e9}, {0, 0x006ea}, {1, 0x006ee},

{0, 0x0070f}, {1, 0x00710}, {0, 0x00711}, {1, 0x00712}, {0, 0x00730},

{1, 0x0074b}, {0, 0x007a6}, {1, 0x007b1}, {0, 0x007eb}, {1, 0x007f4},

{0, 0x00901}, {1, 0x00903}, {0, 0x0093c}, {1, 0x0093d}, {0, 0x00941},

{1, 0x00949}, {0, 0x0094d}, {1, 0x0094e}, {0, 0x00951}, {1, 0x00955},

{0, 0x00962}, {1, 0x00964}, {0, 0x00981}, {1, 0x00982}, {0, 0x009bc},

{1, 0x009bd}, {0, 0x009c1}, {1, 0x009c5}, {0, 0x009cd}, {1, 0x009ce},

{0, 0x009e2}, {1, 0x009e4}, {0, 0x00a01}, {1, 0x00a03}, {0, 0x00a3c},

{1, 0x00a3d}, {0, 0x00a41}, {1, 0x00a43}, {0, 0x00a47}, {1, 0x00a49},

{0, 0x00a4b}, {1, 0x00a4e}, {0, 0x00a70}, {1, 0x00a72}, {0, 0x00a81},

{1, 0x00a83}, {0, 0x00abc}, {1, 0x00abd}, {0, 0x00ac1}, {1, 0x00ac6},

{0, 0x00ac7}, {1, 0x00ac9}, {0, 0x00acd}, {1, 0x00ace}, {0, 0x00ae2},

{1, 0x00ae4}, {0, 0x00b01}, {1, 0x00b02}, {0, 0x00b3c}, {1, 0x00b3d},

{0, 0x00b3f}, {1, 0x00b40}, {0, 0x00b41}, {1, 0x00b44}, {0, 0x00b4d},

{1, 0x00b4e}, {0, 0x00b56}, {1, 0x00b57}, {0, 0x00b82}, {1, 0x00b83},

{0, 0x00bc0}, {1, 0x00bc1}, {0, 0x00bcd}, {1, 0x00bce}, {0, 0x00c3e},

{1, 0x00c41}, {0, 0x00c46}, {1, 0x00c49}, {0, 0x00c4a}, {1, 0x00c4e},

{0, 0x00c55}, {1, 0x00c57}, {0, 0x00cbc}, {1, 0x00cbd}, {0, 0x00cbf},

{1, 0x00cc0}, {0, 0x00cc6}, {1, 0x00cc7}, {0, 0x00ccc}, {1, 0x00cce},

{0, 0x00ce2}, {1, 0x00ce4}, {0, 0x00d41}, {1, 0x00d44}, {0, 0x00d4d},

{1, 0x00d4e}, {0, 0x00dca}, {1, 0x00dcb}, {0, 0x00dd2}, {1, 0x00dd5},

{0, 0x00dd6}, {1, 0x00dd7}, {0, 0x00e31}, {1, 0x00e32}, {0, 0x00e34},

{1, 0x00e3b}, {0, 0x00e47}, {1, 0x00e4f}, {0, 0x00eb1}, {1, 0x00eb2},

{0, 0x00eb4}, {1, 0x00eba}, {0, 0x00ebb}, {1, 0x00ebd}, {0, 0x00ec8},

{1, 0x00ece}, {0, 0x00f18}, {1, 0x00f1a}, {0, 0x00f35}, {1, 0x00f36},

{0, 0x00f37}, {1, 0x00f38}, {0, 0x00f39}, {1, 0x00f3a}, {0, 0x00f71},

{1, 0x00f7f}, {0, 0x00f80}, {1, 0x00f85}, {0, 0x00f86}, {1, 0x00f88},

{0, 0x00f90}, {1, 0x00f98}, {0, 0x00f99}, {1, 0x00fbd}, {0, 0x00fc6},

{1, 0x00fc7}, {0, 0x0102d}, {1, 0x01031}, {0, 0x01032}, {1, 0x01033},

{0, 0x01036}, {1, 0x01038}, {0, 0x01039}, {1, 0x0103a}, {0, 0x01058},

{1, 0x0105a}, {2, 0x01100}, {0, 0x01160}, {1, 0x01200}, {0, 0x0135f},

{1, 0x01360}, {0, 0x01712}, {1, 0x01715}, {0, 0x01732}, {1, 0x01735},

{0, 0x01752}, {1, 0x01754}, {0, 0x01772}, {1, 0x01774}, {0, 0x017b4},

{1, 0x017b6}, {0, 0x017b7}, {1, 0x017be}, {0, 0x017c6}, {1, 0x017c7},

{0, 0x017c9}, {1, 0x017d4}, {0, 0x017dd}, {1, 0x017de}, {0, 0x0180b},

{1, 0x0180e}, {0, 0x018a9}, {1, 0x018aa}, {0, 0x01920}, {1, 0x01923},

{0, 0x01927}, {1, 0x01929}, {0, 0x01932}, {1, 0x01933}, {0, 0x01939},

{1, 0x0193c}, {0, 0x01a17}, {1, 0x01a19}, {0, 0x01b00}, {1, 0x01b04},

{0, 0x01b34}, {1, 0x01b35}, {0, 0x01b36}, {1, 0x01b3b}, {0, 0x01b3c},

{1, 0x01b3d}, {0, 0x01b42}, {1, 0x01b43}, {0, 0x01b6b}, {1, 0x01b74},

{0, 0x01dc0}, {1, 0x01dcb}, {0, 0x01dfe}, {1, 0x01e00}, {0, 0x0200b},

{1, 0x02010}, {0, 0x0202a}, {1, 0x0202f}, {0, 0x02060}, {1, 0x02064},

{0, 0x0206a}, {1, 0x02070}, {0, 0x020d0}, {1, 0x020f0}, {2, 0x02329},

{1, 0x0232b}, {2, 0x02e80}, {0, 0x0302a}, {2, 0x03030}, {1, 0x0303f},

{2, 0x03040}, {0, 0x03099}, {2, 0x0309b}, {1, 0x0a4d0}, {0, 0x0a806},

{1, 0x0a807}, {0, 0x0a80b}, {1, 0x0a80c}, {0, 0x0a825}, {1, 0x0a827},

{2, 0x0ac00}, {1, 0x0d7a4}, {2, 0x0f900}, {1, 0x0fb00}, {0, 0x0fb1e},

{1, 0x0fb1f}, {0, 0x0fe00}, {2, 0x0fe10}, {1, 0x0fe1a}, {0, 0x0fe20},

{1, 0x0fe24}, {2, 0x0fe30}, {1, 0x0fe70}, {0, 0x0feff}, {2, 0x0ff00},

{1, 0x0ff61}, {2, 0x0ffe0}, {1, 0x0ffe7}, {0, 0x0fff9}, {1, 0x0fffc},

{0, 0x10a01}, {1, 0x10a04}, {0, 0x10a05}, {1, 0x10a07}, {0, 0x10a0c},

{1, 0x10a10}, {0, 0x10a38}, {1, 0x10a3b}, {0, 0x10a3f}, {1, 0x10a40},

{0, 0x1d167}, {1, 0x1d16a}, {0, 0x1d173}, {1, 0x1d183}, {0, 0x1d185},

{1, 0x1d18c}, {0, 0x1d1aa}, {1, 0x1d1ae}, {0, 0x1d242}, {1, 0x1d245},

{2, 0x20000}, {1, 0x2fffe}, {2, 0x30000}, {1, 0x3fffe}, {0, 0xe0001},

{1, 0xe0002}, {0, 0xe0020}, {1, 0xe0080}, {0, 0xe0100}, {1, 0xe01f0}

};

/*

** Return an estimate of the width, in columns, for the single Unicode

** character c. For normal characters, the answer is always 1. But the

** estimate might be 0 or 2 for zero-width and double-width characters.

**

** Different display devices display unicode using different widths. So

** it is impossible to know that true display width with 100% accuracy.

** Inaccuracies in the width estimates might cause columns to be misaligned.

** Unfortunately, there is nothing we can do about that.

*/

int cli_wcwidth(int c){

int iFirst, iLast;

/* Fast path for common characters */

if( c<=0x300 ) return 1;

/* The general case */

iFirst = 0;

iLast = sizeof(aUWidth)/sizeof(aUWidth[0]) - 1;

while( iFirst<iLast-1 ){

int iMid = (iFirst+iLast)/2;

int cMid = aUWidth[iMid].iFirst;

if( cMid < c ){

iFirst = iMid;

}else if( cMid > c ){

iLast = iMid - 1;

}else{

return aUWidth[iMid].w;

}

}

if( aUWidth[iLast].iFirst > c ) return aUWidth[iFirst].w;

return aUWidth[iLast].w;

}

/*

** Compute the value and length of a multi-byte UTF-8 character that

** begins at z[0]. Return the length. Write the Unicode value into *pU.

**

** This routine only works for *multi-byte* UTF-8 characters.

*/

static int decodeUtf8(const unsigned char *z, int *pU){

if( (z[0] & 0xe0)==0xc0 && (z[1] & 0xc0)==0x80 ){

*pU = ((z[0] & 0x1f)<<6) | (z[1] & 0x3f);

return 2;

}

if( (z[0] & 0xf0)==0xe0 && (z[1] & 0xc0)==0x80 && (z[2] & 0xc0)==0x80 ){

*pU = ((z[0] & 0x0f)<<12) | ((z[1] & 0x3f)<<6) | (z[2] & 0x3f);

return 3;

}

if( (z[0] & 0xf8)==0xf0 && (z[1] & 0xc0)==0x80 && (z[2] & 0xc0)==0x80

&& (z[3] & 0xc0)==0x80

){

*pU = ((z[0] & 0x0f)<<18) | ((z[1] & 0x3f)<<12) | ((z[2] & 0x3f))<<6

| (z[4] & 0x3f);

return 4;

}

*pU = 0;

return 1;

}

#if 0 /* NOT USED */

/*

** Return the width, in display columns, of a UTF-8 string.

**

** Each normal character counts as 1. Zero-width characters count

** as zero, and double-width characters count as 2.

*/

int cli_wcswidth(const char *z){

const unsigned char *a = (const unsigned char*)z;

int n = 0;

int i = 0;

unsigned char c;

while( (c = a[i])!=0 ){

if( c>=0xc0 ){

int u;

int len = decodeUtf8(&a[i], &u);

i += len;

n += cli_wcwidth(u);

}else if( c>=' ' ){

n++;

i++;

}else{

i++;

}

}

return n;

}

#endif

/*

** Output string zUtf to stdout as w characters. If w is negative,

** then right-justify the text. W is the width in UTF-8 characters, not

** in bytes. This is different from the %*.*s specification in printf

** since with %*.*s the width is measured in bytes, not characters.

**

** Take into account zero-width and double-width Unicode characters.

** In other words, a zero-width character does not count toward the

** the w limit. A double-width character counts as two.

*/

static void utf8_width_print(FILE *out, int w, const char *zUtf){

const unsigned char *a = (const unsigned char*)zUtf;

unsigned char c;

int i = 0;

int n = 0;

int aw = w<0 ? -w : w;

if( zUtf==0 ) zUtf = "";

while( (c = a[i])!=0 ){

if( (c&0xc0)==0xc0 ){

int u;

int len = decodeUtf8(a+i, &u);

int x = cli_wcwidth(u);

if( x+n>aw ){

break;

}

i += len;

n += x;

}else if( n>=aw ){

break;

}else{

n++;

i++;

}

}

if( n>=aw ){

sqlite3_fprintf(out, "%.*s", i, zUtf);

}else if( w<0 ){

sqlite3_fprintf(out, "%*s%s", aw-n, "", zUtf);

}else{

sqlite3_fprintf(out, "%s%*s", zUtf, aw-n, "");

}

}

/*

** Determines if a string is a number of not.

*/

static int isNumber(const char *z, int *realnum){

if( *z=='-' || *z=='+' ) z++;

if( !IsDigit(*z) ){

return 0;

}

z++;

if( realnum ) *realnum = 0;

while( IsDigit(*z) ){ z++; }

if( *z=='.' ){

z++;

if( !IsDigit(*z) ) return 0;

while( IsDigit(*z) ){ z++; }

if( realnum ) *realnum = 1;

}

if( *z=='e' || *z=='E' ){

z++;

if( *z=='+' || *z=='-' ) z++;

if( !IsDigit(*z) ) return 0;

while( IsDigit(*z) ){ z++; }

if( realnum ) *realnum = 1;

}

return *z==0;

}

/*

** Compute a string length that is limited to what can be stored in

** lower 30 bits of a 32-bit signed integer.

*/

static int strlen30(const char *z){

const char *z2 = z;

while( *z2 ){ z2++; }

return 0x3fffffff & (int)(z2 - z);

}

/*

** Return the length of a string in characters. Multibyte UTF8 characters

** count as a single character.

*/

static int strlenChar(const char *z){

int n = 0;

while( *z ){

if( (0xc0&*(z++))!=0x80 ) n++;

}

return n;

}

/*

** Return open FILE * if zFile exists, can be opened for read

** and is an ordinary file or a character stream source.

** Otherwise return 0.

*/

static FILE * openChrSource(const char *zFile){

#if defined(_WIN32) || defined(WIN32)

struct __stat64 x = {0};

# define STAT_CHR_SRC(mode) ((mode & (_S_IFCHR|_S_IFIFO|_S_IFREG))!=0)

/* On Windows, open first, then check the stream nature. This order

** is necessary because _stat() and sibs, when checking a named pipe,

** effectively break the pipe as its supplier sees it. */

FILE *rv = sqlite3_fopen(zFile, "rb");

if( rv==0 ) return 0;

if( _fstat64(_fileno(rv), &x) != 0

|| !STAT_CHR_SRC(x.st_mode)){

fclose(rv);

rv = 0;

}

return rv;

#else

struct stat x = {0};

int rc = stat(zFile, &x);

# define STAT_CHR_SRC(mode) (S_ISREG(mode)||S_ISFIFO(mode)||S_ISCHR(mode))

if( rc!=0 ) return 0;

if( STAT_CHR_SRC(x.st_mode) ){

return sqlite3_fopen(zFile, "rb");

}else{

return 0;

}

#endif

#undef STAT_CHR_SRC

}

/*

** This routine reads a line of text from FILE in, stores

** the text in memory obtained from malloc() and returns a pointer

** to the text. NULL is returned at end of file, or if malloc()

** fails.

**

** If zLine is not NULL then it is a malloced buffer returned from

** a previous call to this routine that may be reused.

*/

static char *local_getline(char *zLine, FILE *in){

int nLine = zLine==0 ? 0 : 100;

int n = 0;

while( 1 ){

if( n+100>nLine ){

nLine = nLine*2 + 100;

zLine = realloc(zLine, nLine);

shell_check_oom(zLine);

}

if( sqlite3_fgets(&zLine[n], nLine - n, in)==0 ){

if( n==0 ){

free(zLine);

return 0;

}

zLine[n] = 0;

break;

}

while( zLine[n] ) n++;

if( n>0 && zLine[n-1]=='\n' ){

n--;

if( n>0 && zLine[n-1]=='\r' ) n--;

zLine[n] = 0;

break;

}

}

return zLine;

}

/*

** Retrieve a single line of input text.

**

** If in==0 then read from standard input and prompt before each line.

** If isContinuation is true, then a continuation prompt is appropriate.

** If isContinuation is zero, then the main prompt should be used.

**

** If zPrior is not NULL then it is a buffer from a prior call to this

** routine that can be reused.

**

** The result is stored in space obtained from malloc() and must either

** be freed by the caller or else passed back into this routine via the

** zPrior argument for reuse.

*/

#ifndef SQLITE_SHELL_FIDDLE

static char *one_input_line(FILE *in, char *zPrior, int isContinuation){

char *zPrompt;

char *zResult;

if( in!=0 ){

zResult = local_getline(zPrior, in);

}else{

zPrompt = isContinuation ? CONTINUATION_PROMPT : mainPrompt;

#if SHELL_USE_LOCAL_GETLINE

sputz(stdout, zPrompt);

fflush(stdout);

do{

zResult = local_getline(zPrior, stdin);

zPrior = 0;

/* ^C trap creates a false EOF, so let "interrupt" thread catch up. */

if( zResult==0 ) sqlite3_sleep(50);

}while( zResult==0 && seenInterrupt>0 );

#else

free(zPrior);

zResult = shell_readline(zPrompt);

while( zResult==0 ){

/* ^C trap creates a false EOF, so let "interrupt" thread catch up. */

sqlite3_sleep(50);

if( seenInterrupt==0 ) break;

zResult = shell_readline("");

}

/* BEGIN SQLCIPHER */

#ifdef SQLITE_HAS_CODEC

/* Simplistic filtering of input lines to prevent PRAGKA key and

PRAGMA rekey statements from being stored in readline history.

Note that this will only prevent single line statements, but that

will be sufficient for common cases. */

if(zResult && *zResult && (

sqlite3_strlike("%pragma%key%=%", zResult, 0)==0 ||

sqlite3_strlike("%attach%database%as%key%", zResult, 0)==0

)

) return zResult;