[paragui-cvs] CVS: paragui/src/physfs/platform pocketpc.c,NONE,1.1.4.1 .cvsignore,1.1.1.1.2.1,1.1.1.1.2.2 beos.cpp,1.3.2.1,1.3.2.2 os2.c,1.2.2.2,1.2.2.3 posix.c,1.3.2.2,1.3.2.3 unix.c,1.2.2.2,1.2.2.3 win32.c,1.2.2.2,1.2.2.3

[Alexander Pipelka <address@hidden>]

Update of /cvsroot/paragui/paragui/src/physfs/platform
In directory subversions:/tmp/cvs-serv30594/src/physfs/platform

Modified Files:
      Tag: devel-opengl
        .cvsignore beos.cpp os2.c posix.c unix.c win32.c 
Added Files:
      Tag: devel-opengl
        pocketpc.c 
Log Message:
- some work on the factory and layout loader
- updated physfs version
- minor automake fixes



--- NEW FILE ---
/*
 * Skeleton platform-dependent support routines for PhysicsFS.
 *
 * Please see the file LICENSE in the source's root directory.
 *
 *  This file written by Ryan C. Gordon.
 */

#if HAVE_CONFIG_H
#  include <config.h>
#endif

#include <stdio.h>
#include <windows.h>

#define __PHYSICSFS_INTERNAL__
#include "physfs_internal.h"

#define INVALID_FILE_ATTRIBUTES         0xFFFFFFFF
#define INVALID_SET_FILE_POINTER        0xFFFFFFFF
typedef struct
{
    HANDLE handle;
    int readonly;
} winCEfile;


const char *__PHYSFS_platformDirSeparator = "\\";

/*
 * Figure out what the last failing Win32 API call was, and
 *  generate a human-readable string for the error message.
 *
 * The return value is a static buffer that is overwritten with
 *  each call to this function.
 */
static const char *win32strerror(void)
{
    static TCHAR msgbuf[255];
    TCHAR *ptr = msgbuf;

    FormatMessage(
        FORMAT_MESSAGE_FROM_SYSTEM |
        FORMAT_MESSAGE_IGNORE_INSERTS,
        NULL,
        GetLastError(),
        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), /* Default language */
        msgbuf,
        sizeof (msgbuf) / sizeof (TCHAR),
        NULL 
    );

        /* chop off newlines. */
    for (ptr = msgbuf; *ptr; ptr++)
    {
        if ((*ptr == '\n') || (*ptr == '\r'))
        {
            *ptr = ' ';
            break;
        } /* if */
    } /* for */

    return((const char *) msgbuf);
} /* win32strerror */


static char *UnicodeToAsc(const wchar_t *w_str)
{
        char *str=NULL;

        if(w_str!=NULL)
        {
                int len=wcslen(w_str)+1;
                str=(char *)malloc(len);

                if(WideCharToMultiByte(CP_ACP,0,w_str,-1,str,len,NULL,NULL)==0)
                {       //Conversion failed
                        free(str);
                        return NULL;
                }
                else
                {       //Conversion successful
                        return(str);
                }

        }
        else
        {       //Given NULL string
                return NULL;
        }
}

static wchar_t *AscToUnicode(const char *str)
{
        wchar_t *w_str=NULL;
        if(str!=NULL)
        {
                int len=strlen(str)+1;
                w_str=(wchar_t *)malloc(sizeof(wchar_t)*len);
                if(MultiByteToWideChar(CP_ACP,0,str,-1,w_str,len)==0)
                {
                        free(w_str);
                        return NULL;
                }
                else
                {
                        return(w_str);
                }
        }
        else
        {
                return NULL;
        }
}


int __PHYSFS_platformInit(void)
{
    return(1);  /* always succeed. */
} /* __PHYSFS_platformInit */


int __PHYSFS_platformDeinit(void)
{
    return(1);  /* always succeed. */
} /* __PHYSFS_platformDeinit */


