--- a/dmres.c	Thu Apr 18 00:01:50 2013 +0300
+++ b/dmres.c	Sun Apr 21 16:40:45 2013 +0300
@@ -2,7 +2,7 @@
  * dmlib
  * -- Resource management
  * Programmed and designed by Matti 'ccr' Hamalainen
- * (C) Copyright 2003-2012 Tecnic Software productions (TNSP)
+ * (C) Copyright 2003-2013 Tecnic Software productions (TNSP)
  */
 #include "dmres.h"
 #include <time.h>
@@ -15,7 +15,7 @@
 #endif
 
 
-DMResource *dmres_new(DMResourceLib *lib, const char *filename, int flags, size_t size)
+DMResource *dmResourceNew(DMResourceLib *lib, const char *filename, const size_t size)
 {
     DMResource *node = dmMalloc0(sizeof(DMResource));
     if (node == NULL)
@@ -23,57 +23,55 @@
     
     node->lib = lib;
     node->filename = dm_strdup(filename);
-    node->flags = flags;
-    node->dataSize = size;
+    node->rawSize = size;
     
     return node;
 }
 
 
-void dmres_free_res_data(DMResource *node)
+void dmResourceFreeResData(DMResource *node)
 {
-    if (node->rdata != NULL &&
+    if (node->resData != NULL &&
         node->rops != NULL &&
         node->rops->free != NULL)
     {
         node->rops->free(node);
     }
 
-    node->rdata = NULL;
+    node->resData = NULL;
     node->flags &= !DMF_LOADED_RES;
 }
 
 
-void dmres_free_raw_data(DMResource *node)
+void dmResourceFreeRawData(DMResource *node)
 {
-    dmFree(node->data);
-    node->data = NULL;
+    dmFree(node->rawData);
+    node->rawData = NULL;
     node->flags &= !DMF_LOADED_RAW;
 }
 
 
-void dmres_purge_raw_data(DMResource *node)
+void dmResourcePurge_raw_data(DMResource *node)
 {
-    if ((node->flags & DMF_PRELOAD_RAW) == 0 &&
-        (node->flags & DMF_LOADED_RAW) &&
-        node->data != NULL)
-        dmres_free_raw_data(node);
+    if ((node->flags & DMF_LOADED_RAW) &&
+        node->rawData != NULL)
+        dmResourceFreeRawData(node);
 }
 
 
-void dmres_free(DMResource *node)
+void dmResourceFree(DMResource *node)
 {
     if (node != NULL)
     {
-        dmres_free_res_data(node);
-        dmres_free_raw_data(node);
+        dmResourceFreeResData(node);
+        dmResourceFreeRawData(node);
         dmFree(node->filename);
         dmFree(node);
     }
 }
 
 
-void dmres_insert(DMResourceLib *lib, DMResource * node)
+void dmResourceInsert(DMResourceLib *lib, DMResource * node)
 {
     if (lib == NULL || node == NULL)
         return;
@@ -95,7 +93,7 @@
 }
 
 
-void dmres_delete(DMResourceLib *lib, DMResource * node)
+void dmResourceDelete(DMResourceLib *lib, DMResource * node)
 {
     if (lib == NULL)
         return;
@@ -112,7 +110,7 @@
 }
 
 
-DMResource * dmres_find(DMResourceLib *lib, const char *filename)
+DMResource * dmResourceFind(DMResourceLib *lib, const char *filename)
 {
     DMResource *node, *found = NULL;
 
@@ -182,8 +180,8 @@
     off_t savePos, fileSize;
 
     // Check if the size is cached
-    if (f->dataSize != 0)
-        return f->dataSize;
+    if (f->rawSize != 0)
+        return f->rawSize;
 
     // Get file size
     savePos = ftello(f->fh);
@@ -200,7 +198,7 @@
         return -1;
     }
 
-    f->dataSize = fileSize;
+    f->rawSize = fileSize;
     return fileSize;
 }
 
@@ -257,11 +255,11 @@
     
     dm_stdio_fsize(handle);
     
-    handle->data = dmMalloc(handle->dataSize);
-    if (handle->data == NULL)
+    handle->rawData = dmMalloc(handle->rawSize);
+    if (handle->rawData == NULL)
         return DMERR_MALLOC;
     
-    if (dm_stdio_fread(handle->data, sizeof(Uint8), handle->dataSize, handle) != handle->dataSize)
+    if (dm_stdio_fread(handle->rawData, sizeof(Uint8), handle->rawSize, handle) != handle->rawSize)
         return DMERR_FREAD;
     
     return DMERR_OK;
