TB9.2 Example Applications: examples/PIPS/antiword/src/misc.c Source File

00001 /*
-00002  * misc.c
-00003  * Copyright (C) 1998-2005 A.J. van Os; Released under GNU GPL
-00004  *
-00005  * Description:
-00006  * Miscellaneous functions
-00007  */
-00008 
-00009 #include <stdio.h>
-00010 #include <stdlib.h>
-00011 #include <string.h>
-00012 #include <ctype.h>
-00013 #include <time.h>
-00014 #if defined(__riscos)
-00015 #include "DeskLib:SWI.h"
-00016 #else
-00017 #include <errno.h>
-00018 #include <sys/types.h>
-00019 #include <sys/stat.h>
-00020 #endif /* __riscos */
-00021 #if !defined(S_ISREG)
-00022 #define S_ISREG(x)      (((x) & S_IFMT) == S_IFREG)
-00023 #endif /* !S_ISREG */
-00024 #include "antiword.h"
-00025 #if defined(__vms)
-00026 #include <unixlib.h>
-00027 #endif
-00028 
-00029 #if !defined(__riscos)
-00030 /*
-00031  * szGetHomeDirectory - get the name of the home directory
-00032  */
-00033 const char *
-00034 szGetHomeDirectory(void)
-00035 {
-00036         const char      *szHome;
-00037 
-00038 #if defined(__vms)
-00039         szHome = decc$translate_vms(getenv("HOME"));
-00040 #elif defined(__Plan9__)
-00041         szHome = getenv("home");
-00042 #else
-00043         szHome = getenv("HOME");
-00044 #endif /* __vms */
-00045 
-00046         if (szHome == NULL || szHome[0] == '\0') {
-00047 #if defined(N_PLAT_NLM)
-00048                 szHome = "SYS:";
-00049 #elif defined(__dos)
-00050                 szHome = "C:";
-00051 #else
-00052                 werr(0, "I can't find the name of your HOME directory");
-00053                 szHome = "";
-00054 #endif /* __dos */
-00055         }
-00056         return szHome;
-00057 } /* end of szGetHomeDirectory */
-00058 
-00059 /*
-00060  * szGetAntiwordDirectory - get the name of the Antiword directory
-00061  */
-00062 const char *
-00063 szGetAntiwordDirectory(void)
-00064 {
-00065 #if defined(__vms)
-00066         return decc$translate_vms(getenv("ANTIWORDHOME"));
-00067 #else
-00068         return getenv("ANTIWORDHOME");
-00069 #endif /* __vms */
-00070 } /* end of szGetAntiwordDirectory */
-00071 #endif /* !__riscos */
-00072 
-00073 /*
-00074  * Get the size of the specified file.
-00075  * Returns -1 if the file does not exist or is not a proper file.
-00076  */
-00077 long
-00078 lGetFilesize(const char *szFilename)
-00079 {
-00080 #if defined(__riscos)
-00081         os_error        *e;
-00082         int     iType, iSize;
-00083 
-00084         e = SWI(2, 5, SWI_OS_File | XOS_Bit,
-00085                 17, szFilename,
-00086                 &iType, NULL, NULL, NULL, &iSize);
-00087         if (e != NULL) {
-00088                 werr(0, "Get Filesize error %d: %s",
-00089                         e->errnum, e->errmess);
-00090                 return -1;
-00091         }
-00092         if (iType != 1) {
-00093                 /* It's not a proper file or the file does not exist */
-00094                 return -1;
-00095         }
-00096         return (long)iSize;
-00097 #else
-00098         struct stat     tBuffer;
-00099 
-00100         errno = 0;
-00101         if (stat(szFilename, &tBuffer) != 0) {
-00102                 werr(0, "Get Filesize error %d", errno);
-00103                 return -1;
-00104         }
-00105         if (!S_ISREG(tBuffer.st_mode)) {
-00106                 /* It's not a regular file */
-00107                 return -1;
-00108         }
-00109         return (long)tBuffer.st_size;
-00110 #endif /* __riscos */
-00111 } /* end of lGetFilesize */
-00112 
-00113 #if defined(DEBUG)
-00114 void
-00115 vPrintBlock(const char  *szFile, int iLine,
-00116                 const UCHAR *aucBlock, size_t tLength)
-00117 {
-00118         int i, j;
-00119 
-00120         fail(szFile == NULL || iLine < 0 || aucBlock == NULL);
-00121 
-00122         fprintf(stderr, "%s[%3d]:\n", szFile, iLine);
-00123         for (i = 0; i < 32; i++) {
-00124                 if (16 * i >= (int)tLength) {
-00125                         return;
-00126                 }
-00127                 fprintf(stderr, "%03x: ", (unsigned int)(16 * i));
-00128                 for (j = 0; j < 16; j++) {
-00129                         if (16 * i + j < (int)tLength) {
-00130                                 fprintf(stderr, "%02x ",
-00131                                         (unsigned int)aucBlock[16 * i + j]);
-00132                         }
-00133                 }
-00134                 fprintf(stderr, "\n");
-00135         }
-00136 } /* end of vPrintBlock */
-00137 
-00138 void
-00139 vPrintUnicode(const char *szFile, int iLine, const UCHAR *aucUni, size_t tLen)
-00140 {
-00141         char    *szASCII;
-00142 
-00143         fail(tLen % 2 != 0);
-00144 
-00145         tLen /= 2;      /* Length in bytes to length in characters */
-00146         szASCII = xmalloc(tLen + 1);
-00147         (void)unincpy(szASCII, aucUni, tLen);
-00148         szASCII[tLen] = '\0';
-00149         (void)fprintf(stderr, "%s[%3d]: %.*s\n",
-00150                                 szFile, iLine, (int)tLen, szASCII);
-00151         szASCII = xfree(szASCII);
-00152 } /* end of vPrintUnicode */
-00153 
-00154 BOOL
-00155 bCheckDoubleLinkedList(output_type *pAnchor)
-00156 {
-00157         output_type     *pCurr, *pLast;
-00158         int             iInList;
-00159 
-00160         pLast = pAnchor;
-00161         iInList = 0;
-00162         for (pCurr = pAnchor; pCurr != NULL; pCurr = pCurr->pNext) {
-00163                 pLast = pCurr;
-00164                 iInList++;
-00165         }
-00166         NO_DBG_DEC(iInList);
-00167         for (pCurr = pLast; pCurr != NULL; pCurr = pCurr->pPrev) {
-00168                 pLast = pCurr;
-00169                 iInList--;
-00170         }
-00171         DBG_DEC_C(iInList != 0, iInList);
-00172         return pAnchor == pLast && iInList == 0;
-00173 } /* end of bCheckDoubleLinkedList */
-00174 #endif /* DEBUG */
-00175 
-00176 /*
-00177  * bReadBytes
-00178  * This function reads the specified number of bytes from the specified file,
-00179  * starting from the specified offset.
-00180  * Returns TRUE when successfull, otherwise FALSE
-00181  */
-00182 BOOL
-00183 bReadBytes(UCHAR *aucBytes, size_t tMemb, ULONG ulOffset, FILE *pFile)
-00184 {
-00185         fail(aucBytes == NULL || pFile == NULL || ulOffset > (ULONG)LONG_MAX);
-00186 
-00187         if (ulOffset > (ULONG)LONG_MAX) {
-00188                 return FALSE;
-00189         }
-00190         if (fseek(pFile, (long)ulOffset, SEEK_SET) != 0) {
-00191                 return FALSE;
-00192         }
-00193         if (fread(aucBytes, sizeof(UCHAR), tMemb, pFile) != tMemb) {
-00194                 return FALSE;
-00195         }
-00196         return TRUE;
-00197 } /* end of bReadBytes */
-00198 
-00199 /*
-00200  * bReadBuffer
-00201  * This function fills the specified buffer with the specified number of bytes,
-00202  * starting at the specified offset within the Big/Small Block Depot.
-00203  *
-00204  * Returns TRUE when successful, otherwise FALSE
-00205  */
-00206 BOOL
-00207 bReadBuffer(FILE *pFile, ULONG ulStartBlock,
-00208         const ULONG *aulBlockDepot, size_t tBlockDepotLen, size_t tBlockSize,
-00209         UCHAR *aucBuffer, ULONG ulOffset, size_t tToRead)
-00210 {
-00211         ULONG   ulBegin, ulIndex;
-00212         size_t  tLen;
-00213 
-00214         fail(pFile == NULL);
-00215         fail(ulStartBlock > MAX_BLOCKNUMBER && ulStartBlock != END_OF_CHAIN);
-00216         fail(aulBlockDepot == NULL);
-00217         fail(tBlockSize != BIG_BLOCK_SIZE && tBlockSize != SMALL_BLOCK_SIZE);
-00218         fail(aucBuffer == NULL);
-00219         fail(tToRead == 0);
-00220 
-00221         for (ulIndex = ulStartBlock;
-00222              ulIndex != END_OF_CHAIN && tToRead != 0;
-00223              ulIndex = aulBlockDepot[ulIndex]) {
-00224                 if (ulIndex >= (ULONG)tBlockDepotLen) {
-00225                         DBG_DEC(ulIndex);
-00226                         DBG_DEC(tBlockDepotLen);
-00227                         if (tBlockSize >= BIG_BLOCK_SIZE) {
-00228                                 werr(1, "The Big Block Depot is damaged");
-00229                         } else {
-00230                                 werr(1, "The Small Block Depot is damaged");
-00231                         }
-00232                 }
-00233                 if (ulOffset >= (ULONG)tBlockSize) {
-00234                         ulOffset -= tBlockSize;
-00235                         continue;
-00236                 }
-00237                 ulBegin = ulDepotOffset(ulIndex, tBlockSize) + ulOffset;
-00238                 tLen = min(tBlockSize - (size_t)ulOffset, tToRead);
-00239                 ulOffset = 0;
-00240                 if (!bReadBytes(aucBuffer, tLen, ulBegin, pFile)) {
-00241                         werr(0, "Read big block 0x%lx not possible", ulBegin);
-00242                         return FALSE;
-00243                 }
-00244                 aucBuffer += tLen;
-00245                 tToRead -= tLen;
-00246         }
-00247         DBG_DEC_C(tToRead != 0, tToRead);
-00248         return tToRead == 0;
-00249 } /* end of bReadBuffer */
-00250 
-00251 /*
-00252  * Convert a Word colornumber into a true color for use in a drawfile
-00253  *
-00254  * Returns the true color
-00255  */
-00256 ULONG
-00257 ulColor2Color(UCHAR ucFontColor)
-00258 {
-00259         static const ULONG      aulColorTable[] = {
-00260                 /*  0 */        0x00000000UL,   /* Automatic */
-00261                 /*  1 */        0x00000000UL,   /* Black */
-00262                 /*  2 */        0xff000000UL,   /* Blue */
-00263                 /*  3 */        0xffff0000UL,   /* Turquoise */
-00264                 /*  4 */        0x00ff0000UL,   /* Bright Green */
-00265                 /*  5 */        0xff00ff00UL,   /* Pink */
-00266                 /*  6 */        0x0000ff00UL,   /* Red */
-00267                 /*  7 */        0x00ffff00UL,   /* Yellow */
-00268                 /*  8 */        0xffffff00UL,   /* White */
-00269                 /*  9 */        0x80000000UL,   /* Dark Blue */
-00270                 /* 10 */        0x80800000UL,   /* Teal */
-00271                 /* 11 */        0x00800000UL,   /* Green */
-00272                 /* 12 */        0x80008000UL,   /* Violet */
-00273                 /* 13 */        0x00008000UL,   /* Dark Red */
-00274                 /* 14 */        0x00808000UL,   /* Dark Yellow */
-00275                 /* 15 */        0x80808000UL,   /* Gray 50% */
-00276                 /* 16 */        0xc0c0c000UL,   /* Gray 25% */
-00277         };
-00278         if ((size_t)ucFontColor >= elementsof(aulColorTable)) {
-00279                 return aulColorTable[0];
-00280         }
-00281         return aulColorTable[(int)ucFontColor];
-00282 } /* end of ulColor2Color */
-00283 
-00284 /*
-00285  * iFindSplit - find a place to split the string
-00286  *
-00287  * returns the index of the split character or -1 if no split found.
-00288  */
-00289 static int
-00290 iFindSplit(const char *szString, size_t tStringLen)
-00291 {
-00292         size_t  tSplit;
-00293 
-00294         if (tStringLen == 0) {
-00295                 return -1;
-00296         }
-00297         tSplit = tStringLen - 1;
-00298         while (tSplit >= 1) {
-00299                 if (szString[tSplit] == ' ' ||
-00300                     (szString[tSplit] == '-' && szString[tSplit - 1] != ' ')) {
-00301                         return (int)tSplit;
-00302                 }
-00303                 tSplit--;
-00304         }
-00305         return -1;
-00306 } /* end of iFindSplit */
-00307 
-00308 /*
-00309  * pSplitList - split the specified list in a printable part and a leftover part
-00310  *
-00311  * returns the pointer to the leftover part
-00312  */
-00313 output_type *
-00314 pSplitList(output_type *pAnchor)
-00315 {
-00316         output_type     *pCurr, *pLeftOver;
-00317         int             iIndex;
-00318 
-00319         fail(pAnchor == NULL);
-00320 
-00321         for (pCurr = pAnchor; pCurr->pNext != NULL; pCurr = pCurr->pNext)
-00322                 ;       /* EMPTY */
-00323         iIndex = -1;
-00324         for (; pCurr != NULL; pCurr = pCurr->pPrev) {
-00325                 iIndex = iFindSplit(pCurr->szStorage, pCurr->tNextFree);
-00326                 if (iIndex >= 0) {
-00327                         break;
-00328                 }
-00329         }
-00330 
-00331         if (pCurr == NULL || iIndex < 0) {
-00332                 /* No split, no leftover */
-00333                 return NULL;
-00334         }
-00335         /* Split over the iIndex-th character */
-00336         NO_DBG_MSG("pLeftOver");
-00337         pLeftOver = xmalloc(sizeof(*pLeftOver));
-00338         fail(pCurr->tNextFree < (size_t)iIndex);
-00339         pLeftOver->tStorageSize = pCurr->tNextFree - (size_t)iIndex;
-00340         pLeftOver->szStorage = xmalloc(pLeftOver->tStorageSize);
-00341         pLeftOver->tNextFree = pCurr->tNextFree - (size_t)iIndex - 1;
-00342         (void)strncpy(pLeftOver->szStorage,
-00343                 pCurr->szStorage + iIndex + 1, pLeftOver->tNextFree);
-00344         pLeftOver->szStorage[pLeftOver->tNextFree] = '\0';
-00345         NO_DBG_MSG(pLeftOver->szStorage);
-00346         pLeftOver->ucFontColor = pCurr->ucFontColor;
-00347         pLeftOver->usFontStyle = pCurr->usFontStyle;
-00348         pLeftOver->tFontRef = pCurr->tFontRef;
-00349         pLeftOver->usFontSize = pCurr->usFontSize;
-00350         pLeftOver->lStringWidth = lComputeStringWidth(
-00351                                         pLeftOver->szStorage,
-00352                                         pLeftOver->tNextFree,
-00353                                         pLeftOver->tFontRef,
-00354                                         pLeftOver->usFontSize);
-00355         pLeftOver->pPrev = NULL;
-00356         pLeftOver->pNext = pCurr->pNext;
-00357         if (pLeftOver->pNext != NULL) {
-00358                 pLeftOver->pNext->pPrev = pLeftOver;
-00359         }
-00360         fail(!bCheckDoubleLinkedList(pLeftOver));
-00361 
-00362         NO_DBG_MSG("pAnchor");
-00363         NO_DBG_HEX(pCurr->szStorage[iIndex]);
-00364         while (iIndex >= 0 && isspace((int)(UCHAR)pCurr->szStorage[iIndex])) {
-00365                 iIndex--;
-00366         }
-00367         pCurr->tNextFree = (size_t)iIndex + 1;
-00368         pCurr->szStorage[pCurr->tNextFree] = '\0';
-00369         NO_DBG_MSG(pCurr->szStorage);
-00370         pCurr->lStringWidth = lComputeStringWidth(
-00371                                         pCurr->szStorage,
-00372                                         pCurr->tNextFree,
-00373                                         pCurr->tFontRef,
-00374                                         pCurr->usFontSize);
-00375         pCurr->pNext = NULL;
-00376         fail(!bCheckDoubleLinkedList(pAnchor));
-00377 
-00378         return pLeftOver;
-00379 } /* end of pSplitList */
-00380 
-00381 /*
-00382  * tNumber2Roman - convert a number to Roman Numerals
-00383  *
-00384  * returns the number of characters written
-00385  */
-00386 size_t
-00387 tNumber2Roman(UINT uiNumber, BOOL bUpperCase, char *szOutput)
-00388 {
-00389         char    *outp, *p, *q;
-00390         UINT    uiNextVal, uiValue;
-00391 
-00392         fail(szOutput == NULL);
-00393 
-00394         uiNumber %= 4000;       /* Very high numbers can't be represented */
-00395         if (uiNumber == 0) {
-00396                 szOutput[0] = '\0';
-00397                 return 0;
-00398         }
-00399 
-00400         outp = szOutput;
-00401         p = bUpperCase ? "M\2D\5C\2L\5X\2V\5I" : "m\2d\5c\2l\5x\2v\5i";
-00402         uiValue = 1000;
-00403         for (;;) {
-00404                 while (uiNumber >= uiValue) {
-00405                         *outp++ = *p;
-00406                         uiNumber -= uiValue;
-00407                 }
-00408                 if (uiNumber == 0) {
-00409                         *outp = '\0';
-00410                         fail(outp < szOutput);
-00411                         return (size_t)(outp - szOutput);
-00412                 }
-00413                 q = p + 1;
-00414                 uiNextVal = uiValue / (UINT)(UCHAR)*q;
-00415                 if ((int)*q == 2) {             /* magic */
-00416                         uiNextVal /= (UINT)(UCHAR)*(q += 2);
-00417                 }
-00418                 if (uiNumber + uiNextVal >= uiValue) {
-00419                         *outp++ = *++q;
-00420                         uiNumber += uiNextVal;
-00421                 } else {
-00422                         p++;
-00423                         uiValue /= (UINT)(UCHAR)(*p++);
-00424                 }
-00425         }
-00426 } /* end of tNumber2Roman */
-00427 
-00428 /*
-00429  * iNumber2Alpha - convert a number to alphabetic "numbers"
-00430  *
-00431  * returns the number of characters written
-00432  */
-00433 size_t
-00434 tNumber2Alpha(UINT uiNumber, BOOL bUpperCase, char *szOutput)
-00435 {
-00436         char    *outp;
-00437         UINT    uiTmp;
-00438 
-00439         fail(szOutput == NULL);
-00440 
-00441         if (uiNumber == 0) {
-00442                 szOutput[0] = '\0';
-00443                 return 0;
-00444         }
-00445 
-00446         outp = szOutput;
-00447         uiTmp = (UINT)(bUpperCase ? 'A': 'a');
-00448         if (uiNumber <= 26) {
-00449                 uiNumber -= 1;
-00450                 *outp++ = (char)(uiTmp + uiNumber);
-00451         } else if (uiNumber <= 26U + 26U*26U) {
-00452                 uiNumber -= 26 + 1;
-00453                 *outp++ = (char)(uiTmp + uiNumber / 26);
-00454                 *outp++ = (char)(uiTmp + uiNumber % 26);
-00455         } else if (uiNumber <= 26U + 26U*26U + 26U*26U*26U) {
-00456                 uiNumber -= 26 + 26*26 + 1;
-00457                 *outp++ = (char)(uiTmp + uiNumber / (26*26));
-00458                 *outp++ = (char)(uiTmp + uiNumber / 26 % 26);
-00459                 *outp++ = (char)(uiTmp + uiNumber % 26);
-00460         }
-00461         *outp = '\0';
-00462         fail(outp < szOutput);
-00463         return (size_t)(outp - szOutput);
-00464 } /* end of tNumber2Alpha */
-00465 
-00466 /*
-00467  * unincpy - copy a counted Unicode string to an single-byte string
-00468  */
-00469 char *
-00470 unincpy(char *s1, const UCHAR *s2, size_t n)
-00471 {
-00472         char    *pcDest;
-00473         ULONG   ulChar;
-00474         size_t  tLen;
-00475         USHORT  usUni;
-00476 
-00477         for (pcDest = s1, tLen = 0; tLen < n; pcDest++, tLen++) {
-00478                 usUni = usGetWord(tLen * 2, s2);
-00479                 if (usUni == 0) {
-00480                         break;
-00481                 }
-00482                 ulChar = ulTranslateCharacters(usUni, 0, 8,
-00483                                 conversion_unknown, encoding_neutral, FALSE);
-00484                 if (ulChar == IGNORE_CHARACTER) {
-00485                         ulChar = (ULONG)'?';
-00486                 }
-00487                 *pcDest = (char)ulChar;
-00488         }
-00489         for (; tLen < n; tLen++) {
-00490                 *pcDest++ = '\0';
-00491         }
-00492         return s1;
-00493 } /* end of unincpy */
-00494 
-00495 /*
-00496  * unilen - calculate the length of a Unicode string
-00497  *
-00498  * returns the length in bytes
-00499  */
-00500 size_t
-00501 unilen(const UCHAR *s)
-00502 {
-00503         size_t  tLen;
-00504         USHORT  usUni;
-00505 
-00506         tLen = 0;
-00507         for (;;) {
-00508                 usUni = usGetWord(tLen, s);
-00509                 if (usUni == 0) {
-00510                         return tLen;
-00511                 }
-00512                 tLen += 2;
-00513         }
-00514 } /* end of unilen */
-00515 
-00516 /*
-00517  * szBaseName - get the basename of the specified filename
-00518  */
-00519 const char *
-00520 szBasename(const char *szFilename)
-00521 {
-00522         const char      *szTmp;
-00523 
-00524         fail(szFilename == NULL);
-00525 
-00526         if (szFilename == NULL || szFilename[0] == '\0') {
-00527                 return "null";
-00528         }
-00529 
-00530         szTmp = strrchr(szFilename, FILE_SEPARATOR[0]);
-00531         if (szTmp == NULL) {
-00532                 return szFilename;
-00533         }
-00534         return ++szTmp;
-00535 } /* end of szBasename */
-00536 
-00537 /*
-00538  * lComputeLeading - compute the leading
-00539  *
-00540  * NOTE: the fontsize is specified in half points
-00541  *
-00542  * Returns the leading in drawunits
-00543  */
-00544 long
-00545 lComputeLeading(USHORT usFontSize)
-00546 {
-00547         long    lLeading;
-00548 
-00549         lLeading = (long)usFontSize * 500L;
-00550         if (usFontSize < 18) {          /* Small text: 112% */
-00551                 lLeading *= 112;
-00552         } else if (usFontSize < 28) {   /* Normal text: 124% */
-00553                 lLeading *= 124;
-00554         } else if (usFontSize < 48) {   /* Small headlines: 104% */
-00555                 lLeading *= 104;
-00556         } else {                        /* Large headlines: 100% */
-00557                 lLeading *= 100;
-00558         }
-00559         lLeading = lMilliPoints2DrawUnits(lLeading);
-00560         lLeading += 50;
-00561         lLeading /= 100;
-00562         return lLeading;
-00563 } /* end of lComputeLeading */
-00564 
-00565 /*
-00566  * Convert a UCS character to an UTF-8 string
-00567  *
-00568  * Returns the string length of the result
-00569  */
-00570 size_t
-00571 tUcs2Utf8(ULONG ulChar, char *szResult, size_t tMaxResultLen)
-00572 {
-00573         if (szResult == NULL || tMaxResultLen == 0) {
-00574                 return 0;
-00575         }
-00576 
-00577         if (ulChar < 0x80 && tMaxResultLen >= 2) {
-00578                 szResult[0] = (char)ulChar;
-00579                 szResult[1] = '\0';
-00580                 return 1;
-00581         }
-00582         if (ulChar < 0x800 && tMaxResultLen >= 3) {
-00583                 szResult[0] = (char)(0xc0 | ulChar >> 6);
-00584                 szResult[1] = (char)(0x80 | (ulChar & 0x3f));
-00585                 szResult[2] = '\0';
-00586                 return 2;
-00587         }
-00588         if (ulChar < 0x10000 && tMaxResultLen >= 4) {
-00589                 szResult[0] = (char)(0xe0 | ulChar >> 12);
-00590                 szResult[1] = (char)(0x80 | (ulChar >> 6 & 0x3f));
-00591                 szResult[2] = (char)(0x80 | (ulChar & 0x3f));
-00592                 szResult[3] = '\0';
-00593                 return 3;
-00594         }
-00595         if (ulChar < 0x200000 && tMaxResultLen >= 5) {
-00596                 szResult[0] = (char)(0xf0 | ulChar >> 18);
-00597                 szResult[1] = (char)(0x80 | (ulChar >> 12 & 0x3f));
-00598                 szResult[2] = (char)(0x80 | (ulChar >> 6 & 0x3f));
-00599                 szResult[3] = (char)(0x80 | (ulChar & 0x3f));
-00600                 szResult[4] = '\0';
-00601                 return 4;
-00602         }
-00603         szResult[0] = '\0';
-00604         return 0;
-00605 } /* end of tUcs2Utf8 */
-00606 
-00607 /*
-00608  * vGetBulletValue - get the bullet value for the conversing type and encoding
-00609  */
-00610 void
-00611 vGetBulletValue(conversion_type eConversionType, encoding_type eEncoding,
-00612         char *szResult, size_t tMaxResultLen)
-00613 {
-00614         fail(szResult == NULL);
-00615         fail(tMaxResultLen < 2);
-00616 
-00617         if (eEncoding == encoding_utf_8) {
-00618                 (void)tUcs2Utf8(UNICODE_BULLET, szResult, tMaxResultLen);
-00619         } else {
-00620                 szResult[0] = (char)ucGetBulletCharacter(eConversionType,
-00621                                                         eEncoding);
-00622                 szResult[1] = '\0';
-00623         }
-00624 } /* end of vGetBulletValue */
-00625 
-00626 /*
-00627  * bAllZero - are all bytes zero?
-00628  */
-00629 BOOL
-00630 bAllZero(const UCHAR *aucBytes, size_t tLength)
-00631 {
-00632         size_t  tIndex;
-00633 
-00634         if (aucBytes == NULL || tLength == 0) {
-00635                 return TRUE;
-00636         }
-00637 
-00638         for (tIndex = 0; tIndex < tLength; tIndex++) {
-00639                 if (aucBytes[tIndex] != 0) {
-00640                         return FALSE;
-00641                 }
-00642         }
-00643         return TRUE;
-00644 } /* end of bAllZero */
-00645 
-00646 #if !defined(__riscos)
-00647 /*
-00648  * GetCodesetFromLocale - get the codeset from the current locale
-00649  *
-00650  * Original version: Copyright (C) 1999  Bruno Haible
-00651  * Syntax:
-00652  * language[_territory][.codeset][@modifier][+special][,[sponsor][_revision]]
-00653  *
-00654  * Returns TRUE when sucessful, otherwise FALSE
-00655  */
-00656 static BOOL
-00657 bGetCodesetFromLocale(char *szCodeset, size_t tMaxCodesetLength, BOOL *pbEuro)
-00658 {
-00659 #if !defined(__dos)
-00660         const char      *szLocale;
-00661         const char      *pcTmp;
-00662         size_t          tIndex;
-00663         char            szModifier[6];
-00664 #endif /* __dos */
-00665 
-00666         if (pbEuro != NULL) {
-00667                 *pbEuro = FALSE;        /* Until proven otherwise */
-00668         }
-00669         if (szCodeset == NULL || tMaxCodesetLength == 0) {
-00670                 return FALSE;
-00671         }
-00672 
-00673 #if defined(__dos)
-00674         if (tMaxCodesetLength < 2 + sizeof(int) * 3 + 1) {
-00675                 DBG_DEC(tMaxCodesetLength);
-00676                 DBG_DEC(2 + sizeof(int) * 3 + 1);
-00677                 return FALSE;
-00678         }
-00679         /* Get the active codepage from DOS */
-00680         sprintf(szCodeset, "cp%d", iGetCodepage());
-00681         DBG_MSG(szCodeset);
-00682 #else
-00683         /* Get the locale from the environment */
-00684         szLocale = getenv("LC_ALL");
-00685         if (szLocale == NULL || szLocale[0] == '\0') {
-00686                 szLocale = getenv("LC_CTYPE");
-00687                 if (szLocale == NULL || szLocale[0] == '\0') {
-00688                         szLocale = getenv("LANG");
-00689                 }
-00690         }
-00691         if (szLocale == NULL || szLocale[0] == '\0') {
-00692                 /* No locale, so no codeset name and no modifier */
-00693                 return FALSE;
-00694         }
-00695         DBG_MSG(szLocale);
-00696         pcTmp = strchr(szLocale, '.');
-00697         if (pcTmp == NULL) {
-00698                 /* No codeset name */
-00699                 szCodeset[0] = '\0';
-00700         } else {
-00701                 /* Copy the codeset name */
-00702                 pcTmp++;
-00703                 for (tIndex = 0; tIndex < tMaxCodesetLength; tIndex++) {
-00704                         if (*pcTmp == '@' || *pcTmp == '+' ||
-00705                             *pcTmp == ',' || *pcTmp == '_' ||
-00706                             *pcTmp == '\0') {
-00707                                 szCodeset[tIndex] = '\0';
-00708                                 break;
-00709                         }
-00710                         szCodeset[tIndex] = *pcTmp;
-00711                         pcTmp++;
-00712                 }
-00713                 szCodeset[tMaxCodesetLength - 1] = '\0';
-00714         }
-00715         if (pbEuro == NULL) {
-00716                 /* No need to get the modifier */
-00717                 return TRUE;
-00718         }
-00719         pcTmp = strchr(szLocale, '@');
-00720         if (pcTmp != NULL) {
-00721                 /* Copy the modifier */
-00722                 pcTmp++;
-00723                 for (tIndex = 0; tIndex < sizeof(szModifier); tIndex++) {
-00724                         if (*pcTmp == '+' || *pcTmp == ',' ||
-00725                             *pcTmp == '_' || *pcTmp == '\0') {
-00726                                 szModifier[tIndex] = '\0';
-00727                                 break;
-00728                         }
-00729                         szModifier[tIndex] = *pcTmp;
-00730                         pcTmp++;
-00731                 }
-00732                 szModifier[sizeof(szModifier) - 1] = '\0';
-00733                 *pbEuro = STRCEQ(szModifier, "Euro");
-00734         }
-00735 #endif /* __dos */
-00736         return TRUE;
-00737 } /* end of bGetCodesetFromLocale */
-00738 
-00739 /*
-00740  * GetNormalizedCodeset - get the normalized codeset from the current locale
-00741  *
-00742  * Returns TRUE when sucessful, otherwise FALSE
-00743  */
-00744 BOOL
-00745 bGetNormalizedCodeset(char *szCodeset, size_t tMaxCodesetLength, BOOL *pbEuro)
-00746 {
-00747         BOOL    bOnlyDigits;
-00748         const char      *pcSrc;
-00749         char    *pcDest;
-00750         char    *szTmp, *szCodesetNorm;
-00751 
-00752         if (pbEuro != NULL) {
-00753                 *pbEuro = FALSE;        /* Until proven otherwise */
-00754         }
-00755         if (szCodeset == NULL || tMaxCodesetLength < 4) {
-00756                 return FALSE;
-00757         }
-00758 
-00759         /* Get the codeset name */
-00760         szTmp = xmalloc(tMaxCodesetLength - 3);
-00761         if (!bGetCodesetFromLocale(szTmp, tMaxCodesetLength - 3, pbEuro)) {
-00762                 szTmp = xfree(szTmp);
-00763                 return FALSE;
-00764         }
-00765         /* Normalize the codeset name */
-00766         szCodesetNorm = xmalloc(tMaxCodesetLength - 3);
-00767         bOnlyDigits = TRUE;
-00768         pcDest = szCodesetNorm;
-00769         for (pcSrc = szTmp; *pcSrc != '\0'; pcSrc++) {
-00770                 if (isalnum(*pcSrc)) {
-00771                         *pcDest = tolower(*pcSrc);
-00772                         if (!isdigit(*pcDest)) {
-00773                                 bOnlyDigits = FALSE;
-00774                         }
-00775                         pcDest++;
-00776                 }
-00777         }
-00778         *pcDest = '\0';
-00779         DBG_MSG(szCodesetNorm);
-00780         /* Add "iso" when szCodesetNorm contains all digits */
-00781         if (bOnlyDigits && szCodesetNorm[0] != '\0') {
-00782                 fail(strlen(szCodesetNorm) + 3 >= tMaxCodesetLength);
-00783                 sprintf(szCodeset, "iso%s", szCodesetNorm);
-00784         } else {
-00785                 fail(strlen(szCodesetNorm) >= tMaxCodesetLength);
-00786                 strncpy(szCodeset, szCodesetNorm, pcDest - szCodesetNorm + 1);
-00787                 szCodeset[tMaxCodesetLength - 1] = '\0';
-00788         }
-00789         DBG_MSG(szCodeset);
-00790         /* Clean up and leave */
-00791         szCodesetNorm = xfree(szCodesetNorm);
-00792         szTmp = xfree(szTmp);
-00793         return TRUE;
-00794 } /* end of bGetNormalizedCodeset */
-00795 
-00796 /*
-00797  * szGetDefaultMappingFile - get the default mapping file
-00798  *
-00799  * Returns the basename of the default mapping file
-00800  */
-00801 const char *
-00802 szGetDefaultMappingFile(void)
-00803 {
-00804         static const struct {
-00805                 const char      *szCodeset;
-00806                 const char      *szMappingFile;
-00807         } atMappingFile[] = {
-00808                 { "iso88591",   MAPPING_FILE_8859_1 },
-00809                 { "iso88592",   MAPPING_FILE_8859_2 },
-00810                 { "iso88593",   "8859-3.txt" },
-00811                 { "iso88594",   "8859-4.txt" },
-00812                 { "iso88595",   "8859-5.txt" },
-00813                 { "iso88596",   MAPPING_FILE_8859_5 },
-00814                 { "iso88597",   "8859-7.txt" },
-00815                 { "iso88598",   "8859-8.txt" },
-00816                 { "iso88599",   "8859-9.txt" },
-00817                 { "iso885910",  "8859-10.txt" },
-00818                 { "iso885913",  "8859-13.txt" },
-00819                 { "iso885914",  "8859-14.txt" },
-00820                 { "iso885915",  MAPPING_FILE_8859_15 },
-00821                 { "iso885916",  "8859-16.txt" },
-00822                 { "koi8r",      MAPPING_FILE_KOI8_R },
-00823                 { "koi8u",      MAPPING_FILE_KOI8_U },
-00824                 { "utf8",       MAPPING_FILE_UTF_8 },
-00825                 { "cp437",      MAPPING_FILE_CP437 },
-00826                 { "cp850",      "cp850.txt" },
-00827                 { "cp852",      MAPPING_FILE_CP852 },
-00828                 { "cp862",      "cp862.txt" },
-00829                 { "cp864",      "cp864.txt" },
-00830                 { "cp866",      MAPPING_FILE_CP866 },
-00831                 { "cp1250",     MAPPING_FILE_CP1250 },
-00832                 { "cp1251",     MAPPING_FILE_CP1251 },
-00833                 { "cp1252",     "cp1252.txt" },
-00834         };
-00835         size_t  tIndex;
-00836         BOOL    bEuro;
-00837         char    szCodeset[20];
-00838 
-00839         szCodeset[0] = '\0';
-00840         bEuro = FALSE;
-00841         /* Get the normalized codeset name */
-00842         if (!bGetNormalizedCodeset(szCodeset, sizeof(szCodeset), &bEuro)) {
-00843                 return MAPPING_FILE_8859_1;
-00844         }
-00845         if (szCodeset[0] == '\0') {
-00846                 if (bEuro) {
-00847                         /* Default mapping file (with Euro sign) */
-00848                         return MAPPING_FILE_8859_15;
-00849                 } else {
-00850                         /* Default mapping file (without Euro sign) */
-00851                         return MAPPING_FILE_8859_1;
-00852                 }
-00853         }
-00854         /* Find the name in the table */
-00855         for (tIndex = 0; tIndex < elementsof(atMappingFile); tIndex++) {
-00856                 if (STREQ(atMappingFile[tIndex].szCodeset, szCodeset)) {
-00857                         return atMappingFile[tIndex].szMappingFile;
-00858                 }
-00859         }
-00860         /* Default default mapping file */
-00861 #if defined(__dos)
-00862         return MAPPING_FILE_CP437;
-00863 #else
-00864         return MAPPING_FILE_8859_1;
-00865 #endif /* __dos */
-00866 } /* end of szGetDefaultMappingFile */
-00867 #endif /* !__riscos */
-00868 
-00869 /*
-00870  * tConvertDTTM - convert Windows Date and Time format
-00871  *
-00872  * returns Unix time_t or -1
-00873  */
-00874 time_t
-00875 tConvertDTTM(ULONG ulDTTM)
-00876 {
-00877         struct tm       tTime;
-00878         time_t          tResult;
-00879 
-00880         if (ulDTTM == 0) {
-00881                 return (time_t)-1;
-00882         }
-00883         memset(&tTime, 0, sizeof(tTime));
-00884         tTime.tm_min = (int)(ulDTTM & 0x0000003f);
-00885         tTime.tm_hour = (int)((ulDTTM & 0x000007c0) >> 6);
-00886         tTime.tm_mday = (int)((ulDTTM & 0x0000f800) >> 11);
-00887         tTime.tm_mon = (int)((ulDTTM & 0x000f0000) >> 16);
-00888         tTime.tm_year = (int)((ulDTTM & 0x1ff00000) >> 20);
-00889         tTime.tm_isdst = -1;
-00890         tTime.tm_mon--;         /* From 01-12 to 00-11 */
-00891         tResult = mktime(&tTime);
-00892         NO_DBG_MSG(ctime(&tResult));
-00893         return tResult;
-00894 } /* end of tConvertDTTM */
-