char **__PHYSFS_platformDetectAvailableCDs(void)
{
    BAIL_MACRO(ERR_NOT_IMPLEMENTED, NULL);
} /* __PHYSFS_platformDetectAvailableCDs */


char *__PHYSFS_platformCalcBaseDir(const char *argv0)
{
        return("\\");
//    BAIL_MACRO(ERR_NOT_IMPLEMENTED, NULL);
} /* __PHYSFS_platformCalcBaseDir */


char *__PHYSFS_platformGetUserName(void)
{
    BAIL_MACRO(ERR_NOT_IMPLEMENTED, NULL);
} /* __PHYSFS_platformGetUserName */


char *__PHYSFS_platformGetUserDir(void)
{
        return("\\");
    BAIL_MACRO(ERR_NOT_IMPLEMENTED, NULL);
} /* __PHYSFS_platformGetUserDir */


PHYSFS_uint64 __PHYSFS_platformGetThreadID(void)
{
    return(1);  /* single threaded. */
} /* __PHYSFS_platformGetThreadID */


int __PHYSFS_platformStricmp(const char *x, const char *y)
{    
        const char *p1 = x, *p2 = y;
        int r = 0;

    while((*p1) && (*p2) && (toupper(*p1++) == toupper(*p2++)))  ++r;

    r = (!((*p1) || (*p2)) ? (0) : ((toupper(*p1) > toupper(*p2)) ?
                                    (r + 1) : -(r + 1)));

    return(r);

} /* __PHYSFS_platformStricmp */


int __PHYSFS_platformExists(const char *fname)
{
        int retval=0;

        wchar_t *w_fname=AscToUnicode(fname);
        
        if(w_fname!=NULL)
        {
                retval=(GetFileAttributes(w_fname) != INVALID_FILE_ATTRIBUTES);
                free(w_fname);
        }

        return(retval);
} /* __PHYSFS_platformExists */


int __PHYSFS_platformIsSymLink(const char *fname)
{
    BAIL_MACRO(ERR_NOT_IMPLEMENTED, 0);
} /* __PHYSFS_platformIsSymlink */


int __PHYSFS_platformIsDirectory(const char *fname)
{
        int retval=0;

        wchar_t *w_fname=AscToUnicode(fname);

        if(w_fname!=NULL)
        {
            retval=((GetFileAttributes(w_fname) & FILE_ATTRIBUTE_DIRECTORY) != 
0);
                free(w_fname);
        }

        return(retval);
} /* __PHYSFS_platformIsDirectory */


char *__PHYSFS_platformCvtToDependent(const char *prepend,
                                      const char *dirName,
                                      const char *append)
{
    int len = ((prepend) ? strlen(prepend) : 0) +
              ((append) ? strlen(append) : 0) +
              strlen(dirName) + 1;
    char *retval = malloc(len);
    char *p;

    BAIL_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, NULL);

    if (prepend)
        strcpy(retval, prepend);
    else
        retval[0] = '\0';

    strcat(retval, dirName);

    if (append)
        strcat(retval, append);

    for (p = strchr(retval, '/'); p != NULL; p = strchr(p + 1, '/'))
        *p = '\\';

    return(retval);
} /* __PHYSFS_platformCvtToDependent */


void __PHYSFS_platformTimeslice(void)
{
    Sleep(10);
} /* __PHYSFS_platformTimeslice */


