static NEOERR *wdb_alloc (WDB **wdb, int flags)
{
WDB *my_wdb;
NEOERR *err = STATUS_OK;
my_wdb = (WDB *) calloc (1, sizeof (WDB));
if (my_wdb == NULL)
return nerr_raise (NERR_NOMEM, "Unable to allocate memory for WDB");
do
{
err = dictCreate (&(my_wdb->attrs), 0, 2, 5, 0, 0, free_cb, NULL);
if (err != STATUS_OK) break;
err = dictCreate (&(my_wdb->cols), 0, 2, 5, 0, 0, free_col_cb, NULL);
if (err != STATUS_OK) break;
err = uListInit (&(my_wdb->cols_l), 0, 0);
if (err != STATUS_OK) break;
err = skipNewList(&(my_wdb->ondisk), 0, 4, 2, 0, NULL, NULL);
if (err != STATUS_OK) break;
*wdb = my_wdb;
return STATUS_OK;
} while (0);
wdb_destroy(&my_wdb);
return nerr_pass (err);
}
/* Ok, this version avoids the bubble sort by walking the level once to
* load them all into a ULIST, qsort'ing the list, and then dumping them
* back out... */
NEOERR *hdf_sort_obj (HDF *h, int (*compareFunc)(const void *, const void *))
{
NEOERR *err = STATUS_OK;
ULIST *level = NULL;
HDF *p, *c;
int x;
if (h == NULL) return STATUS_OK;
c = h->child;
if (c == NULL) return STATUS_OK;
do {
err = uListInit(&level, 40, 0);
if (err) return nerr_pass(err);
for (p = c; p; p = p->next) {
err = uListAppend(level, p);
if (err) break;
}
err = uListSort(level, compareFunc);
if (err) break;
uListGet(level, 0, (void *)&c);
h->child = c;
for (x = 1; x < uListLength(level); x++)
{
uListGet(level, x, (void *)&p);
c->next = p;
p->next = NULL;
c = p;
}
h->last_child = c;
} while (0);
uListDestroy(&level, 0);
return nerr_pass(err);
}
/*
* get fileset's info
* inp: urls, url list you want to get
* out: files, file list with file_t elements. don't forget free
*/
int file_get_infos_by_list(mdb_conn *conn, ULIST *urls, ULIST **files, int *noksn)
{
int listlen;
char *url;
file_t *file;
NEOERR *err;
int ret;
listlen = uListLength(urls);
if (listlen <= 0 || urls == NULL || files == NULL) {
return RET_RBTOP_INPUTE;
}
err = uListInit(files, 0, 0);
RETURN_V_NOK(err, RET_RBTOP_MEMALLOCE);
int pid = 1;
int i;
for (i = 0; i < listlen; i++) {
err = uListGet(urls, i, (void**)&url);
RETURN_V_NOK(err, RET_RBTOP_GETLISTE);
ret = file_get_info_by_id(conn, 0, url, pid, &file);
if (ret != RET_RBTOP_OK) {
mtc_warn("can't get file info for %s", url);
*noksn = i;
return RET_RBTOP_GETLISTE;
} else {
pid = file->id;
uListAppend(*files, file);
}
}
*noksn = -1;
return RET_RBTOP_OK;
}
NEOERR *nerr_init (void)
{
NEOERR *err;
if (Inited == 0)
{
#ifdef HAVE_PTHREADS
/* In threaded environments, we have to mutex lock to do this init, but
* we don't want to use a mutex every time to check that it was Inited.
* So, we only lock if our first test of Inited was false */
err = mLock(&InitLock);
if (err != STATUS_OK) return nerr_pass(err);
if (Inited == 0) {
#endif
err = uListInit (&Errors, 10, 0);
if (err != STATUS_OK) return nerr_pass(err);
err = nerr_register (&NERR_PASS, "InternalPass");
if (err != STATUS_OK) return nerr_pass(err);
err = nerr_register (&NERR_ASSERT, "AssertError");
if (err != STATUS_OK) return nerr_pass(err);
err = nerr_register (&NERR_NOT_FOUND, "NotFoundError");
if (err != STATUS_OK) return nerr_pass(err);
err = nerr_register (&NERR_DUPLICATE, "DuplicateError");
if (err != STATUS_OK) return nerr_pass(err);
err = nerr_register (&NERR_NOMEM, "MemoryError");
if (err != STATUS_OK) return nerr_pass(err);
err = nerr_register (&NERR_PARSE, "ParseError");
if (err != STATUS_OK) return nerr_pass(err);
err = nerr_register (&NERR_OUTOFRANGE, "RangeError");
if (err != STATUS_OK) return nerr_pass(err);
err = nerr_register (&NERR_SYSTEM, "SystemError");
if (err != STATUS_OK) return nerr_pass(err);
err = nerr_register (&NERR_IO, "IOError");
if (err != STATUS_OK) return nerr_pass(err);
err = nerr_register (&NERR_LOCK, "LockError");
if (err != STATUS_OK) return nerr_pass(err);
err = nerr_register (&NERR_DB, "DBError");
if (err != STATUS_OK) return nerr_pass(err);
err = nerr_register (&NERR_EXISTS, "ExistsError");
if (err != STATUS_OK) return nerr_pass(err);
err = nerr_register (&NERR_MAX_RECURSION, "MaxRecursionError");
if (err != STATUS_OK) return nerr_pass(err);
Inited = 1;
#ifdef HAVE_PTHREADS
}
err = mUnlock(&InitLock);
if (err != STATUS_OK) return nerr_pass(err);
#endif
}
return STATUS_OK;
}
NEOERR * rcfs_listdir (const char *path, ULIST **list)
{
NEOERR *err;
DIR *dp;
ULIST *files;
struct dirent *de;
int l;
char *f;
*list = NULL;
err = uListInit (&files, 10, 0);
if (err) return nerr_pass (err);
dp = opendir(path);
if (dp == NULL)
{
uListDestroy(&files, ULIST_FREE);
if (errno == ENOENT)
return nerr_raise (NERR_NOT_FOUND, "Directory %s doesn't exist", path);
return nerr_raise_errno (NERR_IO, "Unable to open directory %s", path);
}
while ((de = readdir (dp)) != NULL)
{
l = strlen (de->d_name);
if (l>4 && !strcmp (de->d_name+l-4, ",log"))
{
f = (char *) malloc ((l-3) * sizeof(char));
if (f == NULL)
{
uListDestroy (&files, ULIST_FREE);
closedir(dp);
return nerr_raise (NERR_NOMEM,
"Unable to allocate memory for filename %s", de->d_name);
}
strncpy (f, de->d_name, l-4);
f[l-4] = '\0';
err = uListAppend (files, f);
if (err)
{
free (f);
uListDestroy (&files, ULIST_FREE);
closedir(dp);
return nerr_pass (err);
}
}
}
*list = files;
closedir(dp);
return STATUS_OK;
}
NEOERR *wdb_keys (WDB *wdb, char **primary_key, ULIST **data)
{
NEOERR *err;
int x, len;
WDBColumn *col;
ULIST *my_data;
char *my_key = NULL;
char *my_col = NULL;
*data = NULL;
*primary_key = NULL;
my_key = strdup(wdb->key);
if (my_key == NULL)
return nerr_raise (NERR_NOMEM, "Unable to allocate memory for keys");
len = uListLength(wdb->cols_l);
err = uListInit (&my_data, len, 0);
if (err != STATUS_OK)
{
free(my_key);
return nerr_pass(err);
}
for (x = 0; x < len; x++)
{
err = uListGet (wdb->cols_l, x, (void *)&col);
if (err) goto key_err;
my_col = strdup(col->name);
if (my_col == NULL)
{
err = nerr_raise (NERR_NOMEM, "Unable to allocate memory for keys");
goto key_err;
}
err = uListAppend (my_data, my_col);
my_col = NULL;
if (err) goto key_err;
}
*data = my_data;
*primary_key = my_key;
return STATUS_OK;
key_err:
if (my_key != NULL) free (my_key);
if (my_col != NULL) free (my_col);
*primary_key = NULL;
uListDestroy (&my_data, 0);
return nerr_pass(err);
}
NEOERR *ne_listdir_fmatch(const char *path, ULIST **files, MATCH_FUNC fmatch,
void *rock)
{
DIR *dp;
struct dirent *de;
ULIST *myfiles = NULL;
NEOERR *err = STATUS_OK;
if (files == NULL)
return nerr_raise(NERR_ASSERT, "Invalid call to ne_listdir_fmatch");
if (*files == NULL)
{
err = uListInit(&myfiles, 10, 0);
if (err) return nerr_pass(err);
}
else
{
myfiles = *files;
}
if ((dp = opendir (path)) == NULL)
{
return nerr_raise_errno(NERR_IO, "Unable to opendir %s", path);
}
while ((de = readdir (dp)) != NULL)
{
if (!strcmp(de->d_name, ".") || !strcmp(de->d_name, ".."))
continue;
if (fmatch != NULL && !fmatch(rock, de->d_name))
continue;
err = uListAppend(myfiles, strdup(de->d_name));
if (err) break;
}
closedir(dp);
if (err && *files == NULL)
{
uListDestroy(&myfiles, ULIST_FREE);
}
else if (*files == NULL)
{
*files = myfiles;
}
return nerr_pass(err);
}
NEOERR* masset_init()
{
NEOERR *err;
if (!g_datah) {
err = hash_init(&g_datah, hash_str_hash, hash_str_comp, NULL);
if (err != STATUS_OK) return nerr_pass(err);
}
HASH *mh = hash_lookup(g_datah, ASSET_KEY);
if (!mh) {
err = hash_init(&mh, hash_str_hash, hash_str_comp, hash_asset_free);
if (err != STATUS_OK) return nerr_pass(err);
hash_insert(g_datah, ASSET_KEY, (void*)mh);
}
if (asset_drivers) return STATUS_OK;
err = uListInit(&asset_drivers, 10, 0);
if (err != STATUS_OK) return nerr_pass(err);
uListAppend(asset_drivers, masset_driver_new("obj", mast_vb_obj_load, mast_vb_unload));
uListAppend(asset_drivers, masset_driver_new("mat", mast_mat_load, mast_mat_unload));
uListAppend(asset_drivers, masset_driver_new("vs", mast_vs_load, mast_shader_unload));
uListAppend(asset_drivers, masset_driver_new("fs", mast_fs_load, mast_shader_unload));
uListAppend(asset_drivers, masset_driver_new("dds", mast_dds_load, mast_dds_unload));
uListAppend(asset_drivers, masset_driver_new("lut", mast_lut_load, mast_lut_unload));
uListAppend(asset_drivers, masset_driver_new("tga", mast_tex_sdl_load, mast_tex_sdl_unload));
uListAppend(asset_drivers, masset_driver_new("bmp", mast_tex_sdl_load, mast_tex_sdl_unload));
uListAppend(asset_drivers, masset_driver_new("gif", mast_tex_sdl_load, mast_tex_sdl_unload));
uListAppend(asset_drivers, masset_driver_new("jpg", mast_tex_sdl_load, mast_tex_sdl_unload));
uListAppend(asset_drivers, masset_driver_new("png", mast_tex_sdl_load, mast_tex_sdl_unload));
uListAppend(asset_drivers, masset_driver_new("tif", mast_tex_sdl_load, mast_tex_sdl_unload));
return STATUS_OK;
}
NEOERR *ne_listdir_fmatch(const char *path, ULIST **files, MATCH_FUNC fmatch,
void *rock)
{
NEOERR *err = STATUS_OK;
ULIST *myfiles = NULL;
if (files == NULL)
return nerr_raise(NERR_ASSERT, "Invalid call to ne_listdir_fmatch");
if (*files == NULL)
{
err = uListInit(&myfiles, 10, 0);
if (err) return nerr_pass(err);
}
else
{
myfiles = *files;
}
#ifdef _MSC_VER
HANDLE hFind = INVALID_HANDLE_VALUE;
WIN32_FIND_DATA ffd;
CHAR rootDir[MAX_PATH];
StringCchCopy(rootDir, MAX_PATH, path);
StringCchCat(rootDir, MAX_PATH, TEXT("\\*"));
hFind = FindFirstFile(rootDir, &ffd);
if (hFind == INVALID_HANDLE_VALUE)
return nerr_raise_errno(NERR_IO, "Unable to opendir %s", path);
do {
if (!strcmp(ffd.cFileName, ".") || !strcmp(ffd.cFileName, ".."))
continue;
if (fmatch != NULL && !fmatch(rock, ffd.cFileName))
continue;
err = uListAppend(myfiles, strdup(ffd.cFileName));
if (err) break;
} while (FindNextFile(hFind, &ffd) != 0);
FindClose(hFind);
#else
DIR *dp;
struct dirent *de;
if ((dp = opendir (path)) == NULL)
{
return nerr_raise_errno(NERR_IO, "Unable to opendir %s", path);
}
while ((de = readdir (dp)) != NULL)
{
if (!strcmp(de->d_name, ".") || !strcmp(de->d_name, ".."))
continue;
if (fmatch != NULL && !fmatch(rock, de->d_name))
continue;
err = uListAppend(myfiles, strdup(de->d_name));
if (err) break;
}
closedir(dp);
#endif
if (err && *files == NULL)
{
uListDestroy(&myfiles, ULIST_FREE);
}
else if (*files == NULL)
{
*files = myfiles;
}
return nerr_pass(err);
}
