blob: b82d20b227f5b5e5747f1ec2e25f4de40cd9e211 [file] [log] [blame]
#include "go-sqlite.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "_cgo_export.h"
static sqlite3_io_methods g_file_methods;
typedef struct GoFile GoFile;
struct GoFile {
sqlite3_io_methods const *pMethod; /* Always the first entry */
int fd;
};
/* File methods */
static int go_file_close(sqlite3_file* file) {
GoFileClose(((GoFile*) file)->fd);
// Matching sqlite3's os_unix.c here.
memset(file, 0, sizeof(GoFile));
return SQLITE_OK;
}
static int go_file_read(sqlite3_file* file, void* dest, int iAmt, sqlite3_int64 iOfst) {
return GoFileRead(((GoFile*) file)->fd, dest, iAmt, iOfst);
}
static int go_file_write(sqlite3_file* file, const void* src, int iAmt, sqlite3_int64 iOfst) {
return GoFileWrite(((GoFile*) file)->fd, src, iAmt, iOfst);
}
static int go_file_truncate(sqlite3_file* file, sqlite3_int64 size) {
const int fd = ((GoFile*) file)->fd;
fprintf(stderr, "TODO go_file_truncate(%d)\n", fd);
// TODO: implement
return SQLITE_OK;
}
static int go_file_sync(sqlite3_file* file, int flags) {
const int fd = ((GoFile*) file)->fd;
fprintf(stderr, "TODO go_file_sync(%d)\n", fd);
// TODO: implement
return SQLITE_OK;
}
static int go_file_file_size(sqlite3_file* file, sqlite3_int64* pSize) {
const int fd = ((GoFile*) file)->fd;
struct GoFileFileSize_return result = GoFileFileSize(fd);
fprintf(stderr, "go_file_file_size(%d) = %d, %lld\n", fd, result.r0, result.r1);
if (result.r0 != 0) {
return SQLITE_ERROR;
}
*pSize = result.r1;
return SQLITE_OK;
}
static int go_file_lock(sqlite3_file* file, int flags) {
const int fd = ((GoFile*) file)->fd;
fprintf(stderr, "TODO go_file_lock(%d)\n", fd);
// TODO: implement
return SQLITE_OK;
}
static int go_file_unlock(sqlite3_file* file, int flags) {
const int fd = ((GoFile*) file)->fd;
fprintf(stderr, "TODO go_file_unlock(%d)\n", fd);
// TODO: implement
return SQLITE_OK;
}
static int go_file_check_reserved_lock(sqlite3_file* file, int* pResOut) {
const int fd = ((GoFile*) file)->fd;
fprintf(stderr, "TODO go_file_check_reserved_lock(%d)\n", fd);
// TODO: implement
return SQLITE_OK;
}
static int go_file_file_control(sqlite3_file* file, int op, void* pArg) {
const int fd = ((GoFile*) file)->fd;
fprintf(stderr, "TODO go_file_file_control(%d, %d)\n", fd, op);
// TODO: implement
return SQLITE_OK;
}
static int go_file_sector_size(sqlite3_file* file) {
// Matching sqlite3's os_unix.c here; this is SQLITE_DEFAULT_SECTOR_SIZE.
return 512;
}
static int go_file_device_characteristics(sqlite3_file* file) {
// Matching sqlite3's os_unix.c here.
return 0;
}
/* VFS methods */
static int go_vfs_open(sqlite3_vfs* vfs,
const char* zName,
sqlite3_file* file,
int flags,
int* pOutFlags) {
fprintf(stderr, "go_vfs_open: %s\n", zName);
GoFile* go_file = (GoFile*) file;
memset(go_file, 0, sizeof(go_file));
const int fd = GoVFSOpen((char*) zName, flags);
if (fd == -1) {
return SQLITE_ERROR;
}
go_file->pMethod = &g_file_methods;
go_file->fd = fd;
return SQLITE_OK;
}
static int go_vfs_delete(sqlite3_vfs* vfs, const char* zName, int syncDir) {
return GoVFSDelete(zName, syncDir);
}
static int go_vfs_access(sqlite3_vfs* vfs,
const char* zName,
int flags,
int* pResOut) {
*pResOut = GoVFSAccess(zName, flags);
return SQLITE_OK;
}
static int go_vfs_full_pathname(sqlite3_vfs* vfs,
const char* zName,
int nOut,
char* zOut) {
fprintf(stderr, "TODO go_vfs_full_pathname: %s\n", zName);
// TODO: Actually implement this.
strncpy(zOut, zName, nOut);
zOut[nOut - 1] = '\0';
return SQLITE_OK;
}
static void* go_vfs_dl_open(sqlite3_vfs* vfs, const char* zFilename) {
fprintf(stderr, "TODO go_vfs_dl_open\n");
return NULL;
}
static void go_vfs_dl_error(sqlite3_vfs* vfs, int nByte, char *zErrMsg) {
fprintf(stderr, "TODO go_vfs_dl_error\n");
}
static void* go_vfs_dl_sym(sqlite3_vfs* vfs,
void* handle,
const char* zSymbol) {
fprintf(stderr, "TODO go_vfs_dl_sym\n");
return NULL;
}
static void go_vfs_dl_close(sqlite3_vfs* vfs, void* handle) {
fprintf(stderr, "TODO go_vfs_dl_close\n");
}
static int go_vfs_randomness(sqlite3_vfs* vfs, int nByte, char *zOut) {
fprintf(stderr, "TODO go_vfs_randomness\n");
return SQLITE_OK;
}
static int go_vfs_sleep(sqlite3_vfs* vfs, int microseconds) {
fprintf(stderr, "TODO go_vfs_sleep\n");
return SQLITE_OK;
}
static int go_vfs_current_time(sqlite3_vfs* vfs, double* now) {
*now = GoVFSCurrentTimeInt64() / 86400000.0;
return SQLITE_OK;
}
static int go_vfs_get_last_error(sqlite3_vfs* vfs, int foo, char* bar) {
// Unused, per sqlite3's os_unix.c.
return SQLITE_OK;
}
static int go_vfs_current_time_int64(sqlite3_vfs* vfs, sqlite3_int64* now) {
*now = GoVFSCurrentTimeInt64();
return SQLITE_OK;
}
int go_init_vfs(void) {
static sqlite3_vfs vfs;
memset(&vfs, 0, sizeof(vfs));
vfs.iVersion = 2;
vfs.szOsFile = sizeof(GoFile);
vfs.mxPathname = 512;
vfs.pNext = NULL;
vfs.zName = "go";
vfs.pAppData = NULL;
/* Version 1 methods */
vfs.xOpen = go_vfs_open;
vfs.xDelete = go_vfs_delete;
vfs.xAccess = go_vfs_access;
vfs.xFullPathname = go_vfs_full_pathname;
vfs.xDlOpen = go_vfs_dl_open;
vfs.xDlError = go_vfs_dl_error;
vfs.xDlSym = go_vfs_dl_sym;
vfs.xDlClose = go_vfs_dl_close;
vfs.xRandomness = go_vfs_randomness;
vfs.xSleep = go_vfs_sleep;
vfs.xCurrentTime = go_vfs_current_time;
vfs.xGetLastError = go_vfs_get_last_error;
/* Version 2 method */
vfs.xCurrentTimeInt64 = go_vfs_current_time_int64;
#if 0
/*
** The methods above are in versions 1 and 2 of the sqlite_vfs object.
** Those below are for version 3 and greater.
*/
int (*xSetSystemCall)(sqlite3_vfs*, const char *zName, sqlite3_syscall_ptr);
sqlite3_syscall_ptr (*xGetSystemCall)(sqlite3_vfs*, const char *zName);
const char *(*xNextSystemCall)(sqlite3_vfs*, const char *zName);
/*
** The methods above are in versions 1 through 3 of the sqlite_vfs object.
** New fields may be appended in figure versions. The iVersion
** value will increment whenever this happens.
*/
};
#endif
sqlite3_vfs_register(&vfs, 1);
memset(&g_file_methods, 0, sizeof(g_file_methods));
g_file_methods.iVersion = 1;
g_file_methods.xClose = go_file_close;
g_file_methods.xRead = go_file_read;
g_file_methods.xWrite = go_file_write;
g_file_methods.xTruncate = go_file_truncate;
g_file_methods.xSync = go_file_sync;
g_file_methods.xFileSize = go_file_file_size;
g_file_methods.xLock = go_file_lock;
g_file_methods.xUnlock = go_file_unlock;
g_file_methods.xCheckReservedLock = go_file_check_reserved_lock;
g_file_methods.xFileControl = go_file_file_control;
g_file_methods.xSectorSize = go_file_sector_size;
g_file_methods.xDeviceCharacteristics = go_file_device_characteristics;
#if 0
/* Methods above are valid for version 1 */
int (*xShmMap)(sqlite3_file*, int iPg, int pgsz, int, void volatile**);
int (*xShmLock)(sqlite3_file*, int offset, int n, int flags);
void (*xShmBarrier)(sqlite3_file*);
int (*xShmUnmap)(sqlite3_file*, int deleteFlag);
/* Methods above are valid for version 2 */
/* Additional methods may be added in future releases */
#endif
return SQLITE_OK;
}
#if SQLITE_OS_OTHER==1
int sqlite3_os_init(void) { return SQLITE_OK; }
int sqlite3_os_end(void) { return SQLITE_OK; }
#endif