/*

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

#ifndef _WIN32

# include <sys/time.h>

#endif

#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)

#define IsAlnum(X) isalnum((unsigned char)X)

#define IsAlpha(X) isalpha((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 in microseconds since the

** Unix epoch (1970-01-01T00:00:00Z)

*/

static sqlite3_int64 timeOfDay(void){

#if defined(_WIN64)

sqlite3_uint64 t;

FILETIME tm;

GetSystemTimePreciseAsFileTime(&tm);

t = ((u64)tm.dwHighDateTime<<32) | (u64)tm.dwLowDateTime;

t += 116444736000000000LL;

t /= 10;

return t;

#elif defined(_WIN32)

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*1000;

#else

struct timeval sNow;

(void)gettimeofday(&sNow,0);

return ((i64)sNow.tv_sec)*1000000 + sNow.tv_usec;

#endif

}

#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 %.6f user %.6f sys %.6f\n",

(iEnd - iBegin)*0.000001,

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);

#ifdef _WIN64

/* microsecond precision on 64-bit windows */

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

(ftWallEnd - ftWallBegin)*0.000001,

timeDiff(&ftUserBegin, &ftUserEnd),

timeDiff(&ftKernelBegin, &ftKernelEnd));

#else

/* millisecond precisino on 32-bit windows */

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

(ftWallEnd - ftWallBegin)*0.000001,

timeDiff(&ftUserBegin, &ftUserEnd),

timeDiff(&ftKernelBegin, &ftKernelEnd));

#endif

}

}

#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 128

/* 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[3] & 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

/*

** Check to see if z[] is a valid VT100 escape. If it is, then

** return the number of bytes in the escape sequence. Return 0 if

** z[] is not a VT100 escape.

**

** This routine assumes that z[0] is \033 (ESC).

*/

static int isVt100(const unsigned char *z){

int i;

if( z[1]!='[' ) return 0;

i = 2;

while( z[i]>=0x30 && z[i]<=0x3f ){ i++; }

while( z[i]>=0x20 && z[i]<=0x2f ){ i++; }

if( z[i]<0x40 || z[i]>0x7e ) return 0;

return i+1;

}

/*

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

**

** w should normally be a small number. A couple hundred at most. This

** routine caps w at 100 million to avoid integer overflow issues.

*/

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

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

static const int mxW = 10000000;

unsigned char c;

int i = 0;

int n = 0;

int k;

int aw;

if( w<-mxW ){

w = -mxW;

}else if( w>mxW ){

w= mxW;

}

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( c==0x1b && (k = isVt100(&a[i]))>0 ){

i += k;

}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 for single-width characters, or as two

** characters for double-width characters.

*/

static int strlenChar(const char *z){

int n = 0;

while( *z ){

if( (0x80&z[0])==0 ){

n++;

z++;

}else{

int u = 0;

int len = decodeUtf8((const u8*)z, &u);

z += len;

n += cli_wcwidth(u);

}

}

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, or if the length of the line is longer than about a gigabyte.

**

** 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 ){

if( nLine>=1073741773 ){

free(zLine);

return 0;

}

nLine = nLine*2 + 100;