docdecoder.cpp

此文件为Word 格式文件.DOC转换为TXT文件的源代码。

			*piOffset = pFootBlockCurrent->tInfo.iFileOffset +
				iBlockOffset +
				iByteNext;
		}
		return aucBlock[iByteNext++];
} /* end of iNextFootByte */


int
CDocDecoder::iNextEndByte(unsigned char *pFile, int *piOffset)
{
	static int	iByteNext = 0;
	static int	iBlockOffset = 0;
	int	iReadLen, iReadOff;

	if (pEndBlockCurrent == NULL ||
		iByteNext >= sizeof(aucBlock) ||
		iBlockOffset + iByteNext >= pEndBlockCurrent->tInfo.iLength) {
			if (pEndBlockCurrent == NULL) {
				/* First block, first part */
				pEndBlockCurrent = pEndAnchor;
				iBlockOffset = 0;
			} else if (iBlockOffset + (signed)sizeof(aucBlock) <
				pEndBlockCurrent->tInfo.iLength) {
					/* Same block, next part */
					iBlockOffset += sizeof(aucBlock);
				} else {
					/* Next block, first part */
					pEndBlockCurrent = pEndBlockCurrent->pNext;
					iBlockOffset = 0;
				}
				if (pEndBlockCurrent == NULL) {
					/* Past the last part of the last block */
					return EOF;
				}
				iReadLen = pEndBlockCurrent->tInfo.iLength - iBlockOffset;
				if (iReadLen > sizeof(aucBlock)) {
					iReadLen = sizeof(aucBlock);
				}
				iReadOff = pEndBlockCurrent->tInfo.iFileOffset +
					iBlockOffset;
				if (!bReadBytes(aucBlock, iReadLen, iReadOff, pFile)) {
					return EOF;
				}
				iByteNext = 0;
		}
		if (piOffset != NULL) {
			*piOffset = pEndBlockCurrent->tInfo.iFileOffset +
				iBlockOffset +
				iByteNext;
		}
		return aucBlock[iByteNext++];
} /* end of iNextEndByte */


int
CDocDecoder::iNextTextChar(unsigned char *pFile, int *piOffset)
{
	int	iChar, iMSB;

	iChar = iNextTextByte(pFile, piOffset);
	if (iChar == EOF) {
		return EOF;
	}
	if (pTextBlockCurrent->tInfo.bUsesUnicode) {
		iMSB = iNextTextByte(pFile, NULL);
	} else {
		iMSB = 0x00;
	}
	if (iMSB == EOF) {
		return EOF;
	}
	iChar |= iMSB << 8;
	return iChar;
} /* end of iNextTextChar */


int
CDocDecoder::iNextFootChar(unsigned char *pFile, int *piOffset)
{
	int	iChar, iMSB;

	iChar = iNextFootByte(pFile, piOffset);
	if (iChar == EOF) {
		return EOF;
	}
	if (pFootBlockCurrent->tInfo.bUsesUnicode) {
		iMSB = iNextFootByte(pFile, NULL);
	} else {
		iMSB = 0x00;
	}
	if (iMSB == EOF) {
		return EOF;
	}
	iChar |= iMSB << 8;
	return iChar;
} /* end of iNextFootChar */


int
CDocDecoder::iNextEndChar(unsigned char *pFile, int *piOffset)
{
	int	iChar, iMSB;

	iChar = iNextEndByte(pFile, piOffset);
	if (iChar == EOF) {
		return EOF;
	}
	if (pEndBlockCurrent->tInfo.bUsesUnicode) {
		iMSB = iNextEndByte(pFile, NULL);
	} else {
		iMSB = 0x00;
	}
	if (iMSB == EOF) {
		return EOF;
	}
	iChar |= iMSB << 8;
	return iChar;
} /* end of iNextEndChar */


