00001
00002
00003
00004
00005
00006
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
00021 #if !defined(S_ISREG)
00022 #define S_ISREG(x) (((x) & S_IFMT) == S_IFREG)
00023 #endif
00024 #include "antiword.h"
00025 #if defined(__vms)
00026 #include <unixlib.h>
00027 #endif
00028
00029 #if !defined(__riscos)
00030
00031
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
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
00055 }
00056 return szHome;
00057 }
00058
00059
00060
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
00070 }
00071 #endif
00072
00073
00074
00075
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
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
00107 return -1;
00108 }
00109 return (long)tBuffer.st_size;
00110 #endif
00111 }
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 }
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;
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 }
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 }
00174 #endif
00175
00176
00177
00178
00179
00180
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 }
00198
00199
00200
00201
00202
00203
00204
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 }
00250
00251
00252
00253
00254
00255
00256 ULONG
00257 ulColor2Color(UCHAR ucFontColor)
00258 {
00259 static const ULONG aulColorTable[] = {
00260 0x00000000UL,
00261 0x00000000UL,
00262 0xff000000UL,
00263 0xffff0000UL,
00264 0x00ff0000UL,
00265 0xff00ff00UL,
00266 0x0000ff00UL,
00267 0x00ffff00UL,
00268 0xffffff00UL,
00269 0x80000000UL,
00270 0x80800000UL,
00271 0x00800000UL,
00272 0x80008000UL,
00273 0x00008000UL,
00274 0x00808000UL,
00275 0x80808000UL,
00276 0xc0c0c000UL,
00277 };
00278 if ((size_t)ucFontColor >= elementsof(aulColorTable)) {
00279 return aulColorTable[0];
00280 }
00281 return aulColorTable[(int)ucFontColor];
00282 }
00283
00284
00285
00286
00287
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 }
00307
00308
00309
00310
00311
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 ;
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
00333 return NULL;
00334 }
00335
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 }
00380
00381
00382
00383
00384
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;
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) {
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 }
00427
00428
00429
00430
00431
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 }
00465
00466
00467
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 }
00494
00495
00496
00497
00498
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 }
00515
00516
00517
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 }
00536
00537
00538
00539
00540
00541
00542
00543
00544 long
00545 lComputeLeading(USHORT usFontSize)
00546 {
00547 long lLeading;
00548
00549 lLeading = (long)usFontSize * 500L;
00550 if (usFontSize < 18) {
00551 lLeading *= 112;
00552 } else if (usFontSize < 28) {
00553 lLeading *= 124;
00554 } else if (usFontSize < 48) {
00555 lLeading *= 104;
00556 } else {
00557 lLeading *= 100;
00558 }
00559 lLeading = lMilliPoints2DrawUnits(lLeading);
00560 lLeading += 50;
00561 lLeading /= 100;
00562 return lLeading;
00563 }
00564
00565
00566
00567
00568
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 }
00606
00607
00608
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 }
00625
00626
00627
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 }
00645
00646 #if !defined(__riscos)
00647
00648
00649
00650
00651
00652
00653
00654
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
00665
00666 if (pbEuro != NULL) {
00667 *pbEuro = FALSE;
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
00680 sprintf(szCodeset, "cp%d", iGetCodepage());
00681 DBG_MSG(szCodeset);
00682 #else
00683
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
00693 return FALSE;
00694 }
00695 DBG_MSG(szLocale);
00696 pcTmp = strchr(szLocale, '.');
00697 if (pcTmp == NULL) {
00698
00699 szCodeset[0] = '\0';
00700 } else {
00701
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
00717 return TRUE;
00718 }
00719 pcTmp = strchr(szLocale, '@');
00720 if (pcTmp != NULL) {
00721
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
00736 return TRUE;
00737 }
00738
00739
00740
00741
00742
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;
00754 }
00755 if (szCodeset == NULL || tMaxCodesetLength < 4) {
00756 return FALSE;
00757 }
00758
00759
00760 szTmp = xmalloc(tMaxCodesetLength - 3);
00761 if (!bGetCodesetFromLocale(szTmp, tMaxCodesetLength - 3, pbEuro)) {
00762 szTmp = xfree(szTmp);
00763 return FALSE;
00764 }
00765
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
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
00791 szCodesetNorm = xfree(szCodesetNorm);
00792 szTmp = xfree(szTmp);
00793 return TRUE;
00794 }
00795
00796
00797
00798
00799
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
00842 if (!bGetNormalizedCodeset(szCodeset, sizeof(szCodeset), &bEuro)) {
00843 return MAPPING_FILE_8859_1;
00844 }
00845 if (szCodeset[0] == '\0') {
00846 if (bEuro) {
00847
00848 return MAPPING_FILE_8859_15;
00849 } else {
00850
00851 return MAPPING_FILE_8859_1;
00852 }
00853 }
00854
00855 for (tIndex = 0; tIndex < elementsof(atMappingFile); tIndex++) {
00856 if (STREQ(atMappingFile[tIndex].szCodeset, szCodeset)) {
00857 return atMappingFile[tIndex].szMappingFile;
00858 }
00859 }
00860
00861 #if defined(__dos)
00862 return MAPPING_FILE_CP437;
00863 #else
00864 return MAPPING_FILE_8859_1;
00865 #endif
00866 }
00867 #endif
00868
00869
00870
00871
00872
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--;
00891 tResult = mktime(&tTime);
00892 NO_DBG_MSG(ctime(&tResult));
00893 return tResult;
00894 }