LinkedStringList *__PHYSFS_platformEnumerateFiles(const char *dirname,
                                                  int omitSymLinks)
{
    LinkedStringList *retval = NULL;
    LinkedStringList *l = NULL;
    LinkedStringList *prev = NULL;
    HANDLE dir;
    WIN32_FIND_DATA ent;
    char *SearchPath;
        wchar_t *w_SearchPath;
    size_t len = strlen(dirname);

    /* Allocate a new string for path, maybe '\\', "*", and NULL terminator */
    SearchPath = (char *) alloca(len + 3);
    BAIL_IF_MACRO(SearchPath == NULL, ERR_OUT_OF_MEMORY, NULL); 

    /* Copy current dirname */
    strcpy(SearchPath, dirname);

    /* if there's no '\\' at the end of the path, stick one in there. */
    if (SearchPath[len - 1] != '\\')
    {
        SearchPath[len++] = '\\';
        SearchPath[len] = '\0';
    } /* if */

    /* Append the "*" to the end of the string */
    strcat(SearchPath, "*");

        w_SearchPath=AscToUnicode(SearchPath);

    dir = FindFirstFile(w_SearchPath, &ent);
        free(w_SearchPath);
        free(SearchPath);

        if(dir == INVALID_HANDLE_VALUE)
        {
                return NULL;
        }

    do
    {
        if (wcscmp(ent.cFileName, L".") == 0)
            continue;

        if (wcscmp(ent.cFileName, L"..") == 0)
            continue;

        l = (LinkedStringList *) malloc(sizeof (LinkedStringList));
        if (l == NULL)
            break;

                l->str=UnicodeToAsc(ent.cFileName);

        if (l->str == NULL)
        {
            free(l);
            break;
        }


        if (retval == NULL)
            retval = l;
        else
            prev->next = l;

        prev = l;
        l->next = NULL;
    } while (FindNextFile(dir, &ent) != 0);

    FindClose(dir);
    return(retval);
} /* __PHYSFS_platformEnumerateFiles */


char *__PHYSFS_platformCurrentDir(void)
{
        return("\\");
} /* __PHYSFS_platformCurrentDir */


char *__PHYSFS_platformRealPath(const char *path)
{
        char *retval=(char *)malloc(strlen(path)+1);

        strcpy(retval,path);

        return(retval);

} /* __PHYSFS_platformRealPath */


int __PHYSFS_platformMkDir(const char *path)
{
        wchar_t *w_path = AscToUnicode(path);
        if(w_path!=NULL)
        {
            DWORD rc = CreateDirectory(w_path, NULL);
                free(w_path);
                if(rc==0)
                {
                        return(0);
                }
                return(1);
        }
        else
        {
                return(0);
        }
} /* __PHYSFS_platformMkDir */


static void *doOpen(const char *fname, DWORD mode, DWORD creation, int rdonly)
{
    HANDLE fileHandle;
    winCEfile *retval;
        wchar_t *w_fname=AscToUnicode(fname);

    fileHandle = CreateFile(w_fname, mode, FILE_SHARE_READ, NULL,
                            creation, FILE_ATTRIBUTE_NORMAL, NULL);

        free(w_fname);

        if(fileHandle==INVALID_HANDLE_VALUE)
        {
                return NULL;
        }

    BAIL_IF_MACRO(fileHandle == INVALID_HANDLE_VALUE, win32strerror(), NULL);

        retval = malloc(sizeof (winCEfile));
        if (retval == NULL)
        {
                CloseHandle(fileHandle);
                BAIL_MACRO(ERR_OUT_OF_MEMORY, NULL);
        } /* if */

        retval->readonly = rdonly;
        retval->handle = fileHandle;
        return(retval);
} /* doOpen */


void *__PHYSFS_platformOpenRead(const char *filename)
{
    return(doOpen(filename, GENERIC_READ, OPEN_EXISTING, 1));
} /* __PHYSFS_platformOpenRead */


void *__PHYSFS_platformOpenWrite(const char *filename)
{
    return(doOpen(filename, GENERIC_WRITE, CREATE_ALWAYS, 0));
} /* __PHYSFS_platformOpenWrite */


void *__PHYSFS_platformOpenAppend(const char *filename)
{
    void *retval = doOpen(filename, GENERIC_WRITE, OPEN_ALWAYS, 0);
    if (retval != NULL)
    {
        HANDLE h = ((winCEfile *) retval)->handle;
        if (SetFilePointer(h, 0, NULL, FILE_END) == INVALID_SET_FILE_POINTER)
        {
            const char *err = win32strerror();
            CloseHandle(h);
            free(retval);
            BAIL_MACRO(err, NULL);
        } /* if */
    } /* if */

    return(retval);

} /* __PHYSFS_platformOpenAppend */


PHYSFS_sint64 __PHYSFS_platformRead(void *opaque, void *buffer,
                                    PHYSFS_uint32 size, PHYSFS_uint32 count)
{
    HANDLE FileHandle = ((winCEfile *) opaque)->handle;
    DWORD CountOfBytesRead;
    PHYSFS_sint64 retval;

    /* Read data from the file */
    /*!!! - uint32 might be a greater # than DWORD */
    if(!ReadFile(FileHandle, buffer, count * size, &CountOfBytesRead, NULL))
    {
                retval=-1;
    } /* if */
    else
    {
        /* Return the number of "objects" read. */
        /* !!! - What if not the right amount of bytes was read to make an 
object? */
        retval = CountOfBytesRead / size;
    } /* else */

    return(retval);

} /* __PHYSFS_platformRead */


PHYSFS_sint64 __PHYSFS_platformWrite(void *opaque, const void *buffer,
                                     PHYSFS_uint32 size, PHYSFS_uint32 count)
{
    HANDLE FileHandle = ((winCEfile *) opaque)->handle;
    DWORD CountOfBytesWritten;
    PHYSFS_sint64 retval;

    /* Read data from the file */
    /*!!! - uint32 might be a greater # than DWORD */
    if(!WriteFile(FileHandle, buffer, count * size, &CountOfBytesWritten, NULL))
    {
                retval=-1;
    } /* if */
    else
    {
        /* Return the number of "objects" read. */
        /*!!! - What if not the right number of bytes was written? */
        retval = CountOfBytesWritten / size;
    } /* else */

        return(retval);

} /* __PHYSFS_platformWrite */


int __PHYSFS_platformSeek(void *opaque, PHYSFS_uint64 pos)
{
    HANDLE FileHandle = ((winCEfile *) opaque)->handle;
    DWORD HighOrderPos;
    DWORD rc;

    /* Get the high order 32-bits of the position */
    //HighOrderPos = HIGHORDER_UINT64(pos);
        HighOrderPos = (unsigned long)(pos>>32);

    /*!!! SetFilePointer needs a signed 64-bit value. */
    /* Move pointer "pos" count from start of file */
    rc = SetFilePointer(FileHandle, (unsigned long)(pos&0x00000000ffffffff),
                        &HighOrderPos, FILE_BEGIN);

    if ((rc == INVALID_SET_FILE_POINTER) && (GetLastError() != NO_ERROR))
        {
        BAIL_MACRO(win32strerror(), 0);
        }

    return(1);  /* No error occured */
} /* __PHYSFS_platformSeek */


PHYSFS_sint64 __PHYSFS_platformTell(void *opaque)
{
    HANDLE FileHandle = ((winCEfile *) opaque)->handle;
    DWORD HighPos = 0;
    DWORD LowPos;
    PHYSFS_sint64 retval;

    /* Get current position */
    LowPos = SetFilePointer(FileHandle, 0, &HighPos, FILE_CURRENT);
    if ((LowPos == INVALID_SET_FILE_POINTER) && (GetLastError() != NO_ERROR))
    {
        BAIL_MACRO(win32strerror(), 0);
    } /* if */
    else
    {
        /* Combine the high/low order to create the 64-bit position value */
        retval = (((PHYSFS_uint64) HighPos) << 32) | LowPos;
        //assert(retval >= 0);
    } /* else */

    return(retval);
} /* __PHYSFS_platformTell */


PHYSFS_sint64 __PHYSFS_platformFileLength(void *opaque)
{
    HANDLE FileHandle = ((winCEfile *) opaque)->handle;
    DWORD SizeHigh;
    DWORD SizeLow;
    PHYSFS_sint64 retval;

    SizeLow = GetFileSize(FileHandle, &SizeHigh);
    if ((SizeLow == INVALID_SET_FILE_POINTER) && (GetLastError() != NO_ERROR))
    {
        BAIL_MACRO(win32strerror(), -1);
    } /* if */
    else
    {
        /* Combine the high/low order to create the 64-bit position value */
        retval = (((PHYSFS_uint64) SizeHigh) << 32) | SizeLow;
        //assert(retval >= 0);
    } /* else */

    return(retval);
} /* __PHYSFS_platformFileLength */


