Added win32 version of glob to allow windows clients the ability to do unix like folder traversal

mk/windoze/shared_lib.vcproj

@@ -416,6 +416,10 @@
 						RelativePath="..\..\source\shared_lib\sources\platform\win32\factory_repository.cpp"
 						>
 					</File>
+					<File
+						RelativePath="..\..\source\shared_lib\sources\platform\win32\glob.c"
+						>
+					</File>
 					<File
 						RelativePath="..\..\source\shared_lib\sources\platform\win32\platform_util.cpp"
 						>
@@ -730,6 +734,10 @@
 				<Filter
 					Name="win32"
 					>
+					<File
+						RelativePath="..\..\source\shared_lib\include\platform\win32\glob.h"
+						>
+					</File>
 					<File
 						RelativePath="..\..\source\shared_lib\include\platform\win32\platform_definitions.h"
 						>

source/shared_lib/include/platform/win32/glob.h

@@ -0,0 +1,166 @@
+/* /////////////////////////////////////////////////////////////////////////
+ * File:    glob.h
+ *
+ * Purpose: Declaration of the glob() API functions and types for the
+ *          Win32 platform.
+ *
+ * Created: 13th November 2002
+ * Updated: 5th February 2010
+ *
+ * Home:    http://synesis.com.au/software/
+ *
+ * Copyright (c) 2002-2010, Matthew Wilson and Synesis Software
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ * - Neither the names of Matthew Wilson and Synesis Software nor the names of
+ *   any contributors may be used to endorse or promote products derived from
+ *   this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ////////////////////////////////////////////////////////////////////// */
+
+
+/** \file glob.h
+ *
+ * Contains the declarations for the glob() API.
+ */
+
+#ifndef SYNSOFT_UNIXEM_INCL_H_GLOB
+#define SYNSOFT_UNIXEM_INCL_H_GLOB
+
+/* ////////////////////////////////////////////////////////////////////// */
+
+/** \weakgroup unixem Synesis Software UNIX Emulation for Win32
+ * \brief The UNIX emulation library
+ */
+
+/** \weakgroup unixem_glob glob() API
+ * \ingroup UNIXem unixem
+ * \brief This API provides facilities for enumerating the file-system contents
+ * @{
+ */
+
+/* ////////////////////////////////////////////////////////////////////// */
+
+#ifndef _WIN32
+# error This file is only currently defined for compilation on Win32 systems
+#endif /* _WIN32 */
+
+/* /////////////////////////////////////////////////////////////////////////
+ * Constants and definitions
+ */
+
+/* Error codes */
+#define GLOB_NOSPACE    (1)             /*!< \brief (Error result code:) An attempt to allocate memory failed, or if errno was 0 GLOB_LIMIT was specified in the flags and ARG_MAX patterns were matched. */
+#define GLOB_ABORTED    (2)             /*!< \brief (Error result code:) The scan was stopped because an error was encountered and either GLOB_ERR was set or (*errfunc)() returned non-zero. */
+#define GLOB_NOMATCH    (3)             /*!< \brief (Error result code:) The pattern does not match any existing pathname, and GLOB_NOCHECK was not set int flags. */
+#define GLOB_NOSYS      (4)             /*!< \brief (Error result code:) . */
+#define GLOB_ABEND      GLOB_ABORTED    /*!< \brief (Error result code:) . */
+
+/* Flags */
+#define GLOB_ERR            0x00000001  /*!< \brief Return on read errors. */
+#define GLOB_MARK           0x00000002  /*!< \brief Append a slash to each name. */
+#define GLOB_NOSORT         0x00000004  /*!< \brief Don't sort the names. */
+#define GLOB_DOOFFS         0x00000008  /*!< \brief Insert PGLOB->gl_offs NULLs. Supported from version 1.6 of UNIXem. */
+#define GLOB_NOCHECK        0x00000010  /*!< \brief If nothing matches, return the pattern. Supported from version 1.6 of UNIXem. */
+#define GLOB_APPEND         0x00000020  /*!< \brief Append to results of a previous call. Not currently supported in this implementation. */
+#define GLOB_NOESCAPE       0x00000040  /*!< \brief Backslashes don't quote metacharacters. Has no effect in this implementation, since escaping is not supported. */
+
+#define GLOB_PERIOD         0x00000080  /*!< \brief Leading `.' can be matched by metachars. Supported from version 1.6 of UNIXem. */
+#define GLOB_MAGCHAR        0x00000100  /*!< \brief Set in gl_flags if any metachars seen. Supported from version 1.6 of UNIXem. */
+/* #define GLOB_ALTDIRFUNC     0x00000200 */  /*!< \brief Use gl_opendir et al functions. Not currently supported in this implementation. */
+/* #define GLOB_BRACE          0x00000400 */  /*!< \brief Expand "{a,b}" to "a" "b". Not currently supported in this implementation. */
+#define GLOB_NOMAGIC        0x00000800  /*!< \brief If no magic chars, return the pattern. Supported from version 1.6 of UNIXem. */
+#define GLOB_TILDE          0x00001000  /*!< \brief Expand ~user and ~ to home directories. Partially supported from version 1.6 of UNIXem: leading ~ is expanded to %HOMEDRIVE%%HOMEPATH%. */
+#define GLOB_ONLYDIR        0x00002000  /*!< \brief Match only directories. This implementation guarantees to only return directories when this flag is specified. */
+#define GLOB_TILDE_CHECK    0x00004000  /*!< \brief Like GLOB_TILDE but return an GLOB_NOMATCH even if GLOB_NOCHECK specified. Supported from version 1.6 of UNIXem. */
+#define GLOB_ONLYFILE       0x00008000  /*!< \brief Match only files. Supported from version 1.6 of UNIXem. */
+#define GLOB_NODOTSDIRS     0x00010000  /*!< \brief Elide "." and ".." directories from wildcard searches. Supported from version 1.6 of UNIXem. */
+#define GLOB_LIMIT          0x00020000  /*!< \brief Limits the search to the number specified by the caller in gl_matchc. Supported from version 1.6 of UNIXem. */
+
+/* /////////////////////////////////////////////////////////////////////////
+ * Typedefs
+ */
+
+/** \brief Result structure for glob()
+ *
+ * This structure is used by glob() to return the results of the search.
+ */
+typedef struct
+{
+  int   gl_pathc;   /*!< count of total paths so far */
+  int   gl_matchc;  /*!< count of paths matching pattern */
+  int   gl_offs;    /*!< reserved at beginning of gl_pathv */
+  int   gl_flags;   /*!< returned flags */
+  char  **gl_pathv; /*!< list of paths matching pattern */
+} glob_t;
+
+/* /////////////////////////////////////////////////////////////////////////
+ * API functions
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/** \brief Generates pathnames matching a pattern
+ *
+ * This function is a pathname generator that implements the rules for
+ * file name pattern matching used by the UNIX shell.
+ *
+ * \param pattern The pattern controlling the search
+ * \param flags A combination of the <b>GLOB_*</b> flags
+ * \param errfunc A function that is called each time part of the search processing fails
+ * \param pglob Pointer to a glob_t structure to receive the search results
+ * \return 0 on success, otherwise one of the <b>GLOB_*</b> error codes
+ */
+int glob( char const  *pattern
+        , int         flags
+#if defined(__COMO__)
+        , int       (*errfunc)(char const *, int)
+#else /* ? compiler */
+        , const int (*errfunc)(char const *, int)
+#endif /* compiler */
+        , glob_t      *pglob);
+
+/** \brief Frees the results of a call to glob
+ *
+ * This function releases any memory allocated in a call to glob. It must
+ * always be called for a successful call to glob.
+ *
+ * \param pglob Pointer to a glob_t structure to receive the search results
+ */
+void globfree(glob_t *pglob);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+/* ////////////////////////////////////////////////////////////////////// */
+
+/** @} // end of group unixem_glob */
+
+/* ////////////////////////////////////////////////////////////////////// */
+
+#endif /* SYNSOFT_UNIXEM_INCL_H_GLOB */
+
+/* ///////////////////////////// end of file //////////////////////////// */

