mirror of
https://github.com/ZDoom/Raze.git
synced 2024-12-13 22:21:14 +00:00
936 lines
19 KiB
C
936 lines
19 KiB
C
/*
|
|
* Playing-field leveller for Build
|
|
* by Jonathon Fowler
|
|
*
|
|
* A note about this:
|
|
* 1. There is some kind of problem somewhere in the functions below because
|
|
* compiling with __compat_h_macrodef__ disabled makes stupid things happen.
|
|
* 2. The functions below, aside from the ones which aren't trivial, were never
|
|
* really intended to be used for anything except tracking anr removing ties
|
|
* to the standard C library from games. Using the Bxx versions of functions
|
|
* means we can redefine those names to link up with different runtime library
|
|
* names.
|
|
*/
|
|
|
|
#include "compat.h"
|
|
|
|
#ifdef _WIN32
|
|
# include <shlobj.h>
|
|
# include <direct.h>
|
|
#elif __APPLE__
|
|
# include "osxbits.h"
|
|
#endif
|
|
|
|
#if defined(_MSC_VER)
|
|
# include <io.h>
|
|
#else
|
|
# include <dirent.h>
|
|
#endif
|
|
|
|
#if defined(__linux) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
|
|
# include <libgen.h> // for dirname()
|
|
#endif
|
|
#if defined(__FreeBSD__)
|
|
# include <sys/sysctl.h> // for sysctl() to get path to executable
|
|
#endif
|
|
|
|
#include "baselayer.h"
|
|
|
|
////////// PANICKING ALLOCATION FUNCTIONS //////////
|
|
|
|
static void (*g_MemErrHandler)(int32_t line, const char *file, const char *func);
|
|
|
|
#ifdef DEBUGGINGAIDS
|
|
static const char *g_MemErrFunc = "???";
|
|
static const char *g_MemErrFile = "???";
|
|
static int32_t g_MemErrLine;
|
|
|
|
void xalloc_set_location(int32_t line, const char *file, const char *func)
|
|
{
|
|
g_MemErrLine = line;
|
|
g_MemErrFile = file;
|
|
|
|
if (func)
|
|
g_MemErrFunc = func;
|
|
}
|
|
#endif
|
|
|
|
void handle_memerr(void)
|
|
{
|
|
if (g_MemErrHandler)
|
|
{
|
|
#ifdef DEBUGGINGAIDS
|
|
g_MemErrHandler(g_MemErrLine, g_MemErrFile, g_MemErrFunc);
|
|
#else
|
|
g_MemErrHandler(0, "???", "???");
|
|
#endif
|
|
}
|
|
|
|
Bexit(EXIT_FAILURE);
|
|
}
|
|
|
|
void set_memerr_handler(void(*handlerfunc)(int32_t, const char *, const char *))
|
|
{
|
|
g_MemErrHandler = handlerfunc;
|
|
}
|
|
|
|
//////////
|
|
|
|
#ifndef compat_h_macrodef__
|
|
|
|
void Bassert(int expr)
|
|
{
|
|
assert(expr);
|
|
}
|
|
|
|
int32_t Brand(void)
|
|
{
|
|
return rand();
|
|
}
|
|
|
|
void *Bmalloc(bsize_t size)
|
|
{
|
|
return malloc(size);
|
|
}
|
|
|
|
void Bfree(void *ptr)
|
|
{
|
|
Bfree(ptr);
|
|
}
|
|
|
|
int32_t Bopen(const char *pathname, int32_t flags, uint32_t mode)
|
|
{
|
|
int32_t n=0,o=0;
|
|
|
|
if (flags&BO_BINARY) n|=O_BINARY; else n|=O_TEXT;
|
|
if ((flags&BO_RDWR)==BO_RDWR) n|=O_RDWR;
|
|
else if ((flags&BO_RDWR)==BO_WRONLY) n|=O_WRONLY;
|
|
else if ((flags&BO_RDWR)==BO_RDONLY) n|=O_RDONLY;
|
|
if (flags&BO_APPEND) n|=O_APPEND;
|
|
if (flags&BO_CREAT) n|=O_CREAT;
|
|
if (flags&BO_TRUNC) n|=O_TRUNC;
|
|
if (mode&BS_IREAD) o|=S_IREAD;
|
|
if (mode&BS_IWRITE) o|=S_IWRITE;
|
|
if (mode&BS_IEXEC) o|=S_IEXEC;
|
|
|
|
return open(pathname,n,o);
|
|
}
|
|
|
|
int32_t Bclose(int32_t fd)
|
|
{
|
|
return close(fd);
|
|
}
|
|
|
|
bssize_t Bwrite(int32_t fd, const void *buf, bsize_t count)
|
|
{
|
|
return write(fd,buf,count);
|
|
}
|
|
|
|
bssize_t Bread(int32_t fd, void *buf, bsize_t count)
|
|
{
|
|
return read(fd,buf,count);
|
|
}
|
|
|
|
int32_t Blseek(int32_t fildes, int32_t offset, int32_t whence)
|
|
{
|
|
switch (whence)
|
|
{
|
|
case BSEEK_SET:
|
|
whence=SEEK_SET; break;
|
|
case BSEEK_CUR:
|
|
whence=SEEK_CUR; break;
|
|
case BSEEK_END:
|
|
whence=SEEK_END; break;
|
|
}
|
|
return lseek(fildes,offset,whence);
|
|
}
|
|
|
|
BFILE *Bfopen(const char *path, const char *mode)
|
|
{
|
|
return (BFILE *)fopen(path,mode);
|
|
}
|
|
|
|
int32_t Bfclose(BFILE *stream)
|
|
{
|
|
return fclose((FILE *)stream);
|
|
}
|
|
|
|
void Brewind(BFILE *stream)
|
|
{
|
|
rewind((FILE *)stream);
|
|
}
|
|
|
|
int32_t Bfgetc(BFILE *stream)
|
|
{
|
|
return fgetc((FILE *)stream);
|
|
}
|
|
|
|
char *Bfgets(char *s, int32_t size, BFILE *stream)
|
|
{
|
|
return fgets(s,size,(FILE *)stream);
|
|
}
|
|
|
|
int32_t Bfputc(int32_t c, BFILE *stream)
|
|
{
|
|
return fputc(c,(FILE *)stream);
|
|
}
|
|
|
|
int32_t Bfputs(const char *s, BFILE *stream)
|
|
{
|
|
return fputs(s,(FILE *)stream);
|
|
}
|
|
|
|
bsize_t Bfread(void *ptr, bsize_t size, bsize_t nmemb, BFILE *stream)
|
|
{
|
|
return fread(ptr,size,nmemb,(FILE *)stream);
|
|
}
|
|
|
|
bsize_t Bfwrite(const void *ptr, bsize_t size, bsize_t nmemb, BFILE *stream)
|
|
{
|
|
return fwrite(ptr,size,nmemb,(FILE *)stream);
|
|
}
|
|
|
|
|
|
char *Bstrdup(const char *s)
|
|
{
|
|
return strdup(s);
|
|
}
|
|
|
|
char *Bstrcpy(char *dest, const char *src)
|
|
{
|
|
return strcpy(dest,src);
|
|
}
|
|
|
|
char *Bstrncpy(char *dest, const char *src, bsize_t n)
|
|
{
|
|
return Bstrncpy(dest,src,n);
|
|
}
|
|
|
|
int32_t Bstrcmp(const char *s1, const char *s2)
|
|
{
|
|
return strcmp(s1,s2);
|
|
}
|
|
|
|
int32_t Bstrncmp(const char *s1, const char *s2, bsize_t n)
|
|
{
|
|
return strncmp(s1,s2,n);
|
|
}
|
|
|
|
int32_t Bstrcasecmp(const char *s1, const char *s2)
|
|
{
|
|
#ifdef _MSC_VER
|
|
return _stricmp(s1,s2);
|
|
#else
|
|
return strcasecmp(s1,s2);
|
|
#endif
|
|
}
|
|
|
|
int32_t Bstrncasecmp(const char *s1, const char *s2, bsize_t n)
|
|
{
|
|
#ifdef _MSC_VER
|
|
return _strnicmp(s1,s2,n);
|
|
#else
|
|
return strncasecmp(s1,s2,n);
|
|
#endif
|
|
}
|
|
|
|
char *Bstrcat(char *dest, const char *src)
|
|
{
|
|
return strcat(dest,src);
|
|
}
|
|
|
|
char *Bstrncat(char *dest, const char *src, bsize_t n)
|
|
{
|
|
return strncat(dest,src,n);
|
|
}
|
|
|
|
bsize_t Bstrlen(const char *s)
|
|
{
|
|
return strlen(s);
|
|
}
|
|
|
|
char *Bstrchr(const char *s, int32_t c)
|
|
{
|
|
return strchr(s,c);
|
|
}
|
|
|
|
char *Bstrrchr(const char *s, int32_t c)
|
|
{
|
|
return strrchr(s,c);
|
|
}
|
|
|
|
int32_t Batoi(const char *nptr)
|
|
{
|
|
return strtol(nptr, NULL, 10);
|
|
}
|
|
|
|
int32_t Batol(const char *nptr)
|
|
{
|
|
return strtol(nptr, NULL, 10);
|
|
}
|
|
|
|
int32_t Bstrtol(const char *nptr, char **endptr, int32_t base)
|
|
{
|
|
return strtol(nptr,endptr,base);
|
|
}
|
|
|
|
uint32_t Bstrtoul(const char *nptr, char **endptr, int32_t base)
|
|
{
|
|
return strtoul(nptr,endptr,base);
|
|
}
|
|
|
|
void *Bmemcpy(void *dest, const void *src, bsize_t n)
|
|
{
|
|
return memcpy(dest,src,n);
|
|
}
|
|
|
|
void *Bmemmove(void *dest, const void *src, bsize_t n)
|
|
{
|
|
return memmove(dest,src,n);
|
|
}
|
|
|
|
void *Bmemchr(const void *s, int32_t c, bsize_t n)
|
|
{
|
|
return memchr(s,c,n);
|
|
}
|
|
|
|
void *Bmemset(void *s, int32_t c, bsize_t n)
|
|
{
|
|
return memset(s,c,n);
|
|
}
|
|
|
|
int32_t Bprintf(const char *format, ...)
|
|
{
|
|
va_list ap;
|
|
int32_t r;
|
|
|
|
va_start(ap,format);
|
|
#ifdef _MSC_VER
|
|
r = _vprintf(format,ap);
|
|
#else
|
|
r = vprintf(format,ap);
|
|
#endif
|
|
va_end(ap);
|
|
return r;
|
|
}
|
|
|
|
int32_t Bsprintf(char *str, const char *format, ...)
|
|
{
|
|
va_list ap;
|
|
int32_t r;
|
|
|
|
va_start(ap,format);
|
|
#ifdef _MSC_VER
|
|
r = _vsprintf(str,format,ap);
|
|
#else
|
|
r = vsprintf(str,format,ap);
|
|
#endif
|
|
va_end(ap);
|
|
return r;
|
|
}
|
|
|
|
int32_t Bsnprintf(char *str, bsize_t size, const char *format, ...)
|
|
{
|
|
va_list ap;
|
|
int32_t r;
|
|
|
|
va_start(ap,format);
|
|
#ifdef _MSC_VER
|
|
r = _vsnprintf(str,size,format,ap);
|
|
#else
|
|
r = vsnprintf(str,size,format,ap);
|
|
#endif
|
|
va_end(ap);
|
|
return r;
|
|
}
|
|
|
|
int32_t Bvsnprintf(char *str, bsize_t size, const char *format, va_list ap)
|
|
{
|
|
#ifdef _MSC_VER
|
|
return _vsnprintf(str,size,format,ap);
|
|
#else
|
|
return vsnprintf(str,size,format,ap);
|
|
#endif
|
|
}
|
|
|
|
char *Bgetenv(const char *name)
|
|
{
|
|
return getenv(name);
|
|
}
|
|
|
|
char *Bgetcwd(char *buf, bsize_t size)
|
|
{
|
|
return getcwd(buf,size);
|
|
}
|
|
|
|
#endif // __compat_h_macrodef__
|
|
|
|
|
|
//
|
|
// Stuff which must be a function
|
|
//
|
|
#ifdef _WIN32
|
|
typedef BOOL (WINAPI * aSHGetSpecialFolderPathAtype)(HWND, LPTSTR, int, BOOL);
|
|
#endif
|
|
|
|
char *Bgethomedir(void)
|
|
{
|
|
#ifdef _WIN32
|
|
aSHGetSpecialFolderPathAtype aSHGetSpecialFolderPathA;
|
|
TCHAR appdata[MAX_PATH];
|
|
int32_t loaded = 0;
|
|
HMODULE hShell32 = GetModuleHandle("shell32.dll");
|
|
|
|
if (hShell32 == NULL)
|
|
{
|
|
hShell32 = LoadLibrary("shell32.dll");
|
|
loaded = 1;
|
|
}
|
|
|
|
if (hShell32 == NULL)
|
|
return NULL;
|
|
|
|
aSHGetSpecialFolderPathA = (aSHGetSpecialFolderPathAtype)GetProcAddress(hShell32, "SHGetSpecialFolderPathA");
|
|
if (aSHGetSpecialFolderPathA != NULL)
|
|
if (SUCCEEDED(aSHGetSpecialFolderPathA(NULL, appdata, CSIDL_APPDATA, FALSE)))
|
|
{
|
|
if (loaded)
|
|
FreeLibrary(hShell32);
|
|
return Bstrdup(appdata);
|
|
}
|
|
|
|
if (loaded)
|
|
FreeLibrary(hShell32);
|
|
return NULL;
|
|
#elif defined __APPLE__
|
|
return osx_gethomedir();
|
|
#elif defined(GEKKO)
|
|
// return current drive's name
|
|
char *drv, cwd[BMAX_PATH] = {0};
|
|
getcwd(cwd, BMAX_PATH);
|
|
drv = strchr(cwd, ':');
|
|
if (drv)
|
|
drv[1] = '\0';
|
|
return Bstrdup(cwd);
|
|
#else
|
|
char *e = getenv("HOME");
|
|
if (!e) return NULL;
|
|
return Bstrdup(e);
|
|
#endif
|
|
}
|
|
|
|
char *Bgetsupportdir(void)
|
|
{
|
|
#if defined __APPLE__
|
|
return osx_getsupportdir();
|
|
#else
|
|
return Bgethomedir();
|
|
#endif
|
|
}
|
|
|
|
char *Bgetappdir(void)
|
|
{
|
|
char *dir = NULL;
|
|
|
|
#ifdef _WIN32
|
|
TCHAR appdir[MAX_PATH];
|
|
|
|
if (GetModuleFileName(NULL, appdir, MAX_PATH) > 0) {
|
|
// trim off the filename
|
|
char *slash = strrchr(appdir, '\\');
|
|
if (slash) slash[0] = 0;
|
|
dir = strdup(appdir);
|
|
}
|
|
|
|
#elif defined __APPLE__
|
|
dir = osx_getappdir();
|
|
#elif defined(__linux) || defined(__NetBSD__) || defined(__OpenBSD__)
|
|
char buf[PATH_MAX] = {0};
|
|
char buf2[PATH_MAX] = {0};
|
|
# ifdef __linux
|
|
snprintf(buf, sizeof(buf), "/proc/%d/exe", getpid());
|
|
# else // the BSDs.. except for FreeBSD which has a sysctl
|
|
snprintf(buf, sizeof(buf), "/proc/%d/file", getpid());
|
|
# endif
|
|
int len = readlink(buf, buf2, sizeof(buf2));
|
|
if (len != -1) {
|
|
// remove executable name with dirname(3)
|
|
// on Linux, dirname() will modify buf2 (cutting off executable name) and return it
|
|
// on FreeBSD it seems to use some internal buffer instead.. anyway, just strdup()
|
|
dir = strdup(dirname(buf2));
|
|
}
|
|
#elif defined(__FreeBSD__)
|
|
// the sysctl should also work when /proc/ is not mounted (which seems to
|
|
// be common on FreeBSD), so use it..
|
|
char buf[PATH_MAX] = {0};
|
|
int name[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1};
|
|
size_t len = sizeof(buf)-1;
|
|
int ret = sysctl(name, sizeof(name)/sizeof(name[0]), buf, &len, NULL, 0);
|
|
if(ret == 0 && buf[0] != '\0') {
|
|
// again, remove executable name with dirname()
|
|
// on FreeBSD dirname() seems to use some internal buffer
|
|
dir = strdup(dirname(buf));
|
|
}
|
|
#endif
|
|
|
|
return dir;
|
|
}
|
|
|
|
int32_t Bcorrectfilename(char *filename, int32_t removefn)
|
|
{
|
|
char *fn;
|
|
char *tokarr[64], *first, *next = NULL, *token;
|
|
int32_t i, ntok = 0, leadslash = 0, trailslash = 0;
|
|
|
|
fn = Bstrdup(filename);
|
|
if (!fn) return -1;
|
|
|
|
for (first=fn; *first; first++)
|
|
{
|
|
#ifdef _WIN32
|
|
if (*first == '\\') *first = '/';
|
|
#endif
|
|
}
|
|
leadslash = (*fn == '/');
|
|
trailslash = (first>fn && first[-1] == '/');
|
|
|
|
first = fn;
|
|
do
|
|
{
|
|
token = Bstrtoken(first, "/", &next, 1);
|
|
first = NULL;
|
|
if (!token) break;
|
|
else if (token[0] == 0) continue;
|
|
else if (token[0] == '.' && token[1] == 0) continue;
|
|
else if (token[0] == '.' && token[1] == '.' && token[2] == 0) ntok = max(0,ntok-1);
|
|
else tokarr[ntok++] = token;
|
|
}
|
|
while (1);
|
|
|
|
if (!trailslash && removefn) { ntok = max(0,ntok-1); trailslash = 1; }
|
|
if (ntok == 0 && trailslash && leadslash) trailslash = 0;
|
|
|
|
first = filename;
|
|
if (leadslash) *(first++) = '/';
|
|
for (i=0; i<ntok; i++)
|
|
{
|
|
if (i>0) *(first++) = '/';
|
|
for (token=tokarr[i]; *token; token++)
|
|
*(first++) = *token;
|
|
}
|
|
if (trailslash) *(first++) = '/';
|
|
*(first++) = 0;
|
|
|
|
Bfree(fn);
|
|
return 0;
|
|
}
|
|
|
|
int32_t Bcanonicalisefilename(char *filename, int32_t removefn)
|
|
{
|
|
char cwd[BMAX_PATH], fn[BMAX_PATH], *p;
|
|
char *fnp = filename;
|
|
#ifdef _WIN32
|
|
int32_t drv = 0;
|
|
#endif
|
|
|
|
#ifdef _WIN32
|
|
{
|
|
if (filename[0] && filename[1] == ':')
|
|
{
|
|
// filename is prefixed with a drive
|
|
drv = toupper(filename[0])-'A' + 1;
|
|
fnp += 2;
|
|
}
|
|
if (!_getdcwd(drv, cwd, sizeof(cwd))) return -1;
|
|
for (p=cwd; *p; p++) if (*p == '\\') *p = '/';
|
|
}
|
|
#else
|
|
if (!getcwd(cwd,sizeof(cwd))) return -1;
|
|
#endif
|
|
p = strrchr(cwd,'/'); if (!p || p[1]) strcat(cwd, "/");
|
|
|
|
strcpy(fn, fnp);
|
|
#ifdef _WIN32
|
|
for (p=fn; *p; p++) if (*p == '\\') *p = '/';
|
|
#endif
|
|
|
|
if (fn[0] != '/')
|
|
{
|
|
// we are dealing with a path relative to the current directory
|
|
strcpy(filename, cwd);
|
|
strcat(filename, fn);
|
|
}
|
|
else
|
|
{
|
|
#ifdef _WIN32
|
|
filename[0] = cwd[0];
|
|
filename[1] = ':';
|
|
filename[2] = 0;
|
|
#else
|
|
filename[0] = 0;
|
|
#endif
|
|
strcat(filename, fn);
|
|
}
|
|
fnp = filename;
|
|
#ifdef _WIN32
|
|
fnp += 2; // skip the drive
|
|
#endif
|
|
UNREFERENCED_PARAMETER(removefn); // change the call below to use removefn instead of 1?
|
|
return Bcorrectfilename(fnp,1);
|
|
}
|
|
|
|
char *Bgetsystemdrives(void)
|
|
{
|
|
#ifdef _WIN32
|
|
char *str, *p;
|
|
DWORD drv, mask;
|
|
int32_t number=0;
|
|
|
|
drv = GetLogicalDrives();
|
|
if (drv == 0) return NULL;
|
|
|
|
for (mask=1; mask<0x8000000l; mask<<=1)
|
|
{
|
|
if ((drv&mask) == 0) continue;
|
|
number++;
|
|
}
|
|
|
|
str = p = (char *)Bmalloc(1 + (3*number));
|
|
if (!str) return NULL;
|
|
|
|
number = 0;
|
|
for (mask=1; mask<0x8000000l; mask<<=1, number++)
|
|
{
|
|
if ((drv&mask) == 0) continue;
|
|
*(p++) = 'A' + number;
|
|
*(p++) = ':';
|
|
*(p++) = 0;
|
|
}
|
|
*(p++) = 0;
|
|
|
|
return str;
|
|
#else
|
|
// Perhaps have Unix OS's put /, /home/user, and /mnt/* in the "drives" list?
|
|
return NULL;
|
|
#endif
|
|
}
|
|
|
|
|
|
int32_t Bfilelength(int32_t fd)
|
|
{
|
|
struct Bstat st;
|
|
if (Bfstat(fd, &st) < 0) return -1;
|
|
return(int32_t)(st.st_size);
|
|
}
|
|
|
|
|
|
typedef struct
|
|
{
|
|
#ifdef _MSC_VER
|
|
intptr_t dir;
|
|
struct _finddata_t fid;
|
|
#else
|
|
DIR *dir;
|
|
#endif
|
|
struct Bdirent info;
|
|
int32_t status;
|
|
char name[1];
|
|
} BDIR_real;
|
|
|
|
BDIR *Bopendir(const char *name)
|
|
{
|
|
BDIR_real *dirr;
|
|
#ifdef _MSC_VER
|
|
char *t,*tt;
|
|
t = (char *)Bmalloc(strlen(name)+1+4);
|
|
if (!t) return NULL;
|
|
#endif
|
|
|
|
dirr = (BDIR_real *)Bmalloc(sizeof(BDIR_real) + strlen(name));
|
|
if (!dirr)
|
|
{
|
|
#ifdef _MSC_VER
|
|
Bfree(t);
|
|
#endif
|
|
return NULL;
|
|
}
|
|
|
|
#ifdef _MSC_VER
|
|
strcpy(t,name);
|
|
tt = t+strlen(name)-1;
|
|
while (*tt == ' ' && tt>t) tt--;
|
|
if (*tt != '/' && *tt != '\\') *(++tt) = '/';
|
|
*(++tt) = '*';
|
|
*(++tt) = '.';
|
|
*(++tt) = '*';
|
|
*(++tt) = 0;
|
|
|
|
dirr->dir = _findfirst(t,&dirr->fid);
|
|
Bfree(t);
|
|
if (dirr->dir == -1)
|
|
{
|
|
Bfree(dirr);
|
|
return NULL;
|
|
}
|
|
#else
|
|
dirr->dir = opendir(name);
|
|
if (dirr->dir == NULL)
|
|
{
|
|
Bfree(dirr);
|
|
return NULL;
|
|
}
|
|
#endif
|
|
|
|
dirr->status = 0;
|
|
strcpy(dirr->name, name);
|
|
|
|
return (BDIR *)dirr;
|
|
}
|
|
|
|
struct Bdirent *Breaddir(BDIR *dir)
|
|
{
|
|
BDIR_real *dirr = (BDIR_real *)dir;
|
|
struct dirent *de;
|
|
struct Bstat st;
|
|
char *fn;
|
|
|
|
#ifdef _MSC_VER
|
|
if (dirr->status > 0)
|
|
{
|
|
if (_findnext(dirr->dir,&dirr->fid) != 0)
|
|
{
|
|
dirr->status = -1;
|
|
return NULL;
|
|
}
|
|
}
|
|
dirr->info.namlen = strlen(dirr->fid.name);
|
|
dirr->info.name = dirr->fid.name;
|
|
dirr->status++;
|
|
#else
|
|
de = readdir(dirr->dir);
|
|
if (de == NULL)
|
|
{
|
|
dirr->status = -1;
|
|
return NULL;
|
|
}
|
|
else
|
|
{
|
|
dirr->status++;
|
|
}
|
|
//# if defined(__WATCOMC__) || defined(__linux) || defined(__BEOS__) || defined(__QNX__) || defined(SKYOS)
|
|
dirr->info.namlen = strlen(de->d_name);
|
|
//# else
|
|
// dirr->info.namlen = de->d_namlen;
|
|
//# endif
|
|
dirr->info.name = de->d_name;
|
|
#endif
|
|
dirr->info.mode = 0;
|
|
dirr->info.size = 0;
|
|
dirr->info.mtime = 0;
|
|
|
|
fn = (char *)Bmalloc(strlen(dirr->name) + 1 + dirr->info.namlen + 1);
|
|
if (fn)
|
|
{
|
|
Bsprintf(fn,"%s/%s",dirr->name,dirr->info.name);
|
|
if (!Bstat(fn, &st))
|
|
{
|
|
dirr->info.mode = st.st_mode;
|
|
dirr->info.size = st.st_size;
|
|
dirr->info.mtime = st.st_mtime;
|
|
}
|
|
Bfree(fn);
|
|
}
|
|
|
|
return &dirr->info;
|
|
}
|
|
|
|
int32_t Bclosedir(BDIR *dir)
|
|
{
|
|
BDIR_real *dirr = (BDIR_real *)dir;
|
|
|
|
#ifdef _MSC_VER
|
|
_findclose(dirr->dir);
|
|
#else
|
|
closedir(dirr->dir);
|
|
#endif
|
|
Bfree(dirr);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
char *Bstrtoken(char *s, const char *delim, char **ptrptr, int32_t chop)
|
|
{
|
|
char *p, *start;
|
|
|
|
if (!ptrptr) return NULL;
|
|
|
|
if (s) p = s;
|
|
else p = *ptrptr;
|
|
|
|
if (!p) return NULL;
|
|
|
|
while (*p != 0 && strchr(delim, *p)) p++;
|
|
if (*p == 0)
|
|
{
|
|
*ptrptr = NULL;
|
|
return NULL;
|
|
}
|
|
start = p;
|
|
while (*p != 0 && !strchr(delim, *p)) p++;
|
|
if (*p == 0) *ptrptr = NULL;
|
|
else
|
|
{
|
|
if (chop) *(p++) = 0;
|
|
*ptrptr = p;
|
|
}
|
|
|
|
return start;
|
|
}
|
|
|
|
char *Bstrtolower(char *str)
|
|
{
|
|
if (!str) return NULL;
|
|
|
|
{
|
|
int32_t i = 0, len = Bstrlen(str);
|
|
|
|
if (len <= 0) return str;
|
|
|
|
do
|
|
{
|
|
*(str+i) = Btolower(*(str+i));
|
|
i++;
|
|
}
|
|
while (--len);
|
|
}
|
|
|
|
return str;
|
|
}
|
|
|
|
|
|
//Brute-force case-insensitive, slash-insensitive, * and ? wildcard matcher
|
|
//Given: string i and string j. string j can have wildcards
|
|
//Returns: 1:matches, 0:doesn't match
|
|
#ifndef WITHKPLIB
|
|
extern char toupperlookup[256];
|
|
|
|
static int32_t wildmatch(const char *match, const char *wild)
|
|
{
|
|
do
|
|
{
|
|
if (*match && (toupperlookup[*wild] == toupperlookup[*match] || *wild == '?'))
|
|
{
|
|
wild++, match++;
|
|
continue;
|
|
}
|
|
else if ((*match|*wild) == '\0')
|
|
return 1;
|
|
else if (*wild == '*')
|
|
{
|
|
while (*wild == '*') wild++;
|
|
if (*wild == '\0') return 1;
|
|
while (*match && toupperlookup[*match] != toupperlookup[*wild]) match++;
|
|
if (toupperlookup[*match] == toupperlookup[*wild])
|
|
continue;
|
|
}
|
|
return 0;
|
|
} while (1);
|
|
}
|
|
#endif
|
|
|
|
#if !defined(_WIN32)
|
|
char *Bstrlwr(char *s)
|
|
{
|
|
char *t = s;
|
|
if (!s) return s;
|
|
while (*t) { *t = Btolower(*t); t++; }
|
|
return s;
|
|
}
|
|
|
|
char *Bstrupr(char *s)
|
|
{
|
|
char *t = s;
|
|
if (!s) return s;
|
|
while (*t) { *t = Btoupper(*t); t++; }
|
|
return s;
|
|
}
|
|
#endif
|
|
|
|
|
|
//
|
|
// Bgetsysmemsize() -- gets the amount of system memory in the machine
|
|
//
|
|
#ifdef _WIN32
|
|
typedef BOOL (WINAPI *aGlobalMemoryStatusExType)(LPMEMORYSTATUSEX);
|
|
#endif
|
|
|
|
uint32_t Bgetsysmemsize(void)
|
|
{
|
|
#ifdef _WIN32
|
|
uint32_t siz = UINT32_MAX;
|
|
HMODULE lib = LoadLibrary("KERNEL32.DLL");
|
|
|
|
if (lib)
|
|
{
|
|
aGlobalMemoryStatusExType aGlobalMemoryStatusEx =
|
|
(aGlobalMemoryStatusExType)GetProcAddress(lib, "GlobalMemoryStatusEx");
|
|
|
|
if (aGlobalMemoryStatusEx)
|
|
{
|
|
//WinNT
|
|
MEMORYSTATUSEX memst;
|
|
memst.dwLength = sizeof(MEMORYSTATUSEX);
|
|
if (aGlobalMemoryStatusEx(&memst))
|
|
siz = (uint32_t)min(UINT32_MAX, memst.ullTotalPhys);
|
|
}
|
|
else
|
|
{
|
|
// Yeah, there's enough Win9x hatred here that a perfectly good workaround
|
|
// has been replaced by an error message. Oh well, we don't support 9x anyway.
|
|
initprintf("Bgetsysmemsize(): error determining system memory size!\n");
|
|
}
|
|
|
|
FreeLibrary(lib);
|
|
}
|
|
|
|
return siz;
|
|
#elif (defined(_SC_PAGE_SIZE) || defined(_SC_PAGESIZE)) && defined(_SC_PHYS_PAGES) && !defined(GEKKO)
|
|
uint32_t siz = UINT32_MAX;
|
|
int64_t scpagesiz, scphyspages;
|
|
|
|
#ifdef _SC_PAGE_SIZE
|
|
scpagesiz = sysconf(_SC_PAGE_SIZE);
|
|
#else
|
|
scpagesiz = sysconf(_SC_PAGESIZE);
|
|
#endif
|
|
scphyspages = sysconf(_SC_PHYS_PAGES);
|
|
if (scpagesiz >= 0 && scphyspages >= 0)
|
|
siz = (uint32_t)min(UINT32_MAX, (int64_t)scpagesiz * (int64_t)scphyspages);
|
|
|
|
//initprintf("Bgetsysmemsize(): %d pages of %d bytes, %d bytes of system memory\n",
|
|
// scphyspages, scpagesiz, siz);
|
|
|
|
return siz;
|
|
#else
|
|
return UINT32_MAX;
|
|
#endif
|
|
}
|
|
|
|
#ifdef GEKKO
|
|
int access(const char *pathname, int mode)
|
|
{
|
|
struct stat st;
|
|
if (stat(pathname, &st)==-1)
|
|
return -1;
|
|
|
|
// TODO: Check mode against st_mode
|
|
UNREFERENCED_PARAMETER(mode);
|
|
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
#define LIBDIVIDE_BODY
|
|
#include "libdivide.h"
|
|
|