int
CDocDecoder::iNextChar(unsigned char *pFile, list_id_enum eListID, int *piOffset)
{

	switch (eListID) {
	case text_list:
		return iNextTextChar(pFile, piOffset);
	case footnote_list:
		return iNextFootChar(pFile, piOffset);
	case endnote_list:
		return iNextEndChar(pFile, piOffset);
	default:
		if (piOffset != NULL) {
			*piOffset = -1;
		}
		return EOF;
	}
} /* end of iNextChar */


int
CDocDecoder::iTextOffset2FileOffset(int iTextOffset)
{
	list_mem_type	*apAnchors[5];
	list_mem_type	*pCurr;
	int		iIndex;
	bool		bStartOfList;


	if (iTextOffset < 0) {
		return -1;
	}

	apAnchors[0] = pTextAnchor;
	apAnchors[1] = pFootAnchor;
	apAnchors[2] = pUnused1Anchor;
	apAnchors[3] = pEndAnchor;
	apAnchors[4] = pUnused2Anchor;

	bStartOfList = false;

	for (iIndex = 0; iIndex < 5; iIndex++) {
		pCurr = apAnchors[iIndex];
		while (pCurr != NULL) {
			if (bStartOfList) {
				if (iIndex >= 4) {
					/* Past the last used byte */
					return -1;
				}
				return pCurr->tInfo.iFileOffset;
			}
			if (iTextOffset < pCurr->tInfo.iTextOffset ||
				iTextOffset >= pCurr->tInfo.iTextOffset +
				pCurr->tInfo.iLength) {
					pCurr = pCurr->pNext;
					continue;
				}
				switch (iIndex) {
			case 0:
			case 1:
			case 3:
				/* The textoffset is in the current block */
				return pCurr->tInfo.iFileOffset +
					iTextOffset -
					pCurr->tInfo.iTextOffset;
			case 2:
				/* Use the start of the next non-empty list */
				bStartOfList = TRUE;
				break;
			case 4:
				/* In Unused2, means after the last used byte */
				return -1;
			default:
				/* This should not happen */
				return -1;
				}
				if (bStartOfList) {
					/* To the start of the next list */
					break;
				}
		}
	}
	/* Passed beyond the end of the last list */
	return -1;
} /* end of iTextOffset2FileOffset */



