# HG changeset patch
# User Matti Hamalainen <ccr@tnsp.org>
# Date 1366551645 -10800
# Node ID bb14d7907eb2cad09e4f8c1767a34b5080db6b46
# Parent  451fde45e11617513a8e7f835786a3a704235783
Rename many pack & resource handling functions.

diff -r 451fde45e116 -r bb14d7907eb2 dmengine.c
--- a/dmengine.c	Thu Apr 18 00:01:50 2013 +0300
+++ b/dmengine.c	Sun Apr 21 16:40:45 2013 +0300
@@ -113,7 +113,7 @@
     SDL_Surface *img = dmLoadImage(res);
     if (res != NULL)
     {
-        res->rdata = img;
+        res->resData = img;
         return DMERR_OK;
     }
     else
@@ -123,7 +123,7 @@
 
 static void engineResImageFree(DMResource *res)
 {
-    SDL_FreeSurface((SDL_Surface *)res->rdata);
+    SDL_FreeSurface((SDL_Surface *)res->resData);
 }
 
 static BOOL engineResImageProbe(DMResource *res, const char *fext)
@@ -136,12 +136,12 @@
 #ifdef JSS_SUP_XM
 static int engineResModuleLoad(DMResource *res)
 {
-    return jssLoadXM(res, (JSSModule **) &(res->rdata));
+    return jssLoadXM(res, (JSSModule **) &(res->resData));
 }
 
 static void engineResModuleFree(DMResource *res)
 {
-    jssFreeModule((JSSModule *) res->rdata);
+    jssFreeModule((JSSModule *) res->resData);
 }
 
 static BOOL engineResModuleProbe(DMResource *res, const char *fext)
@@ -188,23 +188,23 @@
     OggVorbis_File vf;
 
     dmMsg(1, "vorbisfile '%s', %d bytes resource loading\n",
-        res->filename, res->dataSize);
+        res->filename, res->rawSize);
 
     if (ov_open_callbacks(res, &vf, NULL, 0, vorbisFileCBS) < 0)
         return DMERR_FOPEN;
 
-    res->rdataSize = ov_pcm_total(&vf, -1) * 2 * 2;
-    if ((res->rdata = dmMalloc(res->rdataSize + 16)) == NULL)
+    res->resSize = ov_pcm_total(&vf, -1) * 2 * 2;
+    if ((res->resData = dmMalloc(res->resSize + 16)) == NULL)
     {
         ov_clear(&vf);
         return DMERR_MALLOC;
     }
 
-    dmMsg(1, "rdataSize=%d bytes?\n", res->rdataSize);
+    dmMsg(1, "rdataSize=%d bytes?\n", res->resSize);
 
     BOOL eof = FALSE;
