physfs/platform/pocketpc.c

700 lines
17 KiB
C
Raw Normal View History

2002-11-22 07:17:59 +01:00
/*
* 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"
2003-07-20 23:08:24 +02:00
#define INVALID_FILE_ATTRIBUTES 0xFFFFFFFF
#define INVALID_SET_FILE_POINTER 0xFFFFFFFF
2002-11-22 07:17:59 +01:00
typedef struct
{
HANDLE handle;
int readonly;
} winCEfile;
const char *__PHYSFS_platformDirSeparator = "\\";
2003-05-18 09:52:28 +02:00
static char *userDir = NULL;
2002-11-22 07:17:59 +01:00
/*
* 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(
2003-07-20 23:08:24 +02:00
FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
NULL,
GetLastError(),
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), /* Default language */
msgbuf,
sizeof (msgbuf) / sizeof (TCHAR),
NULL
);
2003-05-18 09:52:28 +02:00
/* chop off newlines. */
2002-11-22 07:17:59 +01:00
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;
2002-11-22 07:17:59 +01:00
if (w_str != NULL)
2003-05-18 09:52:28 +02:00
{
int len = wcslen(w_str) + 1;
str = (char *) allocator.Malloc(len);
2003-05-18 09:52:28 +02:00
if (WideCharToMultiByte(CP_ACP,0,w_str,-1,str,len,NULL,NULL) == 0)
{ /*Conversion failed */
allocator.Free(str);
return(NULL);
} /* if */
else
{ /* Conversion successful */
return(str);
} /* else */
} /* if */
2003-07-20 23:08:24 +02:00
else
{ /* Given NULL string */
return NULL;
2003-05-18 09:52:28 +02:00
}
} /* UnicodeToAsc */
2002-11-22 07:17:59 +01:00
static wchar_t *AscToUnicode(const char *str)
{
wchar_t *w_str = NULL;
if (str != NULL)
2003-05-18 09:52:28 +02:00
{
int len = strlen(str) + 1;
w_str = (wchar_t *) allocator.Malloc(sizeof (wchar_t) * len);
if (MultiByteToWideChar(CP_ACP,0,str,-1,w_str,len) == 0)
{
allocator.Free(w_str);
return(NULL);
} /* if */
else
{
return(w_str);
} /* else */
} /* if */
2003-07-20 23:08:24 +02:00
else
{
return(NULL);
} /* else */
} /* AscToUnicode */
2002-11-22 07:17:59 +01:00
2003-05-18 09:52:28 +02:00
static char *getExePath()
{
DWORD buflen;
int success = 0;
TCHAR *ptr = NULL;
TCHAR *retval = (TCHAR*) allocator.Malloc(sizeof (TCHAR) * (MAX_PATH + 1));
2003-05-18 09:52:28 +02:00
char *charretval;
BAIL_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, NULL);
retval[0] = _T('\0');
buflen = GetModuleFileName(NULL, retval, MAX_PATH + 1);
if (buflen <= 0) {
__PHYSFS_setError(win32strerror());
} else {
retval[buflen] = '\0'; /* does API always null-terminate this? */
2003-07-20 23:08:24 +02:00
ptr = retval+buflen;
while( ptr != retval )
{
if( *ptr != _T('\\') ) {
*ptr-- = _T('\0');
} else {
break;
}
}
success = 1;
2003-05-18 09:52:28 +02:00
} /* else */
if (!success)
{
allocator.Free(retval);
2003-05-18 09:52:28 +02:00
return(NULL); /* physfs error message will be set, above. */
} /* if */
/* free up the bytes we didn't actually use. */
ptr = (TCHAR *) allocator.Realloc(retval, sizeof(TCHAR)*_tcslen(retval)+1);
2003-05-18 09:52:28 +02:00
if (ptr != NULL)
retval = ptr;
charretval = UnicodeToAsc(retval);
allocator.Free(retval);
2003-05-18 09:52:28 +02:00
if(charretval == NULL) {
2003-07-20 23:08:24 +02:00
BAIL_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, NULL);
2003-05-18 09:52:28 +02:00
}
return(charretval); /* w00t. */
} /* getExePath */
2002-11-22 07:17:59 +01:00
int __PHYSFS_platformInit(void)
{
2003-05-18 09:52:28 +02:00
userDir = getExePath();
BAIL_IF_MACRO(userDir == NULL, NULL, 0); /* failed? */
2002-11-22 07:17:59 +01:00
return(1); /* always succeed. */
} /* __PHYSFS_platformInit */
int __PHYSFS_platformDeinit(void)
{
allocator.Free(userDir);
2002-11-22 07:17:59 +01:00
return(1); /* always succeed. */
} /* __PHYSFS_platformDeinit */
void __PHYSFS_platformDetectAvailableCDs(PHYSFS_StringCallback cb, void *data)
2002-11-22 07:17:59 +01:00
{
/* no-op on this platform. */
2002-11-22 07:17:59 +01:00
} /* __PHYSFS_platformDetectAvailableCDs */
char *__PHYSFS_platformCalcBaseDir(const char *argv0)
{
2003-05-18 09:52:28 +02:00
return(getExePath());
2002-11-22 07:17:59 +01:00
} /* __PHYSFS_platformCalcBaseDir */
char *__PHYSFS_platformGetUserName(void)
{
BAIL_MACRO(ERR_NOT_IMPLEMENTED, NULL);
} /* __PHYSFS_platformGetUserName */
char *__PHYSFS_platformGetUserDir(void)
{
2003-05-18 09:52:28 +02:00
return userDir;
2002-11-22 07:17:59 +01:00
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)
{
2003-05-18 09:52:28 +02:00
return(_stricmp(x, y));
2002-11-22 07:17:59 +01:00
} /* __PHYSFS_platformStricmp */
int __PHYSFS_platformStrnicmp(const char *x, const char *y, PHYSFS_uint32 len)
{
return(_strnicmp(x, y, (int) len));
} /* __PHYSFS_platformStrnicmp */
2002-11-22 07:17:59 +01:00
int __PHYSFS_platformExists(const char *fname)
{
2003-05-18 09:52:28 +02:00
int retval=0;
2002-11-22 07:17:59 +01:00
2003-05-18 09:52:28 +02:00
wchar_t *w_fname=AscToUnicode(fname);
2003-07-20 23:08:24 +02:00
2003-05-18 09:52:28 +02:00
if(w_fname!=NULL)
{
2003-07-20 23:08:24 +02:00
retval=(GetFileAttributes(w_fname) != INVALID_FILE_ATTRIBUTES);
allocator.Free(w_fname);
2003-05-18 09:52:28 +02:00
}
2002-11-22 07:17:59 +01:00
2003-05-18 09:52:28 +02:00
return(retval);
2002-11-22 07:17:59 +01:00
} /* __PHYSFS_platformExists */
int __PHYSFS_platformIsSymLink(const char *fname)
{
BAIL_MACRO(ERR_NOT_IMPLEMENTED, 0);
} /* __PHYSFS_platformIsSymlink */
int __PHYSFS_platformIsDirectory(const char *fname)
{
2003-05-18 09:52:28 +02:00
int retval=0;
2002-11-22 07:17:59 +01:00
2003-05-18 09:52:28 +02:00
wchar_t *w_fname=AscToUnicode(fname);
2002-11-22 07:17:59 +01:00
2003-05-18 09:52:28 +02:00
if(w_fname!=NULL)
{
2003-07-20 23:08:24 +02:00
retval=((GetFileAttributes(w_fname) & FILE_ATTRIBUTE_DIRECTORY) != 0);
allocator.Free(w_fname);
2003-05-18 09:52:28 +02:00
}
2002-11-22 07:17:59 +01:00
2003-05-18 09:52:28 +02:00
return(retval);
2002-11-22 07:17:59 +01:00
} /* __PHYSFS_platformIsDirectory */
char *__PHYSFS_platformCvtToDependent(const char *prepend,
const char *dirName,
const char *append)
{
int len = ((prepend) ? strlen(prepend) : 0) +
2003-07-20 23:08:24 +02:00
((append) ? strlen(append) : 0) +
strlen(dirName) + 1;
char *retval = (char *) allocator.Malloc(len);
2002-11-22 07:17:59 +01:00
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 */
void __PHYSFS_platformEnumerateFiles(const char *dirname,
int omitSymLinks,
PHYSFS_EnumFilesCallback callback,
const char *origdir,
void *callbackdata)
2002-11-22 07:17:59 +01:00
{
HANDLE dir;
WIN32_FIND_DATA ent;
char *SearchPath;
2003-05-18 09:52:28 +02:00
wchar_t *w_SearchPath;
2002-11-22 07:17:59 +01:00
size_t len = strlen(dirname);
/* Allocate a new string for path, maybe '\\', "*", and NULL terminator */
SearchPath = (char *) alloca(len + 3);
2003-07-20 23:08:24 +02:00
BAIL_IF_MACRO(SearchPath == NULL, ERR_OUT_OF_MEMORY, NULL);
2002-11-22 07:17:59 +01:00
/* 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, "*");
2003-05-18 09:52:28 +02:00
w_SearchPath=AscToUnicode(SearchPath);
2002-11-22 07:17:59 +01:00
dir = FindFirstFile(w_SearchPath, &ent);
allocator.Free(w_SearchPath);
allocator.Free(SearchPath);
2002-11-22 07:17:59 +01:00
if (dir == INVALID_HANDLE_VALUE)
return;
2002-11-22 07:17:59 +01:00
do
{
const char *str;
2002-11-22 07:17:59 +01:00
if (wcscmp(ent.cFileName, L".") == 0)
continue;
if (wcscmp(ent.cFileName, L"..") == 0)
continue;
/* !!! FIXME: avoid malloc in UnicodeToAsc? */
str = UnicodeToAsc(ent.cFileName);
if (str == NULL)
2002-11-22 07:17:59 +01:00
break;
callback(callbackdata, origdir, str);
allocator.Free(str);
2002-11-22 07:17:59 +01:00
} while (FindNextFile(dir, &ent) != 0);
FindClose(dir);
} /* __PHYSFS_platformEnumerateFiles */
char *__PHYSFS_platformCurrentDir(void)
{
2003-05-18 09:52:28 +02:00
return("\\");
2002-11-22 07:17:59 +01:00
} /* __PHYSFS_platformCurrentDir */
char *__PHYSFS_platformRealPath(const char *path)
{
char *retval = (char *) allocator.Malloc(strlen(path) + 1);
2003-05-18 09:52:28 +02:00
strcpy(retval,path);
return(retval);
2002-11-22 07:17:59 +01:00
} /* __PHYSFS_platformRealPath */
int __PHYSFS_platformMkDir(const char *path)
{
2003-05-18 09:52:28 +02:00
wchar_t *w_path = AscToUnicode(path);
if(w_path!=NULL)
{
2003-07-20 23:08:24 +02:00
DWORD rc = CreateDirectory(w_path, NULL);
allocator.Free(w_path);
2003-07-20 23:08:24 +02:00
if(rc==0)
{
return(0);
}
return(1);
2003-05-18 09:52:28 +02:00
}
else
{
2003-07-20 23:08:24 +02:00
return(0);
2003-05-18 09:52:28 +02:00
}
2002-11-22 07:17:59 +01:00
} /* __PHYSFS_platformMkDir */
static void *doOpen(const char *fname, DWORD mode, DWORD creation, int rdonly)
{
HANDLE fileHandle;
winCEfile *retval;
2003-05-18 09:52:28 +02:00
wchar_t *w_fname=AscToUnicode(fname);
2002-11-22 07:17:59 +01:00
fileHandle = CreateFile(w_fname, mode, FILE_SHARE_READ, NULL,
creation, FILE_ATTRIBUTE_NORMAL, NULL);
allocator.Free(w_fname);
2002-11-22 07:17:59 +01:00
2003-05-18 09:52:28 +02:00
if(fileHandle==INVALID_HANDLE_VALUE)
{
2003-07-20 23:08:24 +02:00
return NULL;
2003-05-18 09:52:28 +02:00
}
2002-11-22 07:17:59 +01:00
BAIL_IF_MACRO(fileHandle == INVALID_HANDLE_VALUE, win32strerror(), NULL);
retval = (winCEfile *) allocator.Malloc(sizeof (winCEfile));
2003-05-18 09:52:28 +02:00
if (retval == NULL)
{
2003-07-20 23:08:24 +02:00
CloseHandle(fileHandle);
BAIL_MACRO(ERR_OUT_OF_MEMORY, NULL);
2003-05-18 09:52:28 +02:00
} /* if */
2002-11-22 07:17:59 +01:00
2003-05-18 09:52:28 +02:00
retval->readonly = rdonly;
retval->handle = fileHandle;
return(retval);
2002-11-22 07:17:59 +01:00
} /* 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);
allocator.Free(retval);
2002-11-22 07:17:59 +01:00
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 Handle = ((winCEfile *) opaque)->handle;
2002-11-22 07:17:59 +01:00
DWORD CountOfBytesRead;
PHYSFS_sint64 retval;
/* Read data from the file */
/*!!! - uint32 might be a greater # than DWORD */
if (!ReadFile(Handle, buffer, count * size, &CountOfBytesRead, NULL))
2002-11-22 07:17:59 +01:00
{
retval = -1;
2002-11-22 07:17:59 +01:00
} /* 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 Handle = ((winCEfile *) opaque)->handle;
2002-11-22 07:17:59 +01:00
DWORD CountOfBytesWritten;
PHYSFS_sint64 retval;
/* Read data from the file */
/*!!! - uint32 might be a greater # than DWORD */
if (!WriteFile(Handle, buffer, count * size, &CountOfBytesWritten, NULL))
2002-11-22 07:17:59 +01:00
{
retval = -1;
2002-11-22 07:17:59 +01:00
} /* if */
else
{
/* Return the number of "objects" read. */
/*!!! - What if not the right number of bytes was written? */
retval = CountOfBytesWritten / size;
} /* else */
2003-05-18 09:52:28 +02:00
return(retval);
2002-11-22 07:17:59 +01:00
} /* __PHYSFS_platformWrite */
int __PHYSFS_platformSeek(void *opaque, PHYSFS_uint64 pos)
{
HANDLE Handle = ((winCEfile *) opaque)->handle;
2002-11-22 07:17:59 +01:00
DWORD HighOrderPos;
DWORD rc;
/* Get the high order 32-bits of the position */
//HighOrderPos = HIGHORDER_UINT64(pos);
2003-05-18 09:52:28 +02:00
HighOrderPos = (unsigned long)(pos>>32);
2002-11-22 07:17:59 +01:00
/*!!! SetFilePointer needs a signed 64-bit value. */
/* Move pointer "pos" count from start of file */
rc = SetFilePointer(Handle, (unsigned long)(pos&0x00000000ffffffff),
2002-11-22 07:17:59 +01:00
&HighOrderPos, FILE_BEGIN);
if ((rc == INVALID_SET_FILE_POINTER) && (GetLastError() != NO_ERROR))
2003-05-18 09:52:28 +02:00
{
2002-11-22 07:17:59 +01:00
BAIL_MACRO(win32strerror(), 0);
2003-05-18 09:52:28 +02:00
}
2002-11-22 07:17:59 +01:00
return(1); /* No error occured */
} /* __PHYSFS_platformSeek */
PHYSFS_sint64 __PHYSFS_platformTell(void *opaque)
{
HANDLE Handle = ((winCEfile *) opaque)->handle;
2002-11-22 07:17:59 +01:00
DWORD HighPos = 0;
DWORD LowPos;
PHYSFS_sint64 retval;
/* Get current position */
LowPos = SetFilePointer(Handle, 0, &HighPos, FILE_CURRENT);
2002-11-22 07:17:59 +01:00
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 Handle = ((winCEfile *) opaque)->handle;
2002-11-22 07:17:59 +01:00
DWORD SizeHigh;
DWORD SizeLow;
PHYSFS_sint64 retval;
SizeLow = GetFileSize(Handle, &SizeHigh);
2002-11-22 07:17:59 +01:00
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 Handle = ((winCEfile *) opaque)->handle;
BAIL_IF_MACRO(!CloseHandle(Handle), win32strerror(), 0);
allocator.Free(opaque);
2002-11-22 07:17:59 +01:00
return(1);
} /* __PHYSFS_platformClose */
int __PHYSFS_platformDelete(const char *path)
{
2003-05-18 09:52:28 +02:00
wchar_t *w_path=AscToUnicode(path);
2002-11-22 07:17:59 +01:00
/* If filename is a folder */
if (GetFileAttributes(w_path) == FILE_ATTRIBUTE_DIRECTORY)
{
2003-07-20 23:08:24 +02:00
int retval=!RemoveDirectory(w_path);
allocator.Free(w_path);
2002-11-22 07:17:59 +01:00
BAIL_IF_MACRO(retval, win32strerror(), 0);
} /* if */
else
{
2003-07-20 23:08:24 +02:00
int retval=!DeleteFile(w_path);
allocator.Free(w_path);
2002-11-22 07:17:59 +01:00
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 */
/* !!! FIXME: Don't use C runtime for allocators? */
int __PHYSFS_platformAllocatorInit(void)
{
return(1); /* always succeeds. */
} /* __PHYSFS_platformAllocatorInit */
void __PHYSFS_platformAllocatorDeinit(void)
{
/* no-op */
} /* __PHYSFS_platformAllocatorInit */
void *__PHYSFS_platformAllocatorMalloc(PHYSFS_uint64 s)
{
BAIL_IF_MACRO(__PHYSFS_ui64FitsAddressSpace(s), ERR_OUT_OF_MEMORY, NULL);
#undef malloc
return(malloc((size_t) s));
} /* __PHYSFS_platformMalloc */
void *__PHYSFS_platformAllocatorRealloc(void *ptr, PHYSFS_uint64 s)
{
BAIL_IF_MACRO(__PHYSFS_ui64FitsAddressSpace(s), ERR_OUT_OF_MEMORY, NULL);
#undef realloc
return(realloc(ptr, (size_t) s));
} /* __PHYSFS_platformRealloc */
void __PHYSFS_platformAllocatorFree(void *ptr)
{
#undef free
free(ptr);
} /* __PHYSFS_platformAllocatorFree */
2005-02-15 23:25:03 +01:00
/* end of pocketpc.c ... */
2002-11-22 07:17:59 +01:00