int __PHYSFS_platformEOF(void *opaque)
{
    PHYSFS_sint64 FilePosition;
    int retval = 0;

    /* Get the current position in the file */
    if ((FilePosition = __PHYSFS_platformTell(opaque)) != 0)
    {
        /* Non-zero if EOF is equal to the file length */
        retval = FilePosition == __PHYSFS_platformFileLength(opaque);
    } /* if */

    return(retval);
} /* __PHYSFS_platformEOF */


int __PHYSFS_platformFlush(void *opaque)
{
    winCEfile *fh = ((winCEfile *) opaque);
    if (!fh->readonly)
        BAIL_IF_MACRO(!FlushFileBuffers(fh->handle), win32strerror(), 0);

    return(1);
} /* __PHYSFS_platformFlush */


int __PHYSFS_platformClose(void *opaque)
{
    HANDLE FileHandle = ((winCEfile *) opaque)->handle;
    BAIL_IF_MACRO(!CloseHandle(FileHandle), win32strerror(), 0);
    free(opaque);
    return(1);
} /* __PHYSFS_platformClose */


int __PHYSFS_platformDelete(const char *path)
{
        wchar_t *w_path=AscToUnicode(path);

    /* If filename is a folder */
    if (GetFileAttributes(w_path) == FILE_ATTRIBUTE_DIRECTORY)
    {
                int retval=!RemoveDirectory(w_path);
                free(w_path);
        BAIL_IF_MACRO(retval, win32strerror(), 0);
    } /* if */
    else
    {
                int retval=!DeleteFile(w_path);
                free(w_path);
        BAIL_IF_MACRO(retval, win32strerror(), 0);
    } /* else */

    return(1);  /* if you got here, it worked. */
} /* __PHYSFS_platformDelete */


void *__PHYSFS_platformCreateMutex(void)
{
    return((void *) CreateMutex(NULL, FALSE, NULL));
} /* __PHYSFS_platformCreateMutex */


void __PHYSFS_platformDestroyMutex(void *mutex)
{
    CloseHandle((HANDLE) mutex);
} /* __PHYSFS_platformDestroyMutex */


int __PHYSFS_platformGrabMutex(void *mutex)
{
    return(WaitForSingleObject((HANDLE) mutex, INFINITE) != WAIT_FAILED);
} /* __PHYSFS_platformGrabMutex */


void __PHYSFS_platformReleaseMutex(void *mutex)
{
    ReleaseMutex((HANDLE) mutex);
} /* __PHYSFS_platformReleaseMutex */


PHYSFS_sint64 __PHYSFS_platformGetLastModTime(const char *fname)
{
    BAIL_MACRO(ERR_NOT_IMPLEMENTED, -1);
} /* __PHYSFS_platformGetLastModTime */

/* end of skeleton.c ... */


Index: .cvsignore
===================================================================
RCS file: /cvsroot/paragui/paragui/src/physfs/platform/.cvsignore,v
retrieving revision 1.1.1.1.2.1
retrieving revision 1.1.1.1.2.2
diff -C2 -r1.1.1.1.2.1 -r1.1.1.1.2.2
*** .cvsignore  31 Oct 2002 11:10:25 -0000      1.1.1.1.2.1
--- .cvsignore  3 Feb 2003 21:04:57 -0000       1.1.1.1.2.2
***************
*** 1,10 ****
  Makefile
  .deps
  .libs
! libplatform.la
! Makefile.in
! unix.lo
! posix.lo
! beos.lo
! win32.lo
! os2.lo
--- 1,6 ----
  Makefile
+ Makefile.in
  .deps
  .libs
