ref: 347bb2a7a7110e55debd5ebe57ba03bbe315c5ba
dir: /sys/src/cmd/aux/antiword/misc.c/
/*
* misc.c
* Copyright (C) 1998-2005 A.J. van Os; Released under GNU GPL
*
* Description:
* Miscellaneous functions
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <time.h>
#if defined(__riscos)
#include "DeskLib:SWI.h"
#else
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#endif /* __riscos */
#if !defined(S_ISREG)
#define S_ISREG(x) (((x) & S_IFMT) == S_IFREG)
#endif /* !S_ISREG */
#include "antiword.h"
#if defined(__vms)
#include <unixlib.h>
#endif
#if !defined(__riscos)
/*
* szGetHomeDirectory - get the name of the home directory
*/
const char *
szGetHomeDirectory(void)
{
const char *szHome;
#if defined(__vms)
szHome = decc$translate_vms(getenv("HOME"));
#elif defined(__Plan9__)
szHome = getenv("home");
#else
szHome = getenv("HOME");
#endif /* __vms */
if (szHome == NULL || szHome[0] == '\0') {
#if defined(N_PLAT_NLM)
szHome = "SYS:";
#elif defined(__dos)
szHome = "C:";
#else
werr(0, "I can't find the name of your HOME directory");
szHome = "";
#endif /* __dos */
}
return szHome;
} /* end of szGetHomeDirectory */
/*
* szGetAntiwordDirectory - get the name of the Antiword directory
*/
const char *
szGetAntiwordDirectory(void)
{
#if defined(__vms)
return decc$translate_vms(getenv("ANTIWORDHOME"));
#else
return getenv("ANTIWORDHOME");
#endif /* __vms */
} /* end of szGetAntiwordDirectory */
#endif /* !__riscos */
/*
* Get the size of the specified file.
* Returns -1 if the file does not exist or is not a proper file.
*/
long
lGetFilesize(const char *szFilename)
{
#if defined(__riscos)
os_error *e;
int iType, iSize;
e = SWI(2, 5, SWI_OS_File | XOS_Bit,
17, szFilename,
&iType, NULL, NULL, NULL, &iSize);
if (e != NULL) {
werr(0, "Get Filesize error %d: %s",
e->errnum, e->errmess);
return -1;
}
if (iType != 1) {
/* It's not a proper file or the file does not exist */
return -1;
}
return (long)iSize;
#else
struct stat tBuffer;
errno = 0;
if (stat(szFilename, &tBuffer) != 0) {
werr(0, "Get Filesize error %d", errno);
return -1;
}
if (!S_ISREG(tBuffer.st_mode)) {
/* It's not a regular file */
return -1;
}
return (long)tBuffer.st_size;
#endif /* __riscos */
} /* end of lGetFilesize */
#if defined(DEBUG)
void
vPrintBlock(const char *szFile, int iLine,
const UCHAR *aucBlock, size_t tLength)
{
int i, j;
fail(szFile == NULL || iLine < 0 || aucBlock == NULL);
fprintf(stderr, "%s[%3d]:\n", szFile, iLine);
for (i = 0; i < 32; i++) {
if (16 * i >= (int)tLength) {
return;
}
fprintf(stderr, "%03x: ", (unsigned int)(16 * i));
for (j = 0; j < 16; j++) {
if (16 * i + j < (int)tLength) {
fprintf(stderr, "%02x ",
(unsigned int)aucBlock[16 * i + j]);
}
}
fprintf(stderr, "\n");
}
} /* end of vPrintBlock */
void
vPrintUnicode(const char *szFile, int iLine, const UCHAR *aucUni, size_t tLen)
{
char *szASCII;
fail(tLen % 2 != 0);
tLen /= 2; /* Length in bytes to length in characters */
szASCII = xmalloc(tLen + 1);
(void)unincpy(szASCII, aucUni, tLen);
szASCII[tLen] = '\0';
(void)fprintf(stderr, "%s[%3d]: %.*s\n",
szFile, iLine, (int)tLen, szASCII);
szASCII = xfree(szASCII);
} /* end of vPrintUnicode */
BOOL
bCheckDoubleLinkedList(output_type *pAnchor)
{
output_type *pCurr, *pLast;
int iInList;
pLast = pAnchor;
iInList = 0;
for (pCurr = pAnchor; pCurr != NULL; pCurr = pCurr->pNext) {
pLast = pCurr;
iInList++;
}
NO_DBG_DEC(iInList);
for (pCurr = pLast; pCurr != NULL; pCurr = pCurr->pPrev) {
pLast = pCurr;
iInList--;
}
DBG_DEC_C(iInList != 0, iInList);
return pAnchor == pLast && iInList == 0;
} /* end of bCheckDoubleLinkedList */
#endif /* DEBUG */
/*
* bReadBytes
* This function reads the specified number of bytes from the specified file,
* starting from the specified offset.
* Returns TRUE when successfull, otherwise FALSE
*/
BOOL
bReadBytes(UCHAR *aucBytes, size_t tMemb, ULONG ulOffset, FILE *pFile)
{
fail(aucBytes == NULL || pFile == NULL || ulOffset > (ULONG)LONG_MAX);
if (ulOffset > (ULONG)LONG_MAX) {
return FALSE;
}
if (fseek(pFile, (long)ulOffset, SEEK_SET) != 0) {
return FALSE;
}
if (fread(aucBytes, sizeof(UCHAR), tMemb, pFile) != tMemb) {
return FALSE;
}
return TRUE;
} /* end of bReadBytes */
/*
* bReadBuffer
* This function fills the specified buffer with the specified number of bytes,
* starting at the specified offset within the Big/Small Block Depot.
*
* Returns TRUE when successful, otherwise FALSE
*/
BOOL
bReadBuffer(FILE *pFile, ULONG ulStartBlock,
const ULONG *aulBlockDepot, size_t tBlockDepotLen, size_t tBlockSize,
UCHAR *aucBuffer, ULONG ulOffset, size_t tToRead)
{
ULONG ulBegin, ulIndex;
size_t tLen;
fail(pFile == NULL);
fail(ulStartBlock > MAX_BLOCKNUMBER && ulStartBlock != END_OF_CHAIN);
fail(aulBlockDepot == NULL);
fail(tBlockSize != BIG_BLOCK_SIZE && tBlockSize != SMALL_BLOCK_SIZE);
fail(aucBuffer == NULL);
fail(tToRead == 0);
for (ulIndex = ulStartBlock;
ulIndex != END_OF_CHAIN && tToRead != 0;
ulIndex = aulBlockDepot[ulIndex]) {
if (ulIndex >= (ULONG)tBlockDepotLen) {
DBG_DEC(ulIndex);
DBG_DEC(tBlockDepotLen);
if (tBlockSize >= BIG_BLOCK_SIZE) {
werr(1, "The Big Block Depot is damaged");
} else {
werr(1, "The Small Block Depot is damaged");
}
}
if (ulOffset >= (ULONG)tBlockSize) {
ulOffset -= tBlockSize;
continue;
}
ulBegin = ulDepotOffset(ulIndex, tBlockSize) + ulOffset;
tLen = min(tBlockSize - (size_t)ulOffset, tToRead);
ulOffset = 0;
if (!bReadBytes(aucBuffer, tLen, ulBegin, pFile)) {
werr(0, "Read big block 0x%lx not possible", ulBegin);
return FALSE;
}
aucBuffer += tLen;
tToRead -= tLen;
}
DBG_DEC_C(tToRead != 0, tToRead);
return tToRead == 0;
} /* end of bReadBuffer */
/*
* Convert a Word colornumber into a true color for use in a drawfile
*
* Returns the true color
*/
ULONG
ulColor2Color(UCHAR ucFontColor)
{
static const ULONG aulColorTable[] = {
/* 0 */ 0x00000000UL, /* Automatic */
/* 1 */ 0x00000000UL, /* Black */
/* 2 */ 0xff000000UL, /* Blue */
/* 3 */ 0xffff0000UL, /* Turquoise */
/* 4 */ 0x00ff0000UL, /* Bright Green */
/* 5 */ 0xff00ff00UL, /* Pink */
/* 6 */ 0x0000ff00UL, /* Red */
/* 7 */ 0x00ffff00UL, /* Yellow */
/* 8 */ 0xffffff00UL, /* White */
/* 9 */ 0x80000000UL, /* Dark Blue */
/* 10 */ 0x80800000UL, /* Teal */
/* 11 */ 0x00800000UL, /* Green */
/* 12 */ 0x80008000UL, /* Violet */
/* 13 */ 0x00008000UL, /* Dark Red */
/* 14 */ 0x00808000UL, /* Dark Yellow */
/* 15 */ 0x80808000UL, /* Gray 50% */
/* 16 */ 0xc0c0c000UL, /* Gray 25% */
};
if ((size_t)ucFontColor >= elementsof(aulColorTable)) {
return aulColorTable[0];
}
return aulColorTable[(int)ucFontColor];
} /* end of ulColor2Color */
/*
* iFindSplit - find a place to split the string
*
* returns the index of the split character or -1 if no split found.
*/
static int
iFindSplit(const char *szString, size_t tStringLen)
{
size_t tSplit;
if (tStringLen == 0) {
return -1;
}
tSplit = tStringLen - 1;
while (tSplit >= 1) {
if (szString[tSplit] == ' ' ||
(szString[tSplit] == '-' && szString[tSplit - 1] != ' ')) {
return (int)tSplit;
}
tSplit--;
}
return -1;
} /* end of iFindSplit */
/*
* pSplitList - split the specified list in a printable part and a leftover part
*
* returns the pointer to the leftover part
*/
output_type *
pSplitList(output_type *pAnchor)
{
output_type *pCurr, *pLeftOver;
int iIndex;
fail(pAnchor == NULL);
for (pCurr = pAnchor; pCurr->pNext != NULL; pCurr = pCurr->pNext)
; /* EMPTY */
iIndex = -1;
for (; pCurr != NULL; pCurr = pCurr->pPrev) {
iIndex = iFindSplit(pCurr->szStorage, pCurr->tNextFree);
if (iIndex >= 0) {
break;
}
}
if (pCurr == NULL || iIndex < 0) {
/* No split, no leftover */
return NULL;
}
/* Split over the iIndex-th character */
NO_DBG_MSG("pLeftOver");
pLeftOver = xmalloc(sizeof(*pLeftOver));
fail(pCurr->tNextFree < (size_t)iIndex);
pLeftOver->tStorageSize = pCurr->tNextFree - (size_t)iIndex;
pLeftOver->szStorage = xmalloc(pLeftOver->tStorageSize);
pLeftOver->tNextFree = pCurr->tNextFree - (size_t)iIndex - 1;
(void)strncpy(pLeftOver->szStorage,
pCurr->szStorage + iIndex + 1, pLeftOver->tNextFree);
pLeftOver->szStorage[pLeftOver->tNextFree] = '\0';
NO_DBG_MSG(pLeftOver->szStorage);
pLeftOver->ucFontColor = pCurr->ucFontColor;
pLeftOver->usFontStyle = pCurr->usFontStyle;
pLeftOver->tFontRef = pCurr->tFontRef;
pLeftOver->usFontSize = pCurr->usFontSize;
pLeftOver->lStringWidth = lComputeStringWidth(
pLeftOver->szStorage,
pLeftOver->tNextFree,
pLeftOver->tFontRef,
pLeftOver->usFontSize);
pLeftOver->pPrev = NULL;
pLeftOver->pNext = pCurr->pNext;
if (pLeftOver->pNext != NULL) {
pLeftOver->pNext->pPrev = pLeftOver;
}
fail(!bCheckDoubleLinkedList(pLeftOver));
NO_DBG_MSG("pAnchor");
NO_DBG_HEX(pCurr->szStorage[iIndex]);
while (iIndex >= 0 && isspace((int)(UCHAR)pCurr->szStorage[iIndex])) {
iIndex--;
}
pCurr->tNextFree = (size_t)iIndex + 1;
pCurr->szStorage[pCurr->tNextFree] = '\0';
NO_DBG_MSG(pCurr->szStorage);
pCurr->lStringWidth = lComputeStringWidth(
pCurr->szStorage,
pCurr->tNextFree,
pCurr->tFontRef,
pCurr->usFontSize);
pCurr->pNext = NULL;
fail(!bCheckDoubleLinkedList(pAnchor));
return pLeftOver;
} /* end of pSplitList */
/*
* tNumber2Roman - convert a number to Roman Numerals
*
* returns the number of characters written
*/
size_t
tNumber2Roman(UINT uiNumber, BOOL bUpperCase, char *szOutput)
{
char *outp, *p, *q;
UINT uiNextVal, uiValue;
fail(szOutput == NULL);
uiNumber %= 4000; /* Very high numbers can't be represented */
if (uiNumber == 0) {
szOutput[0] = '\0';
return 0;
}
outp = szOutput;
p = bUpperCase ? "M\2D\5C\2L\5X\2V\5I" : "m\2d\5c\2l\5x\2v\5i";
uiValue = 1000;
for (;;) {
while (uiNumber >= uiValue) {
*outp++ = *p;
uiNumber -= uiValue;
}
if (uiNumber == 0) {
*outp = '\0';
fail(outp < szOutput);
return (size_t)(outp - szOutput);
}
q = p + 1;
uiNextVal = uiValue / (UINT)(UCHAR)*q;
if ((int)*q == 2) { /* magic */
uiNextVal /= (UINT)(UCHAR)*(q += 2);
}
if (uiNumber + uiNextVal >= uiValue) {
*outp++ = *++q;
uiNumber += uiNextVal;
} else {
p++;
uiValue /= (UINT)(UCHAR)(*p++);
}
}
} /* end of tNumber2Roman */
/*
* iNumber2Alpha - convert a number to alphabetic "numbers"
*
* returns the number of characters written
*/
size_t
tNumber2Alpha(UINT uiNumber, BOOL bUpperCase, char *szOutput)
{
char *outp;
UINT uiTmp;
fail(szOutput == NULL);
if (uiNumber == 0) {
szOutput[0] = '\0';
return 0;
}
outp = szOutput;
uiTmp = (UINT)(bUpperCase ? 'A': 'a');
if (uiNumber <= 26) {
uiNumber -= 1;
*outp++ = (char)(uiTmp + uiNumber);
} else if (uiNumber <= 26U + 26U*26U) {
uiNumber -= 26 + 1;
*outp++ = (char)(uiTmp + uiNumber / 26);
*outp++ = (char)(uiTmp + uiNumber % 26);
} else if (uiNumber <= 26U + 26U*26U + 26U*26U*26U) {
uiNumber -= 26 + 26*26 + 1;
*outp++ = (char)(uiTmp + uiNumber / (26*26));
*outp++ = (char)(uiTmp + uiNumber / 26 % 26);
*outp++ = (char)(uiTmp + uiNumber % 26);
}
*outp = '\0';
fail(outp < szOutput);
return (size_t)(outp - szOutput);
} /* end of tNumber2Alpha */
/*
* unincpy - copy a counted Unicode string to an single-byte string
*/
char *
unincpy(char *s1, const UCHAR *s2, size_t n)
{
char *pcDest;
ULONG ulChar;
size_t tLen;
USHORT usUni;
for (pcDest = s1, tLen = 0; tLen < n; pcDest++, tLen++) {
usUni = usGetWord(tLen * 2, s2);
if (usUni == 0) {
break;
}
ulChar = ulTranslateCharacters(usUni, 0, 8,
conversion_unknown, encoding_neutral, FALSE);
if (ulChar == IGNORE_CHARACTER) {
ulChar = (ULONG)'?';
}
*pcDest = (char)ulChar;
}
for (; tLen < n; tLen++) {
*pcDest++ = '\0';
}
return s1;
} /* end of unincpy */
/*
* unilen - calculate the length of a Unicode string
*
* returns the length in bytes
*/
size_t
unilen(const UCHAR *s)
{
size_t tLen;
USHORT usUni;
tLen = 0;
for (;;) {
usUni = usGetWord(tLen, s);
if (usUni == 0) {
return tLen;
}
tLen += 2;
}
} /* end of unilen */
/*
* szBaseName - get the basename of the specified filename
*/
const char *
szBasename(const char *szFilename)
{
const char *szTmp;
fail(szFilename == NULL);
if (szFilename == NULL || szFilename[0] == '\0') {
return "null";
}
szTmp = strrchr(szFilename, FILE_SEPARATOR[0]);
if (szTmp == NULL) {
return szFilename;
}
return ++szTmp;
} /* end of szBasename */
/*
* lComputeLeading - compute the leading
*
* NOTE: the fontsize is specified in half points
*
* Returns the leading in drawunits
*/
long
lComputeLeading(USHORT usFontSize)
{
long lLeading;
lLeading = (long)usFontSize * 500L;
if (usFontSize < 18) { /* Small text: 112% */
lLeading *= 112;
} else if (usFontSize < 28) { /* Normal text: 124% */
lLeading *= 124;
} else if (usFontSize < 48) { /* Small headlines: 104% */
lLeading *= 104;
} else { /* Large headlines: 100% */
lLeading *= 100;
}
lLeading = lMilliPoints2DrawUnits(lLeading);
lLeading += 50;
lLeading /= 100;
return lLeading;
} /* end of lComputeLeading */
/*
* Convert a UCS character to an UTF-8 string
*
* Returns the string length of the result
*/
size_t
tUcs2Utf8(ULONG ulChar, char *szResult, size_t tMaxResultLen)
{
if (szResult == NULL || tMaxResultLen == 0) {
return 0;
}
if (ulChar < 0x80 && tMaxResultLen >= 2) {
szResult[0] = (char)ulChar;
szResult[1] = '\0';
return 1;
}
if (ulChar < 0x800 && tMaxResultLen >= 3) {
szResult[0] = (char)(0xc0 | ulChar >> 6);
szResult[1] = (char)(0x80 | (ulChar & 0x3f));
szResult[2] = '\0';
return 2;
}
if (ulChar < 0x10000 && tMaxResultLen >= 4) {
szResult[0] = (char)(0xe0 | ulChar >> 12);
szResult[1] = (char)(0x80 | (ulChar >> 6 & 0x3f));
szResult[2] = (char)(0x80 | (ulChar & 0x3f));
szResult[3] = '\0';
return 3;
}
if (ulChar < 0x200000 && tMaxResultLen >= 5) {
szResult[0] = (char)(0xf0 | ulChar >> 18);
szResult[1] = (char)(0x80 | (ulChar >> 12 & 0x3f));
szResult[2] = (char)(0x80 | (ulChar >> 6 & 0x3f));
szResult[3] = (char)(0x80 | (ulChar & 0x3f));
szResult[4] = '\0';
return 4;
}
szResult[0] = '\0';
return 0;
} /* end of tUcs2Utf8 */
/*
* vGetBulletValue - get the bullet value for the conversing type and encoding
*/
void
vGetBulletValue(conversion_type eConversionType, encoding_type eEncoding,
char *szResult, size_t tMaxResultLen)
{
fail(szResult == NULL);
fail(tMaxResultLen < 2);
if (eEncoding == encoding_utf_8) {
(void)tUcs2Utf8(UNICODE_BULLET, szResult, tMaxResultLen);
} else {
szResult[0] = (char)ucGetBulletCharacter(eConversionType,
eEncoding);
szResult[1] = '\0';
}
} /* end of vGetBulletValue */
/*
* bAllZero - are all bytes zero?
*/
BOOL
bAllZero(const UCHAR *aucBytes, size_t tLength)
{
size_t tIndex;
if (aucBytes == NULL || tLength == 0) {
return TRUE;
}
for (tIndex = 0; tIndex < tLength; tIndex++) {
if (aucBytes[tIndex] != 0) {
return FALSE;
}
}
return TRUE;
} /* end of bAllZero */
#if !defined(__riscos)
/*
* GetCodesetFromLocale - get the codeset from the current locale
*
* Original version: Copyright (C) 1999 Bruno Haible
* Syntax:
* language[_territory][.codeset][@modifier][+special][,[sponsor][_revision]]
*
* Returns TRUE when sucessful, otherwise FALSE
*/
static BOOL
bGetCodesetFromLocale(char *szCodeset, size_t tMaxCodesetLength, BOOL *pbEuro)
{
#if !defined(__dos)
const char *szLocale;
const char *pcTmp;
size_t tIndex;
char szModifier[6];
#endif /* __dos */
if (pbEuro != NULL) {
*pbEuro = FALSE; /* Until proven otherwise */
}
if (szCodeset == NULL || tMaxCodesetLength == 0) {
return FALSE;
}
#if defined(__dos)
if (tMaxCodesetLength < 2 + sizeof(int) * 3 + 1) {
DBG_DEC(tMaxCodesetLength);
DBG_DEC(2 + sizeof(int) * 3 + 1);
return FALSE;
}
/* Get the active codepage from DOS */
sprintf(szCodeset, "cp%d", iGetCodepage());
DBG_MSG(szCodeset);
#else
/* Get the locale from the environment */
szLocale = getenv("LC_ALL");
if (szLocale == NULL || szLocale[0] == '\0') {
szLocale = getenv("LC_CTYPE");
if (szLocale == NULL || szLocale[0] == '\0') {
szLocale = getenv("LANG");
}
}
if (szLocale == NULL || szLocale[0] == '\0') {
/* No locale, so no codeset name and no modifier */
return FALSE;
}
DBG_MSG(szLocale);
pcTmp = strchr(szLocale, '.');
if (pcTmp == NULL) {
/* No codeset name */
szCodeset[0] = '\0';
} else {
/* Copy the codeset name */
pcTmp++;
for (tIndex = 0; tIndex < tMaxCodesetLength; tIndex++) {
if (*pcTmp == '@' || *pcTmp == '+' ||
*pcTmp == ',' || *pcTmp == '_' ||
*pcTmp == '\0') {
szCodeset[tIndex] = '\0';
break;
}
szCodeset[tIndex] = *pcTmp;
pcTmp++;
}
szCodeset[tMaxCodesetLength - 1] = '\0';
}
if (pbEuro == NULL) {
/* No need to get the modifier */
return TRUE;
}
pcTmp = strchr(szLocale, '@');
if (pcTmp != NULL) {
/* Copy the modifier */
pcTmp++;
for (tIndex = 0; tIndex < sizeof(szModifier); tIndex++) {
if (*pcTmp == '+' || *pcTmp == ',' ||
*pcTmp == '_' || *pcTmp == '\0') {
szModifier[tIndex] = '\0';
break;
}
szModifier[tIndex] = *pcTmp;
pcTmp++;
}
szModifier[sizeof(szModifier) - 1] = '\0';
*pbEuro = STRCEQ(szModifier, "Euro");
}
#endif /* __dos */
return TRUE;
} /* end of bGetCodesetFromLocale */
/*
* GetNormalizedCodeset - get the normalized codeset from the current locale
*
* Returns TRUE when sucessful, otherwise FALSE
*/
BOOL
bGetNormalizedCodeset(char *szCodeset, size_t tMaxCodesetLength, BOOL *pbEuro)
{
BOOL bOnlyDigits;
const char *pcSrc;
char *pcDest;
char *szTmp, *szCodesetNorm;
if (pbEuro != NULL) {
*pbEuro = FALSE; /* Until proven otherwise */
}
if (szCodeset == NULL || tMaxCodesetLength < 4) {
return FALSE;
}
/* Get the codeset name */
szTmp = xmalloc(tMaxCodesetLength - 3);
if (!bGetCodesetFromLocale(szTmp, tMaxCodesetLength - 3, pbEuro)) {
szTmp = xfree(szTmp);
return FALSE;
}
/* Normalize the codeset name */
szCodesetNorm = xmalloc(tMaxCodesetLength - 3);
bOnlyDigits = TRUE;
pcDest = szCodesetNorm;
for (pcSrc = szTmp; *pcSrc != '\0'; pcSrc++) {
if (isalnum(*pcSrc)) {
*pcDest = tolower(*pcSrc);
if (!isdigit(*pcDest)) {
bOnlyDigits = FALSE;
}
pcDest++;
}
}
*pcDest = '\0';
DBG_MSG(szCodesetNorm);
/* Add "iso" when szCodesetNorm contains all digits */
if (bOnlyDigits && szCodesetNorm[0] != '\0') {
fail(strlen(szCodesetNorm) + 3 >= tMaxCodesetLength);
sprintf(szCodeset, "iso%s", szCodesetNorm);
} else {
fail(strlen(szCodesetNorm) >= tMaxCodesetLength);
strncpy(szCodeset, szCodesetNorm, pcDest - szCodesetNorm + 1);
szCodeset[tMaxCodesetLength - 1] = '\0';
}
DBG_MSG(szCodeset);
/* Clean up and leave */
szCodesetNorm = xfree(szCodesetNorm);
szTmp = xfree(szTmp);
return TRUE;
} /* end of bGetNormalizedCodeset */
/*
* szGetDefaultMappingFile - get the default mapping file
*
* Returns the basename of the default mapping file
*/
const char *
szGetDefaultMappingFile(void)
{
static const struct {
const char *szCodeset;
const char *szMappingFile;
} atMappingFile[] = {
{ "iso88591", MAPPING_FILE_8859_1 },
{ "iso88592", MAPPING_FILE_8859_2 },
{ "iso88593", "8859-3.txt" },
{ "iso88594", "8859-4.txt" },
{ "iso88595", "8859-5.txt" },
{ "iso88596", MAPPING_FILE_8859_5 },
{ "iso88597", "8859-7.txt" },
{ "iso88598", "8859-8.txt" },
{ "iso88599", "8859-9.txt" },
{ "iso885910", "8859-10.txt" },
{ "iso885913", "8859-13.txt" },
{ "iso885914", "8859-14.txt" },
{ "iso885915", MAPPING_FILE_8859_15 },
{ "iso885916", "8859-16.txt" },
{ "koi8r", MAPPING_FILE_KOI8_R },
{ "koi8u", MAPPING_FILE_KOI8_U },
{ "utf8", MAPPING_FILE_UTF_8 },
{ "cp437", MAPPING_FILE_CP437 },
{ "cp850", "cp850.txt" },
{ "cp852", MAPPING_FILE_CP852 },
{ "cp862", "cp862.txt" },
{ "cp864", "cp864.txt" },
{ "cp866", MAPPING_FILE_CP866 },
{ "cp1250", MAPPING_FILE_CP1250 },
{ "cp1251", MAPPING_FILE_CP1251 },
{ "cp1252", "cp1252.txt" },
};
size_t tIndex;
BOOL bEuro;
char szCodeset[20];
szCodeset[0] = '\0';
bEuro = FALSE;
/* Get the normalized codeset name */
if (!bGetNormalizedCodeset(szCodeset, sizeof(szCodeset), &bEuro)) {
return MAPPING_FILE_8859_1;
}
if (szCodeset[0] == '\0') {
if (bEuro) {
/* Default mapping file (with Euro sign) */
return MAPPING_FILE_8859_15;
} else {
/* Default mapping file (without Euro sign) */
return MAPPING_FILE_8859_1;
}
}
/* Find the name in the table */
for (tIndex = 0; tIndex < elementsof(atMappingFile); tIndex++) {
if (STREQ(atMappingFile[tIndex].szCodeset, szCodeset)) {
return atMappingFile[tIndex].szMappingFile;
}
}
/* Default default mapping file */
#if defined(__dos)
return MAPPING_FILE_CP437;
#else
return MAPPING_FILE_8859_1;
#endif /* __dos */
} /* end of szGetDefaultMappingFile */
#endif /* !__riscos */
/*
* tConvertDTTM - convert Windows Date and Time format
*
* returns Unix time_t or -1
*/
time_t
tConvertDTTM(ULONG ulDTTM)
{
struct tm tTime;
time_t tResult;
if (ulDTTM == 0) {
return (time_t)-1;
}
memset(&tTime, 0, sizeof(tTime));
tTime.tm_min = (int)(ulDTTM & 0x0000003f);
tTime.tm_hour = (int)((ulDTTM & 0x000007c0) >> 6);
tTime.tm_mday = (int)((ulDTTM & 0x0000f800) >> 11);
tTime.tm_mon = (int)((ulDTTM & 0x000f0000) >> 16);
tTime.tm_year = (int)((ulDTTM & 0x1ff00000) >> 20);
tTime.tm_isdst = -1;
tTime.tm_mon--; /* From 01-12 to 00-11 */
tResult = mktime(&tTime);
NO_DBG_MSG(ctime(&tResult));
return tResult;
} /* end of tConvertDTTM */