int
CDocDecoder::iTranslateCharacters(int iChar, int iFileOffset, bool bMacFile)
{
	if (bMacFile) {
		/* Translate special Macintosh characters */
		switch (iChar) {
		case MAC_CAPTAL_A_DIAERESIS:
			return OUR_CAPTAL_A_DIAERESIS;
		case MAC_CAPTAL_A_RING_ABOVE:
			return OUR_CAPTAL_A_RING_ABOVE;
		case MAC_CAPTAL_C_CEDILLA:
			return OUR_CAPTAL_C_CEDILLA;
		case MAC_CAPTAL_O_ACUTE_ACCENT:
			return OUR_CAPTAL_O_ACUTE_ACCENT;
		case MAC_CAPTAL_N_TILDE:
			return OUR_CAPTAL_N_TILDE;
		case MAC_CAPTAL_O_DIAERESIS:
			return OUR_CAPTAL_O_DIAERESIS;
		case MAC_CAPTAL_U_DIAERESIS:
			return OUR_CAPTAL_U_DIAERESIS;
		case MAC_SMALL_A_ACUTE_ACCENT:
			return OUR_SMALL_A_ACUTE_ACCENT;
		case MAC_SMALL_A_GRAVE_ACCENT:
			return OUR_SMALL_A_GRAVE_ACCENT;
		case MAC_SMALL_A_CIRCUMFLEX_ACCENT:
			return OUR_SMALL_A_CIRCUMFLEX_ACCENT;
		case MAC_SMALL_A_DIAERESIS:
			return OUR_SMALL_A_DIAERESIS;
		case MAC_SMALL_A_TILDE:
			return OUR_SMALL_A_TILDE;
		case MAC_SMALL_A_RING_ABOVE:
			return OUR_SMALL_A_RING_ABOVE;
		case MAC_SMALL_C_CEDILLA:
			return OUR_SMALL_C_CEDILLA;
		case MAC_SMALL_E_ACUTE_ACCENT:
			return OUR_SMALL_E_ACUTE_ACCENT;
		case MAC_SMALL_E_GRAVE_ACCENT:
			return OUR_SMALL_E_GRAVE_ACCENT;
		case MAC_SMALL_E_CIRCUMFLEX_ACCENT:
			return OUR_SMALL_E_CIRCUMFLEX_ACCENT;
		case MAC_SMALL_E_DIAERESIS:
			return OUR_SMALL_E_DIAERESIS;
		case MAC_SMALL_I_ACUTE_ACCENT:
			return OUR_SMALL_I_ACUTE_ACCENT;
		case MAC_SMALL_I_GRAVE_ACCENT:
			return OUR_SMALL_I_GRAVE_ACCENT;
		case MAC_SMALL_I_CIRCUMFLEX_ACCENT:
			return OUR_SMALL_I_CIRCUMFLEX_ACCENT;
		case MAC_SMALL_I_DIAERESIS:
			return OUR_SMALL_I_DIAERESIS;
		case MAC_SMALL_N_TILDE:
			return OUR_SMALL_N_TILDE;
		case MAC_SMALL_O_ACUTE_ACCENT:
			return OUR_SMALL_O_ACUTE_ACCENT;
		case MAC_SMALL_O_GRAVE_ACCENT:
			return OUR_SMALL_O_GRAVE_ACCENT;
		case MAC_SMALL_O_CIRCUMFLEX_ACCENT:
			return OUR_SMALL_O_CIRCUMFLEX_ACCENT;
		case MAC_SMALL_O_DIAERESIS:
			return OUR_SMALL_O_DIAERESIS;
		case MAC_SMALL_O_TILDE:
			return OUR_SMALL_O_TILDE;
		case MAC_SMALL_U_ACUTE_ACCENT:
			return OUR_SMALL_U_ACUTE_ACCENT;
		case MAC_SMALL_U_GRAVE_ACCENT:
			return OUR_SMALL_U_GRAVE_ACCENT;
		case MAC_SMALL_U_CIRCUMFLEX_ACCENT:
			return OUR_SMALL_U_CIRCUMFLEX_ACCENT;
		case MAC_SMALL_U_DIAERESIS:
			return OUR_SMALL_U_DIAERESIS;
		case MAC_SMALL_SHARP_S:
			return OUR_SMALL_SHARP_S;
		case MAC_LEFT_DOUBLE_QMARK:
			return OUR_LEFT_DOUBLE_QMARK;
		case MAC_RIGHT_DOUBLE_QMARK:
			return OUR_RIGHT_DOUBLE_QMARK;
		case MAC_EN_DASH:
			return OUR_EN_DASH;
		case MAC_EM_DASH:
			return OUR_EM_DASH;
		case MAC_OPENING_DOUBLE_QUOTE:
			return OUR_OPENING_DOUBLE_QUOTE;
		case MAC_CLOSING_DOUBLE_QUOTE:
			return OUR_CLOSING_DOUBLE_QUOTE;
		case MAC_LEFT_SINGLE_QUOTE:
			return OUR_LEFT_SINGLE_QUOTE;
		case MAC_RIGHT_SINGLE_QUOTE:
			return OUR_RIGHT_SINGLE_QUOTE;
		default:
			break;
		}
	}

	/* Translate characters to ISO-8859-1 */
	switch (iChar) {
	case IGNORE_CHAR:
	case ANNOTATION:
	case FRAME:
	case WORD_SOFT_HYPHEN:
	case UNICODE_HYPHENATION_POINT:
		return EOF;
	case PICTURE:
	case TABLE_SEPARATOR:
	case TAB:
	case HARD_RETURN:
	case FORM_FEED:
	case PAR_END:
	case COLUMN_FEED:
		return iChar;
	case FOOTNOTE_OR_ENDNOTE:
		switch (eGetNotetype(iFileOffset)) {
	case notetype_is_footnote:
		return FOOTNOTE_CHAR;
	case notetype_is_endnote:
		return ENDNOTE_CHAR;
	default:
		return UNKNOWN_NOTE_CHAR;
		}
	case WORD_UNBREAKABLE_JOIN:
	case UNICODE_NON_BREAKING_HYPHEN:
		return OUR_UNBREAKABLE_JOIN;
	case WORD_EURO_SIGN:
	case UNICODE_EURO_SIGN:
		return OUR_EURO_SIGN;
	case WORD_CEDILLA:
		return OUR_CEDILLA;
	case WORD_DUTCH_GUILDER_SIGN:
		return OUR_DUTCH_GUILDER_SIGN;
	case WORD_LOW_DOUBLE_QUOTE:
	case UNICODE_LOW_DOUBLE_QUOTE:
		return OUR_LOW_DOUBLE_QUOTE;
	case WORD_ELLIPSIS:
	case UNICODE_ELLIPSIS:
		return OUR_ELLIPSIS;
	case WORD_DAGGER:
	case UNICODE_DAGGER:
		return OUR_DAGGER;
	case WORD_DOUBLE_DAGGER:
	case UNICODE_DOUBLE_DAGGER:
		return OUR_DOUBLE_DAGGER;
	case WORD_NON_SPACING_CIRCUMFLEX_ACCENT:
		return OUR_NON_SPACING_CIRCUMFLEX_ACCENT;
	case WORD_PER_MILLE_SIGN:
	case UNICODE_PER_MILLE_SIGN:
		return OUR_PER_MILLE_SIGN;
	case WORD_LEFT_SINGLE_QMARK:
	case UNICODE_LEFT_SINGLE_QMARK:
		return OUR_LEFT_SINGLE_QMARK;
	case WORD_CAPITAL_LIGATURE_OE:
		return OUR_CAPITAL_LIGATURE_OE;
	case WORD_LEFT_SINGLE_QUOTE:
	case UNICODE_LEFT_SINGLE_QUOTE:
	case UNICODE_LEFT_SINGLE_QUOTE_ALT:
		return OUR_LEFT_SINGLE_QUOTE;
	case WORD_RIGHT_SINGLE_QUOTE:
	case UNICODE_RIGHT_SINGLE_QUOTE:
	case UNICODE_RIGHT_SINGLE_QUOTE_ALT:
		return OUR_RIGHT_SINGLE_QUOTE;
	case WORD_OPENING_DOUBLE_QUOTE:
	case UNICODE_OPENING_DOUBLE_QUOTE:
		return OUR_OPENING_DOUBLE_QUOTE;
	case WORD_CLOSING_DOUBLE_QUOTE:
	case UNICODE_CLOSING_DOUBLE_QUOTE:
		return OUR_CLOSING_DOUBLE_QUOTE;
	case WORD_BULLET:
	case UNICODE_BULLET:
	case UNICODE_BULLET_ALT:
		return OUR_BULLET;
	case WORD_EM_DASH:
	case UNICODE_EM_DASH:
	case UNICODE_HORIZONTAL_BAR:
		return OUR_EM_DASH;
	case WORD_EN_DASH:
	case UNICODE_EN_DASH:
	case UNICODE_FIGURE_DASH:
		return OUR_EN_DASH;
	case WORD_NON_SPACING_TILDE:
		return OUR_NON_SPACING_TILDE;
	case WORD_TRADEMARK:
	case UNICODE_TRADEMARK:
		return OUR_TRADEMARK;
	case WORD_RIGHT_SINGLE_QMARK:
	case UNICODE_RIGHT_SINGLE_QMARK:
		return OUR_RIGHT_SINGLE_QMARK;
	case WORD_SMALL_LIGATURE_OE:
		return OUR_SMALL_LIGATURE_OE;
	case UNICODE_CAPITAL_W_CIRCUMFLEX_ACCENT:
		return OUR_CAPITAL_W_CIRCUMFLEX_ACCENT;
	case UNICODE_SMALL_W_CIRCUMFLEX_ACCENT:
		return OUR_SMALL_W_CIRCUMFLEX_ACCENT;
	case UNICODE_CAPITAL_Y_CIRCUMFLEX_ACCENT:
		return OUR_CAPITAL_Y_CIRCUMFLEX_ACCENT;
	case UNICODE_SMALL_Y_CIRCUMFLEX_ACCENT:
		return OUR_SMALL_Y_CIRCUMFLEX_ACCENT;
	case UNICODE_HYPHEN:
		return OUR_HYPHEN;
	case UNICODE_DOUBLE_VERTICAL_LINE:
		return OUR_DOUBLE_VERTICAL_LINE;
	case UNICODE_DOUBLE_LOW_LINE:
		return OUR_DOUBLE_LOW_LINE;
	case UNICODE_FRACTION_SLASH:
		return OUR_FRACTION_SLASH;
	case UNICODE_WHITE_SMILING_FACE:
		return OUR_WHITE_SMILING_FACE;
	case UNICODE_BLACK_SMILING_FACE:
		return OUR_BLACK_SMILING_FACE;
	case UNICODE_DIAMOND:
		return OUR_DIAMOND;
	case UNICODE_COPYRIGHT:
		return OUR_COPYRIGHT;
	default:
		if (iChar < 0x20) {
			/* A control character slipped through */
			return EOF;
		}
		if (iChar > 0xff) {
			/* Untranslated Unicode character */
			//cjg			return '?';
			return iChar;
		}
		return iChar;
	}
} /* end of iTranslateCharacters */