@@ -326,7 +324,7 @@
         return DMERR_NULLPTR;
 
     // Search PACK nodelist for file
-    if ((node = dm_pack_find(handle->lib->packFile->entries, handle->filename)) == NULL)
+    if ((node = dmPackFind(handle->lib->packFile->entries, handle->filename)) == NULL)
     {
         dmError("Entry '%s' not found in PACK file.\n", handle->filename);
         res = DMERR_NOT_FOUND;
@@ -350,10 +348,10 @@
     }
 
     // Initialize fields
-    handle->dataOffset = 0;
-    handle->dataSize = node->size;
-    handle->data = (Uint8 *) dmMalloc(node->size);
-    if (handle->data == NULL)
+    handle->rawOffset = 0;
+    handle->rawSize = node->size;
+    handle->rawData = (Uint8 *) dmMalloc(node->size);
+    if (handle->rawData == NULL)
     {
         res = DMERR_MALLOC;
         goto error;
@@ -363,8 +361,8 @@
     cstream.zalloc = (alloc_func) Z_NULL;
     cstream.zfree = (free_func) Z_NULL;
     cstream.opaque = (voidpf) Z_NULL;
-    cstream.next_out = handle->data;
-    cstream.avail_out = handle->dataSize;
+    cstream.next_out = handle->rawData;
+    cstream.avail_out = handle->rawSize;
     cdataLeft = node->length;
     cres = inflateInit(&(cstream));
     if (cres != Z_OK)
@@ -399,10 +397,10 @@
 
 static void dm_pack_fclose(DMResource * f)
 {
-    f->dataSize = 0;
-    f->dataOffset = 0;
-    dmFree(f->data);
-    f->data = NULL;
+    f->rawSize = 0;
+    f->rawOffset = 0;
+    dmFree(f->rawData);
+    f->rawData = NULL;
 }
 #endif
 
@@ -425,11 +423,11 @@
             break;
 
         case SEEK_CUR:
-            newPos = f->dataOffset + offset;
+            newPos = f->rawOffset + offset;
             break;
 
         case SEEK_END:
-            newPos = f->dataSize + offset;
+            newPos = f->rawSize + offset;
             break;
 
         default:
@@ -437,10 +435,10 @@
     }
 
     // Set the new position
-    f->dataOffset = newPos;
+    f->rawOffset = newPos;
 
     // Check the new position
-    if (newPos < 0 && (size_t) newPos >= f->dataSize)
+    if (newPos < 0 && (size_t) newPos >= f->rawSize)
         return -1;
 
     return 0;
@@ -449,20 +447,20 @@
 
 static off_t dm_mem_fsize(DMResource * f)
 {
-    return f->dataSize;
+    return f->rawSize;
 }
 
 
 static off_t dm_mem_ftell(DMResource * f)
 {
-    return f->dataOffset;
+    return f->rawOffset;
 }
 
 
 static BOOL dm_mem_feof(DMResource * f)
 {
     // Check for EOF
-    if ((size_t) f->dataOffset <= f->dataSize)
+    if ((size_t) f->rawOffset <= f->rawSize)
         return FALSE;
     else
         return TRUE;
@@ -472,8 +470,8 @@
 static int dm_mem_fgetc(DMResource * f)
 {
     // Check for EOF
-    if ((size_t) f->dataOffset < f->dataSize)
-        return f->data[f->dataOffset++];
+    if ((size_t) f->rawOffset < f->rawSize)
+        return f->rawData[f->rawOffset++];
     else
         return EOF;
 }
@@ -484,14 +482,14 @@
     size_t length = (size * nmemb);
 
     // Check if we can read the whole chunk
-    if (((size_t) f->dataOffset + length) >= f->dataSize)
+    if (((size_t) f->rawOffset + length) >= f->rawSize)
     {
-        nmemb = (f->dataSize - f->dataOffset) / size;
+        nmemb = (f->rawSize - f->rawOffset) / size;
         length = size * nmemb;
     }
 
-    memcpy(buf, f->data + f->dataOffset, length);
-    f->dataOffset += length;
+    memcpy(buf, f->rawData + f->rawOffset, length);
+    f->rawOffset += length;
     return nmemb;
 }
 
@@ -499,9 +497,9 @@
 static int dm_mem_fputc(int ch, DMResource * f)
 {
     // Check for EOF
-    if ((size_t) f->dataOffset < f->dataSize)
+    if ((size_t) f->rawOffset < f->rawSize)
     {
-        f->data[f->dataOffset++] = ch;
+        f->rawData[f->rawOffset++] = ch;
         return ch;
     }
     else
@@ -514,16 +512,16 @@
     size_t length = (size * nmemb);
 
     // Check if we can write the whole chunk
-    if (((size_t) f->dataOffset + length) >= f->dataSize)
+    if (((size_t) f->rawOffset + length) >= f->rawSize)
     {
-        nmemb = (f->dataSize - f->dataOffset) / size;
+        nmemb = (f->rawSize - f->rawOffset) / size;
         length = size * nmemb;
     }
 
     if (length > 0)
     {
-        memcpy(f->data + f->dataOffset, buf, length);
-        f->dataOffset += length;
+        memcpy(f->rawData + f->rawOffset, buf, length);
+        f->rawOffset += length;
     }
     return nmemb;
 }
@@ -606,8 +604,7 @@
     int ret = DMERR_INIT_FAIL;
 
     // Check if we want to preload raw data?
-    if ((handle->flags & DMF_PRELOAD_RAW) ||
-        (handle->lib->flags & DRF_PRELOAD_ALL))
+    if (handle->lib->flags & DRF_PRELOAD_RAW)
     {
         if (handle->flags & DMF_LOADED_RAW)
             ret = DMERR_OK;
@@ -632,7 +629,7 @@
 
 
     // Check if resource data is to be preloaded
-    if ((handle->flags & DMF_PRELOAD_RES) || (handle->lib->flags & DRF_PRELOAD_RES))
+    if (handle->lib->flags & DRF_PRELOAD_RES)
     {
         if (handle->flags & DMF_LOADED_RES)
             ret = DMERR_OK;
@@ -648,7 +645,7 @@
 
                 // Check if we can purge the raw data now
                 if ((handle->flags & DMF_PERSIST) == 0)
-                    dmres_purge_raw_data(handle);
+                    dmResourcePurge_raw_data(handle);
             }
 
             dmf_reset(handle);
@@ -665,13 +662,13 @@
     DMResource *handle;
 
     // Check master directory for resource
-    if ((handle = dmres_find(lib, filename)) == NULL)
+    if ((handle = dmResourceFind(lib, filename)) == NULL)
     {
 #ifdef DM_USE_STDIO
         if (lib->flags & DRF_USE_STDIO)
         {
             // Hmm.. does not exist? Fall back to a stdio file
-            handle = dmres_new(lib, filename, 0, 0);
+            handle = dmResourceNew(lib, filename, 0);
             if (handle == NULL)
                 return NULL;
 
@@ -691,7 +688,7 @@
     // Check if the data is preloaded
     if (handle->flags & DMF_LOADED_RAW)
     {
-        dmres_ref(handle);
+        dmResourceRef(handle);
         return handle;
     }
 
@@ -700,7 +697,7 @@
     
     if (ret == DMERR_OK)
     {
-        dmres_ref(handle);
+        dmResourceRef(handle);
         return handle;
     }
 
@@ -708,25 +705,25 @@
 }
 
 
-DMResource * dmf_create_memio(DMResourceLib *lib, const char *filename, Uint8 *buf, size_t len)
+DMResource * dmf_create_memio(DMResourceLib *lib, const char *filename, Uint8 *buf, const size_t size)
 {
     DMResource *handle;
 
     // Check master directory for resource
-    if ((handle = dmres_find(lib, filename)) == NULL)
+    if ((handle = dmResourceFind(lib, filename)) == NULL)
     {
-        // Hmm.. does not exist? Fall back to a stdio file
-        handle = dmres_new(lib, filename, DMF_LOADED_RAW, len);
+        handle = dmResourceNew(lib, filename, size);
         if (handle == NULL)
             return NULL;
 
-        handle->fops = &dfMemIOFileOps;
-        handle->data = buf;
-        dmres_insert(lib, handle);
+        handle->flags   = DMF_LOADED_RAW;
+        handle->fops    = &dfMemIOFileOps;
+        handle->rawData = buf;
+        dmResourceInsert(lib, handle);
     }
 
     // Increase refcount
-    dmres_ref(handle);
+    dmResourceRef(handle);
 
     dmf_reset(handle);
     return handle;
@@ -736,23 +733,22 @@
 #ifdef DM_USE_STDIO
 DMResource * dmf_create_stdio(const char *filename, const char *mode)
 {
-    DMResource *handle = dmres_new(NULL, filename, 0, 0);
+    DMResource *handle = dmResourceNew(NULL, filename, 0);
     if (handle == NULL)
         return NULL;
 
-    handle->fops = &dfStdioFileOps;
-
-    handle->fh = fopen(filename, mode);
+    handle->fops  = &dfStdioFileOps;
+    handle->fh    = fopen(filename, mode);
     handle->error = dmGetErrno();
     
     if (handle->fh != NULL)
     {
-        dmres_ref(handle);
+        dmResourceRef(handle);
         return handle;
     }
     else
     {
-        dmres_free(handle);
+        dmResourceFree(handle);
         return NULL;
     }
 }
@@ -760,13 +756,13 @@
 
 DMResource * dmf_create_stdio_stream(FILE *fh)
 {
-    DMResource *handle = dmres_new(NULL, "", 0, 0);
+    DMResource *handle = dmResourceNew(NULL, "", 0);
     if (handle == NULL)
         return NULL;
 
     handle->fops = &dfStdioFHOps;
-    handle->fh = fh;
-    dmres_ref(handle);
+    handle->fh   = fh;
+    dmResourceRef(handle);
     return handle;
 }
 #endif
@@ -780,7 +776,7 @@
     if (f->fops->fclose != NULL)
         f->fops->fclose(f);
 
-    dmres_unref(f);
+    dmResourceUnref(f);
 }
 
 
@@ -858,7 +854,7 @@
 }
 
 
-int dmres_ref(DMResource *node)
+int dmResourceRef(DMResource *node)
 {
     if (node->lib != NULL) dmMutexLock(node->lib->mutex);
     node->atime = time(NULL);
@@ -869,7 +865,7 @@
 }
 
 
-int dmres_unref(DMResource *node)
+int dmResourceUnref(DMResource *node)
 {
     if (node->lib != NULL) dmMutexLock(node->lib->mutex);
     node->refcount--;
@@ -879,44 +875,8 @@
 }
 
 
-#define NADDFLAG(flg, ch) \
-    do { \
-        if ((flags & (flg)) && offs < size - 1) \
-            str[offs++] = ch; \
-    } while (0)
-
-void dmres_flags_to_symbolic(char *str, size_t size, int flags)
-{
-    size_t offs = 0;
-    NADDFLAG(DMF_PRELOAD_RAW, 'r');
-    NADDFLAG(DMF_PRELOAD_RES, 'e');
-    NADDFLAG(DMF_PERSIST,     'p');
-    NADDFLAG(DMF_STREAM,      's');
-    if (offs < size)
-        str[offs] = 0;
-}
-
-#undef NADDFLAG
-
-
-int dmres_symbolic_to_flags(const char *str)
-{
-    int offs, flags;
-
-    for (flags = offs = 0; str[offs]; offs++)
-    switch (tolower(str[offs]))
-    {
-        case 'r': flags |= DMF_PRELOAD_RAW; break;
-        case 'e': flags |= DMF_PRELOAD_RES; break;
-        case 'p': flags |= DMF_PERSIST; break;
-        case 's': flags |= DMF_STREAM; break;
-    }
-    return flags;
-}
-
-
 #ifdef DM_USE_STDIO
-static int dmres_load_directory(DMResourceLib *lib, const char *path)
+static int dmResourceLoad_directory(DMResourceLib *lib, const char *path)
 {
     int res = DMERR_OK;
     struct dirent *dh;
@@ -944,13 +904,13 @@
             }
 
             if (S_ISREG(sbuf.st_mode))
-                node = dmres_new(lib, dh->d_name, 0, sbuf.st_size);
+                node = dmResourceNew(lib, dh->d_name, sbuf.st_size);
         }
 
         if (node != NULL)
         {
             node->fops = &dfStdioFileOps;
-            dmres_insert(lib, node);
+            dmResourceInsert(lib, node);
         }
     } while (dh != NULL);
 
@@ -969,7 +929,7 @@
 
 /* Resources subsystem initialization and shutdown routines
  */
-int dmres_init(DMResourceLib **plib, const char *filename, const char *path, const int flags, int (*classifier)(DMResource *))
+int dmResourcesInit(DMResourceLib **plib, const char *filename, const char *path, const int flags, int (*classifier)(DMResource *))
 {
     DMResourceLib *lib;
     BOOL initialized = FALSE;
@@ -993,7 +953,7 @@
         lib->packFilename = dm_strdup((filename != NULL) ? filename : DMRES_DATA_PACK);
 
         // Initialize PACK, open as read-only
-        ret = dm_pack_open(lib->packFilename, &lib->packFile, TRUE);
+        ret = dmPackOpen(lib->packFilename, &lib->packFile, TRUE);
         if (ret != DMERR_OK)
         {
             if ((flags & DRF_USE_STDIO) == 0)
@@ -1009,15 +969,15 @@
             // Initialize resources from a PACK file
             for (node = lib->packFile->entries; node != NULL; node = node->next)
             {
-                DMResource *res = dmres_new(lib, node->filename, node->resFlags & DMF_MASK, node->size);
+                DMResource *res = dmResourceNew(lib, node->filename, node->size);
                 if (res == NULL)
                 {
                     dmError("Could not allocate memory for resource node '%s' [0x%08x], %d.\n",
-                        node->filename, node->resFlags, node->size);
+                        node->filename, node->flags, node->size);
                     return DMERR_INIT_FAIL;
                 }
 
-                dmres_insert(lib, res);
+                dmResourceInsert(lib, res);
             }
             
             initialized = TRUE;
@@ -1029,7 +989,7 @@
     if (!initialized && (flags & DRF_USE_STDIO))
     {
         // Initialize resources from a resource directory
-        int ret = dmres_load_directory(lib, lib->resPath);
+        int ret = dmResourceLoad_directory(lib, lib->resPath);
         if (ret != DMERR_OK)
             return ret;
         initialized = TRUE;
@@ -1056,7 +1016,7 @@
 }
 
 
-int dmres_close(DMResourceLib *lib)
+int dmResourcesClose(DMResourceLib *lib)
 {
     DMResource *node;
     
@@ -1069,11 +1029,11 @@
 #ifdef DM_USE_PACKFS
     if (lib->flags & DRF_USE_PACK)
     {
-        int res = dm_pack_close(lib->packFile);
+        int res = dmPackClose(lib->packFile);
         if (res != DMERR_OK)
         {
             dmError("Error closing PACK, #%i: %s\n",
-                        res, dmErrorStr(res));
+                res, dmErrorStr(res));
         }
 
         dmFree(lib->packFilename);
@@ -1085,7 +1045,7 @@
     while (node != NULL)
     {
         DMResource *next = node->next;
-        dmres_free(node);
+        dmResourceFree(node);
         node = next;
     }
 
@@ -1097,7 +1057,7 @@
 }
 
 
-int dmres_preload(DMResourceLib *lib, BOOL start, int *loaded, int *total)
+int dmResourcesPreload(DMResourceLib *lib, BOOL start, int *loaded, int *total)
 {
     int ret = DMERR_OK;
 
@@ -1113,10 +1073,9 @@
         *total = 0;
 
         // Calculate total number of resources to be preloaded
-        for (node = lib->resources; node != NULL; node = node->next)
+        if (lib->flags & (DRF_PRELOAD_RAW | DRF_PRELOAD_RES))
         {
-            if ((lib->flags & (DRF_PRELOAD_ALL | DRF_PRELOAD_RES)) ||
-                (node->flags & (DMF_PRELOAD_RAW | DMF_PRELOAD_RES)))
+            for (node = lib->resources; node != NULL; node = node->next)
                 (*total)++;
         }
     }
@@ -1145,10 +1104,10 @@
 }
 
 
-void dmres_prune(DMResourceLib *lib, int agems, int flags)
+void dmResourcePrune(DMResourceLib *lib, const int agems, int const flags)
 {
     DMResource *node;
-    int currtime = time(NULL);
+    const int stamp = time(NULL);
     dmMutexLock(lib->mutex);
 
     for (node = lib->resources; node != NULL; node = node->next)
@@ -1159,14 +1118,11 @@
             (node->flags & DMF_PERSIST) == 0 &&
             (node->flags & (DMF_LOADED_RES | DMF_LOADED_RAW)))
         {
-            // Check if we match either one of atime or mtime
-            if (((flags & DMPRUNE_ATIME) &&
-                currtime - node->atime >= agems) ||
-                ((flags & DMPRUNE_MTIME) &&
-                currtime - node->mtime >= agems))
+            if (((flags & DMPRUNE_ATIME) && stamp - node->atime >= agems) ||
+                ((flags & DMPRUNE_MTIME) && stamp - node->mtime >= agems))
             {
-                dmres_free_res_data(node);
-                dmres_free_raw_data(node);
+                dmResourceFreeResData(node);
+                dmResourceFreeRawData(node);
             }
         }
     }