source/shared_lib/sources/platform/win32/glob.c

@@ -0,0 +1,455 @@
+/* /////////////////////////////////////////////////////////////////////////
+ * File:    glob.c
+ *
+ * Purpose: Definition of the glob() API functions for the Win32 platform.
+ *
+ * Created: 13th November 2002
+ * Updated: 6th February 2010
+ *
+ * Home:    http://synesis.com.au/software/
+ *
+ * Copyright (c) 2002-2010, Matthew Wilson and Synesis Software
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer. 
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ * - Neither the names of Matthew Wilson and Synesis Software nor the names of
+ *   any contributors may be used to endorse or promote products derived from
+ *   this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ////////////////////////////////////////////////////////////////////// */
+
+/* /////////////////////////////////////////////////////////////////////////
+ * Includes
+ */
+
+#include <glob.h>
+#include <assert.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <windows.h>
+
+#define NUM_ELEMENTS(ar)      (sizeof(ar) / sizeof(ar[0]))
+
+/* /////////////////////////////////////////////////////////////////////////
+ * Helper functions
+ */
+
+static char const *strrpbrk(char const *string, char const *strCharSet)
+{
+    char        *part   =   NULL;
+    char const  *pch;
+
+    for(pch = strCharSet; *pch; ++pch)
+    {
+        char    *p  =   strrchr(string, *pch);
+
+        if(NULL != p)
+        {
+            if(NULL == part)
+            {
+                part = p;
+            }
+            else
+            {
+                if(part < p)
+                {
+                    part = p;
+                }
+            }
+        }
+    }
+
+    return part;
+}
+
+/* /////////////////////////////////////////////////////////////////////////
+ * API functions
+ */
+
+/* It gives you back the matched contents of your pattern, so for Win32, the
+ * directories must be included
+ */
+
+int glob(   char const  *pattern
+        ,   int         flags
+#if defined(__COMO__)
+        , int         (*errfunc)(char const *, int)
+#else /* ? compiler */
+        , const int   (*errfunc)(char const *, int)
+#endif /* compiler */
+        ,   glob_t      *pglob)
+{
+    int                 result;
+    char                szRelative[1 + _MAX_PATH];
+    char const          *file_part;
+    WIN32_FIND_DATAA    find_data;
+    HANDLE              hFind;
+    char                *buffer;
+    char                szPattern2[1 + _MAX_PATH];
+    char                szPattern3[1 + _MAX_PATH];
+    char const          *effectivePattern   =   pattern;
+    char const          *leafMost;
+    const int           bMagic              =   (NULL != strpbrk(pattern, "?*"));
+    int                 bNoMagic            =   0;
+    int                 bMagic0;
+    size_t              maxMatches          =   ~(size_t)(0);
+
+    assert(NULL != pglob);
+
+    if(flags & GLOB_NOMAGIC)
+    {
+        bNoMagic = !bMagic;
+    }
+
+    if(flags & GLOB_LIMIT)
+    {
+        maxMatches = (size_t)pglob->gl_matchc;
+    }
+
+    if(flags & GLOB_TILDE)
+    {
+        /* Check that begins with "~/" */
+        if( '~' == pattern[0] &&
+            (   '\0' == pattern[1] ||
+                '/' == pattern[1] ||
+                '\\' == pattern[1]))
+        {
+            DWORD   dw;
+
+            (void)lstrcpyA(&szPattern2[0], "%HOMEDRIVE%%HOMEPATH%");
+
+            dw = ExpandEnvironmentStringsA(&szPattern2[0], &szPattern3[0], NUM_ELEMENTS(szPattern3) - 1);
+
+            if(0 != dw)
+            {
+                (void)lstrcpynA(&szPattern3[0] + dw - 1, &pattern[1], (int)(NUM_ELEMENTS(szPattern3) - dw));
+                szPattern3[NUM_ELEMENTS(szPattern3) - 1] = '\0';
+
+                effectivePattern = szPattern3;
+            }
+        }
+    }
+
+    file_part = strrpbrk(effectivePattern, "\\/");
+
+    if(NULL != file_part)
+    {
+        leafMost = ++file_part;
+
+        (void)lstrcpyA(szRelative, effectivePattern);
+        szRelative[file_part - effectivePattern] = '\0';
+    }
+    else
+    {
+        szRelative[0] = '\0';
+        leafMost = effectivePattern;
+    }
+
+    bMagic0 =   (leafMost == strpbrk(leafMost, "?*"));
+
+    hFind   =   FindFirstFileA(effectivePattern, &find_data);
+    buffer  =   NULL;
+
+    pglob->gl_pathc = 0;
+    pglob->gl_pathv = NULL;
+
+    if(0 == (flags & GLOB_DOOFFS))
+    {
+        pglob->gl_offs = 0;
+    }
+
+    if(hFind == INVALID_HANDLE_VALUE)
+    {
+        /* If this was a pattern search, and the
+         * directory exists, then we return 0
+         * matches, rather than GLOB_NOMATCH
+         */
+        if( bMagic &&
+            NULL != file_part)
+        {
+            result = 0;
+        }
+        else
+        {
+            if(NULL != errfunc)
+            {
+                (void)errfunc(effectivePattern, (int)GetLastError());
+            }
+
+            result = GLOB_NOMATCH;
+        }
+    }
+    else
+    {
+        int     cbCurr      =   0;
+        size_t  cbAlloc     =   0;
+        size_t  cMatches    =   0;
+
+        result = 0;
+
+        do
+        {
+            int     cch;
+            size_t  new_cbAlloc;
+
+            if( bMagic0 &&
+                0 == (flags & GLOB_PERIOD))
+            {
+                if('.' == find_data.cFileName[0])
+                {
+                    continue;
+                }
+            }
+
+            if(find_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
+            {
+#ifdef GLOB_ONLYFILE
+                if(flags & GLOB_ONLYFILE)
+                {
+                    continue;
+                }
+#endif /* GLOB_ONLYFILE */
+
+                if( bMagic0 &&
+                    GLOB_NODOTSDIRS == (flags & GLOB_NODOTSDIRS))
+                {
+                    /* Pattern must begin with '.' to match either dots directory */
+                    if( 0 == lstrcmpA(".", find_data.cFileName) ||
+                        0 == lstrcmpA("..", find_data.cFileName))
+                    {
+                        continue;
+                    }
+                }
+
+                if(flags & GLOB_MARK)
+                {
+#if 0
+                    if(find_data.cFileName[0] >= 'A' && find_data.cFileName[0] <= 'M')
+#endif /* 0 */
+                    (void)lstrcatA(find_data.cFileName, "/");
+                }
+            }
+            else
+            {
+                if(flags & GLOB_ONLYDIR)
+                {
+                    /* Skip all further actions, and get the next entry */
+#if 0
+                    if(find_data.cFileName[0] >= 'A' && find_data.cFileName[0] <= 'M')
+#endif /* 0 */
+                    continue;
+                }
+            }
+
+            cch = lstrlenA(find_data.cFileName);
+            if(NULL != file_part)
+            {
+                cch += (int)(file_part - effectivePattern);
+            }
+
+            new_cbAlloc = (size_t)cbCurr + cch + 1;
+            if(new_cbAlloc > cbAlloc)
+            {
+                char    *new_buffer;
+
+                new_cbAlloc *= 2;
+
+                new_cbAlloc = (new_cbAlloc + 31) & ~(31);
+
+                new_buffer  = (char*)realloc(buffer, new_cbAlloc);
+
+                if(new_buffer == NULL)
+                {
+                    result = GLOB_NOSPACE;
+                    free(buffer);
+                    buffer = NULL;
+                    break;
+                }
+
+                buffer = new_buffer;
+                cbAlloc = new_cbAlloc;
+            }
+
+            (void)lstrcpynA(buffer + cbCurr, szRelative, 1 + (int)(file_part - effectivePattern));
+            (void)lstrcatA(buffer + cbCurr, find_data.cFileName);
+            cbCurr += cch + 1;
+
+            ++cMatches;
+        }
+        while(FindNextFile(hFind, &find_data) && cMatches != maxMatches);
+
+        (void)FindClose(hFind);
+
+        if(result == 0)
+        {
+            /* Now expand the buffer, to fit in all the pointers. */
+            size_t  cbPointers  =   (1 + cMatches + pglob->gl_offs) * sizeof(char*);
+            char    *new_buffer =   (char*)realloc(buffer, cbAlloc + cbPointers);
+
+            if(new_buffer == NULL)
+            {
+                result = GLOB_NOSPACE;
+                free(buffer);
+            }
+            else
+            {
+                char    **pp;
+                char    **begin;
+                char    **end;
+                char    *next_str;
+
+                buffer = new_buffer;
+
+                (void)memmove(new_buffer + cbPointers, new_buffer, cbAlloc);
+
+                /* Handle the offsets. */
+                begin =   (char**)new_buffer;
+                end   =   begin + pglob->gl_offs;
+
+                for(; begin != end; ++begin)
+                {
+                    *begin = NULL;
+                }
+
+                /* Sort, or no sort. */
+                pp    =   (char**)new_buffer + pglob->gl_offs;
+                begin =   pp;
+                end   =   begin + cMatches;
+
+                if(flags & GLOB_NOSORT)
+                {
+                    /* The way we need in order to test the removal of dots in the findfile_sequence. */
+                    *end = NULL;
+                    for(begin = pp, next_str = buffer + cbPointers; begin != end; --end)
+                    {
+                        *(end - 1) = next_str;
+
+                        /* Find the next string. */
+                        next_str += 1 + lstrlenA(next_str);
+                    }
+                }
+                else
+                {
+                    /* The normal way. */
+                    for(begin = pp, next_str = buffer + cbPointers; begin != end; ++begin)
+                    {
+                        *begin = next_str;
+
+                        /* Find the next string. */
+                        next_str += 1 + lstrlenA(next_str);
+                    }
+                    *begin = NULL;
+                }
+
+                /* Return results to caller. */
+                pglob->gl_pathc =   (int)cMatches;
+                pglob->gl_matchc=   (int)cMatches;
+                pglob->gl_flags =   0;
+                if(bMagic)
+                {
+                    pglob->gl_flags |= GLOB_MAGCHAR;
+                }
+                pglob->gl_pathv =   (char**)new_buffer;
+            }
+        }
+
+        if(0 == cMatches)
+        {
+            result = GLOB_NOMATCH;
+        }
+    }
+
+    if(GLOB_NOMATCH == result)
+    {
+        if( (flags & GLOB_TILDE_CHECK) &&
+            effectivePattern == szPattern3)
+        {
+            result = GLOB_NOMATCH;
+        }
+        else if(bNoMagic ||
+                (flags & GLOB_NOCHECK))
+        {
+            const size_t    effPattLen  =   strlen(effectivePattern);
+            const size_t    cbNeeded    =   ((2 + pglob->gl_offs) * sizeof(char*)) + (1 + effPattLen);
+            char            **pp        =   (char**)realloc(buffer, cbNeeded);
+
+            if(NULL == pp)
+            {
+                result = GLOB_NOSPACE;
+                free(buffer);
+            }
+            else
+            {
+                /* Handle the offsets. */
+                char**  begin   =   pp;
+                char**  end     =   pp + pglob->gl_offs;
+                char*   dest    =   (char*)(pp + 2 + pglob->gl_offs);
+
+                for(; begin != end; ++begin)
+                {
+                    *begin = NULL;
+                }
+
+                /* Synthesise the pattern result. */
+#ifdef UNIXEM_USING_SAFE_STR_FUNCTIONS
+                pp[0 + pglob->gl_offs]  =   (strcpy_s(dest, effPattLen + 1, effectivePattern), dest);
+#else /* ? UNIXEM_USING_SAFE_STR_FUNCTIONS */
+                pp[0 + pglob->gl_offs]  =   strcpy(dest, effectivePattern);
+#endif /* UNIXEM_USING_SAFE_STR_FUNCTIONS */
+                pp[1 + pglob->gl_offs]  =   NULL;
+
+                /* Return results to caller. */
+                pglob->gl_pathc =   1;
+                pglob->gl_matchc=   1;
+                pglob->gl_flags =   0;
+                if(bMagic)
+                {
+                    pglob->gl_flags |= GLOB_MAGCHAR;
+                }
+                pglob->gl_pathv =   pp;
+
+                result = 0;
+            }
+        }
+    }
+    else if(0 == result)
+    {
+        if((size_t)pglob->gl_matchc == maxMatches)
+        {
+            result = GLOB_NOSPACE;
+        }
+    }
+
+    return result;
+}
+
+void globfree(glob_t *pglob)
+{
+    if(pglob != NULL)
+    {
+        free(pglob->gl_pathv);
+        pglob->gl_pathc = 0;
+        pglob->gl_pathv = NULL;
+    }
+}
+
+/* ///////////////////////////// end of file //////////////////////////// */

source/shared_lib/sources/platform/win32/platform_util.cpp

@@ -29,6 +29,8 @@
 #include "sdl_private.h"
 #include "window.h"
 #include "noimpl.h"
+#include <string.h>
+#include <glob.h>
 
 #include "leak_dumper.h"
 
@@ -214,8 +216,8 @@ void Tokenize(const string& str,vector<string>& tokens,const string& delimiters)
 
 void findDirs(const vector<string> &paths, vector<string> &results, bool errorOnNotFound) {
     results.clear();
-    int pathCount = paths.size();
+    size_t pathCount = paths.size();
-    for(int idx = 0; idx < pathCount; idx++) {
+    for(unsigned int idx = 0; idx < pathCount; idx++) {
         string path = paths[idx] + "/*.";
         vector<string> current_results;
         findAll(path, current_results, false, errorOnNotFound);
@@ -237,8 +239,8 @@ void findDirs(const vector<string> &paths, vector<string> &results, bool errorOn
 
 void findAll(const vector<string> &paths, const string &fileFilter, vector<string> &results, bool cutExtension, bool errorOnNotFound) {
     results.clear();
-    int pathCount = paths.size();
+    size_t pathCount = paths.size();
-    for(int idx = 0; idx < pathCount; idx++) {
+    for(unsigned int idx = 0; idx < pathCount; idx++) {
         string path = paths[idx] + "/" + fileFilter;
         vector<string> current_results;
         findAll(path, current_results, cutExtension, errorOnNotFound);
@@ -332,8 +334,8 @@ bool EndsWith(const string &str, const string& key)
 //finds all filenames like path and gets their checksum of all files combined
 int32 getFolderTreeContentsCheckSumRecursively(vector<string> paths, string pathSearchString, const string filterFileExt, Checksum *recursiveChecksum) {
 	Checksum checksum = (recursiveChecksum == NULL ? Checksum() : *recursiveChecksum);
-	int count = paths.size();
+	size_t count = paths.size();
-	for(int idx = 0; idx < count; ++idx) {
+	for(unsigned int idx = 0; idx < count; ++idx) {
 		string path = paths[idx] + pathSearchString;
 		getFolderTreeContentsCheckSumRecursively(path, filterFileExt, &checksum);
 	}
@@ -348,14 +350,15 @@ int32 getFolderTreeContentsCheckSumRecursively(vector<string> paths, string path
 //finds all filenames like path and gets their checksum of all files combined
 int32 getFolderTreeContentsCheckSumRecursively(const string &path, const string &filterFileExt, Checksum *recursiveChecksum) {
 
+
     Checksum checksum = (recursiveChecksum == NULL ? Checksum() : *recursiveChecksum);
 
-/* MV - PORT THIS to win32
+    SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s] scanning [%s] starting checksum = %d\n",__FILE__,__FUNCTION__,path.c_str(),checksum.getSum());
-
-    //SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s] scanning [%s]\n",__FILE__,__FUNCTION__,path.c_str());
 
 	std::string mypath = path;
-	// Stupid win32 is searching for all files without extension when *. is specified as wildcard
+	/** Stupid win32 is searching for all files without extension when *. is
+	 * specified as wildcard
+	 */
 	if(mypath.compare(mypath.size() - 2, 2, "*.") == 0) {
 		mypath = mypath.substr(0, mypath.size() - 2);
 		mypath += "*";
@@ -372,14 +375,16 @@ int32 getFolderTreeContentsCheckSumRecursively(const string &path, const string
 
 	for(size_t i = 0; i < globbuf.gl_pathc; ++i) {
 		const char* p = globbuf.gl_pathv[i];
-		//
+		/*
-		//const char* begin = p;
+		const char* begin = p;
-		//for( ; *p != 0; ++p) {
+		for( ; *p != 0; ++p) {
-		//	// strip the path component
+			// strip the path component
-		//	if(*p == '/')
+			if(*p == '/')
-		//		begin = p+1;
+				begin = p+1;
-		//}
+		}
+		*/
 
+		//SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s] examining file [%s]\n",__FILE__,__FUNCTION__,p);
 
 		if(isdir(p) == false)
 		{
@@ -391,7 +396,7 @@ int32 getFolderTreeContentsCheckSumRecursively(const string &path, const string
 
             if(addFile)
             {
-                //SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s] adding file [%s]\n",__FILE__,__FUNCTION__,p);
+                SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s] adding file [%s]\n",__FILE__,__FUNCTION__,p);
 
                 checksum.addFile(p);
             }
@@ -410,19 +415,21 @@ int32 getFolderTreeContentsCheckSumRecursively(const string &path, const string
 
 	for(size_t i = 0; i < globbuf.gl_pathc; ++i) {
 		const char* p = globbuf.gl_pathv[i];
-		//
+		/*
-		//const char* begin = p;
+		const char* begin = p;
-		//for( ; *p != 0; ++p) {
+		for( ; *p != 0; ++p) {
 			// strip the path component
-		//	if(*p == '/')
+			if(*p == '/')
-		//		begin = p+1;
+				begin = p+1;
-		//}
+		}
+		*/
 
         getFolderTreeContentsCheckSumRecursively(string(p) + "/*", filterFileExt, &checksum);
 	}
 
 	globfree(&globbuf);
-*/
+
+	SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s] scanning [%s] ending checksum = %d\n",__FILE__,__FUNCTION__,path.c_str(),checksum.getSum());
 
 	if(recursiveChecksum != NULL) {
 		*recursiveChecksum = checksum;
@@ -433,8 +440,8 @@ int32 getFolderTreeContentsCheckSumRecursively(const string &path, const string
 
 vector<std::pair<string,int32> > getFolderTreeContentsCheckSumListRecursively(vector<string> paths, string pathSearchString, string filterFileExt, vector<std::pair<string,int32> > *recursiveMap) {
 	vector<std::pair<string,int32> > checksumFiles = (recursiveMap == NULL ? vector<std::pair<string,int32> >() : *recursiveMap);
-	int count = paths.size();
+	size_t count = paths.size();
-	for(int idx = 0; idx < count; ++idx) {
+	for(unsigned int idx = 0; idx < count; ++idx) {
 		string path = paths[idx] + pathSearchString;
 		getFolderTreeContentsCheckSumListRecursively(path, filterFileExt, &checksumFiles);
 	}
@@ -446,12 +453,12 @@ vector<std::pair<string,int32> > getFolderTreeContentsCheckSumListRecursively(co
 
     vector<std::pair<string,int32> > checksumFiles = (recursiveMap == NULL ? vector<std::pair<string,int32> >() : *recursiveMap);
 
-/* MV - PORT THIS to win32
+    SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s] scanning [%s]\n",__FILE__,__FUNCTION__,path.c_str());
-
-    //SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s] scanning [%s]\n",__FILE__,__FUNCTION__,path.c_str());
 
 	std::string mypath = path;
-	// Stupid win32 is searching for all files without extension when *. is specified as wildcard
+	/** Stupid win32 is searching for all files without extension when *. is
+	 * specified as wildcard
+	 */
 	if(mypath.compare(mypath.size() - 2, 2, "*.") == 0) {
 		mypath = mypath.substr(0, mypath.size() - 2);
 		mypath += "*";
@@ -468,14 +475,14 @@ vector<std::pair<string,int32> > getFolderTreeContentsCheckSumListRecursively(co
 
 	for(size_t i = 0; i < globbuf.gl_pathc; ++i) {
 		const char* p = globbuf.gl_pathv[i];
-		//
+		/*
-		//const char* begin = p;
+		const char* begin = p;
-		//for( ; *p != 0; ++p) {
+		for( ; *p != 0; ++p) {
 			// strip the path component
-		//	if(*p == '/')
+			if(*p == '/')
-		//		begin = p+1;
+				begin = p+1;
-		//}
+		}
-
+		*/
 
 		if(isdir(p) == false)
 		{
@@ -509,19 +516,22 @@ vector<std::pair<string,int32> > getFolderTreeContentsCheckSumListRecursively(co
 
 	for(size_t i = 0; i < globbuf.gl_pathc; ++i) {
 		const char* p = globbuf.gl_pathv[i];
-		//
+		/*
-		//const char* begin = p;
+		const char* begin = p;
-		//for( ; *p != 0; ++p) {
+		for( ; *p != 0; ++p) {
 			// strip the path component
-		//	if(*p == '/')
+			if(*p == '/')
-		//		begin = p+1;
+				begin = p+1;
-		//}
+		}
+		*/
 
         checksumFiles = getFolderTreeContentsCheckSumListRecursively(string(p) + "/*", filterFileExt, &checksumFiles);
 	}
 
 	globfree(&globbuf);
-*/
+
+	SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s] scanning [%s]\n",__FILE__,__FUNCTION__,path.c_str());
+
     return checksumFiles;
 }
 
@@ -700,7 +710,7 @@ void getFullscreenVideoModes(list<ModeInfo> *modeinfos) {
     SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
 
     SDL_PixelFormat format;
-  	SDL_Rect **modes;
+  	//SDL_Rect **modes;
   	int loops(0);
 	int bpp(0);
 	std::map<std::string,bool> uniqueResList;