/* 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_register (int *val, const char *name)
{
NEOERR *err;
err = uListAppend (Errors, (void *) name);
if (err != STATUS_OK) return nerr_pass(err);
*val = uListLength(Errors);
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 *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);
}
NEOERR *wdb_column_insert (WDB *wdb, int loc, const char *key, char type)
{
NEOERR *err;
WDBColumn *col, *ocol;
int x, len;
col = (WDBColumn *) dictSearch (wdb->cols, key, NULL);
if (col != NULL)
return nerr_raise (NERR_DUPLICATE,
"Duplicate key %s:%d", key, col->inmem_index);
col = (WDBColumn *) calloc (1, sizeof (WDBColumn));
if (col == NULL)
{
return nerr_raise (NERR_NOMEM,
"Unable to allocate memory for creation of col %s:%d", key, loc);
}
col->name = strdup(key);
if (col->name == NULL)
{
free(col);
return nerr_raise (NERR_NOMEM,
"Unable to allocate memory for creation of col %s:%d", key, loc);
}
col->type = type;
col->ondisk_index = wdb->last_ondisk++;
/* -1 == append */
if (loc == -1)
{
err = dictSetValue(wdb->cols, key, col);
if (err)
{
free (col->name);
free (col);
return nerr_pass_ctx (err,
"Unable to insert for creation of col %s:%d", key, loc);
}
err = uListAppend (wdb->cols_l, (void *)col);
if (err) return nerr_pass(err);
x = uListLength (wdb->cols_l);
col->inmem_index = x;
err = skipInsert (wdb->ondisk, col->ondisk_index,
(void *)(col->inmem_index), 0);
if (err)
return nerr_pass_ctx (err, "Unable to update ondisk mapping for %s", key);
}
else
{
/* We are inserting this in middle, so the skipList ondisk is now
* invalid, as is the inmem_index for all cols */
err = dictSetValue(wdb->cols, key, col);
if (err)
{
free (col->name);
free (col);
return nerr_pass_ctx (err,
"Unable to insert for creation of col %s:%d", key, loc);
}
err = uListInsert (wdb->cols_l, loc, (void *)col);
if (err) return nerr_pass(err);
len = uListLength (wdb->cols_l);
/* Fix up inmem_index and ondisk skipList */
for (x = 0; x < len; x++)
{
err = uListGet (wdb->cols_l, x, (void *)&ocol);
if (err) return nerr_pass(err);
ocol->inmem_index = x + 1;
err = skipInsert (wdb->ondisk, ocol->ondisk_index,
(void *)(ocol->inmem_index), TRUE);
if (err)
return nerr_pass_ctx (err, "Unable to update ondisk mapping for %s", key);
}
}
wdb->defn_dirty = 1;
wdb->table_version = rand();
return STATUS_OK;
}
static NEOERR *wdb_load_defn_v1 (WDB *wdb, FILE *fp)
{
char line[1024];
int state = 1;
char *k, *v;
NEOERR *err = STATUS_OK;
int colindex = 1;
WDBColumn *col;
while (fgets(line, sizeof(line), fp) != NULL)
{
string_rstrip(line);
switch (state)
{
case STATE_REQUIRED:
if (!strcmp(line, "attributes"))
state = STATE_ATTRIBUTES;
else if (!strcmp(line, "columns"))
state = STATE_COLUMN_DEF;
else
{
k = line;
v = strchr(line, ':');
/* HACK */
if (!strcmp(k, "name") && ((v == NULL) || (v[1] == '\0')))
{
v = "dNone";
}
else
{
if (v == NULL)
return nerr_raise (NERR_PARSE, "Error parsing %s", line);
if (v[1] == '\0')
return nerr_raise (NERR_PARSE, "Error parsing %s", line);
}
v[0] = '\0';
v++;
if (!strcmp(k, "key"))
{
err = wdb_decode_str_alloc (v, &(wdb->key));
if (err) return nerr_pass(err);
}
else if (!strcmp(k, "name"))
{
err = wdb_decode_str_alloc (v, &(wdb->name));
if (err) return nerr_pass(err);
}
else if (!strcmp(k, "ondisk"))
{
wdb->last_ondisk = atoi (v);
}
}
break;
case STATE_ATTRIBUTES:
if (!strcmp(line, "columns"))
state = STATE_COLUMN_DEF;
else
{
k = line;
v = strchr(line, ':');
if (v == NULL)
return nerr_raise (NERR_PARSE, "Error parsing %s", line);
v[0] = '\0';
v++;
err = wdb_decode_str_alloc (k, &k);
if (err) return nerr_pass(err);
err = wdb_decode_str_alloc (v, &v);
if (err) return nerr_pass(err);
err = dictSetValue(wdb->attrs, k, v);
free(k);
if (err)
return nerr_pass_ctx(err, "Error parsing %s", line);
}
break;
case STATE_COLUMN_DEF:
k = line;
v = strchr(line, ':');
if (v == NULL)
return nerr_raise (NERR_PARSE, "Error parsing %s", line);
if (v[1] == '\0')
return nerr_raise (NERR_PARSE, "Error parsing %s", line);
v[0] = '\0';
v++;
err = wdb_decode_str_alloc (k, &k);
if (err) return nerr_pass(err);
col = (WDBColumn *) calloc (1, sizeof (WDBColumn));
col->name = k;
col->inmem_index = colindex++;
col->type = *v;
v+=2;
col->ondisk_index = atoi(v);
err = dictSetValue(wdb->cols, k, col);
if (err)
return nerr_raise (NERR_PARSE, "Error parsing %s", line);
err = uListAppend(wdb->cols_l, col);
if (err) return nerr_pass(err);
/* stupid skiplist will assert */
if (col->ondisk_index == 0)
{
return nerr_raise (NERR_ASSERT, "Invalid ondisk mapping for %s", k);
}
err = skipInsert (wdb->ondisk, col->ondisk_index,
(void *)(col->inmem_index), 0);
if (err)
return nerr_pass_ctx(err, "Unable to update ondisk mapping for %s", k);
break;
default:
return nerr_raise (NERR_ASSERT, "Invalid state %d", state);
}
}
return STATUS_OK;
}
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;
}