WebSVN – pentevo – /tools/asl/asl-current/bpemu.c

/* bpemu.c */
/*****************************************************************************/
/* SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only */
/* */
/* AS-Portierung */
/* */
/* Emulation einiger Borland-Pascal-Funktionen */
/* */
/*****************************************************************************/

#include "stdinc.h"
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <ctype.h>

#include "strutil.h"
#include "bpemu.h"

#ifdef __MSDOS__
#include <dos.h>
#include <dir.h>
#endif

#if defined( __EMX__ ) || defined( __IBMC__ )
#include <os2.h>
#endif

#ifdef __MINGW32__
#include <direct.h>
#endif

char *FExpand(char *Src)
{
static String CurrentDir;
String Copy;
#ifdef DRSEP
String DrvPart;
#endif /* DRSEP */
char *p, *p2;

strmaxcpy(Copy, Src, STRINGSIZE);

#ifdef DRSEP
p = strchr(Copy,DRSEP);
if (p)
{
memcpy(DrvPart, Copy, p - Copy);
DrvPart[p - Copy] = '\0';
strmov(Copy, p + 1);
}
else
*DrvPart = '\0';
#endif

#if (defined __MSDOS__)
{
int DrvNum;

if (*DrvPart == '\0')
{
DrvNum = getdisk();
*DrvPart = DrvNum + 'A';
DrvPart[1] = '\0';
DrvNum++;
}
else
DrvNum = toupper(*DrvPart) - '@';
getcurdir(DrvNum, CurrentDir);
}
#elif (defined __EMX__) || (defined __IBMC__)
{
ULONG DrvNum, Dummy;

if (*DrvPart == '\0')
{
DosQueryCurrentDisk(&DrvNum, &Dummy);
*DrvPart = DrvNum + '@';
DrvPart[1] = '\0';
}
else
DrvNum = toupper(*DrvPart) - '@';
Dummy = 255;
DosQueryCurrentDir(DrvNum, (PBYTE) CurrentDir, &Dummy);
}
#elif (defined __MINGW32__)
{
int DrvNum;

if (!*DrvPart)
{
DrvNum = _getdrive();
*DrvPart = DrvNum + '@';
DrvPart[1] = '\0';
}
else
DrvNum = toupper(*DrvPart) - '@';
_getdcwd(DrvNum, CurrentDir, STRINGSIZE);
if (CurrentDir[1] == ':')
strmov(CurrentDir, CurrentDir + 2);
}
#elif (defined _WIN32) /* CygWIN */
if (!getcwd(CurrentDir, STRINGSIZE))
0[CurrentDir] = '\0';
for (p = CurrentDir; *p; p++)
if (*p == '/') *p = '\\';
#else /* UNIX */
if (!getcwd(CurrentDir, STRINGSIZE))
0[CurrentDir] = '\0';
#endif

if ((*CurrentDir) && (CurrentDir[strlen(CurrentDir) - 1] != PATHSEP))
strmaxcat(CurrentDir, SPATHSEP, STRINGSIZE);
if (*CurrentDir!=PATHSEP)
strmaxprep(CurrentDir, SPATHSEP, STRINGSIZE);

if (*Copy == PATHSEP)
{
strmaxcpy(CurrentDir, SPATHSEP, STRINGSIZE);
strmov(Copy, Copy + 1);
}

#ifdef DRSEP
#ifdef __CYGWIN32__
/* win32 getcwd() does not deliver current drive letter, therefore only prepend a drive letter
if there was one before. */
if (*DrvPart)
#endif
{
strmaxprep(CurrentDir, SDRSEP, STRINGSIZE);
strmaxprep(CurrentDir, DrvPart, STRINGSIZE);
}
#endif

while (True)
{
p = strchr(Copy, PATHSEP);
if (!p)
break;
*p = '\0';
if (!strcmp(Copy, "."));
else if ((!strcmp(Copy, "..")) && (strlen(CurrentDir) > 1))
{
CurrentDir[strlen(CurrentDir) - 1] = '\0';
p2 = strrchr(CurrentDir, PATHSEP); p2[1] = '\0';
}
else
{
strmaxcat(CurrentDir, Copy, STRINGSIZE);
strmaxcat(CurrentDir, SPATHSEP, STRINGSIZE);
}
strmov(Copy, p + 1);
}

strmaxcat(CurrentDir, Copy, STRINGSIZE);

return CurrentDir;
}

/*!------------------------------------------------------------------------
* \fn FSearch(char *pDest, size_t DestSize, const char *pFileToSearch, const char *pCurrFileName, const char *pSearchPath)
* \brief search for file in given path(s)
* \param pDest where to put result
* \param DestSize size of result buffer
* \param pFileToSearch file to search for
* \param pCurrFileName file this file was referenced from
* \param pSearchPath list of directories to search
* \return 0 if found or error code
* ------------------------------------------------------------------------ */

static int AssembleAndCheck(char *pDest, size_t DestSize, const char *pPath, unsigned PathLen, const char *pFileToSearch)
{
FILE *pDummy;

if (PathLen > DestSize - 1)
PathLen = DestSize - 1;
memcpy(pDest, pPath, PathLen);
pDest[PathLen] = '\0';
#ifdef __CYGWIN32__
DeCygwinPath(pDest);
#endif
if (PathLen > 0)
strmaxcat(pDest, SPATHSEP, DestSize);
strmaxcat(pDest, pFileToSearch, DestSize);
pDummy = fopen(pDest, "r");
if (pDummy)
{
fclose(pDummy);
return 0;
}
else
return 2;
}

int FSearch(char *pDest, size_t DestSize, const char *pFileToSearch, const char *pCurrFileName, const char *pSearchPath)
{
/* If the file has an absolute path ('/....', '\....', 'X:....'), do not search relative
to current file's directory: */

Boolean Absolute = (*pFileToSearch == '/');
const char *pPos, *pStart;

#if (defined _WIN32) || (defined __EMX__) || (defined __IBMC__) || (defined __MSDOS__)
if (*pFileToSearch == PATHSEP)
Absolute = True;
#endif
#ifdef DRSEP
if ((as_islower(*pFileToSearch) || as_isupper(*pFileToSearch))
&& (pFileToSearch[1] == DRSEP))
Absolute = True;
#endif

if (pCurrFileName && !Absolute)
{
#if (defined _WIN32) || (defined __EMX__) || (defined __IBMC__) || (defined __MSDOS__)
/* On systems with \ as path separator, we may get a mixture of / and \ in the path.
Assure we find the last one of either: */

pPos = strrmultchr(pCurrFileName, SPATHSEP "/");
#else
pPos = strrchr(pCurrFileName, PATHSEP);
#endif
if (!AssembleAndCheck(pDest, DestSize, pCurrFileName, pPos ? pPos - pCurrFileName : 0, pFileToSearch))
return 0;
}
else
{
if (!AssembleAndCheck(pDest, DestSize, NULL, 0, pFileToSearch))
return 0;
}

/* TODO: if the file has an absolute path, searching the include path should be pointless: */

pStart = pSearchPath;
while (True)
{
pPos = strchr(pStart, DIRSEP);

if (!AssembleAndCheck(pDest, DestSize, pStart, pPos ? pPos - pStart : (int)strlen(pStart), pFileToSearch))
return 0;
if (pPos)
pStart = pPos+ 1;
else
break;
}

*pDest = '\0';
return 2;
}

long FileSize(FILE *file)
{
long Save = ftell(file), Size;

fseek(file, 0, SEEK_END);
Size=ftell(file);
fseek(file, Save, SEEK_SET);
return Size;
}

Byte Lo(Word inp)
{
return (inp & 0xff);
}

Byte Hi(Word inp)
{
return ((inp >> 8) & 0xff);
}

unsigned LoWord(LongWord Src)
{
return (Src & 0xffff);
}

unsigned HiWord(LongWord Src)
{
return ((Src >> 16) & 0xffff);
}

unsigned long LoDWord(LargeWord Src)
{
return Src & 0xfffffffful;
}

Boolean Odd(int inp)
{
return ((inp & 1) == 1);
}

Boolean DirScan(const char *Mask, charcallback callback)
{
char Name[1024];

#ifdef __MSDOS__
struct ffblk blk;
int res;
const char *pos;

res = findfirst(Mask, &blk, FA_RDONLY | FA_HIDDEN | FA_SYSTEM | FA_LABEL | FA_DIREC | FA_ARCH);
if (res < 0)
return False;
pos = strrchr(Mask, PATHSEP);
if (!pos)
pos = strrchr(Mask, DRSEP);
pos = pos ? pos + 1 : Mask;
memcpy(Name, Mask, pos - Mask);
while (res==0)
{
if ((blk.ff_attrib & (FA_LABEL|FA_DIREC)) == 0)
{
strcpy(Name + (pos - Mask), blk.ff_name);
callback(Name);
}
res = findnext(&blk);
}
return True;
#else
#if defined ( __EMX__ ) || defined ( __IBMC__ )
HDIR hdir = 1;
FILEFINDBUF3 buf;
ULONG rescnt;
USHORT res;
char *pos;

rescnt = 1;
res = DosFindFirst(Mask, &hdir, 0x16, &buf, sizeof(buf), &rescnt, 1);
if (res)
return False;
pos = strrchr(Mask, PATHSEP);
if (!pos)
pos = strrchr(Mask, DRSEP);
pos = pos ? pos + 1 : Mask;
memcpy(Name, Mask, pos - Mask);
while (res == 0)
{
strcpy(Name + (pos - Mask), buf.achName);
callback(Name);
res = DosFindNext(hdir, &buf, sizeof(buf), &rescnt);
}
return True;
#else
strmaxcpy(Name, Mask, sizeof(Name));
callback(Name);
return True;
#endif
#endif
}

LongInt MyGetFileTime(char *Name)
{
struct stat st;

if (stat(Name, &st) == -1)
return 0;
else
return st.st_mtime;
}

#ifdef __CYGWIN32__

/* convert CygWin-style paths back to something usable by other Win32 apps */

char *DeCygWinDirList(char *pStr)
{
char *pRun;

for (pRun = pStr; *pRun; pRun++)
if (*pRun == ':')
*pRun = ';';

return pStr;
}

char *DeCygwinPath(char *pStr)
{
char *pRun;

if ((strlen(pStr) >= 4)
&& (pStr[0] =='/') && (pStr[1] == '/') && (pStr[3] == '/')
&& (isalpha(pStr[2])))
{
strmov(pStr, pStr + 1);
pStr[0] = pStr[1];
pStr[1] = ':';
}

if ((strlen(pStr) >= 4)
&& (pStr[0] =='\\') && (pStr[1] == '\\') && (pStr[3] == '\\')
&& (isalpha(pStr[2])))
{
strmov(pStr, pStr + 1);
pStr[0] = pStr[1];
pStr[1] = ':';
}

for (pRun = pStr; *pRun; pRun++)
if (*pRun == '/')
*pRun = '\\';

return pStr;
}
#endif /* __CYGWIN32__ */

void bpemu_init(void)
{
}

Top secrets sources NedoPC pentevo

(root)/tools/asl/asl-current/bpemu.c – Rev 1126