void fstrncpy(char *dest, ucell src, unsigned int maxlen)
{
int len = fstrlen(src);
if (fstrlen(src) >= maxlen) len = maxlen - 1;
memcpy(dest, cell2pointer(src), len);
*(dest + len) = '\0';
}
void f2cstr(char *f, int max_f, char *c, int max_c)
{
int i;
i = min(fstrlen(f,max_f),max_c);
strncpy(c,f,i);
c[i]='\0';
}
static int
compare0 (const char *s1, int s1_len, const char *s2)
{
int len;
/* Strip trailing blanks from the Fortran string. */
len = fstrlen (s1, s1_len);
return strncasecmp (s1, s2, len) == 0;
}
char *
fc_strdup (const char *src, gfc_charlen_type src_len)
{
gfc_charlen_type n = fstrlen (src, src_len);
char *p = strndup (src, n);
if (!p)
os_error ("Memory allocation failed in fc_strdup");
return p;
}
GFC_INTEGER_4
selected_char_kind (gfc_charlen_type name_len, char *name)
{
gfc_charlen_type len = fstrlen (name, name_len);
if ((len == 5 && strncasecmp (name, "ascii", 5) == 0)
|| (len == 7 && strncasecmp (name, "default", 7) == 0))
return 1;
else if (len == 9 && strncasecmp (name, "iso_10646", 9) == 0)
return 4;
else
return -1;
}
int
find_option (st_parameter_common *cmp, const char *s1, gfc_charlen_type s1_len,
const st_option * opts, const char *error_message)
{
/* Strip trailing blanks from the Fortran string. */
size_t len = (size_t) fstrlen (s1, s1_len);
for (; opts->name; opts++)
if (len == strlen(opts->name) && strncasecmp (s1, opts->name, len) == 0)
return opts->value;
generate_error (cmp, LIBERROR_BAD_OPTION, error_message);
return -1;
}
fm::string FUStringConversion::ToString(const fchar* value)
{
FUSStringBuilder builder;
if (value != NULL)
{
uint32 length = (uint32) fstrlen(value);
builder.reserve(length + 1);
for (uint32 i = 0; i < length; ++i)
{
if (value[i] < 0xFF || (value[i] & (~0xFF)) >= 32) builder.append((char)value[i]);
else builder.append('_'); // some generic enough character
}
}
return builder.ToString();
}
void FUDebug::DebugOutV(uint8 verbosity, const fchar* message, va_list& vars)
{
uint32 length = (uint32) fstrlen(message);
fchar* buffer = new fchar[length + 256];
fvsnprintf(buffer, length + 256, message, vars);
length = (uint32) min(wcslen(buffer), (size_t) length + 253);
buffer[length] = '\n';
buffer[length+1] = '\r';
buffer[length+2] = 0;
DebugString(buffer);
FUError::SetCustomErrorString(TO_STRING((const fchar*) buffer));
FUError::Error((FUError::Level) verbosity, FUError::ERROR_CUSTOM_STRING, 5000);
SAFE_DELETE_ARRAY(buffer);
}
xt_t findword(const char *s1)
{
ucell tmplfa, len;
if (!last)
return 0;
tmplfa = read_ucell(last);
len = strlen(s1);
while (tmplfa) {
ucell nfa = lfa2nfa(tmplfa);
if (len == fstrlen(nfa) && !fstrcmp(s1, nfa)) {
return lfa2cfa(tmplfa);
}
tmplfa = read_ucell(cell2pointer(tmplfa));
}
return 0;
}
extern int _vsnprintf(char *pszOutput, size_t uSize, const char *pszFormat, va_list pArgs)
{
int *pparms; // Pointer to the optional arguments following the format
char c;
char cFill;
char szTempBuf[80];
char far *lpszTemp;
char *pszOutput0 = pszOutput;
int iRequested; // Requested width for an output field
int iAvailable; // Number of characters available for output
int iLong; // TRUE if the %l modifier has been provided
pparms = (int *)pArgs;
while (c = *(pszFormat++))
{
if (c == '%') // If c is the format escape character.
{
cFill = ' '; // Default filler for the left side of output fields
if (*pszFormat == '0')
{
cFill = '0'; // Optional filler
pszFormat += 1; // Skip the 0
}
if (*pszFormat == '*') // If variable length format
{
iRequested = *(pparms++); // Get the size from the argument list
pszFormat += 1; // Skip the *
}
else // Else fixed length format
{
// Convert the field size to an int, and advance past the size in format.
pszFormat += stcd_i(pszFormat, &iRequested);
}
iLong = FALSE;
test_format:
switch (*(pszFormat++)) // The next char is the format ID.
{
case 'd':
if (!iLong)
iAvailable = stci_d(szTempBuf, *(pparms++)); // Convert int to string
else
iAvailable = stcli_d(szTempBuf, *(((long *)pparms)++)); // Convert int to string
pszOutput += strcpyform(pszOutput, szTempBuf, iRequested, iAvailable, cFill);
break;
case 'u':
iAvailable = stcu_d(szTempBuf, *(pparms++)); // Convert uint to string
pszOutput += strcpyform(pszOutput, szTempBuf, iRequested, iAvailable, cFill);
break;
case 'p':
if (iLong)
pszOutput += sprintf(pszOutput, "%04X:", pparms[1]);
pszOutput += sprintf(pszOutput, "%04X", pparms[0]);
pparms += iLong+1;
break;
case 'x': // Incompatible! Processed as %X to save space.
case 'X':
if (!iLong)
iAvailable = stci_h(szTempBuf, *(pparms++)); // Convert uint to hex. string
else
iAvailable = stcli_h(szTempBuf, *(((long *)pparms)++)); // Convert uint to hex. string
pszOutput += strcpyform(pszOutput, szTempBuf, iRequested, iAvailable, cFill);
break;
case 's':
if (!iLong)
lpszTemp = *(((char **)pparms)++); // Pointer on the given string
else
lpszTemp = *(((char far **)pparms)++); // Pointer on the given string
pszOutput += strcpyform(pszOutput, lpszTemp, iRequested, fstrlen(lpszTemp), cFill);
break;
case 'c':
*pparms &= 0x00FF; // Make sure the char is followed by a NUL.
pszOutput += strcpyform(pszOutput, (char *)(pparms++), iRequested, 1, ' ');
break;
case '%':
*(pszOutput++) = '%';
break;
case 'l':
case 'F':
iLong = TRUE;
goto test_format; // Ignore long integer specifications
default: // Unsupported format. Just output question marks
pszOutput += strcpyform(pszOutput, "", iRequested, 0, '?');
break;
}
}
else // Else c is a normal character
{
*(pszOutput++) = c; // Just copy it to the output
}
}
*pszOutput = '\0';
return pszOutput - pszOutput0; // Number of characters written
}
VOID DosUpFString(char FAR * str)
/* upcase a string for file names */
{
DosUpFMem(str, fstrlen(str));
}
VOID DosUpString(char FAR * str)
/* upcase a string */
{
DosUpMem(str, fstrlen(str));
}
/* not necessary anymore because of truename */
COUNT ParseDosPath(BYTE * lpszFileName,
COUNT * pnDrive,
BYTE * pszDir,
BYTE * pszCurPath)
{
COUNT nDirCnt,
nPathCnt;
BYTE *lpszLclDir,
*pszBase = pszDir;
/* Initialize the users data fields */
*pszDir = '\0';
lpszLclDir = 0;
nDirCnt = nPathCnt = 0;
/* Start by cheking for a drive specifier ... */
if (DriveChar(*lpszFileName) && ':' == lpszFileName[1])
{
/* found a drive, fetch it and bump pointer past drive */
/* NB: this code assumes ASCII */
if (pnDrive)
{
*pnDrive = *lpszFileName - 'A';
if (*pnDrive > 26)
*pnDrive -= ('a' - 'A');
}
lpszFileName += 2;
}
else
{
if (pnDrive)
{
*pnDrive = -1;
}
}
lpszLclDir = lpszFileName;
if (!PathSep(*lpszLclDir))
{
fstrncpy(pszDir, pszCurPath, PARSE_MAX - 1); /*TE*/
nPathCnt = fstrlen(pszCurPath);
if (!PathSep(pszDir[nPathCnt - 1]) && nPathCnt < PARSE_MAX - 1) /*TE*/
pszDir[nPathCnt++] = '\\';
if (nPathCnt > PARSE_MAX)
nPathCnt = PARSE_MAX;
pszDir += nPathCnt;
}
/* Now see how long a directory component we have. */
while (NameChar(*lpszFileName)
|| PathSep(*lpszFileName)
|| '.' == *lpszFileName)
{
++nDirCnt;
++lpszFileName;
}
/* Fix lengths to maximums allowed by MS-DOS. */
if ((nDirCnt + nPathCnt) > PARSE_MAX - 1) /*TE*/
nDirCnt = PARSE_MAX - 1 - nPathCnt;
/* Finally copy whatever the user wants extracted to the user's */
/* buffers. */
if (pszDir)
{
bcopy(lpszLclDir, pszDir, nDirCnt);
pszDir[nDirCnt] = '\0';
}
/* Clean up before leaving */
DosTrimPath(pszBase);
/* Before returning to the user, eliminate any useless */
/* trailing "\\." since the path prior to this is sufficient. */
nPathCnt = strlen(pszBase);
if (2 == nPathCnt) /* Special case, root */
{
if (!strcmp(pszBase, "\\."))
pszBase[1] = '\0';
}
else if (2 < nPathCnt)
{
if (!strcmp(&pszBase[nPathCnt - 2], "\\."))
pszBase[nPathCnt - 2] = '\0';
}
return SUCCESS;
}
/*
ULONG FAR retcs(int i)
{
char *p = (char*)&i;
p -= 4;
return *(ULONG *)p;
}
*/
COUNT do_printf(CONST BYTE * fmt, BYTE ** arg)
{
int base;
BYTE s[11], FAR * p;
int c, flag, size, fill;
int longarg;
long currentArg;
/*
long cs = retcs(1);
put_console("0123456789ABCDEF"[(cs >> 28) & 0x0f]);
put_console("0123456789ABCDEF"[(cs >> 24) & 0x0f]);
put_console("0123456789ABCDEF"[(cs >> 20) & 0x0f]);
put_console("0123456789ABCDEF"[(cs >> 16) & 0x0f]);
put_console(':');
put_console("0123456789ABCDEF"[(cs >> 12) & 0x0f]);
put_console("0123456789ABCDEF"[(cs >> 8) & 0x0f]);
put_console("0123456789ABCDEF"[(cs >> 4) & 0x0f]);
put_console("0123456789ABCDEF"[(cs >> 0) & 0x0f]);
*/
while ((c = *fmt++) != '\0')
{
if (c != '%')
{
handle_char(c);
continue;
}
longarg = FALSE;
size = 0;
flag = RIGHT;
fill = ' ';
if (*fmt == '-')
{
flag = LEFT;
fmt++;
}
if (*fmt == '0')
{
fill = '0';
fmt++;
}
while (*fmt >= '0' && *fmt <= '9')
{
size = size * 10 + (*fmt++ - '0');
}
if (*fmt == 'l')
{
longarg = TRUE;
fmt++;
}
c = *fmt++;
switch (c)
{
case '\0':
return 0;
case 'c':
handle_char(*(COUNT *) arg++);
continue;
case 'p':
{
UWORD w[2];
w[1] = *((UWORD *) arg);
arg += sizeof(UWORD) / sizeof(BYTE *);
w[0] = *((UWORD *) arg);
arg += sizeof(UWORD) / sizeof(BYTE *);
do_printf("%04x:%04x", (BYTE **) & w);
continue;
}
case 's':
p = *arg++;
goto do_outputstring;
case 'F':
fmt++;
/* we assume %Fs here */
case 'S':
p = *((BYTE FAR **) arg);
arg += sizeof(BYTE FAR *) / sizeof(BYTE *);
goto do_outputstring;
case 'i':
case 'd':
base = -10;
goto lprt;
case 'o':
base = 8;
goto lprt;
case 'u':
base = 10;
goto lprt;
case 'X':
case 'x':
base = 16;
lprt:
if (longarg)
{
currentArg = *((LONG *) arg);
arg += sizeof(LONG) / sizeof(BYTE *);
}
else
{
if (base < 0)
{
currentArg = *((int *)arg);
arg += sizeof(int) / sizeof(BYTE *);
}
else
{
currentArg = *((unsigned int *)arg);
arg += sizeof(unsigned int) / sizeof(BYTE *);
}
}
ltob(currentArg, s, base);
p = s;
do_outputstring:
size -= fstrlen(p);
if (flag == RIGHT)
{
for (; size > 0; size--)
handle_char(fill);
}
for (; *p != '\0'; p++)
handle_char(*p);
for (; size > 0; size--)
handle_char(fill);
continue;
default:
handle_char('?');
handle_char(c);
break;
}
}
return 0;
}
void FUPluginManager::LoadPluginsInFolderName(const fstring& folderName, const fchar* _filter)
{
// Append the wanted extension for the plugins.
FUStringBuilder pluginFolder(folderName);
fchar lastChar = folderName[pluginFolder.length() - 1];
if (lastChar != '\\' && lastChar != '/') pluginFolder.append((fchar) '/');
pluginFolder.append(FC("Plugins/"));
pluginFolderName = pluginFolder.ToString();
if (_filter == NULL || _filter[0] == 0) _filter = FC("*.*");
do
{
const fchar* nextFilter = fstrchr(_filter, '|');
fstring filter(_filter);
if (nextFilter != NULL)
{
filter.erase(nextFilter - _filter);
++nextFilter; // skip the pipe.
}
_filter = nextFilter;
// Windows-only for now.
#if defined(WIN32)
size_t filterLength = filter.length();
// Iterate over all the filtered files within the given folder.
ffinddata folderIterator;
fstring searchString = pluginFolderName + filter;
intptr_t folderHandle = ffindfirst(searchString.c_str(), &folderIterator);
if (folderHandle != -1L)
{
int32 isDone = FALSE;
while (isDone == FALSE)
{
bool keep = false;
PluginLibrary* library = new PluginLibrary();
library->filename = pluginFolderName + folderIterator.name;
// work around for wildcards and 3 letter extensions that pick up 3+ letter extensions
// e.g. "dir *.fvp" in command prompt on a directory with "a.fvp", "a.fvpa", and "a.dll" returns
// "a.fvp" and "a.fvpa"
bool checkModule = true;
if (filterLength > 3)
{
if ((filter.at(filterLength-4) == FC('.')) && (filter.at(filterLength-3) != FC('*')) &&
(filter.at(filterLength-2) != FC('*')) && (filter.at(filterLength-1) != FC('*')))
{
size_t filepathLength = fstrlen(folderIterator.name);
checkModule = (folderIterator.name[filepathLength-4] == filter.at(filterLength-4)) &&
(folderIterator.name[filepathLength-3] == filter.at(filterLength-3)) &&
(folderIterator.name[filepathLength-2] == filter.at(filterLength-2)) &&
(folderIterator.name[filepathLength-1] == filter.at(filterLength-1));
}
}
library->module = LoadLibrary(library->filename.c_str());
if (checkModule && (library->module != NULL))
{
// Retrieve the necessary callbacks
library->getPluginCount = (GetPluginCount) GetProcAddress(library->module, "GetPluginCount");
library->getPluginType = (GetPluginType) GetProcAddress(library->module, "GetPluginType");
library->createPlugin = (CreatePlugin) GetProcAddress(library->module, "CreatePlugin");
keep = library->createPlugin != NULL && library->getPluginType != NULL && library->getPluginCount != NULL;
}
// This is a valid library.
if (keep) loadedLibraries.push_back(library);
else { SAFE_DELETE(library); }
isDone = ffindnext(folderHandle, &folderIterator);
}
ffindclose(folderHandle);
}
#elif defined(__APPLE__) || defined(LINUX)
fm::string s_filter = TO_STRING(filter);
if (s_filter.length() > 0 && s_filter.front() == '*') s_filter.erase(0, 1);
if (s_filter.length() > 0 && s_filter.back() == '*') s_filter.pop_back();
DIR* directory = opendir(TO_STRING(pluginFolderName).c_str());
if (directory == NULL) continue;
dirent* directoryEntry;
while ((directoryEntry = readdir(directory)) != NULL)
{
if (directoryEntry->d_type == DT_DIR) continue; // skip sub-folders.
if (strstr((const char*) directoryEntry->d_name, s_filter.c_str()) != NULL)
{
// We have a match.
bool keep = false;
PluginLibrary* library = new PluginLibrary();
library->filename = pluginFolderName + TO_FSTRING((const char*) directoryEntry->d_name);
fm::string libraryModuleFilename = TO_STRING(library->filename);
DEBUG_OUT("Found dynamic library: %s\n", libraryModuleFilename.c_str());
library->module = dlopen(libraryModuleFilename.c_str(), RTLD_NOW);
if (library->module != NULL)
{
// Retrieve the necessary callbacks
library->getPluginCount = (GetPluginCount) dlsym(library->module, "GetPluginCount");
library->getPluginType = (GetPluginType) dlsym(library->module, "GetPluginType");
library->createPlugin = (CreatePlugin) dlsym(library->module, "CreatePlugin");
keep = library->createPlugin != NULL && library->getPluginType != NULL && library->getPluginCount != NULL;
}
// This is a valid library.
if (keep) loadedLibraries.push_back(library);
else { SAFE_DELETE(library); }
}
}
closedir(directory);
#endif // WIN32
} while (_filter != NULL);
}