int 
CDocDecoder::iToUpper(int iChar)
{
	if ((iChar & ~0x7f) == 0) {
		/* US ASCII: use standard function */
		return toupper(iChar);
	}
	if (iChar >= 0xe0 && iChar <= 0xfe && iChar != 0xf7) {
		/*
		* Lower case accented characters
		* 0xf7 is Division sign; 0xd7 is Multiplication sign
		* 0xff is y with diaeresis; 0xdf is Sharp s
		*/
		return iChar & ~0x20;
	}
	return iChar;
} /* end of iToUpper */


void
CDocDecoder::vDestroySmallBlockList(void)
{
	aiSmallBlockList = (int *)xfree(aiSmallBlockList);
	iSmallBlockListLen = 0;
} /* end of vDestroySmalBlockList */


bool
CDocDecoder::bCreateSmallBlockList(int iStartblock, const int *aiBBD, int iBBDLen)
{
	int	iIndex, iTmp;
	size_t	tSize;


	/* Find the length of the small block list */
	for (iSmallBlockListLen = 0, iTmp = iStartblock;
	     iSmallBlockListLen < iBBDLen && iTmp != END_OF_CHAIN;
	     iSmallBlockListLen++, iTmp = aiBBD[iTmp]) {
		if (iTmp < 0 || iTmp >= iBBDLen) {
			return false;
//			werr(1, "The Big Block Depot is corrupt");
		}
	}
	if (iSmallBlockListLen <= 0) {
		/* There is no small block list */
		aiSmallBlockList = NULL;
		iSmallBlockListLen = 0;
		return TRUE;
	}

	/* Create the small block list */
	tSize = iSmallBlockListLen * sizeof(int);
	aiSmallBlockList = (int *)xmalloc(tSize);
	for (iIndex = 0, iTmp = iStartblock;
	     iIndex < iBBDLen && iTmp != END_OF_CHAIN;
	     iIndex++, iTmp = aiBBD[iTmp]) {
		if (iTmp < 0 || iTmp >= iBBDLen) {
			return false;
//			werr(1, "The Big Block Depot is corrupt");
		}
		aiSmallBlockList[iIndex] = iTmp;
	}
	return TRUE;
} /* end of bCreateSmallBlockList */