Skip to content

Y
ygopro
Commit 24e5ca92 authored by mercury233's avatar mercury233
Browse files
Options

update loadDB

parent ae3da991
Hide whitespace changes
Inline Side-by-side
Showing with 640 additions and 11 deletions
gframe/data_manager.cpp
View file @ 24e5ca92
......@@ -9,20 +9,33 @@ byte DataManager::scriptBuffer[0x20000];
DataManager dataManager;
bool DataManager::LoadDB(const char* file) {
sqlite3* pDB;
if(sqlite3_open_v2(file, &pDB, SQLITE_OPEN_READONLY, 0) != SQLITE_OK)
return Error(pDB);
wchar_t wfile[256];
BufferIO::DecodeUTF8(file, wfile);
IReadFile* reader = FileSystem->createAndOpenFile(wfile);
if(reader == NULL)
return false;
spmemvfs_db_t db;
spmembuffer_t * mem = (spmembuffer_t*)calloc(sizeof(spmembuffer_t), 1);
spmemvfs_env_init();
mem->total = mem->used = reader->getSize();
mem->data = (char*)malloc(mem->total + 1);
reader->read(mem->data, mem->total);
reader->drop();
(mem->data)[mem->total] = '\0';
if(spmemvfs_open_db(&db, file, mem) != SQLITE_OK)
return Error(&db);
sqlite3* pDB = db.handle;
sqlite3_stmt* pStmt;
const char* sql = "select * from datas,texts where datas.id=texts.id";
if(sqlite3_prepare_v2(pDB, sql, -1, &pStmt, 0) != SQLITE_OK)
return Error(pDB);
return Error(&db);
CardDataC cd;
CardString cs;
int step = 0;
do {
step = sqlite3_step(pStmt);
if(step == SQLITE_BUSY || step == SQLITE_ERROR || step == SQLITE_MISUSE)
return Error(pDB, pStmt);
return Error(&db, pStmt);
else if(step == SQLITE_ROW) {
cd.code = sqlite3_column_int(pStmt, 0);
cd.ot = sqlite3_column_int(pStmt, 1);
......@@ -62,7 +75,8 @@ bool DataManager::LoadDB(const char* file) {
}
} while(step != SQLITE_DONE);
sqlite3_finalize(pStmt);
sqlite3_close(pDB);
spmemvfs_close_db(&db);
spmemvfs_env_fini();
return true;
}
bool DataManager::LoadStrings(const char* file) {
......@@ -99,11 +113,12 @@ bool DataManager::LoadStrings(const char* file) {
myswprintf(numStrings[i], L"%d", i);
return true;
}
bool DataManager::Error(sqlite3* pDB, sqlite3_stmt* pStmt) {
BufferIO::DecodeUTF8(sqlite3_errmsg(pDB), strBuffer);
bool DataManager::Error(spmemvfs_db_t* pDB, sqlite3_stmt* pStmt) {
BufferIO::DecodeUTF8(sqlite3_errmsg(pDB->handle), strBuffer);
if(pStmt)
sqlite3_finalize(pStmt);
sqlite3_close(pDB);
spmemvfs_close_db(pDB);
spmemvfs_env_fini();
return false;
}
bool DataManager::GetData(int code, CardData* pData) {
......
gframe/data_manager.h
View file @ 24e5ca92
......@@ -3,6 +3,7 @@
#include "config.h"
#include "sqlite3.h"
#include "spmemvfs.h"
#include "client_card.h"
#include <unordered_map>
......@@ -13,7 +14,7 @@ public:
DataManager(): _datas(8192), _strings(8192) {}
bool LoadDB(const char* file);
bool LoadStrings(const char* file);
bool Error(sqlite3* pDB, sqlite3_stmt* pStmt = 0);
bool Error(spmemvfs_db_t* pDB, sqlite3_stmt* pStmt = 0);
bool GetData(int code, CardData* pData);
code_pointer GetCodePointer(int code);
bool GetString(int code, CardString* pStr);
......@@ -54,7 +55,7 @@ public:
static int CardReader(int, void*);
static byte* ScriptReaderEx(const char* script_name, int* slen);
static byte* ScriptReader(const char* script_name, int* slen);
IFileSystem* FileSystem;
};
extern DataManager dataManager;
......
gframe/game.cpp
View file @ 24e5ca92
......@@ -56,6 +56,7 @@ bool Game::Initialize() {
ErrorLog("Failed to load textures!");
return false;
}
dataManager.FileSystem = device->getFileSystem();
LoadExpansionDB();
if(!dataManager.LoadDB("cards.cdb")) {
ErrorLog("Failed to load card database (cards.cdb)!");
......
gframe/spmemvfs.c 0 → 100644
View file @ 24e5ca92
/*
* BSD 2-Clause License
*
* Copyright 2009 Stephen Liu
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include "spmemvfs.h"
#include "sqlite3.h"
/* Useful macros used in several places */
#define SPMEMVFS_MIN(x,y) ((x)<(y)?(x):(y))
#define SPMEMVFS_MAX(x,y) ((x)>(y)?(x):(y))
static void spmemvfsDebug(const char *format, ...){
#if defined(SPMEMVFS_DEBUG)
char logTemp[ 1024 ] = { 0 };
va_list vaList;
va_start( vaList, format );
vsnprintf( logTemp, sizeof( logTemp ), format, vaList );
va_end ( vaList );
if( strchr( logTemp, '\n' ) ) {
printf( "%s", logTemp );
} else {
printf( "%s\n", logTemp );
}
#endif
}
//===========================================================================
typedef struct spmemfile_t {
sqlite3_file base;
char * path;
int flags;
spmembuffer_t * mem;
} spmemfile_t;
static int spmemfileClose( sqlite3_file * file );
static int spmemfileRead( sqlite3_file * file, void * buffer, int len, sqlite3_int64 offset );
static int spmemfileWrite( sqlite3_file * file, const void * buffer, int len, sqlite3_int64 offset );
static int spmemfileTruncate( sqlite3_file * file, sqlite3_int64 size );
static int spmemfileSync( sqlite3_file * file, int flags );
static int spmemfileFileSize( sqlite3_file * file, sqlite3_int64 * size );
static int spmemfileLock( sqlite3_file * file, int type );
static int spmemfileUnlock( sqlite3_file * file, int type );
static int spmemfileCheckReservedLock( sqlite3_file * file, int * result );
static int spmemfileFileControl( sqlite3_file * file, int op, void * arg );
static int spmemfileSectorSize( sqlite3_file * file );
static int spmemfileDeviceCharacteristics( sqlite3_file * file );
static sqlite3_io_methods g_spmemfile_io_memthods = {
1, /* iVersion */
spmemfileClose, /* xClose */
spmemfileRead, /* xRead */
spmemfileWrite, /* xWrite */
spmemfileTruncate, /* xTruncate */
spmemfileSync, /* xSync */
spmemfileFileSize, /* xFileSize */
spmemfileLock, /* xLock */
spmemfileUnlock, /* xUnlock */
spmemfileCheckReservedLock, /* xCheckReservedLock */
spmemfileFileControl, /* xFileControl */
spmemfileSectorSize, /* xSectorSize */
spmemfileDeviceCharacteristics /* xDeviceCharacteristics */
};
int spmemfileClose( sqlite3_file * file )
{
spmemfile_t * memfile = (spmemfile_t*)file;
spmemvfsDebug( "call %s( %p )", __func__, memfile );
if( SQLITE_OPEN_MAIN_DB & memfile->flags ) {
// noop
} else {
if( NULL != memfile->mem ) {
if( memfile->mem->data ) free( memfile->mem->data );
free( memfile->mem );
}
}
free( memfile->path );
return SQLITE_OK;
}
int spmemfileRead( sqlite3_file * file, void * buffer, int len, sqlite3_int64 offset )
{
spmemfile_t * memfile = (spmemfile_t*)file;
spmemvfsDebug( "call %s( %p, ..., %d, %lld ), len %d",
__func__, memfile, len, offset, memfile->mem->used );
if( ( offset + len ) > memfile->mem->used ) {
return SQLITE_IOERR_SHORT_READ;
}
memcpy( buffer, memfile->mem->data + offset, len );
return SQLITE_OK;
}
int spmemfileWrite( sqlite3_file * file, const void * buffer, int len, sqlite3_int64 offset )
{
spmemfile_t * memfile = (spmemfile_t*)file;
spmembuffer_t * mem = memfile->mem;
spmemvfsDebug( "call %s( %p, ..., %d, %lld ), len %d",
__func__, memfile, len, offset, mem->used );
if( ( offset + len ) > mem->total ) {
int newTotal = 2 * ( offset + len + mem->total );
char * newBuffer = (char*)realloc( mem->data, newTotal );
if( NULL == newBuffer ) {
return SQLITE_NOMEM;
}
mem->total = newTotal;
mem->data = newBuffer;
}
memcpy( mem->data + offset, buffer, len );
mem->used = SPMEMVFS_MAX( mem->used, offset + len );
return SQLITE_OK;
}
int spmemfileTruncate( sqlite3_file * file, sqlite3_int64 size )
{
spmemfile_t * memfile = (spmemfile_t*)file;
spmemvfsDebug( "call %s( %p )", __func__, memfile );
memfile->mem->used = SPMEMVFS_MIN( memfile->mem->used, size );
return SQLITE_OK;
}
int spmemfileSync( sqlite3_file * file, int flags )
{
spmemvfsDebug( "call %s( %p )", __func__, file );
return SQLITE_OK;
}
int spmemfileFileSize( sqlite3_file * file, sqlite3_int64 * size )
{
spmemfile_t * memfile = (spmemfile_t*)file;
spmemvfsDebug( "call %s( %p )", __func__, memfile );
* size = memfile->mem->used;
return SQLITE_OK;
}
int spmemfileLock( sqlite3_file * file, int type )
{
spmemvfsDebug( "call %s( %p )", __func__, file );
return SQLITE_OK;
}
int spmemfileUnlock( sqlite3_file * file, int type )
{
spmemvfsDebug( "call %s( %p )", __func__, file );
return SQLITE_OK;
}
int spmemfileCheckReservedLock( sqlite3_file * file, int * result )
{
spmemvfsDebug( "call %s( %p )", __func__, file );
*result = 0;
return SQLITE_OK;
}
int spmemfileFileControl( sqlite3_file * file, int op, void * arg )
{
spmemvfsDebug( "call %s( %p )", __func__, file );
return SQLITE_OK;
}
int spmemfileSectorSize( sqlite3_file * file )
{
spmemvfsDebug( "call %s( %p )", __func__, file );
return 0;
}
int spmemfileDeviceCharacteristics( sqlite3_file * file )
{
spmemvfsDebug( "call %s( %p )", __func__, file );
return 0;
}
//===========================================================================
typedef struct spmemvfs_cb_t {
void * arg;
spmembuffer_t * ( * load ) ( void * args, const char * path );
} spmemvfs_cb_t;
typedef struct spmemvfs_t {
sqlite3_vfs base;
spmemvfs_cb_t cb;
sqlite3_vfs * parent;
} spmemvfs_t;
static int spmemvfsOpen( sqlite3_vfs * vfs, const char * path, sqlite3_file * file, int flags, int * outflags );
static int spmemvfsDelete( sqlite3_vfs * vfs, const char * path, int syncDir );
static int spmemvfsAccess( sqlite3_vfs * vfs, const char * path, int flags, int * result );
static int spmemvfsFullPathname( sqlite3_vfs * vfs, const char * path, int len, char * fullpath );
static void * spmemvfsDlOpen( sqlite3_vfs * vfs, const char * path );
static void spmemvfsDlError( sqlite3_vfs * vfs, int len, char * errmsg );
static void ( * spmemvfsDlSym ( sqlite3_vfs * vfs, void * handle, const char * symbol ) ) ( void );
static void spmemvfsDlClose( sqlite3_vfs * vfs, void * handle );
static int spmemvfsRandomness( sqlite3_vfs * vfs, int len, char * buffer );
static int spmemvfsSleep( sqlite3_vfs * vfs, int microseconds );
static int spmemvfsCurrentTime( sqlite3_vfs * vfs, double * result );
static spmemvfs_t g_spmemvfs = {
{
1, /* iVersion */
0, /* szOsFile */
0, /* mxPathname */
0, /* pNext */
SPMEMVFS_NAME, /* zName */
0, /* pAppData */
spmemvfsOpen, /* xOpen */
spmemvfsDelete, /* xDelete */
spmemvfsAccess, /* xAccess */
spmemvfsFullPathname, /* xFullPathname */
spmemvfsDlOpen, /* xDlOpen */
spmemvfsDlError, /* xDlError */
spmemvfsDlSym, /* xDlSym */
spmemvfsDlClose, /* xDlClose */
spmemvfsRandomness, /* xRandomness */
spmemvfsSleep, /* xSleep */
spmemvfsCurrentTime /* xCurrentTime */
},
{ 0 },
0 /* pParent */
};
int spmemvfsOpen( sqlite3_vfs * vfs, const char * path, sqlite3_file * file, int flags, int * outflags )
{
spmemvfs_t * memvfs = (spmemvfs_t*)vfs;
spmemfile_t * memfile = (spmemfile_t*)file;
spmemvfsDebug( "call %s( %p(%p), %s, %p, %x, %p )\n",
__func__, vfs, &g_spmemvfs, path, file, flags, outflags );
memset( memfile, 0, sizeof( spmemfile_t ) );
memfile->base.pMethods = &g_spmemfile_io_memthods;
memfile->flags = flags;
memfile->path = strdup( path );
if( SQLITE_OPEN_MAIN_DB & memfile->flags ) {
memfile->mem = memvfs->cb.load( memvfs->cb.arg, path );
} else {
memfile->mem = (spmembuffer_t*)calloc( sizeof( spmembuffer_t ), 1 );
}
return memfile->mem ? SQLITE_OK : SQLITE_ERROR;
}
int spmemvfsDelete( sqlite3_vfs * vfs, const char * path, int syncDir )
{
spmemvfsDebug( "call %s( %p(%p), %s, %d )\n",
__func__, vfs, &g_spmemvfs, path, syncDir );
return SQLITE_OK;
}
int spmemvfsAccess( sqlite3_vfs * vfs, const char * path, int flags, int * result )
{
* result = 0;
return SQLITE_OK;
}
int spmemvfsFullPathname( sqlite3_vfs * vfs, const char * path, int len, char * fullpath )
{
strncpy( fullpath, path, len );
fullpath[ len - 1 ] = '\0';
return SQLITE_OK;
}
void * spmemvfsDlOpen( sqlite3_vfs * vfs, const char * path )
{
return NULL;
}
void spmemvfsDlError( sqlite3_vfs * vfs, int len, char * errmsg )
{
// noop
}
void ( * spmemvfsDlSym ( sqlite3_vfs * vfs, void * handle, const char * symbol ) ) ( void )
{
return NULL;
}
void spmemvfsDlClose( sqlite3_vfs * vfs, void * handle )
{
// noop
}
int spmemvfsRandomness( sqlite3_vfs * vfs, int len, char * buffer )
{
return SQLITE_OK;
}
int spmemvfsSleep( sqlite3_vfs * vfs, int microseconds )
{
return SQLITE_OK;
}
int spmemvfsCurrentTime( sqlite3_vfs * vfs, double * result )
{
return SQLITE_OK;
}
//===========================================================================
int spmemvfs_init( spmemvfs_cb_t * cb )
{
sqlite3_vfs * parent = NULL;
if( g_spmemvfs.parent ) return SQLITE_OK;
parent = sqlite3_vfs_find( 0 );
g_spmemvfs.parent = parent;
g_spmemvfs.base.mxPathname = parent->mxPathname;
g_spmemvfs.base.szOsFile = sizeof( spmemfile_t );
g_spmemvfs.cb = * cb;
return sqlite3_vfs_register( (sqlite3_vfs*)&g_spmemvfs, 0 );
}
//===========================================================================
typedef struct spmembuffer_link_t {
char * path;
spmembuffer_t * mem;
struct spmembuffer_link_t * next;
} spmembuffer_link_t;
spmembuffer_link_t * spmembuffer_link_remove( spmembuffer_link_t ** head, const char * path )
{
spmembuffer_link_t * ret = NULL;
spmembuffer_link_t ** iter = head;
for( ; NULL != *iter; ) {
spmembuffer_link_t * curr = *iter;
if( 0 == strcmp( path, curr->path ) ) {
ret = curr;
*iter = curr->next;
break;
} else {
iter = &( curr->next );
}
}
return ret;
}
void spmembuffer_link_free( spmembuffer_link_t * iter )
{
free( iter->path );
free( iter->mem->data );
free( iter->mem );
free( iter );
}
//===========================================================================
typedef struct spmemvfs_env_t {
spmembuffer_link_t * head;
sqlite3_mutex * mutex;
} spmemvfs_env_t;
static spmemvfs_env_t * g_spmemvfs_env = NULL;
static spmembuffer_t * load_cb( void * arg, const char * path )
{
spmembuffer_t * ret = NULL;
spmemvfs_env_t * env = (spmemvfs_env_t*)arg;
sqlite3_mutex_enter( env->mutex );
{
spmembuffer_link_t * toFind = spmembuffer_link_remove( &( env->head ), path );
if( NULL != toFind ) {
ret = toFind->mem;
free( toFind->path );
free( toFind );
}
}
sqlite3_mutex_leave( env->mutex );
return ret;
}
int spmemvfs_env_init()
{
int ret = 0;
if( NULL == g_spmemvfs_env ) {
spmemvfs_cb_t cb;
g_spmemvfs_env = (spmemvfs_env_t*)calloc( sizeof( spmemvfs_env_t ), 1 );
g_spmemvfs_env->mutex = sqlite3_mutex_alloc( SQLITE_MUTEX_FAST );
cb.arg = g_spmemvfs_env;
cb.load = load_cb;
ret = spmemvfs_init( &cb );
}
return ret;
}
void spmemvfs_env_fini()
{
if( NULL != g_spmemvfs_env ) {
spmembuffer_link_t * iter = NULL;
sqlite3_vfs_unregister( (sqlite3_vfs*)&g_spmemvfs );
g_spmemvfs.parent = NULL;
sqlite3_mutex_free( g_spmemvfs_env->mutex );
iter = g_spmemvfs_env->head;
for( ; NULL != iter; ) {
spmembuffer_link_t * next = iter->next;
spmembuffer_link_free( iter );
iter = next;
}
free( g_spmemvfs_env );
g_spmemvfs_env = NULL;
}
}
int spmemvfs_open_db( spmemvfs_db_t * db, const char * path, spmembuffer_t * mem )
{
int ret = 0;
spmembuffer_link_t * iter = NULL;
memset( db, 0, sizeof( spmemvfs_db_t ) );
iter = (spmembuffer_link_t*)calloc( sizeof( spmembuffer_link_t ), 1 );
iter->path = strdup( path );
iter->mem = mem;
sqlite3_mutex_enter( g_spmemvfs_env->mutex );
{
iter->next = g_spmemvfs_env->head;
g_spmemvfs_env->head = iter;
}
sqlite3_mutex_leave( g_spmemvfs_env->mutex );
ret = sqlite3_open_v2( path, &(db->handle),
SQLITE_OPEN_READONLY, SPMEMVFS_NAME);
//SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, SPMEMVFS_NAME );
if( 0 == ret ) {
db->mem = mem;
} else {
sqlite3_mutex_enter( g_spmemvfs_env->mutex );
{
iter = spmembuffer_link_remove( &(g_spmemvfs_env->head), path );
if( NULL != iter ) spmembuffer_link_free( iter );
}
sqlite3_mutex_leave( g_spmemvfs_env->mutex );
}
return ret;
}
int spmemvfs_close_db( spmemvfs_db_t * db )
{
int ret = 0;
if( NULL == db ) return 0;
if( NULL != db->handle ) {
ret = sqlite3_close( db->handle );
db->handle = NULL;
}
if( NULL != db->mem ) {
if( NULL != db->mem->data ) free( db->mem->data );
free( db->mem );
db->mem = NULL;
}
return ret;
}
gframe/spmemvfs.h 0 → 100644
View file @ 24e5ca92
/*
* BSD 2-Clause License
*
* Copyright 2009 Stephen Liu
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef __spmemvfs_h__
#define __spmemvfs_h__
#ifdef __cplusplus
extern "C" {
#endif
#include "sqlite3.h"
#define SPMEMVFS_NAME "spmemvfs"
typedef struct spmembuffer_t {
char * data;
int used;
int total;
} spmembuffer_t;
typedef struct spmemvfs_db_t {
sqlite3 * handle;
spmembuffer_t * mem;
} spmemvfs_db_t;
int spmemvfs_env_init();
void spmemvfs_env_fini();
int spmemvfs_open_db( spmemvfs_db_t * db, const char * path, spmembuffer_t * mem );
int spmemvfs_close_db( spmemvfs_db_t * db );
#ifdef __cplusplus
}
#endif
#endif
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment