Changeset 334 for ps

Timestamp:

06/01/04 19:34:12 (21 years ago)

Author:

janwas

Message:

lots of type fixes; types.h is now a convenience wrapper on top of the standard uintN_t routines

Location:

ps/trunk/source

Files:

• graphics/MapReader.cpp (modified) (2 diffs)
• graphics/MapWriter.cpp (modified) (2 diffs)
• graphics/Terrain.cpp (modified) (2 diffs)
• graphics/Terrain.h (modified) (1 diff)
• gui/CGUI.h (modified) (1 diff)
• gui/GUItext.cpp (modified) (5 diffs)
• gui/IGUIScrollBar.h (modified) (1 diff)
• lib/detect.h (modified) (2 diffs)
• lib/lib.cpp (modified) (2 diffs)
• lib/lib.h (modified) (4 diffs)
• lib/misc.cpp (modified) (1 diff)
• lib/misc.h (modified) (1 diff)
• lib/precompiled.h (modified) (3 diffs)
• lib/res/file.cpp (modified) (2 diffs)
• lib/res/font.cpp (modified) (2 diffs)
• lib/res/h_mgr.cpp (modified) (3 diffs)
• lib/res/h_mgr.h (modified) (2 diffs)
• lib/res/mem.cpp (modified) (5 diffs)
• lib/res/mem.h (modified) (1 diff)
• lib/res/tex.cpp (modified) (9 diffs)
• lib/res/tex.h (modified) (2 diffs)
• lib/res/vfs.cpp (modified) (26 diffs)
• lib/sysdep/win/waio.cpp (modified) (1 diff)
• lib/sysdep/win/wdetect.cpp (modified) (1 diff)
• lib/sysdep/win/wposix.cpp (modified) (7 diffs)
• lib/sysdep/win/wposix.h (modified) (3 diffs)
• lib/sysdep/win/wsdl.cpp (modified) (1 diff)
• lib/sysdep/win/wsock.cpp (modified) (1 diff)
• lib/sysdep/win/wsock.h (modified) (4 diffs)
• lib/sysdep/x.cpp (modified) (2 diffs)
• lib/timer.cpp (modified) (1 diff)
• lib/types.h (modified) (2 diffs)
• main.cpp (modified) (7 diffs)
• ps/Config.h (modified) (1 diff)
• ps/Overlay.cpp (modified) (4 diffs)
• ps/Overlay.h (modified) (8 diffs)
• ps/Singleton.h (modified) (1 diff)
• ps/ThreadUtil.h (modified) (1 diff)
• renderer/PatchRData.cpp (modified) (1 diff)
• simulation/EntityProperties.cpp (modified) (1 diff)
• terrain/terrainMain.cpp (modified) (1 diff)

ps/trunk/source/graphics/MapReader.cpp

@@ -1 @@
-// switch off warnings before including stl files
-#pragma warning(disable : 4786) // identifier truncated to 255 chars
+#include "precompiled.h"
 
 #include "Types.h"
@@ -17 +16 @@
 extern CLightEnv g_LightEnv;
 
-#include <set>
-#include <stdio.h>
 
 

ps/trunk/source/graphics/MapWriter.cpp

@@ -1 @@
-// switch off warnings before including stl files
-#pragma warning(disable : 4786) // identifier truncated to 255 chars
+#include "precompiled.h"
 
 #include "Types.h"
@@ -13 +12 @@
 extern CTerrain g_Terrain;
 extern CLightEnv g_LightEnv;
-
-#include <set>
-#include <stdio.h>
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////

ps/trunk/source/graphics/Terrain.cpp

@@ -129 +129 @@
 // GetPatch: return the patch at (x,z) in patch space, or null if the patch is 
 // out of bounds
-CPatch* CTerrain::GetPatch(int32 x,int32 z)
-{
-    if (x<0 || x>=int32(m_MapSizePatches)) return 0;    
-    if (z<0 || z>=int32(m_MapSizePatches)) return 0;
+CPatch* CTerrain::GetPatch(int32_t x,int32_t z)
+{
+    if (x<0 || x>=int32_t(m_MapSizePatches)) return 0;  
+    if (z<0 || z>=int32_t(m_MapSizePatches)) return 0;
     return &m_Patches[(z*m_MapSizePatches)+x]; 
 }
@@ -140 +140 @@
 // GetPatch: return the tile at (x,z) in tile space, or null if the tile is out 
 // of bounds
-CMiniPatch* CTerrain::GetTile(int32 x,int32 z)
-{
-    if (x<0 || x>=int32(m_MapSize)-1) return 0; 
-    if (z<0 || z>=int32(m_MapSize)-1) return 0;
+CMiniPatch* CTerrain::GetTile(int32_t x,int32_t z)
+{
+    if (x<0 || x>=int32_t(m_MapSize)-1) return 0;   
+    if (z<0 || z>=int32_t(m_MapSize)-1) return 0;
 
     CPatch* patch=GetPatch(x/16,z/16);

ps/trunk/source/graphics/Terrain.h

@@ -52 +52 @@
     // get patch at given coordinates, expressed in patch-space; return 0 if
     // coordinates represent patch off the edge of the map
-    CPatch* GetPatch(int32 x,int32 z); 
+    CPatch* GetPatch(int32_t x,int32_t z); 
     // get tile at given coordinates, expressed in tile-space; return 0 if
     // coordinates represent tile off the edge of the map
-    CMiniPatch* GetTile(int32 x,int32 z);
+    CMiniPatch* GetTile(int32_t x,int32_t z);
 
     // calculate the position of a given vertex

ps/trunk/source/gui/CGUI.h

@@ -419 +419 @@
     /// Used when reading in XML files
     // TODO Gee: Used?
-    int16 m_Errors;
+    int16_t m_Errors;
 
     //@}

ps/trunk/source/gui/GUItext.cpp

@@ -217 +217 @@
     Parser.InputTaskType("end", "/$ident");
 
-    _long position = 0;
-    _long from=0;           // the position in the raw string where the last tag ended
-    _long from_nonraw=0;    // like from only in position of the REAL string, with tags.
-    _long curpos = 0;
+    long position = 0;
+    long from=0;            // the position in the raw string where the last tag ended
+    long from_nonraw=0; // like from only in position of the REAL string, with tags.
+    long curpos = 0;
 
     // Current Text Chunk
@@ -247 +247 @@
             // First check if there is another TagStart before a TagEnd,
             //  in that case it's just a regular TagStart and we can continue.
-            _long pos_left = str.Find(curpos+1, TagStart);
-            _long pos_right = str.Find(curpos+1, TagEnd);
+            long pos_left = str.Find(curpos+1, TagStart);
+            long pos_right = str.Find(curpos+1, TagEnd);
 
             if (pos_right == -1)
@@ -429 +429 @@
     {
         // Find the next word-delimiter.
-        _long dl = m_RawString.Find(position, ' ');
+        long dl = m_RawString.Find(position, ' ');
 
         if (dl == -1)
@@ -442 +442 @@
     {
         // Find the next word-delimiter.
-        _long dl = m_RawString.Find(position, '-');
+        long dl = m_RawString.Find(position, '-');
 
         if (dl == -1)
@@ -455 +455 @@
     {
         // Find the next word-delimiter.
-        _long dl = m_RawString.Find(position, '\n');
+        long dl = m_RawString.Find(position, '\n');
 
         if (dl == -1)

ps/trunk/source/gui/IGUIScrollBar.h

@@ -229 +229 @@
      * @param width Width
      */
-    void SetWidth(const int16 &width) { m_Width = width; }
+    void SetWidth(const int16_t &width) { m_Width = width; }
     
     /**

ps/trunk/source/lib/detect.h

@@ -20 +20 @@
 #define __DETECT_H__
 
-#include "misc.h"
+#include "lib.h"
 
 #ifdef __cplusplus
@@ -29 +29 @@
 // useful for choosing a video mode. not called by detect().
 // if we fail, outputs are unchanged (assumed initialized to defaults)
-extern int get_cur_resolution(int& xres, int& yres);
+extern int get_cur_vmode(int* xres, int* yres, int* bpp, int* freq);
 
 // useful for determining aspect ratio. not called by detect().

ps/trunk/source/lib/lib.cpp

@@ -37 +37 @@
 //   so we may have shut down something important already).
 
-const int MAX_EXIT_FUNCS = 64;
+static const int MAX_EXIT_FUNCS = 32;
 
 
@@ -112 +112 @@
     atexit(call_exit_funcs);
 }
+
+
+
+
+
+
+
+
+
+
+// FNV1-A hash - good for strings.
+// if len = 0 (default), treat buf as a C-string;
+// otherwise, hash <len> bytes of buf.
+u32 fnv_hash(const void* buf, const size_t len)
+{
+    u32 h = 0x811c9dc5;
+        // give distinct values for different length 0 buffers.
+        // value taken from FNV; it has no special significance.
+
+    const u8* p = (const u8*)buf;
+
+    // expected case: string
+    if(!len)
+    {
+        while(*p)
+        {
+            h ^= *p++;
+            h *= 0x01000193;
+        }
+    }
+    else
+    {
+        size_t bytes_left = len;
+        while(bytes_left != 0)
+        {
+            h ^= *p++;
+            h *= 0x01000193;
+
+            bytes_left--;
+        }
+    }
+
+    return h;
+}
+
+
+// FNV1-A hash - good for strings.
+// if len = 0 (default), treat buf as a C-string;
+// otherwise, hash <len> bytes of buf.
+u64 fnv_hash64(const void* buf, const size_t len)
+{
+    u64 h = 0xCBF29CE484222325ull;
+        // give distinct values for different length 0 buffers.
+        // value taken from FNV; it has no special significance.
+
+    const u8* p = (const u8*)buf;
+
+    // expected case: string
+    if(!len)
+    {
+        while(*p)
+        {
+            h ^= *p++;
+            h *= 0x100000001B3;
+        }
+    }
+    else
+    {
+        size_t bytes_left = len;
+        while(bytes_left != 0)
+        {
+            h ^= *p++;
+            h *= 0x100000001B3;
+
+            bytes_left--;
+        }
+    }
+
+    return h;
+}
+
+
+
+
+bool is_pow2(const long n)
+{
+    return (n != 0) && !(n & (n-1));
+}
+
+
+// return -1 if not an integral power of 2,
+// otherwise the base2 logarithm
+
+int ilog2(const int n)
+{
+#ifdef _M_IX86
+
+    __asm
+    {
+        mov     ecx, [n]
+        or      eax, -1         // return value
+        lea     edx, [ecx-1]
+        test    ecx, edx        // power of 2?
+        jnz     $ret
+        bsf     eax, ecx
+    $ret:
+        mov     [n], eax
+    }
+
+    return n;
+
+#else
+
+    if(n || n & (n-1))
+        return -1;
+
+    int i = 1, j = 0;
+    for(; i != n; i += i, j++)
+        ;
+    return j;
+
+#endif
+}
+
+
+int ilog2(const float x)
+{
+    u32 i = (u32&)x;
+    u32 exp = (i >> 23) & 0xff;
+    return (int)exp - 127;
+}
+
+
+uintptr_t round_up(const uintptr_t n, const uintptr_t multiple)
+{
+    assert(multiple != 0);
+    const uintptr_t padded = n + multiple-1;
+    const uintptr_t remainder = padded % multiple;
+    const uintptr_t result = padded - remainder;
+    assert(n <= result && result < n+multiple);
+    return result;
+}
+
+
+u16 addusw(u16 x, u16 y)
+{
+    u32 t = x;
+    return (u16)MIN(t+y, 0xffff);
+}
+
+
+u16 subusw(u16 x, u16 y)
+{
+    long t = x;
+    return (u16)(MAX(t-y, 0));
+}
+
+
+// provide fminf for non-C99 compilers
+#ifndef HAVE_C99
+
+float fminf(float a, float b)
+{
+    return (a < b)? a : b;
+}
+
+#endif
+
+
+
+long round(double x)
+{
+    return (long)(x + 0.5);
+}
+
+
+// input in [0, 1); convert to u8 range
+u8 fp_to_u8(double in)
+{
+    if(!(0 <= in && in < 1.0))
+    {
+        debug_warn("clampf not in [0,1)");
+        return 255;
+    }
+
+    int l = round(in * 255.0);
+    assert((unsigned int)l <= 255);
+    return (u8)l;
+}
+
+
+// input in [0, 1); convert to u16 range
+u16 fp_to_u16(double in)
+{
+    if(!(0 <= in && in < 1.0))
+    {
+        debug_warn("clampf not in [0,1)");
+        return 65535;
+    }
+
+    long l = round(in * 65535.0);
+    assert((unsigned long)l <= 65535);
+    return (u16)l;
+}
+
+
+
+// big endian!
+void base32(const int len, const u8* in, u8* out)
+{
+    int bits = 0;
+    u32 pool = 0;
+
+    static u8 tbl[33] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+
+    for(int i = 0; i < len; i++)
+    {
+        if(bits < 5)
+        {
+            pool <<= 8;
+            pool |= *in++;
+            bits += 8;
+        }
+
+        bits -= 5;
+        int c = (pool >> bits) & 31;
+        *out++ = tbl[c];
+    }
+}
+/*
+#ifndef _WIN32
+
+char *_itoa(int value, char *out, int radix)
+{
+    return _ltoa(value, out, radix);
+}
+
+static const char digits[]="0123456789abcdef";
+    
+char *_ultoa(unsigned long int value, char *out, int radix)
+{
+    char buf[21];
+    char *p=buf+21;
+    
+    do
+    {
+        *(--p)=digits[value % radix];
+        value /= radix;
+    }
+    while (value);
+    
+    memcpy(out, p, (buf+21)-p);
+    out[(buf+21)-p]=0;
+    return out;
+}
+
+char *_ltoa(long val, char *out, int radix)
+{
+    char buf[21];
+    char *p=buf+21;
+    bool sign=val < 0;
+    if (sign) val=-val;
+    
+    do
+    {
+        *(--p)=digits[val % radix];
+        val /= radix;
+    }
+    while (val);
+    
+    if (sign) *(--p) = '-';
+    
+    memcpy(out, p, (buf+21)-p);
+    out[(buf+21)-p]=0;
+    return out;
+}
+
+#endif
+*/
+
+

ps/trunk/source/lib/lib.h

@@ -21 +21 @@
 
 #include "config.h"
-
-#include "misc.h"
+#include "posix.h"
 #include "types.h"
 
 #include "sysdep/sysdep.h"
-
-
-// yikes! avoid template warning spew on VC6
-#if _MSC_VER <= 1200
-#pragma warning(disable:4786)
-#endif
 
 
@@ -46 +39 @@
 
 
+
 #define STMT(STMT_code__) do { STMT_code__; } while(0)
 
@@ -51 +45 @@
 #define ONCE(ONCE_code__)\
 STMT(\
-    static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;\
+/*  static pthread_mutex_t ONCE_mutex__ = PTHREAD_MUTEX_INITIALIZER;\
+    if(pthread_mutex_trylock(&ONCE_mutex__) == 0)\*/\
     static bool ONCE_done__ = false;\
-    if(pthread_mutex_trylock(&(mutex)) == 0 && !ONCE_done__)\
+    if(!ONCE_done__)\
     {\
         ONCE_done__ = true;\
@@ -192 +187 @@
 extern int atexit2(void* func);
 
-#include "posix.h"
+
+
+
+
+
+
+
+
+
+
+// FNV1-A hash - good for strings.
+// if len = 0 (default), treat buf as a C-string;
+// otherwise, hash <len> bytes of buf.
+extern u32 fnv_hash(const void* buf, const size_t len = 0);
+extern u64 fnv_hash64(const void* buf, const size_t len);
+
+// hash (currently FNV) of a filename
+typedef u32 FnHash;
+
+
+#ifndef min
+inline int min(int a, int b)
+{
+    return (a < b)? a : b;
+}
+
+inline int max(int a, int b)
+{
+    return (a > b)? a : b;
+}
+#endif
+
+extern u16 addusw(u16 x, u16 y);
+extern u16 subusw(u16 x, u16 y);
+
+
+
+
+static inline u16 read_le16(const void* p)
+{
+#ifdef BIG_ENDIAN
+    const u8* _p = (const u8*)p;
+    return (u16)_p[0] | (u16)_p[1] << 8;
+#else
+    return *(u16*)p;
+#endif
+}
+
+
+static inline u32 read_le32(const void* p)
+{
+#ifdef BIG_ENDIAN
+    u32 t = 0;
+    for(int i = 0; i < 4; i++)
+    {
+        t <<= 8;
+        t |= *((const u8*)p)++;
+    }
+    return t;
+#else
+    return *(u32*)p;
+#endif
+}
+
+
+extern bool is_pow2(long n);
+
+
+// return -1 if not an integral power of 2,
+// otherwise the base2 logarithm
+extern int ilog2(const int n);
+
+
+extern uintptr_t round_up(uintptr_t val, uintptr_t multiple);
+
+
+// provide fminf for non-C99 compilers
+#ifndef HAVE_C99
+extern float fminf(float, float);
+#endif
+
+
+
+extern long round(double);
+extern u16 fp_to_u16(double in);
+
+// big endian!
+extern void base32(const int len, const u8* in, u8* out);
+
+#ifndef _WIN32
+
+char *_itoa(int, char *, int radix);
+char *_ultoa(unsigned long int, char*, int radix);
+char *_ltoa(long, char *, int radix);
+
+#endif
+
+
+
 
 

ps/trunk/source/lib/misc.cpp

@@ -22 +22 @@
 #include "misc.h"
 
-
-// FNV1-A hash - good for strings.
-// if len = 0 (default), treat buf as a C-string;
-// otherwise, hash <len> bytes of buf.
-u32 fnv_hash(const void* buf, const size_t len)
-{
-    u32 h = 0x811c9dc5;
-        // give distinct values for different length 0 buffers.
-        // value taken from FNV; it has no special significance.
-
-    const u8* p = (const u8*)buf;
-
-    // expected case: string
-    if(!len)
-    {
-        while(*p)
-        {
-            h ^= *p++;
-            h *= 0x01000193;
-        }
-    }
-    else
-    {
-        size_t bytes_left = len;
-        while(bytes_left != 0)
-        {
-            h ^= *p++;
-            h *= 0x01000193;
-
-            bytes_left--;
-        }
-    }
-
-    return h;
-}
-
-
-// FNV1-A hash - good for strings.
-// if len = 0 (default), treat buf as a C-string;
-// otherwise, hash <len> bytes of buf.
-u64 fnv_hash64(const void* buf, const size_t len)
-{
-    u64 h = 0xCBF29CE484222325ull;
-        // give distinct values for different length 0 buffers.
-        // value taken from FNV; it has no special significance.
-
-    const u8* p = (const u8*)buf;
-
-    // expected case: string
-    if(!len)
-    {
-        while(*p)
-        {
-            h ^= *p++;
-            h *= 0x100000001B3;
-        }
-    }
-    else
-    {
-        size_t bytes_left = len;
-        while(bytes_left != 0)
-        {
-            h ^= *p++;
-            h *= 0x100000001B3;
-
-            bytes_left--;
-        }
-    }
-
-    return h;
-}
-
-
-
-
-bool is_pow2(const long n)
-{
-    return (n != 0) && !(n & (n-1));
-}
-
-
-// return -1 if not an integral power of 2,
-// otherwise the base2 logarithm
-
-int ilog2(const int n)
-{
-#ifdef _M_IX86
-
-    __asm
-    {
-        mov     ecx, [n]
-        or      eax, -1         // return value
-        lea     edx, [ecx-1]
-        test    ecx, edx        // power of 2?
-        jnz     $ret
-        bsf     eax, ecx
-    $ret:
-        mov     [n], eax
-    }
-
-    return n;
-
-#else
-
-    if(n || n & (n-1))
-        return -1;
-
-    int i = 1, j = 0;
-    for(; i != n; i += i, j++)
-        ;
-    return j;
-
-#endif
-}
-
-
-int ilog2(const float x)
-{
-    u32 i = (u32&)x;
-    u32 exp = (i >> 23) & 0xff;
-    return (int)exp - 127;
-}
-
-
-uintptr_t round_up(uintptr_t val, uintptr_t multiple)
-{
-    val += multiple-1;
-    val -= val % multiple;
-    return val;
-}
-
-
-u16 addusw(u16 x, u16 y)
-{
-    u32 t = x;
-    return (u16)MIN(t+y, 0xffff);
-}
-
-
-u16 subusw(u16 x, u16 y)
-{
-    long t = x;
-    return (u16)(MAX(t-y, 0));
-}
-
-
-// provide fminf for non-C99 compilers
-#ifndef HAVE_C99
-
-float fminf(float a, float b)
-{
-    return (a < b)? a : b;
-}
-
-#endif
-
-
-
-long round(double x)
-{
-    return (long)(x + 0.5);
-}
-
-
-// input in [0, 1); convert to u8 range
-u8 fp_to_u8(double in)
-{
-    if(!(0 <= in && in < 1.0))
-    {
-        debug_warn("clampf not in [0,1)");
-        return 255;
-    }
-
-    int l = round(in * 255.0);
-    assert((unsigned int)l <= 255);
-    return (u8)l;
-}
-
-
-// input in [0, 1); convert to u16 range
-u16 fp_to_u16(double in)
-{
-    if(!(0 <= in && in < 1.0))
-    {
-        debug_warn("clampf not in [0,1)");
-        return 65535;
-    }
-
-    long l = round(in * 65535.0);
-    assert((unsigned long)l <= 65535);
-    return (u16)l;
-}
-
-
-
-// big endian!
-void base32(const int len, const u8* in, u8* out)
-{
-    int bits = 0;
-    u32 pool = 0;
-
-    static u8 tbl[33] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
-
-    for(int i = 0; i < len; i++)
-    {
-        if(bits < 5)
-        {
-            pool <<= 8;
-            pool |= *in++;
-            bits += 8;
-        }
-
-        bits -= 5;
-        int c = (pool >> bits) & 31;
-        *out++ = tbl[c];
-    }
-}
-/*
-#ifndef _WIN32
-
-char *_itoa(int value, char *out, int radix)
-{
-    return _ltoa(value, out, radix);
-}
-
-static const char digits[]="0123456789abcdef";
-    
-char *_ultoa(unsigned long int value, char *out, int radix)
-{
-    char buf[21];
-    char *p=buf+21;
-    
-    do
-    {
-        *(--p)=digits[value % radix];
-        value /= radix;
-    }
-    while (value);
-    
-    memcpy(out, p, (buf+21)-p);
-    out[(buf+21)-p]=0;
-    return out;
-}
-
-char *_ltoa(long val, char *out, int radix)
-{
-    char buf[21];
-    char *p=buf+21;
-    bool sign=val < 0;
-    if (sign) val=-val;
-    
-    do
-    {
-        *(--p)=digits[val % radix];
-        val /= radix;
-    }
-    while (val);
-    
-    if (sign) *(--p) = '-';
-    
-    memcpy(out, p, (buf+21)-p);
-    out[(buf+21)-p]=0;
-    return out;
-}
-
-#endif
-*/
-

ps/trunk/source/lib/misc.h

@@ -20 +20 @@
 #define __MISC_H__
 
-#include "types.h"
-#include "config.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-// FNV1-A hash - good for strings.
-// if len = 0 (default), treat buf as a C-string;
-// otherwise, hash <len> bytes of buf.
-extern u32 fnv_hash(const void* buf, const size_t len = 0);
-extern u64 fnv_hash64(const void* buf, const size_t len);
-
-// hash (currently FNV) of a filename
-typedef u32 FnHash;
-
-
-#ifndef min
-inline int min(int a, int b)
-{
-    return (a < b)? a : b;
-}
-
-inline int max(int a, int b)
-{
-    return (a > b)? a : b;
-}
-#endif
-
-extern u16 addusw(u16 x, u16 y);
-extern u16 subusw(u16 x, u16 y);
-
-
-
-
-static inline u16 read_le16(const void* p)
-{
-#ifdef BIG_ENDIAN
-    const u8* _p = (const u8*)p;
-    return (u16)_p[0] | (u16)_p[1] << 8;
-#else
-    return *(u16*)p;
-#endif
-}
-
-
-static inline u32 read_le32(const void* p)
-{
-#ifdef BIG_ENDIAN
-    u32 t = 0;
-    for(int i = 0; i < 4; i++)
-    {
-        t <<= 8;
-        t |= *((const u8*)p)++;
-    }
-    return t;
-#else
-    return *(u32*)p;
-#endif
-}
-
-
-extern bool is_pow2(long n);
-
-
-// return -1 if not an integral power of 2,
-// otherwise the base2 logarithm
-extern int ilog2(const int n);
-
-
-extern uintptr_t round_up(uintptr_t val, uintptr_t multiple);
-
-
-// provide fminf for non-C99 compilers
-#ifndef HAVE_C99
-extern float fminf(float, float);
-#endif
-
-
-
-extern long round(double);
-extern u16 fp_to_u16(double in);
-
-// big endian!
-extern void base32(const int len, const u8* in, u8* out);
-
-#ifndef _WIN32
-
-char *_itoa(int, char *, int radix);
-char *_ultoa(unsigned long int, char*, int radix);
-char *_ltoa(long, char *, int radix);
-
-#endif
-
-
 
 

ps/trunk/source/lib/precompiled.h

@@ -1 +1 @@
 #include <string.h>
 #include <stdlib.h>
-
 #include <stdio.h>
 
@@ -9 +8 @@
 #include <limits.h>
 #include <time.h>
-
 #include <wchar.h>
-
 
 #include <list>
@@ -18 +15 @@
 #include <stack>
 #include <string>
+#include <set>
+#include <deque>
 
 #include <functional>
 #include <algorithm>
-
 #include <numeric>
 
-#pragma warning(disable:4996)
+#ifdef _MSC_VER
+#pragma warning(disable:4996)   // function is deprecated
+#pragma warning(disable:4786)   // identifier truncated to 255 chars
+#endif

ps/trunk/source/lib/res/file.cpp

@@ -754 +754 @@
 
 // free all allocated IOs, so they aren't seen as resource leaks.
-static void io_cleanup(void)
+static void io_shutdown(void)
 {
     std::for_each(all_ios.begin(), all_ios.end(), Free());
@@ -762 +762 @@
 static Handle io_alloc()
 {
-    ONCE(atexit(io_cleanup));
+    ONCE(atexit(io_shutdown));
 /*
     // grab from freelist

ps/trunk/source/lib/res/font.cpp

@@ -22 +22 @@
 
 #include "lib.h"
-#include "mem.h"
-#include "font.h"
-#include "h_mgr.h"
-#include "vfs.h"
-#include "tex.h"
+#include "res.h"
 #include "ogl.h"
-#include "misc.h"
 
 /*
@@ -109 +104 @@
 struct Font
 {
-    Handle ht;
+    Handle ht;      // handle to font texture
     uint list_base;
 };

ps/trunk/source/lib/res/h_mgr.cpp

@@ -20 +20 @@
 
 #include "lib.h"
-#include "misc.h"
 #include "h_mgr.h"
 #include "mem.h"
@@ -236 +235 @@
 
 
-static void cleanup(void)
+void h_mgr_shutdown(void)
 {
     // close open handles
@@ -373 +372 @@
 Handle h_alloc(H_Type type, const char* fn, uint flags, ...)
 {
-    ONCE(atexit2(cleanup));
+    ONCE(atexit2(h_mgr_shutdown));
 
     Handle err;

ps/trunk/source/lib/res/h_mgr.h

@@ -20 +20 @@
 #define H_MGR_H__
 
-#ifdef __cplusplus
-extern "C" {
-#endif
 
 #include <stdarg.h>     // type init routines get va_list of args
 
-#include "../types.h"
+#include "lib.h"
 
 
 // handle type (for 'type safety' - can't use a texture handle as a sound)
+
+    
 //
 // rationale: we could use the destructor passed to h_alloc to identify
@@ -185 +184 @@
 extern int res_cur_scope;
 
-#ifdef __cplusplus
-}
-#endif
-
 
 #endif  // #ifndef H_MGR_H__

ps/trunk/source/lib/res/mem.cpp

@@ -4 +4 @@
 
 #include "lib.h"
-#include "types.h"
-#include "mem.h"
+#include "res.h"
 #include "h_mgr.h"
-#include "misc.h"
-
-#include <map>
-
-
 
 
@@ -24 +18 @@
 
 
-static void* heap_alloc(const size_t size, const int align, uintptr_t& ctx, MEM_DTOR& dtor)
+static void* heap_alloc(const size_t size, const size_t align, uintptr_t& ctx, MEM_DTOR& dtor)
 {
     u8* org_p = (u8*)malloc(size+align-1);
@@ -56 +50 @@
 
 
-static void* pool_alloc(const size_t size, const uint align, uintptr_t& ctx, MEM_DTOR& dtor)
+static void* pool_alloc(const size_t size, const size_t align, uintptr_t& ctx, MEM_DTOR& dtor)
 {
     if(!pool)
@@ -209 +203 @@
     // we've already allocated that pointer - returns its handle
     Handle hm = find_alloc(p);
-    if(hm)
+    if(hm > 0)
         return hm;
 
@@ -234 +228 @@
 
 
-void* mem_alloc(size_t size, const uint align, uint flags, Handle* phm)
+void* mem_alloc(size_t size, const size_t align, uint flags, Handle* phm)
 {
     if(phm)

ps/trunk/source/lib/res/mem.h

@@ -20 +20 @@
 };
 
-extern void* mem_alloc(size_t size, uint align = 1, uint flags = 0, Handle* ph = 0);
+extern void* mem_alloc(size_t size, size_t align = 1, uint flags = 0, Handle* ph = 0);
 
 #define mem_free(p) mem_free_p((void*&)p)

ps/trunk/source/lib/res/tex.cpp

@@ -22 +22 @@
 
 #include "lib.h"
-#include "vfs.h"
-#include "tex.h"
-#include "mem.h"
+#include "res.h"
 #include "ogl.h"
-#include "h_mgr.h"
-#include "misc.h"
 
 
@@ -38 +34 @@
 #endif
 
-
+// libpng includes windows.h - prevent that, and define what it needs.
 #define _WINDOWS_
 #define WINAPI __stdcall
@@ -44 +40 @@
 
 #ifndef NO_PNG
- #include <libpng10/png.h>
-#pragma comment(lib, "libpng10.lib")
+# include <libpng10/png.h>
+# ifdef _MSC_VER
+#  pragma comment(lib, "libpng10.lib")
+# endif
 #endif
 
@@ -470 +468 @@
 
 
-static void png_read_fn(png_struct* png_ptr, u8* data, png_size_t length)
+static void png_read_fn(png_struct* const png_ptr, u8* const data, const png_size_t length)
 {
     MemRange* const mr = (MemRange*)png_ptr->io_ptr;
@@ -478 +476 @@
     memcpy(data, mr->p, length);
     mr->p += length;
-    mr->size -= length; // > 0 due to test above
+    mr->size -= length; // >= 0 due to test above
 }
 
@@ -513 +511 @@
     }
 
-    u8** rows;
+    const u8** rows;
+        // freed in cleanup code; need scoping on VC6 due to goto
 
     {
@@ -525 +524 @@
     png_get_IHDR(png_ptr, info_ptr, &w, &h, &prec, &color_type, 0, 0, 0);
 
-    size_t pitch = png_get_rowbytes(png_ptr, info_ptr);
+    const size_t pitch = png_get_rowbytes(png_ptr, info_ptr);
 
     const u32 fmts[8] = { 0, ~0, GL_RGB, ~0, GL_LUMINANCE_ALPHA, ~0, GL_RGBA, ~0 };
@@ -543 +542 @@
 
     // allocate mem for image - rows point into buffer (sequential)
-    rows = (u8**)malloc((h+1)*sizeof(void*));
+    rows = (const u8**)malloc(h*sizeof(void*));
     if(!rows)
         goto fail;
-    size_t img_size = pitch * (h+1);
+    const size_t img_size = pitch * h;
     Handle img_hm;
-    u8* img = (u8*)mem_alloc(img_size, 64*KB, 0, &img_hm);
+    const u8* img = (const u8*)mem_alloc(img_size, 64*KB, 0, &img_hm);
     if(!img)
         goto fail;
-    u8* pos = img;
-    for(u32 i = 0; i < h+1; i++)
+    const u8* pos = img;
+    for(size_t i = 0; i < h; i++)
     {
         rows[i] = pos;
@@ -558 +557 @@
     }
 
-    png_read_image(png_ptr, rows);
+    png_read_image(png_ptr, (png_bytepp)rows);
 
     png_read_end(png_ptr, info_ptr);
-    
 
     mem_free_h(t->hm);

ps/trunk/source/lib/res/tex.h

@@ -20 +20 @@
 #define __TEX_H__
 
-#include "types.h"
 #include "h_mgr.h"
-#include "misc.h"
 
 // load and return a handle to the texture given in <fn>.
@@ -33 +31 @@
 extern int tex_info(Handle ht, int* w, int* h, int *fmt, int *bpp, void** p);
 
-extern int tex_filter;  // GL values; default: GL_LINEAR
-extern uint tex_bpp;    // 16 or 32; default: 32
+extern int tex_filter;          // GL values; default: GL_LINEAR
+extern unsigned int tex_bpp;    // 16 or 32; default: 32
 
 // upload the specified texture to OpenGL. Texture filter and internal format

ps/trunk/source/lib/res/vfs.cpp

@@ -21 +21 @@
 
 #include "lib.h"
-#include "file.h"
-#include "zip.h"
-#include "misc.h"
-#include "vfs.h"
-#include "mem.h"
+#include "res.h"
 #include "adts.h"
 
@@ -184 +180 @@
 // when opening a file (slow).
 //
-// one Loc is allocated for each archive or directory mounted.
-// therefore, files only /point/ to a (possibly shared) Loc.
+// one FileLoc is allocated for each archive or directory mounted.
+// therefore, files only /point/ to a (possibly shared) FileLoc.
 // if a file's location changes (e.g. after mounting a higher-priority
-// directory), the VFS entry will point to the new Loc; the priority
+// directory), the VFS entry will point to the new FileLoc; the priority
 // of both locations is unchanged.
 //
@@ -198 +194 @@
 
 // not many instances => don't worry about struct size / alignment.
-struct Loc
+struct FileLoc
 {
     Handle archive;
-
     std::string dir;
-
     uint pri;
 
-    Loc() {}
-    Loc(Handle _archive, const char* _dir, uint _pri)
+    FileLoc() {}
+    FileLoc(Handle _archive, const char* _dir, uint _pri)
         : archive(_archive), dir(_dir), pri(_pri) {}
 };
 
 
-struct TreeDir;
-
-typedef std::map<std::string, TreeDir*> SubDirs;
+// rationale for separate file / subdir containers:
+// problems:
+// - more code for insertion (oh well);
+// - makes ordered output of all dirents difficult
+//   (but dirs and files are usually displayed separately)
+// advantages:
+// - simplifies lookup code: it can just check if a path is there,
+//   no need to check if the entry is actually a directory
+// - storing Dir objects directly in the map means less
+//   memory allocations / no need to free them.
+//
+// *_add guard against a subdir and file of the same name.
+
+typedef std::map<const std::string, FileLoc*> Files;
+typedef Files::iterator FileIt;
+    // notes:
+    // - FileLoc is allocated and owned by caller (the mount code)
+    // - priority is accessed by following the FileLoc pointer.
+    //   keeping a copy in the map would lead to better cache coherency,
+    //   but it's a bit more clumsy (map filename to struct {pri, FileLoc*}).
+    //   revisit if file lookup open is too slow (unlikely).
+
+struct Dir;
+typedef std::pair<const std::string, Dir> SubDir;
+typedef std::map<const std::string, Dir> SubDirs;
 typedef SubDirs::iterator SubDirIt;
 
-typedef std::map<std::string, const Loc*> Files;
-typedef Files::iterator FileIt;
-    // note: priority is accessed by following the Loc pointer.
-    // keeping a copy in the map would lead to better cache coherency,
-    // but it's a bit more clumsy (map filename to struct {pri, Loc*}).
-    // revisit if file lookup open is too slow (unlikely).
-
-struct TreeDir
-{
-    std::string v_name;
-
-    void* watch;
-
-
-    int file_add(const char* const fn, const uint pri, const Loc* const loc)
-    {
-        std::string _fn(fn);
-
-        typedef std::pair<std::string, const Loc*> Ent;
-        Ent ent = std::make_pair(_fn, loc);
-        std::pair<FileIt, bool> ret;
-        ret = files.insert(ent);
-        // file already in dir
-        if(!ret.second)
-        {
-            FileIt it = ret.first;
-            const Loc*& old_loc = it->second;
-
-            // new Loc is of higher priority; replace pointer
-            if(old_loc->pri <= loc->pri)
-            {
-                old_loc = loc;
-                return 0;
-            }
-            // new Loc is of lower priority; keep old pointer
-            else
-                return 1;
-        }
-
+struct Dir
+{
+    int file_add(const char* name, const FileLoc* loc);
+    FileLoc* file_find(const char* name);
+
+    int subdir_add(const char* name);
+    Dir* subdir_find(const char* name);
+
+    void clearR();
+
+    SubDirs subdirs;
+    Files files;
+};
+
+
+int Dir::subdir_add(const char* const fn)
+{
+    if(file_find(fn) || subdir_find(fn))
+    {
+        debug_warn("dir_add: file or subdirectory of same name already exists");
+        return -1;
+    }
+
+    subdirs[fn];
+        // side effect: maps <fn> to a newly constructed Dir()
+        // non-const => cannot be optimized away.
+    return 0;
+}
+
+
+Dir* Dir::subdir_find(const char* const fn)
+{
+    SubDirIt it = subdirs.find(fn);
+    if(it == subdirs.end())
         return 0;
-    }
-
-    const Loc* file_find(const char* fn)
-    {
-        std::string _fn(fn);
-        FileIt it = files.find(_fn);
-        if(it == files.end())
-            return 0;
-        return it->second;
-    }
-
-    TreeDir* subdir_add(const char* name)
-    {
-        TreeDir* vdir = new TreeDir;
-        const std::string _name(name);
-        vdir->v_name = _name;
-
-        std::pair<std::string, TreeDir*> item = std::make_pair(_name, vdir);
-        std::pair<SubDirIt, bool> res;
-        res = subdirs.insert(item);
-        // already in container
-        if(!res.second)
-            debug_warn("already in subdir");
-
-        SubDirIt it = res.first;
-        return it->second;
-    }
-
-    TreeDir* subdir_find(const char* name)
-    {
-        const std::string _name(name);
-        SubDirIt it = subdirs.find(_name);
-        if(it == subdirs.end())
-            return 0;
-        return it->second;
-    }
-
-    void subdir_clear()
-    {
-        for(SubDirIt it = subdirs.begin(); it != subdirs.end(); ++it)
-            delete(it->second);
-        subdirs.clear();
-    }
-
-    friend void tree_clearR(TreeDir*);
-
-    SubDirs subdirs;    // can't make private; needed for iterator
-    Files files;
-
-
-private:;
-
-
-};
-
-
-static TreeDir vfs_root;
+    return &it->second;
+}
+
+
+int Dir::file_add(const char* const fn, const FileLoc* const loc)
+{
+    if(subdir_find(fn))
+    {
+        debug_warn("dir_add: file of same name already exists");
+        return -1;
+    }
+
+    // default pointer ctor sets it to 0 =>
+    // if fn wasn't already in the container, old_loc is 0.
+    const FileLoc*& old_loc = files[fn];
+    // old loc exists and is higher priority - keep it.
+    if(old_loc && old_loc->pri > loc->pri)
+        return 1;
+
+    old_loc = loc;
+    return 0;
+}
+
+
+FileLoc* Dir::file_find(const char* const fn)
+{
+    FileIt it = files.find(fn);
+    if(it == files.end())
+        return 0;
+    return it->second;
+}
+
+
+void Dir::clearR()
+{
+    SubDirIt it;
+    for(it = subdirs.begin(); it != subdirs.end(); ++it)
+    {
+        Dir& subdir = it->second;
+        subdir.clearR();
+    }
+
+    subdirs.clear();
+    files.clear();
+}
+
+
+
+
+static Dir vfs_root;
 
 
@@ -325 +329 @@
 // starts in VFS root directory (path = "").
 // path doesn't need to, and shouldn't, start with '/'.
-static int tree_lookup(const char* path, const Loc** const loc = 0, TreeDir** const dir = 0, LookupFlags flags = LF_DEFAULT)
+static int tree_lookup(const char* path, const FileLoc** const loc = 0, Dir** const dir = 0, LookupFlags flags = LF_DEFAULT)
 {
     CHECK_PATH(path);
@@ -338 +342 @@
     const bool create_missing_components = flags & LF_CREATE_MISSING_COMPONENTS;
 
-    TreeDir* cur_dir = &vfs_root;
-
+    Dir* cur_dir = &vfs_root;
+
+    // for each path component:
     for(;;)
     {
         char* slash = strchr(cur_component, '/');
-        // we have followed all path components.
-        // cur_component is the filename or ""
+        // done, cur_component is the filename or "" if <path> is a directory
         if(!slash)
-        {
-            // caller wants pointer to file location returned
-            if(loc)
-            {
-                const char* fn = cur_component;
-                *loc = cur_dir->file_find(fn);
-
-                // user wanted its loc, but it's not found - fail
-                if(!*loc)
-                    return ERR_FILE_NOT_FOUND;
-            }
-            // caller wants pointer to this dir returned
-            if(dir)
-                *dir = cur_dir;
-            return 0;
-        }
-        // cur_component is a subdirectory name; change to it
-        else
-        {
-            const char* subdir_name = cur_component;
-            *slash = 0;
-
-            TreeDir* subdir = cur_dir->subdir_find(subdir_name);
-            if(!subdir)
-            {
-                if(create_missing_components)
-                    subdir = cur_dir->subdir_add(subdir_name);
-                else
-                    return ERR_PATH_NOT_FOUND;
-            }
-
-            cur_dir = subdir;
-            cur_component = slash+1;
-        }
-    }
-}
-
-
-static void tree_clearR(TreeDir* const dir)
-{
-    SubDirIt it;
-    for(it = dir->subdirs.begin(); it != dir->subdirs.end(); ++it)
-    {
-        TreeDir* subdir = it->second;
-        tree_clearR(subdir);
-    }
-
-    dir->files.clear();
-    dir->subdir_clear();
+            break;
+        *slash = 0; // 0-terminate cur_component
+        const char* subdir_name = cur_component;
+
+        // create <subdir_name>
+        // (note: no-op if it already exists
+        if(create_missing_components)
+            cur_dir->subdir_add(subdir_name);
+
+        // switch to <subdir_name>
+        Dir* subdir = cur_dir->subdir_find(subdir_name);
+        if(!subdir)
+            return ERR_PATH_NOT_FOUND;
+
+        // next component
+        cur_dir = subdir;
+        cur_component = slash+1;
+    }
+
+    // we have followed all path components.
+
+    // caller wants pointer to file location returned
+    if(loc)
+    {
+        *loc = cur_dir->file_find(cur_component);
+        // .. but the file doesn't exist
+        if(!*loc)
+            return ERR_FILE_NOT_FOUND;
+    }
+    // caller wants pointer to this dir returned
+    if(dir)
+        *dir = cur_dir;
+    return 0;
 }
 
@@ -400 +388 @@
 static inline void tree_clear()
 {
-    tree_clearR(&vfs_root);
-}
+    vfs_root.clearR();
+}
+
+
 
 
 struct FileCBParams
 {
-    TreeDir* dir;
-    const Loc* loc;
+    Dir* const dir;
+    const FileLoc* loc;
 };
 
@@ -424 +414 @@
 {
     const FileCBParams* const params = (FileCBParams*)user;
-    TreeDir* const cur_dir      = params->dir;
-    const Loc* const cur_loc = params->loc;
+    Dir* const cur_dir = params->dir;
+    const FileLoc* const cur_loc = params->loc;
+
+    int err;
 
     // directory
     if(flags & LOC_DIR)
-        cur_dir->subdir_add(fn);
+        err = cur_dir->subdir_add(fn);
     // file
     else
-        CHECK_ERR(cur_dir->file_add(fn, cur_loc->pri, cur_loc));
-
-    return 0;
-}
-
-
-static int tree_add_dirR(TreeDir* const vdir, const char* const f_path, const Loc* const loc)
+        err = cur_dir->file_add(fn, cur_loc);
+
+    if(err < 0)
+        return -EEXIST;
+    return 0;
+}
+
+
+static int tree_add_dirR(Dir* const dir, const char* const f_path, const FileLoc* const loc)
 {
     CHECK_PATH(f_path);
 
-    // add watch
-    if(!vdir->watch)
-        vdir->watch = 0;
-
     // add files and subdirs to vdir
-    const FileCBParams params = { vdir, loc };
+    const FileCBParams params = { dir, loc };
     file_enum(f_path, add_dirent_cb, (uintptr_t)&params);
 
-    for(SubDirIt it = vdir->subdirs.begin(); it != vdir->subdirs.end(); ++it)
-    {
-        TreeDir* const vsubdir = it->second;
+    for(SubDirIt it = dir->subdirs.begin(); it != dir->subdirs.end(); ++it)
+    {
+        Dir* const subdir = &it->second;
+        const char* const subdir_name_c = (it->first).c_str();
 
         char f_subdir_path[VFS_MAX_PATH];
-        const char* const v_subdir_name_c = vsubdir->v_name.c_str();
-        CHECK_ERR(path_append(f_subdir_path, f_path, v_subdir_name_c));
-
-        tree_add_dirR(vsubdir, f_subdir_path, loc);
-    }
-
-    return 0;
-}
-
-
-static int tree_add_loc(TreeDir* const vdir, const Loc* const loc)
+        CHECK_ERR(path_append(f_subdir_path, f_path, subdir_name_c));
+
+        tree_add_dirR(subdir, f_subdir_path, loc);
+    }
+
+    return 0;
+}
+
+
+static int tree_add_loc(Dir* const dir, const FileLoc* const loc)
 {
     if(loc->archive > 0)
     {
-        FileCBParams params = { vdir, loc };
+        FileCBParams params = { dir, loc };
         return zip_enum(loc->archive, add_dirent_cb, (uintptr_t)&params);
     }
@@ -475 +465 @@
     {
         const char* f_path_c = loc->dir.c_str();
-        return tree_add_dirR(vdir, f_path_c, loc);
+        return tree_add_dirR(dir, f_path_c, loc);
     }
 }
@@ -490 +480 @@
 // (we keep and pass around pointers to Mount.archive_locs elements)
 // see below.
-typedef std::list<Loc> Locs;
+typedef std::list<FileLoc> Locs;
 typedef Locs::iterator LocIt;
 
@@ -506 +496 @@
 
     // storage for all Locs ensuing from this mounting.
-    // the VFS tree only holds pointers to Loc, which is why the
+    // the VFS tree only holds pointers to FileLoc, which is why the
     // Locs container must not invalidate its contents after adding,
     // and also why the VFS tree must be rebuilt after unmounting something.
-    Loc dir_loc;
+    FileLoc dir_loc;
     Locs archive_locs;
-        // if not is_single_archive, contains one Loc for every archive
+        // if not is_single_archive, contains one FileLoc for every archive
         // in the directory (but not its children - see remount()).
-        // otherwise, contains exactly one Loc for the single archive.
+        // otherwise, contains exactly one FileLoc for the single archive.
 
     // is f_name an archive filename? if not, it's a directory.
@@ -547 +537 @@
     uint pri;
 
-    // will add one Loc to this container for
+    // will add one FileLoc to this container for
     // every archive successfully opened.
     Locs* archive_locs;
@@ -574 +564 @@
     const Handle archive = zip_archive_open(f_path);
     if(archive > 0)
-        archive_locs->push_back(Loc(archive, "", pri));
+        archive_locs->push_back(FileLoc(archive, "", pri));
 
     // only add archive to list; don't add its files into the VFS yet,
@@ -593 +583 @@
     const char* const f_name = m.f_name.c_str();
     const uint pri           = m.pri;
-    Loc& dir_loc             = m.dir_loc;
+    FileLoc& dir_loc         = m.dir_loc;
     Locs& archive_locs       = m.archive_locs;
 
-    TreeDir* vdir;
-    CHECK_ERR(tree_lookup(v_path, 0, &vdir, LF_CREATE_MISSING_COMPONENTS));
+    Dir* dir;
+    CHECK_ERR(tree_lookup(v_path, 0, &dir, LF_CREATE_MISSING_COMPONENTS));
 
     // check if target is a single Zip archive
@@ -605 +595 @@
     {
         m.is_single_archive = true;
-        archive_locs.push_back(Loc(archive, "", pri));
-        const Loc* loc = &archive_locs.front();
-        return tree_add_loc(vdir, loc);
+        archive_locs.push_back(FileLoc(archive, "", pri));
+        const FileLoc* loc = &archive_locs.front();
+        return tree_add_loc(dir, loc);
     }
 
@@ -616 +606 @@
     for(LocIt it = archive_locs.begin(); it != archive_locs.end(); ++it)
     {
-        const Loc* const loc = &*it;
-        tree_add_loc(vdir, loc);
+        const FileLoc* const loc = &*it;
+        tree_add_loc(dir, loc);
     }
 
 
     dir_loc.dir = f_name;
-    err = tree_add_loc(vdir, &dir_loc);
+    err = tree_add_loc(dir, &dir_loc);
     if(err < 0)
         err = err;
@@ -634 +624 @@
     for(LocIt it = m.archive_locs.begin(); it != m.archive_locs.end(); ++it)
     {
-        Loc& loc = *it;
+        FileLoc& loc = *it;
         zip_archive_close(loc.archive);
     }
@@ -650 +640 @@
 
 
-static void cleanup(void)
+void vfs_shutdown(void)
 {
     tree_clear();
@@ -659 +649 @@
 int vfs_mount(const char* const vfs_mount_point, const char* const name, const uint pri)
 {
-    ONCE(atexit2(cleanup));
+    ONCE(atexit2(vfs_shutdown));
 
     // make sure it's not already mounted, i.e. in mounts
@@ -716 +706 @@
 ///////////////////////////////////////////////////////////////////////////////
 //
-//
+// directory
 //
 ///////////////////////////////////////////////////////////////////////////////
 
-// OLD
-// rationale for n-archives per PATH entry:
-// We need to be able to unmount specific paths (e.g. when switching mods).
-// Don't want to remount everything (slow), or specify a mod tag when mounting
-// (not this module's job). Instead, we include all archives in one path entry;
-// the game keeps track of what path(s) it mounted for a mod,
-// and unmounts those when needed.
-
 
 int vfs_realpath(const char* fn, char* full_path)
 {
-    const Loc* loc;
+    const FileLoc* loc;
     CHECK_ERR(tree_lookup(fn, &loc));
 
@@ -752 +734 @@
 int vfs_stat(const char* fn, struct stat* s)
 {
-    const Loc* loc;
+    const FileLoc* loc;
     CHECK_ERR(tree_lookup(fn, &loc));
 
@@ -767 +749 @@
 struct VDir
 {
-    TreeDir* dir;
-    FileIt it;
+    // we need to cache the complete contents of the directory:
+    // 
+    SubDirs* subdirs;
+    SubDirIt subdir_it;
+    Files* files;
+    FileIt file_it;
 };
 
 H_TYPE_DEFINE(VDir);
 
-
-
 static void VDir_init(VDir* vd, va_list args)
 {
@@ -781 +765 @@
 static void VDir_dtor(VDir* vd)
 {
-    // remove reference to TreeDir, unlock it for further use
+    delete vd->subdirs;
+    delete vd->files;
 }
 
@@ -787 +772 @@
 {
     // check if actually reloaded, and why it happened?
-    // hmm, if TreeDir changes while handle is open, we are screwed.
-    // need a lock.
-
-    CHECK_ERR(tree_lookup(path, 0, &vd->dir));
-
-    vd->it = vd->dir->files.begin();
+
+    Dir* dir;
+    CHECK_ERR(tree_lookup(path, 0, &dir));
+
+    vd->subdirs = new SubDirs(dir->subdirs);
+    vd->subdir_it = vd->subdirs->begin();
+    vd->files = new Files(dir->files);
+    vd->file_it = vd->files->begin();
     return 0;
 }
@@ -802 +789 @@
 }
 
+
 int vfs_close_dir(Handle& hd)
 {
@@ -807 +795 @@
 }
 
+
+// filter:
+// 0: any file
+// ".": file without extension (filename doesn't contain '.')
+// ".ext": file with extension <ext> (which must not contain '.')
+// "/": subdirectory
 int vfs_next_dirent(const Handle hd, vfsDirEnt* ent, const char* const filter)
 {
-    // make sure filter is valid
-    // interpret filter, decide if they want files or subdirs
-
-    // until no more entries, or one matches filter
+    H_DEREF(hd, VDir, vd);
+
+    // interpret filter
+    bool filter_dir = false;
+    bool filter_no_ext = false;
+    if(filter)
+    {
+        if(filter[0] == '/')
+        {
+            if(filter[1] != '\0')
+                goto invalid_filter;
+            filter_dir = true;
+        }
+        else if(filter[0] == '.')
+        {
+            if(strchr(filter+1, '.'))
+                goto invalid_filter;
+            filter_no_ext = filter[1] == '\0';
+        }
+        else
+            goto invalid_filter;
+    }
+
+    const char* fn;
+
+    // caller wants a subdirectory; return the next one.
+    if(filter_dir)
+    {
+        if(vd->subdir_it == vd->subdirs->end())
+            return -1;
+        fn = vd->subdir_it->first.c_str();
+        ++vd->subdir_it;
+        goto have_match;
+    }
+
+    // caller wants a file; loop until one matches or end of list.
     for(;;)
     {
-        H_DEREF(hd, VDir, vd);
-        if(vd->it == vd->dir->files.end())
-            return 1;
-
-        const std::string& fn_s = vd->it->first;
-        const char* const fn = fn_s.c_str();
-
-        if(filter)
-        {
-            char* ext = strrchr(fn, '.');
-            if(!ext || strcmp(ext, filter) != 0)
-                continue;
-        }
-
-        // found matching entry
-    }
+        if(vd->file_it == vd->files->end())
+            return -1;
+        fn = vd->file_it->first.c_str();
+        ++vd->file_it;
+
+        char* const ext = strrchr(fn, '.');
+        if(!filter || (filter_no_ext && !ext) || strcmp(ext, filter) == 0)
+            goto have_match;
+    }
+
+have_match:
+    ent->name = fn;
+    return 0;
+
+invalid_filter:
+    debug_warn("vfs_next_dirent: invalid filter");
+    return -1;
 }
 
@@ -928 +955 @@
 
 
-    const Loc* loc;
+    const FileLoc* loc;
     CHECK_ERR(tree_lookup(path, &loc));
 

ps/trunk/source/lib/sysdep/win/waio.cpp

@@ -23 +23 @@
 #include "lib.h"
 #include "win_internal.h"
-#include "misc.h"
-#include "types.h"
 
 

ps/trunk/source/lib/sysdep/win/wdetect.cpp

@@ -52 +52 @@
 // useful for choosing a video mode. not called by detect().
 // if we fail, outputs are unchanged (assumed initialized to defaults)
-int get_cur_resolution(int& xres, int& yres)
-{
-    DEVMODEA dm;
+int get_cur_vmode(int* xres, int* yres, int* bpp, int* freq)
+{
+    DEVMODEW dm;
     memset(&dm, 0, sizeof(dm));
     dm.dmSize = sizeof(dm);
     // dm.dmDriverExtra already set to 0 by memset
 
-    if(!EnumDisplaySettingsA(0, ENUM_CURRENT_SETTINGS, &dm))
-        return -1;
-
-    xres = dm.dmPelsWidth;
-    yres = dm.dmPelsHeight;
+    if(!EnumDisplaySettingsW(0, ENUM_CURRENT_SETTINGS, &dm))
+        return -1;
+
+    if(dm.dmFields & DM_PELSWIDTH && xres)
+        *xres = (int)dm.dmPelsWidth;
+    if(dm.dmFields & DM_PELSHEIGHT && yres)
+        *yres = (int)dm.dmPelsHeight;
+    if(dm.dmFields & DM_BITSPERPEL && bpp)
+        *bpp  = (int)dm.dmBitsPerPel;
+    if(dm.dmFields & DM_DISPLAYFREQUENCY && freq)
+        *freq = (int)dm.dmDisplayFrequency;
+
     return 0;
 }

ps/trunk/source/lib/sysdep/win/wposix.cpp

@@ -27 +27 @@
 #include "hrt.h"
 
+// waio included via lib -> posix -> wposix
+
+
+static HANDLE mk_handle(intptr_t i)
+{
+    // passing in -1 (e.g. if _get_osfhandle fails),
+    // is fine, it ends up INVALID_HANDLE_VALUE.
+    return (HANDLE)((char*)0 + i);
+}
+
 
 //////////////////////////////////////////////////////////////////////////////
@@ -68 +78 @@
 int close(int fd)
 {
+    assert(3 <= fd && fd < 256);
     aio_close(fd);
     return _close(fd);
@@ -75 +86 @@
 int ioctl(int fd, int op, int* data)
 {
-    HANDLE h = (HANDLE)((char*)0 + _get_osfhandle(fd));
+    const HANDLE h = mk_handle(_get_osfhandle(fd));
 
     switch(op)
@@ -213 +224 @@
 
 
-static HANDLE std_h[2] = { (HANDLE)(((char*)0) + 3), (HANDLE)(((char*)0) + 7) };
+static HANDLE std_h[2] = { (HANDLE)((char*)0 + 3), (HANDLE)((char*)0 + 7) };
 
 
@@ -275 +286 @@
     if(param)
     {
-        HANDLE hThread = (HANDLE)((char*)0 + thread);
+        const HANDLE hThread = mk_handle((intptr_t)thread);
         param->sched_priority = GetThreadPriority(hThread);
     }
@@ -287 +298 @@
         SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS);
 
-    HANDLE hThread = (HANDLE)((char*)0 + thread);
-
+    const HANDLE hThread = mk_handle((intptr_t)thread);
     SetThreadPriority(hThread, param->sched_priority);
     return 0;
@@ -389 +399 @@
     DWORD len_hi = (DWORD)((u64)len >> 32), len_lo = (DWORD)len & 0xffffffff;
 
-    HANDLE hFile = (HANDLE)((char*)0 + _get_osfhandle(fd));
+    HANDLE hFile = mk_handle(_get_osfhandle(fd));
     HANDLE hMap = CreateFileMapping(hFile, &sec, flProtect, len_hi, len_lo, 0);
 

ps/trunk/source/lib/sysdep/win/wposix.h

@@ -27 +27 @@
 
 #include <sys/types.h>
+#include <stddef.h>
 
 #ifdef __cplusplus
@@ -33 +34 @@
 
 
-#define IMP(ret, name, param) extern "C" __declspec(dllimport) ret __stdcall name param;
-
-// for functions actually implemented in the CRT
-#ifdef _DLL
-#define _CRTIMP __declspec(dllimport)
+//
+// <inttypes.h>
+//
+
+typedef char int8_t;
+typedef short int16_t;
+typedef int int32_t;
+#if defined(_MSC_VER) || defined(__INTEL_COMPILER) || defined(__LCC__)
+typedef __int64 int64_t;
+#elif defined(__GNUC__) || defined(__MWERKS__) || defined(__SUNPRO_C) || defined(__DMC__)
+typedef long long int64_t;
 #else
-#define _CRTIMP
+#error "port int64_t"
 #endif
 
-
-
-//
-// <inttypes.h>
-//
-
-typedef unsigned short u16_t;
+typedef unsigned char uint8_t;
+typedef unsigned short uint16_t;
+typedef unsigned int uint32_t;
+#if defined(_MSC_VER) || defined(__INTEL_COMPILER) || defined(__LCC__)
+typedef unsigned __int64 uint64_t;
+#elif defined(__GNUC__) || defined(__MWERKS__) || defined(__SUNPRO_C) || defined(__DMC__)
+typedef unsigned long long uint64_t;
+#else
+#error "port uint64_t"
+#endif
+
+#ifdef _MSC_VER
+# ifndef _UINTPTR_T_DEFINED
+#  define _UINTPTR_T_DEFINED
+#  define uintptr_t unsigned int
+# endif // _UINTPTR_T_DEFINED
+# ifndef _INTPTR_T_DEFINED
+#  define _INTPTR_T_DEFINED
+#  define intptr_t signed int
+# endif // _INTPTR_T_DEFINED
+#else   // _MSC_VER
+#include <stdint.h>
+#endif  // _MSC_VER
 
 
@@ -226 +249 @@
 extern long sysconf(int name);
 
-#ifndef _WINSOCKAPI_
-
-IMP(int, gethostname, (char* name, size_t namelen))
-
-#endif
 
 //

ps/trunk/source/lib/sysdep/win/wsdl.cpp

@@ -32 +32 @@
 #include "lib.h"
 #include "win_internal.h"
-#include "misc.h"
 
 #include <SDL_vkeys.h>

ps/trunk/source/lib/sysdep/win/wsock.cpp

@@ -47 +47 @@
 
 
-u16_t htons(u16_t s)
+uint16_t htons(uint16_t s)
 {
     return (s >> 8) | ((s & 0xff) << 8);

ps/trunk/source/lib/sysdep/win/wsock.h

@@ -2 +2 @@
 #define WSOCK_H__
 
+#define IMP(ret, name, param) extern "C" __declspec(dllimport) ret __stdcall name param;
+
+IMP(int, gethostname, (char* name, size_t namelen))
+
 
 //
@@ -10 +14 @@
 typedef unsigned short sa_family_t;
 
-//#ifndef _WINSOCKAPI_
-
 // Win32 values - do not change
-
 #define SOCK_STREAM 1
 #define SOCK_DGRAM 2
@@ -179 +180 @@
 //
 
-extern u16_t htons(u16_t hostshort);
+extern uint16_t htons(uint16_t hostshort);
 #define ntohs htons
 IMP(unsigned long, htonl, (unsigned long hostlong))
@@ -194 +195 @@
 IMP(ssize_t, sendto, (int, const void*, size_t, int, const struct sockaddr*, socklen_t))
 IMP(ssize_t, recvfrom, (int, void*, size_t, int, struct sockaddr*, socklen_t*))
- 
-//#endif /* _WINSOCKAPI_ */
-
+
+
+#undef IMP
 
 #endif  // #ifndef WSOCK_H__

ps/trunk/source/lib/sysdep/x.cpp

@@ -25 +25 @@
 // useful for choosing a video mode. not called by detect().
 // if we fail, outputs are unchanged (assumed initialized to defaults)
-int get_cur_resolution(int& xres, int& yres)
+int get_cur_vmode(int* xres, int* yres, int* bpp, int* freq)
 {
     Display* disp = XOpenDisplay(0);
@@ -32 +32 @@
 
     int screen = XDefaultScreen(disp);
-    xres = XDisplayWidth (disp, screen);
-    yres = XDisplayHeight(disp, screen);
+    if(xres)
+        *xres = XDisplayWidth (disp, screen);
+    if(yres)
+        *yres = XDisplayHeight(disp, screen);
+    if(bpp)
+        *bpp = 0;
+    if(freq)
+        *freq = 0;
     XCloseDisplay(disp);
     return 0;

ps/trunk/source/lib/timer.cpp

@@ -18 +18 @@
 #include "precompiled.h"
 
+#include "lib.h"
 #include "timer.h"
-#include "types.h"
-#include "misc.h"
-#include "lib.h"
 
 #ifdef _WIN32

ps/trunk/source/lib/types.h

@@ +1 @@
+// convenience type (shorter defs than stdint uintN_t)
+
 #ifndef __TYPES_H__
 #define __TYPES_H__
 
+#include "posix.h"
 
 // defines instead of typedefs so we can #undef conflicting decls
-
 
 #define ulong unsigned long
@@ -10 +12 @@
 #define uint unsigned int
 
-#define i8 signed char
-#define i16 short
-#define i32 long
+#define i8 int8_t
+#define i16 int16_t
+#define i32 int32_t
+#define i64 int64_t
 
-#define u8  unsigned char
-#define u16 unsigned short
-#define u32 unsigned long       // long to match Win32 DWORD
-
-#if defined(_MSC_VER) || defined(__INTEL_COMPILER) || defined(__LCC__)
-#define i64 __int64
-#define u64 unsigned __int64
-#elif defined(__GNUC__) || defined(__MWERKS__) || defined(__SUNPRO_C) || defined(__DMC__)
-#define i64 long long
-#define u64 unsigned long long
-#else
-#error "TODO: port u64"
-#endif
+#define u8  uint8_t
+#define u16 uint16_t
+#define u32 uint32_t
+#define u64 uint64_t
 
 
-#define int8 i8
-#define int16 i16
-#define int32 i32
-
-#include <stddef.h>
-#ifdef _MSC_VER
-# ifndef _UINTPTR_T_DEFINED
-#  define _UINTPTR_T_DEFINED
-#  define uintptr_t u32
-# endif // _UINTPTR_T_DEFINED
-# ifndef _INTPTR_T_DEFINED
-#  define _INTPTR_T_DEFINED
-#  define intptr_t i32
-# endif // _INTPTR_T_DEFINED
-#else   // !_MSC_VER
-# include <stdint.h>
-#endif  // _MSC_VER
-
+// the standard only guarantees 16 bits.
+// we use this for memory offsets and ranges, so it better be big enough.
+#if defined(SIZE_MAX) && SIZE_MAX < 32
+#error "check size_t and SIZE_MAX - too small?"
+#endif
+    
 
 #endif // #ifndef __TYPES_H__

ps/trunk/source/main.cpp

@@ -110 +110 @@
     fprintf(f, "%s\n", gfx_card);
     fprintf(f, "%s\n", gfx_drv_ver);
+    fprintf(f, "%dx%d:%d@%d\n", g_xres, g_yres, g_bpp, g_freq);
     // .. network name / ips
     char hostname[100]; // possibly nodename != hostname
     gethostname(hostname, sizeof(hostname));
     fprintf(f, "%s\n", hostname);
-    hostent* h = gethostbyname(hostname);
-    if(h)
-    {
-        struct in_addr** ips = (struct in_addr**)h->h_addr_list;
+    hostent* host = gethostbyname(hostname);
+    if(host)
+    {
+        struct in_addr** ips = (struct in_addr**)host->h_addr_list;
         for(int i = 0; ips && ips[i]; i++)
             fprintf(f, "%s ", inet_ntoa(*ips[i]));
@@ -229 +230 @@
 
 //////////////////////////////////////////////////////////////////////////////////////////////////
-// SubmitModelRecursive: recurse down given model, submitting it and all it's descendents to the 
+// SubmitModelRecursive: recurse down given model, submitting it and all its descendents to the 
 // renderer
 void SubmitModelRecursive(CModel* model)
@@ -434 +435 @@
 #endif
 
+
     detect();
 
@@ -477 +479 @@
     // preferred video mode = current desktop settings
     // (command line params may override these)
-    get_cur_resolution(g_xres, g_yres);
+    get_cur_vmode(&g_xres, &g_yres, &g_bpp, &g_freq);
 
     for(int a = 1; a < argc; a++)
@@ -514 +516 @@
     vfs_mount("", "mods/official/", 0);
 ////    dir_add_watch("mods\\official", false);
-
-
-//Handle xx = tex_load("art/textures/skins/structural/null.png");
 
 #ifndef NO_GUI
@@ -640 +639 @@
     }
 
-    // TODO MT: Move this to atexit() code? Capture original gamma ramp at initialization and restore it?
-
-    SDL_SetGamma( 1.0f, 1.0f, 1.0f );
-
 #ifndef NO_GUI
     g_GUI.Destroy();
@@ -666 +661 @@
     delete CRenderer::GetSingletonPtr();
 
+    exit(0);
     return 0;
 }

ps/trunk/source/ps/Config.h

@@ -48 +48 @@
 //--------------------------------------------------------
 
-#include "stdlib.h"
+#include <stdlib.h>
+
 #include "Prometheus.h"
 #include "Singleton.h"
 #include "CStr.h"
 #include "LogFile.h"
-#include "posix.h"
-#include "misc.h"
+#include "lib.h"
 
 #include <vector>

ps/trunk/source/ps/Overlay.cpp

@@ -50 +50 @@
 }
 
-CRect::CRect(const int32 &_l, const int32 &_t, const int32 &_r, const int32 &_b) : 
+CRect::CRect(const int32_t &_l, const int32_t &_t, const int32_t &_r, const int32_t &_b) : 
     left(_l), top(_t), right(_r), bottom(_b) 
 {
@@ -181 +181 @@
 }
 
-int32 CRect::GetWidth() const 
+int32_t CRect::GetWidth() const 
 {
     return right-left;
 }
 
-int32 CRect::GetHeight() const
+int32_t CRect::GetHeight() const
 {
     return bottom-top;
@@ -225 +225 @@
 }
 
-CPos::CPos(const int32 &_x, const int32 &_y) : x(_x), y(_y)
+CPos::CPos(const int32_t &_x, const int32_t &_y) : x(_x), y(_y)
 {
 }
@@ -326 +326 @@
 }
 
-CSize::CSize(const int32 &_cx, const int32 &_cy) : cx(_cx), cy(_cy)
+CSize::CSize(const int32_t &_cx, const int32_t &_cy) : cx(_cx), cy(_cy)
 {
 }

ps/trunk/source/ps/Overlay.h

@@ -13 +13 @@
 #define COVERLAY_H
 
-#include "types.h"
+#include "lib.h"
 
 struct CColor
@@ -61 +61 @@
     CRect(const CPos &upperleft, const CPos &bottomright);
     CRect(const CPos &pos, const CSize &size);
-    CRect(const int32 &_l, const int32 &_t, const int32 &_r, const int32 &_b);
+    CRect(const int32_t &_l, const int32_t &_t, const int32_t &_r, const int32_t &_b);
 
     // Operators
@@ -87 +87 @@
      * @return Width of Rectangle
      */
-    int32 GetWidth() const;
+    int32_t GetWidth() const;
     
     /**
      * @return Height of Rectangle
      */
-    int32 GetHeight() const;
+    int32_t GetHeight() const;
 
     /**
@@ -129 +129 @@
      * Dimensions
      */
-    int32 left, top, right, bottom;
+    int32_t left, top, right, bottom;
 };
 
@@ -143 +143 @@
 public:
     CPos();
-    CPos(const int32 &_x, const int32 &_y);
+    CPos(const int32_t &_x, const int32_t &_y);
 
     // Operators
@@ -166 +166 @@
      * Position
      */
-    int32 x, y;
+    int32_t x, y;
 };
 
@@ -184 +184 @@
     CSize(const CRect &rect);
     CSize(const CPos &pos);
-    CSize(const int32 &_cx, const int32 &_cy);
+    CSize(const int32_t &_cx, const int32_t &_cy);
 
     // Operators
@@ -207 +207 @@
      * Size
      */
-    int32 cx, cy;
+    int32_t cx, cy;
 };
 

ps/trunk/source/ps/Singleton.h

@@ -21 +21 @@
 
 #include <assert.h>
-#include "types.h"  // uintptr_t - not otherwise defined by VC6
+#include "lib.h"
 
 

ps/trunk/source/ps/ThreadUtil.h

@@ -67 +67 @@
 //--------------------------------------------------------
 
-#include "posix.h"
-#include "misc.h"
+#include "lib.h"
+
 #ifdef DEBUG_LOCKS
 

ps/trunk/source/renderer/PatchRData.cpp

@@ -1 @@
-#pragma warning(disable:4786)
+#include "precompiled.h"
 
 #include <assert.h>

ps/trunk/source/simulation/EntityProperties.cpp

@@ -50 +50 @@
 }
 
-CGenericProperty& CGenericProperty::operator=( int32 value )
+CGenericProperty& CGenericProperty::operator=( int32_t value )
 {
     if( m_type & PROP_TYPELOCKED )

ps/trunk/source/terrain/terrainMain.cpp

@@ -42 +42 @@
 void terr_init()
 {
-    int xres,yres;
-    get_cur_resolution(xres,yres);
-    g_Renderer.Open(xres,yres,32);
+    g_Renderer.Open(g_xres,g_yres,g_bpp);
 
     SViewPort vp;
     vp.m_X=0;
     vp.m_Y=0;
-    vp.m_Width=xres;
-    vp.m_Height=yres;
+    vp.m_Width=g_xres;
+    vp.m_Height=g_yres;
     g_Camera.SetViewPort(&vp);