-    int left = res->rdataSize;
-    char *ptr = res->rdata;
+    int left = res->resSize;
+    char *ptr = res->resData;
     int current_section;
     while (!eof && left > 0)
     {
@@ -230,7 +230,7 @@
 
 static void engineResVorbisFree(DMResource *res)
 {
-    dmFree(res->rdata);
+    dmFree(res->resData);
 }
 
 static BOOL engineResVorbisProbe(DMResource *res, const char *fext)
@@ -296,9 +296,9 @@
 {
     DMResource *res;
     if (eng != NULL &&
-        (res = dmres_find(eng->resources, name)) != NULL &&
-        res->rdata != NULL)
-        return res->rdata;
+        (res = dmResourceFind(eng->resources, name)) != NULL &&
+        res->resData != NULL)
+        return res->resData;
     else
     {
         dmError("Could not find resource '%s'.\n", name);
diff -r 451fde45e116 -r bb14d7907eb2 dmengine.h
--- a/dmengine.h	Thu Apr 18 00:01:50 2013 +0300
+++ b/dmengine.h	Sun Apr 21 16:40:45 2013 +0300
@@ -339,7 +339,7 @@
             return DMERR_INIT_FAIL; \
     } while (0)
 
-#define engineFindResource(eng, name) dmres_find((eng)->resources, name)
+#define engineFindResource(eng, name) dmResourceFind((eng)->resources, name)
 
 
 int    engineClassifier(DMResource *res);
diff -r 451fde45e116 -r bb14d7907eb2 dmpack.c
--- a/dmpack.c	Thu Apr 18 00:01:50 2013 +0300
+++ b/dmpack.c	Sun Apr 21 16:40:45 2013 +0300
@@ -9,19 +9,19 @@
 #include <zlib.h>
 
 
-DMPackEntry *dm_pack_entry_new()
+DMPackEntry *dmPackEntryNew()
 {
     return (DMPackEntry *) dmMalloc0(sizeof(DMPackEntry));
 }
 
 
-void dm_pack_entry_free(DMPackEntry * node)
+void dmPackEntryFree(DMPackEntry * node)
 {
     dmFree(node);
 }
 
 
-void dm_pack_entry_insert(DMPackEntry ** packDir, DMPackEntry * node)
+void dmPackEntryInsert(DMPackEntry ** packDir, DMPackEntry * node)
 {
     if (*packDir != NULL)
     {
@@ -38,7 +38,7 @@
 }
 
 
-void dm_pack_entry_delete(DMPackEntry ** packDir, DMPackEntry * node)
+void dmPackEntryDelete(DMPackEntry ** packDir, DMPackEntry * node)
 {
     if (node->prev)
         node->prev->next = node->next;
@@ -52,7 +52,7 @@
 }
 
 
-DMPackEntry *dm_pack_find(DMPackEntry *list, const char *filename)
+DMPackEntry *dmPackFind(DMPackEntry *list, const char *filename)
 {
     DMPackEntry *node;
 
@@ -69,7 +69,7 @@
 /*
  * OPEN a packfile
  */
-int dm_pack_open(const char *filename, DMPackFile ** ppPack, BOOL readOnly)
+int dmPackOpen(const char *filename, DMPackFile ** ppPack, BOOL readOnly)
 {
     unsigned int i;
     DMPackFile *pack;
@@ -83,7 +83,7 @@
         return DMERR_MALLOC;
 
     // Open the file
-    pack->file = fopen(filename, (readOnly) ? "rb" : "r+b");
+    pack->file = fopen(filename, readOnly ? "rb" : "r+b");
     if (pack->file == NULL)
     {
         dmFree(pack);
@@ -99,38 +99,38 @@
         !dm_fread_le32(pack->file, &hdr.dirEntries) ||
         !dm_fread_le32(pack->file, &hdr.dirOffset))
     {
-        dm_pack_close(pack);
+        dmPackClose(pack);
         return DMERR_FREAD;
     }
 
     // Check information
     if (memcmp(&hdr.ident, DPACK_IDENT, sizeof(hdr.ident)) != 0)
     {
-        dm_pack_close(pack);
+        dmPackClose(pack);
         return DMERR_NOTPACK;
     }
 
     if (hdr.version != DPACK_VERSION)
     {
-        dm_pack_close(pack);
+        dmPackClose(pack);
         return DMERR_VERSION;
     }
 
     // Read directory
     if (fseek(pack->file, hdr.dirOffset, SEEK_SET) != 0)
     {
-        dm_pack_close(pack);
+        dmPackClose(pack);
         return DMERR_INVALID;
     }
 
     for (i = 0; i < hdr.dirEntries; i++)
     {
         // Allocate and read directory entry
-        DMPackEntry *entry = dm_pack_entry_new();
+        DMPackEntry *entry = dmPackEntryNew();
 
         if (entry == NULL)
         {
-            dm_pack_close(pack);
+            dmPackClose(pack);
             return DMERR_MALLOC;
         }
 
@@ -138,14 +138,14 @@
             !dm_fread_le32(pack->file, &entry->size) ||
             !dm_fread_le32(pack->file, &entry->offset) ||
             !dm_fread_le32(pack->file, &entry->length) ||
-            !dm_fread_le32(pack->file, &entry->resFlags))
+            !dm_fread_le32(pack->file, &entry->flags))
         {
             *ppPack = pack;
             return DMERR_FREAD;
         }
 
         // Insert into list
-        dm_pack_entry_insert(&pack->entries, entry);
+        dmPackEntryInsert(&pack->entries, entry);
     }
 
     // Set the result
@@ -157,9 +157,9 @@
 /*
  * CLOSE the packfile
  */
-int dm_pack_close(DMPackFile * pack)
+int dmPackClose(DMPackFile * pack)
 {
-    DMPackEntry *node, *next;
+    DMPackEntry *node;
 
     if (pack == NULL)
         return DMERR_OK;
@@ -168,8 +168,8 @@
     node = pack->entries;
     while (node != NULL)
     {
-        next = node->next;
-        dm_pack_entry_free(node);
+        DMPackEntry *next = node->next;
+        dmPackEntryFree(node);
         node = next;
     }
 
diff -r 451fde45e116 -r bb14d7907eb2 dmpack.h
--- a/dmpack.h	Thu Apr 18 00:01:50 2013 +0300
+++ b/dmpack.h	Sun Apr 21 16:40:45 2013 +0300
@@ -20,11 +20,9 @@
     Uint32  size;              // Size (UNCOMPRESSED)
     Uint32  offset;            // Offset in pack file
     Uint32  length;            // (Compressed) data length
+
+    Uint32  flags, privFlags;
     
-    Uint32  resFlags;          // Resource flags (used by resource handler)
-
-    Uint32  privFlags;         // Private flags
-
     struct _DMPackEntry *next, *prev;
 } DMPackEntry;
 
@@ -46,16 +44,16 @@
 } DMPackFileHeader;
 
 
-DMPackEntry *  dm_pack_entry_new();
-void           dm_pack_entry_free(DMPackEntry *);
-void           dm_pack_entry_insert(DMPackEntry **, DMPackEntry *);
-void           dm_pack_entry_delete(DMPackEntry **, DMPackEntry *);
+DMPackEntry *  dmPackEntryNew();
+void           dmPackEntryFree(DMPackEntry *);
+void           dmPackEntryInsert(DMPackEntry **, DMPackEntry *);
+void           dmPackEntryDelete(DMPackEntry **, DMPackEntry *);
 
-DMPackEntry *  dm_pack_find(DMPackEntry *list, const char *filename);
+DMPackEntry *  dmPackFind(DMPackEntry *list, const char *filename);
 
-int            dm_pack_open(const char *, DMPackFile **, BOOL);
-int            dm_pack_close(DMPackFile *);
-int            dm_pack_read(DMPackFile *, const char *, Uint8 **, size_t *);
+int            dmPackOpen(const char *, DMPackFile **, BOOL);
+int            dmPackClose(DMPackFile *);
+int            dmPackRead(DMPackFile *, const char *, Uint8 **, size_t *);
 
 
 #endif // DMPACK_H
diff -r 451fde45e116 -r bb14d7907eb2 dmpackutil.c
--- a/dmpackutil.c	Thu Apr 18 00:01:50 2013 +0300
+++ b/dmpackutil.c	Sun Apr 21 16:40:45 2013 +0300
@@ -9,9 +9,9 @@
 #include "dmfile.h"
 
 
-DMPackEntry *dm_pack_entry_copy(const DMPackEntry *src)
+DMPackEntry *dmPackEntryCopy(const DMPackEntry *src)
 {
-    DMPackEntry *node = dm_pack_entry_new();
+    DMPackEntry *node = dmPackEntryNew();
     if (node == NULL)
         return NULL;
 
@@ -21,7 +21,7 @@
     node->size     = src->size;
     node->offset   = src->offset;
     node->length   = src->length;
-    node->resFlags = src->resFlags;
+    node->flags    = src->flags;
 
     return node;
 }
@@ -30,7 +30,7 @@
 /*
  * CLOSE/WRITE the packfile
  */
-int dm_pack_write(DMPackFile * pack)
+int dmPackWrite(DMPackFile * pack)
 {
     DMPackEntry *node;
     DMPackFileHeader hdr;
@@ -78,7 +78,6 @@
         dm_fwrite_le32(pack->file, node->size);
         dm_fwrite_le32(pack->file, node->offset);
         dm_fwrite_le32(pack->file, node->length);
-        dm_fwrite_le32(pack->file, node->resFlags);
 
         node = node->next;
     }
@@ -90,7 +89,7 @@
 /*
  * CREATE a packfile, for writing
  */
-int dm_pack_create(const char *filename, DMPackFile ** pack)
+int dmPackCreate(const char *filename, DMPackFile ** pack)
 {
     // Allocate packfile-structure
     *pack = (DMPackFile *) dmCalloc(1, sizeof(DMPackFile));
@@ -115,12 +114,12 @@
 /*
  * ADD a file into the PACK
  */
-int dm_pack_add_file(DMPackFile * pack, const char *filename, BOOL doCompress, int resFlags,
-                    DMPackEntry ** ppEntry)
+int dmPackAddFile(DMPackFile * pack, const char *filename,
+    BOOL doCompress, const Uint32 flags, DMPackEntry ** ppEntry)
 {
-    z_stream compStream;
+    z_stream zstr;
     off_t startOffs;
-    unsigned int compSize;
+    unsigned int zstrSize;
     FILE *inFile;
     Uint8 *inBuffer, *outBuffer;
     DMPackEntry entry, *node;
@@ -168,11 +167,11 @@
     }
 
     // Read (and possibly compress) the data
-    compSize = 0;
-    compStream.zalloc = (alloc_func) Z_NULL;
-    compStream.zfree = (free_func) Z_NULL;
-    compStream.opaque = (voidpf) Z_NULL;
-    result = deflateInit(&compStream, (doCompress) ? Z_DEFAULT_COMPRESSION : 0);
+    zstrSize = 0;
+    zstr.zalloc = (alloc_func) Z_NULL;
+    zstr.zfree = (free_func) Z_NULL;
+    zstr.opaque = (voidpf) Z_NULL;
+    result = deflateInit(&zstr, (doCompress) ? Z_DEFAULT_COMPRESSION : 0);
     if (result != Z_OK)
     {
         dmFree(inBuffer);
@@ -185,40 +184,39 @@
     result = Z_OK;
     while (!feof(inFile) && result == Z_OK)
     {
-        compStream.avail_in = fread(inBuffer, sizeof(Uint8), DPACK_TMPSIZE, inFile);
-        compStream.next_in = inBuffer;
-        compStream.next_out = outBuffer;
-        compStream.avail_out = DPACK_TMPSIZE;
-        compStream.total_out = 0;
-        result = deflate(&compStream, Z_FULL_FLUSH);
+        zstr.avail_in = fread(inBuffer, sizeof(Uint8), DPACK_TMPSIZE, inFile);
+        zstr.next_in = inBuffer;
+        zstr.next_out = outBuffer;
+        zstr.avail_out = DPACK_TMPSIZE;
+        zstr.total_out = 0;
+        result = deflate(&zstr, Z_FULL_FLUSH);
 
-        if (result == Z_OK && compStream.total_out > 0)
+        if (result == Z_OK && zstr.total_out > 0)
         {
-            compSize += compStream.total_out;
-            fwrite(outBuffer, sizeof(Uint8), compStream.total_out, pack->file);
+            zstrSize += zstr.total_out;
+            fwrite(outBuffer, sizeof(Uint8), zstr.total_out, pack->file);
         }
     }
 
     // Create directory entry
     strncpy(entry.filename, filename, sizeof(entry.filename));
     entry.filename[sizeof(entry.filename) - 1] = 0;
-    entry.size = compStream.total_in;
+    entry.size   = zstr.total_in;
     entry.offset = startOffs;
-    entry.length = compSize;
-    entry.resFlags = resFlags;
+    entry.length = zstrSize;
+    entry.flags  = flags;
 
     // Cleanup
-    deflateEnd(&compStream);
+    deflateEnd(&zstr);
     dmFree(inBuffer);
     dmFree(outBuffer);
     fclose(inFile);
 
     // Add directory entry
-    *ppEntry = dm_pack_entry_copy(&entry);
-    if (*ppEntry == NULL)
+    if ((*ppEntry = dmPackEntryCopy(&entry)) == NULL)
         return DMERR_MALLOC;
 
-    dm_pack_entry_insert(&pack->entries, *ppEntry);
+    dmPackEntryInsert(&pack->entries, *ppEntry);
 
     return DMERR_OK;
 }
@@ -227,9 +225,9 @@
 /*
  * EXTRACT a file from the PACK
  */
-int dm_pack_extract_file(DMPackFile *pack, DMPackEntry * entry)
+int dmPackExtractFile(DMPackFile *pack, DMPackEntry * entry)
 {
-    z_stream compStream;
+    z_stream zstr;
     FILE *outFile;
     Uint8 *inBuffer, *outBuffer;
     size_t inDataLeft;
@@ -264,10 +262,10 @@
     }
 
     // Read and uncompress the data
-    compStream.zalloc = (alloc_func) Z_NULL;
-    compStream.zfree = (free_func) Z_NULL;
-    compStream.opaque = (voidpf) Z_NULL;
-    ret = inflateInit(&compStream);
+    zstr.zalloc = (alloc_func) Z_NULL;
+    zstr.zfree = (free_func) Z_NULL;
+    zstr.opaque = (voidpf) Z_NULL;
+    ret = inflateInit(&zstr);
     if (ret != Z_OK)
     {
         dmFree(inBuffer);
@@ -282,28 +280,28 @@
     while (inDataLeft > 0 && ret == Z_OK)
     {
         if (inDataLeft >= DPACK_TMPSIZE)
-            compStream.avail_in = fread(inBuffer, sizeof(Uint8), DPACK_TMPSIZE, pack->file);
+            zstr.avail_in = fread(inBuffer, sizeof(Uint8), DPACK_TMPSIZE, pack->file);
         else
-            compStream.avail_in = fread(inBuffer, sizeof(Uint8), inDataLeft, pack->file);
+            zstr.avail_in = fread(inBuffer, sizeof(Uint8), inDataLeft, pack->file);
 
-        inDataLeft -= compStream.avail_in;
-        compStream.next_in = inBuffer;
+        inDataLeft -= zstr.avail_in;
+        zstr.next_in = inBuffer;
 
-        while (compStream.avail_in > 0 && ret == Z_OK)
+        while (zstr.avail_in > 0 && ret == Z_OK)
         {
-            compStream.next_out = outBuffer;
-            compStream.avail_out = DPACK_TMPSIZE;
-            compStream.total_out = 0;
-            ret = inflate(&compStream, Z_FULL_FLUSH);
-            if (compStream.total_out > 0)
+            zstr.next_out = outBuffer;
+            zstr.avail_out = DPACK_TMPSIZE;
+            zstr.total_out = 0;
+            ret = inflate(&zstr, Z_FULL_FLUSH);
+            if (zstr.total_out > 0)
             {
-                fwrite(outBuffer, sizeof(Uint8), compStream.total_out, outFile);
+                fwrite(outBuffer, sizeof(Uint8), zstr.total_out, outFile);
             }
         }
     }
 
     // Cleanup
-    inflateEnd(&compStream);
+    inflateEnd(&zstr);
     dmFree(inBuffer);
     dmFree(outBuffer);
     fclose(outFile);
diff -r 451fde45e116 -r bb14d7907eb2 dmpackutil.h
--- a/dmpackutil.h	Thu Apr 18 00:01:50 2013 +0300
+++ b/dmpackutil.h	Sun Apr 21 16:40:45 2013 +0300
@@ -8,10 +8,10 @@
 #define DMPACKUTIL_H
 #include "dmpack.h"
 
-DMPackEntry *  dm_pack_entry_copy(const DMPackEntry *);
-int            dm_pack_write(DMPackFile *);
-int            dm_pack_create(const char *, DMPackFile **);
-int            dm_pack_add_file(DMPackFile *, const char *, BOOL, int resFlags, DMPackEntry **);
-int            dm_pack_extract_file(DMPackFile *, DMPackEntry *);
+DMPackEntry *  dmPackEntryCopy(const DMPackEntry *);
+int            dmPackWrite(DMPackFile *);
+int            dmPackCreate(const char *, DMPackFile **);
+int            dmPackAddFile(DMPackFile *, const char *, BOOL, const Uint32 flags, DMPackEntry **);
+int            dmPackExtractFile(DMPackFile *, DMPackEntry *);
 
 #endif // DMPACKUTIL_H
diff -r 451fde45e116 -r bb14d7907eb2 dmres.c
--- 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);
             }
         }
     }
diff -r 451fde45e116 -r bb14d7907eb2 dmres.h
--- a/dmres.h	Thu Apr 18 00:01:50 2013 +0300
+++ b/dmres.h	Sun Apr 21 16:40:45 2013 +0300
@@ -31,18 +31,13 @@
 {
     DRF_USE_PACK    = 0x0001,
     DRF_USE_STDIO   = 0x0002,
-    DRF_PRELOAD_ALL = 0x0004,
+    DRF_PRELOAD_RAW = 0x0004,
     DRF_PRELOAD_RES = 0x0008,
 };
 
 enum
 {
-    DMF_PRELOAD_RAW = 0x0001, // Preload raw data
-    DMF_PRELOAD_RES = 0x0002, // Perform resource preloading (not 
-    DMF_PERSIST     = 0x0004, // Persist loaded resource (only freed at shutdown/explicit prune)
-    DMF_STREAM      = 0x0008, // This resource is streamed (UNSUPPORTED FOR NOW)
-    DMF_MASK        = 0x0fff,
-
+    DMF_PERSIST     = 0x0001, // Persist loaded RAW resource
     DMF_LOADED_RAW  = 0x1000, // Raw data has been loaded
     DMF_LOADED_RES  = 0x2000, // Resource has been loaded
 };
@@ -59,27 +54,31 @@
 {
     // Timestamps (in seconds from time())
     int    mtime,              // When resource was loaded
-           atime;              // Last accessed (dmres_ref()/unref)
+           atime;              // Last accessed (dmResourceRef()/unref)
     int    refcount;           // Reference count
 
     int    flags;              // Resource flags (DMF_*)
     char   *filename;
 
-    size_t dataSize;           // Size of data
-    off_t  dataOffset;         // Current offset in data
-    Uint8 *data;               // Pointer to data
+    // Raw data (or mem data)
+    size_t rawSize;            // Size of data
+    off_t  rawOffset;          // Current offset in data
+    Uint8 *rawData;            // Pointer to data
+
+    // Decoded resource data
+    void   *resData;
+    size_t resSize;
+    struct DMResourceDataOps *rops;
 
     int    error;              // Error code
 
-    struct DMResourceOps *fops;    // Pointer to file handling functions struct
-    struct DMResourceLib *lib;
-    struct DMResource *next, *prev;
+#ifdef DM_USE_STDIO
+    FILE * fh;                 // File handle for stdio
+#endif
 
-    void   *rdata;
-    size_t rdataSize;
-    struct DMResourceDataOps *rops;
-
-    FILE * fh;
+    struct DMResourceOps *fops;    // Pointer to file handling functions struct
+    struct DMResourceLib *lib;     // Pointer to the resource library
+    struct DMResource *next, *prev;
 } DMResource;
 
 
@@ -126,22 +125,19 @@
 
 /* Functions
  */
-int          dmres_init(DMResourceLib **lib, const char *filename, const char *path, const int flags, int (*classifier)(DMResource *));
-int          dmres_close(DMResourceLib *lib);
+int          dmResourcesInit(DMResourceLib **lib, const char *filename, const char *path, const int flags, int (*classifier)(DMResource *));
+int          dmResourcesClose(DMResourceLib *lib);
 
-void         dmres_prune(DMResourceLib *lib, int agems, int flags);
-int          dmres_preload(DMResourceLib *lib, BOOL start, int *loaded, int *total);
+void         dmResourcesPrune(DMResourceLib *lib, const int agems, int const flags);
+int          dmResourcesPreload(DMResourceLib *lib, BOOL start, int *loaded, int *total);
 
-void         dmres_flags_to_symbolic(char *str, size_t size, int flags);
-int          dmres_symbolic_to_flags(const char *str);
-
-DMResource * dmres_new(DMResourceLib *lib, const char *filename, int flags, size_t size);
-void         dmres_free(DMResource *node);
-void         dmres_insert(DMResourceLib *lib, DMResource * node);
-void         dmres_delete(DMResourceLib *lib, DMResource * node);
-DMResource * dmres_find(DMResourceLib *lib, const char *filename);
-int          dmres_ref(DMResource *);
-int          dmres_unref(DMResource *);
+DMResource * dmResourceNew(DMResourceLib *lib, const char *filename, const size_t size);
+void         dmResourceFree(DMResource *node);
+void         dmResourceInsert(DMResourceLib *lib, DMResource * node);
+void         dmResourceDelete(DMResourceLib *lib, DMResource * node);
+DMResource * dmResourceFind(DMResourceLib *lib, const char *filename);
+int          dmResourceRef(DMResource *);
+int          dmResourceUnref(DMResource *);
 
 
 // Opening and closing resources