! *.lo
! *.la

Index: beos.cpp
===================================================================
RCS file: /cvsroot/paragui/paragui/src/physfs/platform/beos.cpp,v
retrieving revision 1.3.2.1
retrieving revision 1.3.2.2
diff -C2 -r1.3.2.1 -r1.3.2.2
*** beos.cpp    31 Aug 2002 04:01:25 -0000      1.3.2.1
--- beos.cpp    3 Feb 2003 21:04:57 -0000       1.3.2.2
***************
*** 27,31 ****
  #include <string.h>
  #include <errno.h>
- #include <assert.h>
  #include <unistd.h>
  
--- 27,30 ----

Index: os2.c
===================================================================
RCS file: /cvsroot/paragui/paragui/src/physfs/platform/os2.c,v
retrieving revision 1.2.2.2
retrieving revision 1.2.2.3
diff -C2 -r1.2.2.2 -r1.2.2.3
*** os2.c       30 Oct 2002 20:15:18 -0000      1.2.2.2
--- os2.c       3 Feb 2003 21:04:57 -0000       1.2.2.3
***************
*** 27,31 ****
  #include <errno.h>
  #include <string.h>
- #include <assert.h>
  #include <time.h>
  #include <ctype.h>
--- 27,30 ----

Index: posix.c
===================================================================
RCS file: /cvsroot/paragui/paragui/src/physfs/platform/posix.c,v
retrieving revision 1.3.2.2
retrieving revision 1.3.2.3
diff -C2 -r1.3.2.2 -r1.3.2.3
*** posix.c     30 Oct 2002 20:15:18 -0000      1.3.2.2
--- posix.c     3 Feb 2003 21:04:57 -0000       1.3.2.3
***************
*** 44,48 ****
  #include <errno.h>
  #include <fcntl.h>
- #include <assert.h>
  
  #ifdef PHYSFS_HAVE_LLSEEK
--- 44,47 ----

Index: unix.c
===================================================================
RCS file: /cvsroot/paragui/paragui/src/physfs/platform/unix.c,v
retrieving revision 1.2.2.2
retrieving revision 1.2.2.3
diff -C2 -r1.2.2.2 -r1.2.2.3
*** unix.c      30 Oct 2002 20:15:18 -0000      1.2.2.2
--- unix.c      3 Feb 2003 21:04:57 -0000       1.2.2.3
***************
*** 222,226 ****
          /* build full binary path... */
          strcpy(exe, start);
!         if (exe[strlen(exe) - 1] != '/')
              strcat(exe, "/");
          strcat(exe, bin);
--- 222,226 ----
          /* build full binary path... */
          strcpy(exe, start);
!         if ((exe[0] == '\0') || (exe[strlen(exe) - 1] != '/'))
              strcat(exe, "/");
          strcat(exe, bin);

Index: win32.c
===================================================================
RCS file: /cvsroot/paragui/paragui/src/physfs/platform/win32.c,v
retrieving revision 1.2.2.2
retrieving revision 1.2.2.3
diff -C2 -r1.2.2.2 -r1.2.2.3
*** win32.c     30 Oct 2002 20:15:18 -0000      1.2.2.2
--- win32.c     3 Feb 2003 21:04:57 -0000       1.2.2.3
***************
*** 20,30 ****
  #include <ctype.h>
  #include <time.h>
- #include <assert.h>
  
  #define __PHYSICSFS_INTERNAL__
  #include "physfs_internal.h"
  
! #ifdef _MSC_VER /* for Cygwin, etc. */
! #define alloca _alloca
  #endif
  
--- 20,31 ----
  #include <ctype.h>
  #include <time.h>
  
  #define __PHYSICSFS_INTERNAL__
  #include "physfs_internal.h"
  
! #if (defined _MSC_VER)
!     #define alloca(x) _alloca(x)
! #elif (defined MINGW)  /* scary...hopefully this is okay. */
!     #define alloca(x) __builtin_alloca(x) 
  #endif