diff --git a/contrib/sdk/sources/sqlite3/Makefile b/contrib/sdk/sources/sqlite3/Makefile index 26f529540e..a42a16f3c0 100644 --- a/contrib/sdk/sources/sqlite3/Makefile +++ b/contrib/sdk/sources/sqlite3/Makefile @@ -7,7 +7,7 @@ STRIP = kos32-strip INSTALLDIR ?= /home/autobuild/tools/win32/lib -CFLAGS = -U__MINGW32__ -UWIN32 -UWindows -U_WINDOWS -U_WIN32 -U__WIN32__ -U_WIN32 -DPACKAGE_NAME=\"sqlite\" -DPACKAGE_TARNAME=\"sqlite\" -DPACKAGE_VERSION=\"3.36.0\" -DPACKAGE_STRING=\"sqlite\ 3.36.0\" -DPACKAGE_BUGREPORT=\"http://www.sqlite.org\" -DPACKAGE_URL=\"\" -DPACKAGE=\"sqlite\" -DVERSION=\"3.36.0\" -DSTDC_HEADERS=1 -DHAVE_SYS_TYPES_H=1 -DHAVE_SYS_STAT_H=1 -DHAVE_STDLIB_H=1 -DHAVE_STRING_H=1 -DHAVE_MEMORY_H=1 -DHAVE_STRINGS_H=1 -DHAVE_INTTYPES_H=1 -DHAVE_STDINT_H=1 -DHAVE_UNISTD_H=0 -DHAVE_DLFCN_H=1 -DLT_OBJDIR=\".libs/\" -DHAVE_FDATASYNC=1 -DHAVE_USLEEP=1 -DHAVE_LOCALTIME_R=1 -DHAVE_GMTIME_R=1 -DHAVE_DECL_STRERROR_R=1 -DHAVE_STRERROR_R=1 -DHAVE_EDITLINE_READLINE_H=1 -DHAVE_EDITLINE=1 -DHAVE_ZLIB_H=1 -I. -D_REENTRANT=1 -DSQLITE_THREADSAFE=0 -DSQLITE_ENABLE_MATH_FUNCTIONS -DSQLITE_ENABLE_FTS4 -DSQLITE_ENABLE_FTS5 -DSQLITE_ENABLE_JSON1 -DSQLITE_ENABLE_RTREE -DSQLITE_ENABLE_GEOPOLY -DSQLITE_HAVE_ZLIB=1 -DSQLITE_OS_OTHER=1 -USQLITE_OS_WIN_H -c -O2 -fomit-frame-pointer +CFLAGS = -U__MINGW32__ -UWIN32 -UWindows -U_WINDOWS -U_WIN32 -U__WIN32__ -U_WIN32 -DPACKAGE_NAME=\"sqlite\" -DPACKAGE_TARNAME=\"sqlite\" -DPACKAGE_VERSION=\"3.36.0\" -DPACKAGE_STRING=\"sqlite\ 3.36.0\" -DPACKAGE_BUGREPORT=\"http://www.sqlite.org\" -DPACKAGE_URL=\"\" -DPACKAGE=\"sqlite\" -DVERSION=\"3.36.0\" -DSTDC_HEADERS=1 -DHAVE_SYS_TYPES_H=1 -DHAVE_SYS_STAT_H=1 -DHAVE_STDLIB_H=1 -DHAVE_STRING_H=1 -DHAVE_MEMORY_H=1 -DHAVE_STRINGS_H=1 -DHAVE_INTTYPES_H=1 -DHAVE_STDINT_H=1 -DHAVE_UNISTD_H=0 -DHAVE_DLFCN_H=1 -DLT_OBJDIR=\".libs/\" -DHAVE_FDATASYNC=0 -DHAVE_USLEEP=0 -DHAVE_LOCALTIME_R=1 -DHAVE_GMTIME_R=1 -DHAVE_DECL_STRERROR_R=1 -DHAVE_STRERROR_R=1 -DHAVE_EDITLINE_READLINE_H=1 -DHAVE_EDITLINE=1 -DHAVE_ZLIB_H=1 -I. -D_REENTRANT=1 -DSQLITE_THREADSAFE=0 -DSQLITE_ENABLE_MATH_FUNCTIONS -DSQLITE_ENABLE_FTS4 -DSQLITE_ENABLE_FTS5 -DSQLITE_ENABLE_JSON1 -DSQLITE_ENABLE_RTREE -DSQLITE_ENABLE_GEOPOLY -DSQLITE_HAVE_ZLIB=1 -DSQLITE_OS_OTHER=1 -USQLITE_OS_WIN_H -DSQLITE_TEMP_STORE=3 -D_NO_STDERR -c -O2 -fomit-frame-pointer -D_KOLIBRI LDFLAGS=$(LDFLAGS_CMD) LDFLAGS+= -shared -s -T dll.lds --entry _DllStartup --image-base=0 @@ -16,7 +16,7 @@ ARFLAGS:= crs INCLUDES= -I. -I../newlib/libc/include LIBS:= -ldll -lgcc -lc.dll -SOURCES = sqlite3.c stub.c +SOURCES = sqlite3.c kolibri_vfs.c OBJECTS = $(patsubst %.c, %.o, $(SOURCES)) all:$(LIBRARY).a $(LIBRARY).dll @@ -27,15 +27,12 @@ $(LIBRARY).a: $(OBJECTS) Makefile $(LIBRARY).dll: sqlite3.def $(OBJECTS) Makefile $(LD) $(LDFLAGS) -o $@ sqlite3.def $(OBJECTS) $(LIBS) - $(STRIP) $@ + $(STRIP) -S $@ #mv -f $(LIBRARY).dll.a $(INSTALLDIR) %.o : %.c Makefile $(CC) $(CFLAGS) $(DEFINES) $(INCLUDES) -o $@ $< - -sqlite3_shell: - $(CC) $(CFLAGS) $(DEFINES) $(INCLUDES) shell.c clean: -rm -f *.o diff --git a/contrib/sdk/sources/sqlite3/kolibri_vfs.c b/contrib/sdk/sources/sqlite3/kolibri_vfs.c new file mode 100644 index 0000000000..9abd5b5a1d --- /dev/null +++ b/contrib/sdk/sources/sqlite3/kolibri_vfs.c @@ -0,0 +1,608 @@ +#if !defined(SQLITE_TEST) || _KOLIBRI + +#include "sqlite3.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* +** Size of the write buffer used by journal files in bytes. +*/ +#ifndef SQLITE_DEMOVFS_BUFFERSZ +# define SQLITE_DEMOVFS_BUFFERSZ 8192 +#endif + +/* +** The maximum pathname length supported by this VFS. +*/ +#define MAXPATHNAME 512 + +sqlite3_vfs *sqlite3_kosvfs(void); + +/* +** When using this VFS, the sqlite3_file* handles that SQLite uses are +** actually pointers to instances of type KosFile. +*/ +typedef struct KosFile KosFile; +struct KosFile { + sqlite3_file base; /* Base class. Must be first. */ + int fd; /* File descriptor */ + + char *aBuffer; /* Pointer to malloc'd buffer */ + int nBuffer; /* Valid bytes of data in zBuffer */ + sqlite3_int64 iBufferOfst; /* Offset in file of zBuffer[0] */ +}; + +/* +** Write directly to the file passed as the first argument. Even if the +** file has a write-buffer (KosFile.aBuffer), ignore it. +*/ +static int kosDirectWrite( + KosFile *p, /* File handle */ + const void *zBuf, /* Buffer containing data to write */ + int iAmt, /* Size of data to write in bytes */ + sqlite_int64 iOfst /* File offset to write to */ +){ + off_t ofst; /* Return value from lseek() */ + size_t nWrite; /* Return value from write() */ + + ofst = lseek(p->fd, iOfst, SEEK_SET); + if( ofst!=iOfst ){ + return SQLITE_IOERR_WRITE; + } + + nWrite = write(p->fd, zBuf, iAmt); + if( nWrite!=iAmt ){ + return SQLITE_IOERR_WRITE; + } + + return SQLITE_OK; +} + +/* +** Flush the contents of the KosFile.aBuffer buffer to disk. This is a +** no-op if this particular file does not have a buffer (i.e. it is not +** a journal file) or if the buffer is currently empty. +*/ + +int sqlite3_os_init(){ + return sqlite3_vfs_register(sqlite3_kosvfs(), 0); +} + +static int kosFlushBuffer(KosFile *p){ + int rc = SQLITE_OK; + if( p->nBuffer ){ + rc = kosDirectWrite(p, p->aBuffer, p->nBuffer, p->iBufferOfst); + p->nBuffer = 0; + } + return rc; +} + +/* +** Close a file. +*/ +static int kosClose(sqlite3_file *pFile){ + int rc; + KosFile *p = (KosFile*)pFile; + rc = kosFlushBuffer(p); + sqlite3_free(p->aBuffer); + close(p->fd); + return rc; +} + +/* +** Read data from a file. +*/ +static int kosRead( + sqlite3_file *pFile, + void *zBuf, + int iAmt, + sqlite_int64 iOfst +){ + KosFile *p = (KosFile*)pFile; + off_t ofst; /* Return value from lseek() */ + int nRead; /* Return value from read() */ + int rc; /* Return code from kosFlushBuffer() */ + + /* Flush any data in the write buffer to disk in case this operation + ** is trying to read data the file-region currently cached in the buffer. + ** It would be possible to detect this case and possibly save an + ** unnecessary write here, but in practice SQLite will rarely read from + ** a journal file when there is data cached in the write-buffer. + */ + rc = kosFlushBuffer(p); + if( rc!=SQLITE_OK ){ + return rc; + } + + ofst = lseek(p->fd, iOfst, SEEK_SET); + if( ofst!=iOfst ){ + return SQLITE_IOERR_READ; + } + nRead = read(p->fd, zBuf, iAmt); + + if( nRead==iAmt ){ + return SQLITE_OK; + }else if( nRead>=0 ){ + if( nReadaBuffer ){ + char *z = (char *)zBuf; /* Pointer to remaining data to write */ + int n = iAmt; /* Number of bytes at z */ + sqlite3_int64 i = iOfst; /* File offset to write to */ + + while( n>0 ){ + int nCopy; /* Number of bytes to copy into buffer */ + + /* If the buffer is full, or if this data is not being written directly + ** following the data already buffered, flush the buffer. Flushing + ** the buffer is a no-op if it is empty. + */ + if( p->nBuffer==SQLITE_DEMOVFS_BUFFERSZ || p->iBufferOfst+p->nBuffer!=i ){ + int rc = kosFlushBuffer(p); + if( rc!=SQLITE_OK ){ + return rc; + } + } + assert( p->nBuffer==0 || p->iBufferOfst+p->nBuffer==i ); + p->iBufferOfst = i - p->nBuffer; + + /* Copy as much data as possible into the buffer. */ + nCopy = SQLITE_DEMOVFS_BUFFERSZ - p->nBuffer; + if( nCopy>n ){ + nCopy = n; + } + memcpy(&p->aBuffer[p->nBuffer], z, nCopy); + p->nBuffer += nCopy; + + n -= nCopy; + i += nCopy; + z += nCopy; + } + }else{ + return kosDirectWrite(p, zBuf, iAmt, iOfst); + } + + return SQLITE_OK; +} + +/* +** Truncate a file. This is a no-op for this VFS (see header comments at +** the top of the file). +*/ +static int kosTruncate(sqlite3_file *pFile, sqlite_int64 size){ +#if 0 + if( ftruncate(((KosFile *)pFile)->fd, size) ) return SQLITE_IOERR_TRUNCATE; +#endif + return SQLITE_OK; +} + +/* +** Sync the contents of the file to the persistent media. +*/ +static int kosSync(sqlite3_file *pFile, int flags){ + KosFile *p = (KosFile*)pFile; + int rc; + + rc = kosFlushBuffer(p); + if( rc!=SQLITE_OK ){ + return rc; + } + + rc = fsync(p->fd); + return (rc==0 ? SQLITE_OK : SQLITE_IOERR_FSYNC); +} + +/* +** Write the size of the file in bytes to *pSize. +*/ +static int kosFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){ + KosFile *p = (KosFile*)pFile; + int rc; /* Return code from fstat() call */ + struct stat sStat; /* Output of fstat() call */ + + /* Flush the contents of the buffer to disk. As with the flush in the + ** kosRead() method, it would be possible to avoid this and save a write + ** here and there. But in practice this comes up so infrequently it is + ** not worth the trouble. + */ + rc = kosFlushBuffer(p); + if( rc!=SQLITE_OK ){ + return rc; + } + + rc = fstat(p->fd, &sStat); + if( rc!=0 ) return SQLITE_IOERR_FSTAT; + *pSize = sStat.st_size; + return SQLITE_OK; +} + +/* +** Locking functions. The xLock() and xUnlock() methods are both no-ops. +** The xCheckReservedLock() always indicates that no other process holds +** a reserved lock on the database file. This ensures that if a hot-journal +** file is found in the file-system it is rolled back. +*/ +static int kosLock(sqlite3_file *pFile, int eLock){ + return SQLITE_OK; +} +static int kosUnlock(sqlite3_file *pFile, int eLock){ + return SQLITE_OK; +} +static int kosCheckReservedLock(sqlite3_file *pFile, int *pResOut){ + *pResOut = 0; + return SQLITE_OK; +} + +/* +** No xFileControl() verbs are implemented by this VFS. +*/ +static int kosFileControl(sqlite3_file *pFile, int op, void *pArg){ + return SQLITE_NOTFOUND; +} + +/* +** The xSectorSize() and xDeviceCharacteristics() methods. These two +** may return special values allowing SQLite to optimize file-system +** access to some extent. But it is also safe to simply return 0. +*/ +static int kosSectorSize(sqlite3_file *pFile){ + return 0; +} +static int kosDeviceCharacteristics(sqlite3_file *pFile){ + return 0; +} + +/* +** Open a file handle. +*/ +static int kosOpen( + sqlite3_vfs *pVfs, /* VFS */ + const char *zName, /* File to open, or 0 for a temp file */ + sqlite3_file *pFile, /* Pointer to KosFile struct to populate */ + int flags, /* Input SQLITE_OPEN_XXX flags */ + int *pOutFlags /* Output SQLITE_OPEN_XXX flags (or NULL) */ +){ + static const sqlite3_io_methods kosio = { + 1, /* iVersion */ + kosClose, /* xClose */ + kosRead, /* xRead */ + kosWrite, /* xWrite */ + kosTruncate, /* xTruncate */ + kosSync, /* xSync */ + kosFileSize, /* xFileSize */ + kosLock, /* xLock */ + kosUnlock, /* xUnlock */ + kosCheckReservedLock, /* xCheckReservedLock */ + kosFileControl, /* xFileControl */ + kosSectorSize, /* xSectorSize */ + kosDeviceCharacteristics /* xDeviceCharacteristics */ + }; + + KosFile *p = (KosFile*)pFile; /* Populate this structure */ + int oflags = 0; /* flags to pass to open() call */ + char *aBuf = 0; + + if( zName==0 ){ + return SQLITE_IOERR; + } + + if( flags&SQLITE_OPEN_MAIN_JOURNAL ){ + aBuf = (char *)sqlite3_malloc(SQLITE_DEMOVFS_BUFFERSZ); + if( !aBuf ){ + return SQLITE_NOMEM; + } + } + + if( flags&SQLITE_OPEN_EXCLUSIVE ) oflags |= O_EXCL; + if( flags&SQLITE_OPEN_CREATE ) oflags |= O_CREAT; + if( flags&SQLITE_OPEN_READONLY ) oflags |= O_RDONLY; + if( flags&SQLITE_OPEN_READWRITE ) oflags |= O_RDWR; + + memset(p, 0, sizeof(KosFile)); + p->fd = open(zName, oflags, 0600); + if( p->fd<0 ){ + sqlite3_free(aBuf); + return SQLITE_CANTOPEN; + } + p->aBuffer = aBuf; + + if( pOutFlags ){ + *pOutFlags = flags; + } + p->base.pMethods = &kosio; + return SQLITE_OK; +} + +/* +** Delete the file identified by argument zPath. If the dirSync parameter +** is non-zero, then ensure the file-system modification to delete the +** file has been synced to disk before returning. +*/ +static int kosDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){ + int rc; /* Return code */ + + rc = unlink(zPath); + if( rc!=0 && errno==ENOENT ) return SQLITE_OK; + + if( rc==0 && dirSync ){ + int dfd; /* File descriptor open on directory */ + int i; /* Iterator variable */ + char zDir[MAXPATHNAME+1]; /* Name of directory containing file zPath */ + + /* Figure out the directory name from the path of the file deleted. */ + sqlite3_snprintf(MAXPATHNAME, zDir, "%s", zPath); + zDir[MAXPATHNAME] = '\0'; + for(i=strlen(zDir); i>1 && zDir[i]!='/'; i++); + zDir[i] = '\0'; + + /* Open a file-descriptor on the directory. Sync. Close. */ + dfd = open(zDir, O_RDONLY, 0); + if( dfd<0 ){ + rc = -1; + }else{ + rc = fsync(dfd); + close(dfd); + } + } + return (rc==0 ? SQLITE_OK : SQLITE_IOERR_DELETE); +} + +#ifndef F_OK +# define F_OK 0 +#endif +#ifndef R_OK +# define R_OK 4 +#endif +#ifndef W_OK +# define W_OK 2 +#endif + +/* +** Query the file-system to see if the named file exists, is readable or +** is both readable and writable. +*/ +static int kosAccess( + sqlite3_vfs *pVfs, + const char *zPath, + int flags, + int *pResOut +){ + int rc; /* access() return code */ + int eAccess = F_OK; /* Second argument to access() */ + + assert( flags==SQLITE_ACCESS_EXISTS /* access(zPath, F_OK) */ + || flags==SQLITE_ACCESS_READ /* access(zPath, R_OK) */ + || flags==SQLITE_ACCESS_READWRITE /* access(zPath, R_OK|W_OK) */ + ); + + if( flags==SQLITE_ACCESS_READWRITE ) eAccess = R_OK|W_OK; + if( flags==SQLITE_ACCESS_READ ) eAccess = R_OK; + + rc = access(zPath, eAccess); + *pResOut = (rc==0); + return SQLITE_OK; +} + +/* +** Argument zPath points to a nul-terminated string containing a file path. +** If zPath is an absolute path, then it is copied as is into the output +** buffer. Otherwise, if it is a relative path, then the equivalent full +** path is written to the output buffer. +** +** This function assumes that paths are UNIX style. Specifically, that: +** +** 1. Path components are separated by a '/'. and +** 2. Full paths begin with a '/' character. +*/ +static int kosFullPathname( + sqlite3_vfs *pVfs, /* VFS */ + const char *zPath, /* Input path (possibly a relative path) */ + int nPathOut, /* Size of output buffer in bytes */ + char *zPathOut /* Pointer to output buffer */ +){ + char zDir[MAXPATHNAME+1]; + if( zPath[0]=='/' ){ + zDir[0] = '\0'; + }else{ + if( getcwd(zDir, sizeof(zDir))==0 ) return SQLITE_IOERR; + } + zDir[MAXPATHNAME] = '\0'; + + sqlite3_snprintf(nPathOut, zPathOut, "%s/%s", zDir, zPath); + zPathOut[nPathOut-1] = '\0'; + + return SQLITE_OK; +} + +/* +** The following four VFS methods: +** +** xDlOpen +** xDlError +** xDlSym +** xDlClose +** +** are supposed to implement the functionality needed by SQLite to load +** extensions compiled as shared objects. This simple VFS does not support +** this functionality, so the following functions are no-ops. +*/ +static void *kosDlOpen(sqlite3_vfs *pVfs, const char *zPath){ + return 0; +} +static void kosDlError(sqlite3_vfs *pVfs, int nByte, char *zErrMsg){ + sqlite3_snprintf(nByte, zErrMsg, "Loadable extensions are not supported"); + zErrMsg[nByte-1] = '\0'; +} +static void (*kosDlSym(sqlite3_vfs *pVfs, void *pH, const char *z))(void){ + return 0; +} +static void kosDlClose(sqlite3_vfs *pVfs, void *pHandle){ + return; +} + +/* +** Parameter zByte points to a buffer nByte bytes in size. Populate this +** buffer with pseudo-random data. +*/ +static int kosRandomness(sqlite3_vfs *pVfs, int nByte, char *zByte){ + return SQLITE_OK; +} + +/* +** Sleep for at least nMicro microseconds. Return the (approximate) number +** of microseconds slept for. +*/ +static int kosSleep(sqlite3_vfs *pVfs, int nMicro){ + sleep(nMicro / 1000000); + usleep(nMicro % 1000000); + return nMicro; +} + +/* +** Set *pTime to the current UTC time expressed as a Julian day. Return +** SQLITE_OK if successful, or an error code otherwise. +** +** http://en.wikipedia.org/wiki/Julian_day +** +** This implementation is not very good. The current time is rounded to +** an integer number of seconds. Also, assuming time_t is a signed 32-bit +** value, it will stop working some time in the year 2038 AD (the so-called +** "year 2038" problem that afflicts systems that store time this way). +*/ +static int kosCurrentTime(sqlite3_vfs *pVfs, double *pTime){ + time_t t = time(0); + *pTime = t/86400.0 + 2440587.5; + return SQLITE_OK; +} + +/* +** This function returns a pointer to the VFS implemented in this file. +** To make the VFS available to SQLite: +** +** sqlite3_vfs_register(sqlite3_kosvfs(), 0); +*/ +sqlite3_vfs *sqlite3_kosvfs(void){ + static sqlite3_vfs kosvfs = { + 1, /* iVersion */ + sizeof(KosFile), /* szOsFile */ + MAXPATHNAME, /* mxPathname */ + 0, /* pNext */ + "kos", /* zName */ + 0, /* pAppData */ + kosOpen, /* xOpen */ + kosDelete, /* xDelete */ + kosAccess, /* xAccess */ + kosFullPathname, /* xFullPathname */ + kosDlOpen, /* xDlOpen */ + kosDlError, /* xDlError */ + kosDlSym, /* xDlSym */ + kosDlClose, /* xDlClose */ + kosRandomness, /* xRandomness */ + kosSleep, /* xSleep */ + kosCurrentTime, /* xCurrentTime */ + }; + return &kosvfs; +} + +SQLITE_API int sqlite3_os_end(void){ + return SQLITE_OK; +} + +void _ksys_sleep(unsigned time) +{ + __asm__ __volatile__( + "int $0x40" + ::"a"(5), "b"(time) + :"memory"); +}; + +unsigned sleep(unsigned time){ + _ksys_sleep(time*100); + return 0; +} + +int usleep(useconds_t usec){ + _ksys_sleep(usec); + return 0; +} + +int fsync(int fd){ + return 0; +} + + +#endif /* !defined(SQLITE_TEST) || SQLITE_OS_UNIX */ + + +#ifdef SQLITE_TEST + +#if defined(INCLUDE_SQLITE_TCL_H) +# include "sqlite_tcl.h" +#else +# include "tcl.h" +# ifndef SQLITE_TCLAPI +# define SQLITE_TCLAPI +# endif +#endif + +#if SQLITE_OS_UNIX +static int SQLITE_TCLAPI register_kosvfs( + ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ + Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ + int objc, /* Number of arguments */ + Tcl_Obj *CONST objv[] /* Command arguments */ +){ + sqlite3_vfs_register(sqlite3_kosvfs(), 1); + return TCL_OK; +} +static int SQLITE_TCLAPI unregister_kosvfs( + ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ + Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ + int objc, /* Number of arguments */ + Tcl_Obj *CONST objv[] /* Command arguments */ +){ + sqlite3_vfs_unregister(sqlite3_kosvfs()); + return TCL_OK; +} + +/* +** Register commands with the TCL interpreter. +*/ +int Sqlitetest_kosvfs_Init(Tcl_Interp *interp){ + Tcl_CreateObjCommand(interp, "register_kosvfs", register_kosvfs, 0, 0); + Tcl_CreateObjCommand(interp, "unregister_kosvfs", unregister_kosvfs, 0, 0); + return TCL_OK; +} + +#else +int Sqlitetest_kosvfs_Init(Tcl_Interp *interp){ return TCL_OK; } +#endif + +#endif /* SQLITE_TEST */ diff --git a/contrib/sdk/sources/sqlite3/shell/Makefile b/contrib/sdk/sources/sqlite3/shell/Makefile index f88367f6b9..075c630077 100755 --- a/contrib/sdk/sources/sqlite3/shell/Makefile +++ b/contrib/sdk/sources/sqlite3/shell/Makefile @@ -3,7 +3,7 @@ LD = kos32-ld SDK_DIR = $(abspath ../../../../sdk) -CFLAGS = -c -fno-ident -O2 -fomit-frame-pointer -fno-ident -U__WIN32__ -U_Win32 -U_WIN32 -U__MINGW32__ -UWIN32 -DSQLITE_OS_OTHER=1 -DHAVE_UNISTD_H=0 -DSQLITE_OMIT_POPEN -DSQLITE_THREADSAFE=0 -D_KOLIBRI -U__linux__ -DPACKAGE_NAME=\"sqlite\" -DPACKAGE_TARNAME=\"sqlite\" -DPACKAGE_VERSION=\"3.36.0\" -DPACKAGE_STRING=\"sqlite\ 3.36.0\" -DPACKAGE_BUGREPORT=\"http://www.sqlite.org\" -DPACKAGE_URL=\"\" -DPACKAGE=\"sqlite\" -DVERSION=\"3.36.0\" +CFLAGS = -c -fno-ident -O2 -fomit-frame-pointer -fno-ident -U__WIN32__ -U_Win32 -U_WIN32 -U__MINGW32__ -UWIN32 -DSQLITE_OS_OTHER=1 -DHAVE_UNISTD_H=0 -D_NO_STDERR -DSQLITE_OMIT_POPEN -DSQLITE_THREADSAFE=0 -D_KOLIBRI -U__linux__ -DPACKAGE_NAME=\"sqlite\" -DPACKAGE_TARNAME=\"sqlite\" -DPACKAGE_VERSION=\"3.36.0\" -DPACKAGE_STRING=\"sqlite\ 3.36.0\" -DPACKAGE_BUGREPORT=\"http://www.sqlite.org\" -DPACKAGE_URL=\"\" -DPACKAGE=\"sqlite\" -DVERSION=\"3.36.0\" LDFLAGS = -static -S -nostdlib -T $(SDK_DIR)/sources/newlib/app.lds --image-base 0 INCLUDES = -I $(SDK_DIR)/sources/newlib/libc/include -I.. @@ -11,16 +11,16 @@ LIBPATH = -L $(SDK_DIR)/lib -L /home/autobuild/tools/win32/mingw32/lib -L.. # Only selected -SRC = test.c stub.c +SRC = shell.c stub.c # All .c files # SRC = $(notdir $(wildcard *.c)) OBJECTS = $(patsubst %.c, %.o, $(SRC)) default: $(patsubst %.c,%.o,$(SRC)) - kos32-ld $(LDFLAGS) $(LIBPATH) --subsystem console -o slite3_shell $(OBJECTS) -lgcc -lsqlite3.dll -lc.dll - strip -S slite3_shell - objcopy slite3_shell -O binary + kos32-ld $(LDFLAGS) $(LIBPATH) --subsystem console -o sqlite3 $(OBJECTS) -lgcc -lsqlite3.dll -lc.dll + strip -S sqlite3 + objcopy sqlite3 -O binary %.o : %.c Makefile $(SRC) $(CC) $(CFLAGS) $(INCLUDES) -o $@ $< diff --git a/contrib/sdk/sources/sqlite3/shell/shell.c b/contrib/sdk/sources/sqlite3/shell/shell.c index c847eaec1d..c1a5c116a4 100644 --- a/contrib/sdk/sources/sqlite3/shell/shell.c +++ b/contrib/sdk/sources/sqlite3/shell/shell.c @@ -21007,12 +21007,14 @@ static char *cmdline_option_value(int argc, char **argv, int i){ # endif #endif + #if SQLITE_SHELL_IS_UTF8 int SQLITE_CDECL main(int argc, char **argv){ #else int SQLITE_CDECL wmain(int argc, wchar_t **wargv){ char **argv; #endif + con_init_opt(-1,-1,-1,-1, "SQLite3"); char *zErrMsg = 0; ShellState data; const char *zInitFile = 0; diff --git a/contrib/sdk/sources/sqlite3/stub.c b/contrib/sdk/sources/sqlite3/stub.c deleted file mode 100644 index d9ed8b91f8..0000000000 --- a/contrib/sdk/sources/sqlite3/stub.c +++ /dev/null @@ -1,9 +0,0 @@ -#include "sqlite3.h" - -SQLITE_API int sqlite3_os_init(void){ - return -1; -} - -SQLITE_API int sqlite3_os_end(void){ - return -1; -}