diff -r 451fde45e116 -r bb14d7907eb2 dmsimple.c
--- a/dmsimple.c	Thu Apr 18 00:01:50 2013 +0300
+++ b/dmsimple.c	Sun Apr 21 16:40:45 2013 +0300
@@ -80,11 +80,11 @@
 #endif
 #ifdef DM_USE_TREMOR
         case DM_ASETUP_TREMOR:
-            if (engine.audioPos + len >= engine.audioRes->rdataSize)
+            if (engine.audioPos + len >= engine.audioRes->resSize)
                 engine.exitFlag = TRUE;
             else
             {
-                memcpy(stream, engine.audioRes->rdata + engine.audioPos, len);
+                memcpy(stream, engine.audioRes->resData + engine.audioPos, len);
                 engine.audioPos += len;
             }
             break;
@@ -140,7 +140,7 @@
         if ((err = engineShowProgress(loaded, total)) != DMERR_OK)
             return err;
 
-        err = dmres_preload(engine.resources, first, &loaded, &total);
+        err = dmResourcesPreload(engine.resources, first, &loaded, &total);
         first = FALSE;
     }
     while (err == DMERR_PROGRESS);
@@ -607,7 +607,7 @@
 
     // Initialize resource subsystem
     dmPrint(1, "Initializing resources subsystem.\n");
-    if ((err = dmres_init(&engine.resources, engine.optPackFilename,
+    if ((err = dmResourcesInit(&engine.resources, engine.optPackFilename,
         engine.optDataPath, engine.optResFlags, engineClassifier)) != DMERR_OK)
     {
         dmError("Could not initialize resource manager, #%d: %s.\n", err, dmErrorStr(err));
@@ -890,7 +890,7 @@
 #endif
 
     engineShutdownEffects(&engine);
-    dmres_close(engine.resources);
+    dmResourcesClose(engine.resources);
 
     if (engine.demoShutdown != NULL)
         engine.demoShutdown(&engine);
diff -r 451fde45e116 -r bb14d7907eb2 tools/packed.c
--- a/tools/packed.c	Thu Apr 18 00:01:50 2013 +0300
+++ b/tools/packed.c	Sun Apr 21 16:40:45 2013 +0300
@@ -250,30 +250,6 @@
 }
 
 
-int dmAddFileToPack(DMPackFile *pack, const char *filename, int compression, int resFlags)
-{
-    DMPackEntry *node;
-    int res = dm_pack_add_file(pack, filename, compression, resFlags, &node);
-
-    if (res != DMERR_OK)
-    {
-        dmPrint(1, "%-32s [ERROR:%d]\n",
-            filename, res);
-    }
-    else
-    {
-        char tmp[16];
-        dmres_flags_to_symbolic(tmp, sizeof(tmp), node->resFlags);
-        dmPrint(1, "%-32s ['%s', s=%d, c=%d, o=%ld, f=%s]\n",
-            filename, node->filename,
-            node->size, node->length, node->offset,
-            tmp);
-    }
-
-    return res;
-}
-
-
 int main(int argc, char *argv[])
 {
     int i, res = 0;
@@ -314,12 +290,12 @@
         {
         case CMD_CREATE:
             dmMsg(1, "Creating new PACK\n");
-            res = dm_pack_create(optPackFilename, &pack);
+            res = dmPackCreate(optPackFilename, &pack);
             break;
 
         case CMD_ADD:
             dmMsg(1, "Opening existing PACK\n");
-            res = dm_pack_open(optPackFilename, &pack, FALSE);
+            res = dmPackOpen(optPackFilename, &pack, FALSE);
             break;
         }
 
@@ -330,18 +306,24 @@
 
             for (i = 0; i < nsrcFilenames; i++)
             {
-                // Handle resource definition files
-                if (srcFilenames[i][0] == '@')
+                DMPackEntry *node = NULL;
+                int res = dmPackAddFile(pack, srcFilenames[i], optCompress, optDefResFlags, &node);
+
+                if (res != DMERR_OK)
                 {
+                    dmPrint(1, "%-32s [ERROR:%d]\n",
+                        srcFilenames[i], res);
                 }
                 else
                 {
-                    dmAddFileToPack(pack, srcFilenames[i], optCompress, optDefResFlags);
+                    dmPrint(1, "%-32s ['%s', s=%d, c=%d, o=%ld, f=0x%04x]\n",
+                        srcFilenames[i], node->filename,
+                        node->size, node->length, node->offset, node->flags);
                 }
             }
 
-            dmMsg(1, "w=%d\n", dm_pack_write(pack));
-            dmMsg(1, "c=%d\n", dm_pack_close(pack));
+            dmMsg(1, "w=%d\n", dmPackWrite(pack));
+            dmMsg(1, "c=%d\n", dmPackClose(pack));
         }
         else
         {
@@ -352,7 +334,7 @@
 
     case CMD_LIST:
         // List files in PACK
-        res = dm_pack_open(optPackFilename, &pack, TRUE);
+        res = dmPackOpen(optPackFilename, &pack, TRUE);
         if (res == DMERR_OK)
         {
             DMPackEntry *node;
@@ -381,16 +363,13 @@
 
                 if (match)
                 {
-                    char flags[16];
-                    dmres_flags_to_symbolic(flags, sizeof(flags), node->resFlags);
-
-                    dmPrint(0, "%-32s | %8d | %8d | %08x | %s\n",
+                    dmPrint(0, "%-32s | %8d | %8d | %08x | %04x\n",
                         node->filename, node->size, node->length,
-                        node->offset, flags);
+                        node->offset, node->flags);
                 }
             }
 
-            dmMsg(1, "c=%d\n", dm_pack_close(pack));
+            dmMsg(1, "c=%d\n", dmPackClose(pack));
         }
         else
             dmError("Could not open packfile, error #%d: %s\n", res,
@@ -399,7 +378,7 @@
 
     case CMD_EXTRACT:
         // Extract files from PACK
-        res = dm_pack_open(optPackFilename, &pack, TRUE);
+        res = dmPackOpen(optPackFilename, &pack, TRUE);
         if (res == DMERR_OK)
         {
             DMPackEntry *node;
@@ -428,28 +407,19 @@
 
                 if (match && (node->privFlags & PACK_EXTRACTED) == 0)
                 {
-                    char tmp[16];
-
                     // Mark as done
                     node->privFlags |= PACK_EXTRACTED;
 
                     // Print one entry
-                    dmres_flags_to_symbolic(tmp, sizeof(tmp), node->resFlags);
-                    dmPrint(0, "Extracting: %-32s [siz=%d, cmp=%d, offs=0x%08x, flags=%s]\n",
+                    dmPrint(0, "Extracting: %-32s [siz=%d, cmp=%d, offs=0x%08x, flags=0x%04x]\n",
                             node->filename, node->size, node->length,
-                            node->offset, tmp);
+                            node->offset, node->flags);
 
-                    dm_pack_extract_file(pack, node);
-                    
-                    if (resFile != NULL)
-                    {
-                        fprintf(resFile,
-                        "%s|%s\n", node->filename, tmp);
-                    }
+                    dmPackExtractFile(pack, node);
                 }
             }
 
-            dmMsg(1, "c=%d\n", dm_pack_close(pack));
+            dmMsg(1, "c=%d\n", dmPackClose(pack));
             
             if (resFile != NULL)
                 fclose(resFile);