// Markup.cpp: implementation of the CMarkup class. // // Markup Release 11.5 // Copyright (C) 2011 First Objective Software, Inc. All rights reserved // Go to www.firstobject.com for the latest CMarkup and EDOM documentation // Use in commercial applications requires written permission // This software is provided "as is", with no warranty. // #include "stdafx.h" #include #include "Markup.h" #if defined(MCD_STRERROR) // C error routine #include #endif // C error routine #if defined (MARKUP_ICONV) #include #endif #define x_ATTRIBQUOTE '\"' // can be double or single quote #if defined(MARKUP_STL) && ( defined(MARKUP_WINCONV) || (! defined(MCD_STRERROR))) #include // for MultiByteToWideChar, WideCharToMultiByte, FormatMessage #endif // need windows.h when STL and (not setlocale or not strerror), MFC afx.h includes it already #if defined(MARKUP_MBCS) // MBCS/double byte #pragma message( "Note: MBCS build (not UTF-8)" ) // For UTF-8, remove MBCS from project settings C/C++ preprocessor definitions #if defined (MARKUP_WINCONV) #include // for VC++ _mbclen #endif // WINCONV #endif // MBCS/double byte #if defined(_DEBUG) && _MSC_VER > 1000 // VC++ DEBUG #undef THIS_FILE static char THIS_FILE[]=__FILE__; #if defined(DEBUG_NEW) #define new DEBUG_NEW #endif // DEBUG_NEW #endif // VC++ DEBUG // Disable "while ( 1 )" warning in VC++ 2002 #if _MSC_VER >= 1300 // VC++ 2002 (7.0) #pragma warning(disable:4127) #endif // VC++ 2002 (7.0) ////////////////////////////////////////////////////////////////////// // Internal static utility functions // void x_StrInsertReplace( MCD_STR& str, int nLeft, int nReplace, const MCD_STR& strInsert ) { // Insert strInsert into str at nLeft replacing nReplace chars // Reduce reallocs on growing string by reserving string space // If realloc needed, allow for 1.5 times the new length // int nStrLength = MCD_STRLENGTH(str); int nInsLength = MCD_STRLENGTH(strInsert); int nNewLength = nInsLength + nStrLength - nReplace; int nAllocLen = MCD_STRCAPACITY(str); #if defined(MCD_STRINSERTREPLACE) // STL, replace method if ( nNewLength > nAllocLen ) MCD_BLDRESERVE( str, (nNewLength + nNewLength/2 + 128) ); MCD_STRINSERTREPLACE( str, nLeft, nReplace, strInsert ); #else // MFC, no replace method int nBufferLen = nNewLength; if ( nNewLength > nAllocLen ) nBufferLen += nBufferLen/2 + 128; MCD_CHAR* pDoc = MCD_GETBUFFER( str, nBufferLen ); if ( nInsLength != nReplace && nLeft+nReplace < nStrLength ) memmove( &pDoc[nLeft+nInsLength], &pDoc[nLeft+nReplace], (nStrLength-nLeft-nReplace)*sizeof(MCD_CHAR) ); if ( nInsLength ) memcpy( &pDoc[nLeft], strInsert, nInsLength*sizeof(MCD_CHAR) ); MCD_RELEASEBUFFER( str, pDoc, nNewLength ); #endif // MFC, no replace method } int x_Hash( MCD_PCSZ p, int nSize ) { unsigned int n=0; while (*p) n += (unsigned int)(*p++); return n % nSize; } MCD_STR x_IntToStr( int n ) { MCD_CHAR sz[25]; MCD_SPRINTF(MCD_SSZ(sz),MCD_T("%d"),n); MCD_STR s=sz; return s; } int x_StrNCmp( MCD_PCSZ p1, MCD_PCSZ p2, int n, int bIgnoreCase = 0 ) { // Fast string compare to determine equality if ( bIgnoreCase ) { bool bNonAsciiFound = false; MCD_CHAR c1, c2; while ( n-- ) { c1 = *p1++; c2 = *p2++; if ( c1 != c2 ) { if ( bNonAsciiFound ) return c1 - c2; if ( c1 >= 'a' && c1 <= 'z' ) c1 = (MCD_CHAR)( c1 - ('a'-'A') ); if ( c2 >= 'a' && c2 <= 'z' ) c2 = (MCD_CHAR)( c2 - ('a'-'A') ); if ( c1 != c2 ) return c1 - c2; } else if ( (unsigned int)c1 > 127 ) bNonAsciiFound = true; } } else { while ( n-- ) { if ( *p1 != *p2 ) return *p1 - *p2; p1++; p2++; } } return 0; } enum MarkupResultCode { MRC_COUNT = 1, MRC_TYPE = 2, MRC_NUMBER = 4, MRC_ENCODING = 8, MRC_LENGTH = 16, MRC_MODIFY = 32, MRC_MSG = 64 }; void x_AddResult( MCD_STR& strResult, MCD_CSTR pszID, MCD_CSTR pszVal = NULL, int nResultCode = 0, int n = -1, int n2 = -1 ) { // Call this to append an error result to strResult, discard if accumulating too large if ( MCD_STRLENGTH(strResult) < 1000 ) { // Use a temporary CMarkup object but keep strResult in a string to minimize memory footprint CMarkup mResult( strResult ); if ( nResultCode & MRC_MODIFY ) mResult.FindElem( pszID ); else mResult.AddElem( pszID, MCD_T(""), CMarkup::MNF_WITHNOLINES ); if ( pszVal.pcsz ) { if ( nResultCode & MRC_TYPE ) mResult.SetAttrib( MCD_T("type"), pszVal ); else if ( nResultCode & MRC_ENCODING ) mResult.SetAttrib( MCD_T("encoding"), pszVal ); else if ( nResultCode & MRC_MSG ) mResult.SetAttrib( MCD_T("msg"), pszVal ); else mResult.SetAttrib( MCD_T("tagname"), pszVal ); } if ( nResultCode & MRC_NUMBER ) mResult.SetAttrib( MCD_T("n"), n ); else if ( nResultCode & MRC_COUNT ) mResult.SetAttrib( MCD_T("count"), n ); else if ( nResultCode & MRC_LENGTH ) mResult.SetAttrib( MCD_T("length"), n ); else if ( n != -1 ) mResult.SetAttrib( MCD_T("offset"), n ); if ( n2 != -1 ) mResult.SetAttrib( MCD_T("offset2"), n2 ); strResult = mResult.GetDoc(); } } ////////////////////////////////////////////////////////////////////// // Encoding conversion struct and methods // struct TextEncoding { TextEncoding( MCD_CSTR pszFromEncoding, const void* pFromBuffer, int nFromBufferLen ) { m_strFromEncoding = pszFromEncoding; m_pFrom = pFromBuffer; m_nFromLen = nFromBufferLen; m_nFailedChars = 0; m_nToCount = 0; }; int PerformConversion( void* pTo, MCD_CSTR pszToEncoding = NULL ); bool FindRaggedEnd( int& nTruncBeforeBytes ); #if defined(MARKUP_ICONV) static const char* IConvName( char* szEncoding, MCD_CSTR pszEncoding ); int IConv( void* pTo, int nToCharSize, int nFromCharSize ); #endif // ICONV #if ! defined(MARKUP_WCHAR) static bool CanConvert( MCD_CSTR pszToEncoding, MCD_CSTR pszFromEncoding ); #endif // WCHAR MCD_STR m_strToEncoding; MCD_STR m_strFromEncoding; const void* m_pFrom; int m_nFromLen; int m_nToCount; int m_nFailedChars; }; // Encoding names // This is a precompiled ASCII hash table for speed and minimum memory requirement // Each entry consists of a 2 digit name length, 5 digit code page, and the encoding name // Each table slot can have multiple entries, table size 155 was chosen for even distribution // MCD_PCSZ EncodingNameTable[155] = { MCD_T("0800949ksc_5601"),MCD_T("1920932cseucpkdfmtjapanese0920003x-cp20003"), MCD_T("1250221_iso-2022-jp0228591l10920004x-cp20004"), MCD_T("0228592l20920005x-cp20005"), MCD_T("0228593l30600850ibm8501000858ccsid00858"), MCD_T("0228594l40600437ibm4370701201ucs-2be0600860ibm860"), MCD_T("0600852ibm8520501250ms-ee0600861ibm8610228599l50751932cp51932"), MCD_T("0600862ibm8620620127ibm3670700858cp008581010021x-mac-thai0920261x-cp20261"), MCD_T("0600737ibm7370500869cp-gr1057003x-iscii-be0600863ibm863"), MCD_T("0750221ms502210628591ibm8190600855ibm8550600864ibm864"), MCD_T("0600775ibm7751057002x-iscii-de0300949uhc0228605l91028591iso-ir-1000600865ibm865"), MCD_T("1028594iso-ir-1101028592iso-ir-1010600866ibm8660500861cp-is0600857ibm857"), MCD_T("0950227x-cp50227"), MCD_T("0320866koi1628598csisolatinhebrew1057008x-iscii-ka"), MCD_T("1000950big5-hkscs1220106x-ia5-german0600869ibm869"), MCD_T("1057009x-iscii-ma0701200ucs-2le0712001utf32be0920269x-cp20269"), MCD_T("0800708asmo-7080500437cspc81765000unicode-1-1-utf-70612000utf-320920936x-cp20936"), MCD_T("1200775ebcdic-cp-be0628598hebrew0701201utf16be1765001unicode-1-1-utf-81765001unicode-2-0-utf-80551932x-euc"), MCD_T("1028595iso-ir-1441028597iso-ir-1260728605latin-90601200utf-161057011x-iscii-pa"), MCD_T("1028596iso-ir-1271028593iso-ir-1090751932ms51932"), MCD_T("0801253ms-greek0600949korean1050225iso2022-kr1128605iso_8859-150920949x-cp20949"), MCD_T("1200775ebcdic-cp-ch1028598iso-ir-1381057006x-iscii-as1450221iso-2022-jp-ms"), MCD_T("1057004x-iscii-ta1028599iso-ir-148"), MCD_T("1000949iso-ir-1490820127us-ascii"),MCD_T(""), MCD_T("1000936gb_2312-801900850cspc850multilingual0712000utf32le"), MCD_T("1057005x-iscii-te1300949csksc560119871965000x-unicode-2-0-utf-7"), MCD_T("0701200utf16le1965001x-unicode-2-0-utf-80928591iso8859-1"), MCD_T("0928592iso8859-21420002x_chinese-eten0520866koi8r1000932x-ms-cp932"), MCD_T("1320000x-chinese-cns1138598iso8859-8-i1057010x-iscii-gu0928593iso8859-3"), MCD_T("0928594iso8859-4"),MCD_T("0928595iso8859-51150221csiso2022jp"), MCD_T("0928596iso8859-60900154csptcp154"), MCD_T("0928597iso8859-70900932shift_jis1400154cyrillic-asian"), MCD_T("0928598iso8859-81057007x-iscii-or1150225csiso2022kr"), MCD_T("0721866koi8-ru0928599iso8859-9"),MCD_T("0910000macintosh"),MCD_T(""), MCD_T(""),MCD_T(""), MCD_T("1210004x-mac-arabic0800936gb2312800628598visual1520108x-ia5-norwegian"), MCD_T(""),MCD_T("0829001x-europa"),MCD_T(""),MCD_T("1510079x-mac-icelandic"), MCD_T("0800932sjis-win1128591csisolatin1"),MCD_T("1128592csisolatin2"), MCD_T("1400949ks_c_5601-19871128593csisolatin3"),MCD_T("1128594csisolatin4"), MCD_T("0400950big51128595csisolatin51400949ks_c_5601-1989"), MCD_T("0500775cp5001565000csunicode11utf7"),MCD_T("0501361johab"), MCD_T("1100932windows-9321100437codepage437"), MCD_T("1800862cspc862latinhebrew1310081x-mac-turkish"),MCD_T(""), MCD_T("0701256ms-arab0800775csibm5000500154cp154"), MCD_T("1100936windows-9360520127ascii"), MCD_T("1528597csisolatingreek1100874windows-874"),MCD_T("0500850cp850"), MCD_T("0700720dos-7200500950cp9500500932cp9320500437cp4370500860cp8601650222_iso-2022-jp$sio"), MCD_T("0500852cp8520500861cp8610700949ksc56010812001utf-32be"), MCD_T("0528597greek0500862cp8620520127cp3670500853cp853"), MCD_T("0500737cp7371150220iso-2022-jp0801201utf-16be0500863cp863"), MCD_T("0500936cp9360528591cp8194520932extended_unix_code_packed_format_for_japanese0500855cp8550500864cp864"), MCD_T("0500775cp7750500874cp8740800860csibm8600500865cp865"), MCD_T("0500866cp8660800861csibm8611150225iso-2022-kr0500857cp8571101201unicodefffe"), MCD_T("0700862dos-8620701255ms-hebr0500858cp858"), MCD_T("1210005x-mac-hebrew0500949cp9490800863csibm863"), MCD_T("0500869cp8691600437cspc8codepage4370700874tis-6200800855csibm8550800864csibm864"), MCD_T("0800950x-x-big50420866koi80800932ms_kanji0700874dos-8740800865csibm865"), MCD_T("0800866csibm8661210003x-mac-korean0800857csibm8570812000utf-32le"), MCD_T(""),MCD_T("0500932ms9320801200utf-16le1028591iso-8859-10500154pt154"), MCD_T("1028592iso-8859-20620866koi8-r0800869csibm869"), MCD_T("1500936csiso58gb2312800828597elot_9281238598iso-8859-8-i1028593iso-8859-30820127iso-ir-6"), MCD_T("1028594iso-8859-4"), MCD_T("0800852cspcp8520500936ms9361028595iso-8859-50621866koi8-u0701252ms-ansi"), MCD_T("1028596iso-8859-60220127us2400858pc-multilingual-850+euro"), MCD_T("1028597iso-8859-71028603iso8859-13"), MCD_T("1320000x-chinese_cns1028598iso-8859-8"), MCD_T("1828595csisolatincyrillic1028605iso8859-151028599iso-8859-9"), MCD_T("0465001utf8"),MCD_T("1510017x-mac-ukrainian"),MCD_T(""), MCD_T("0828595cyrillic"),MCD_T("0900936gb2312-80"),MCD_T(""), MCD_T("0720866cskoi8r1528591iso_8859-1:1987"),MCD_T("1528592iso_8859-2:1987"), MCD_T("1354936iso-4873:1986"),MCD_T("0700932sjis-ms1528593iso_8859-3:1988"), MCD_T("1528594iso_8859-4:19880600936gb23120701251ms-cyrl"), MCD_T("1528596iso_8859-6:19871528595iso_8859-5:1988"), MCD_T("1528597iso_8859-7:1987"), MCD_T("1201250windows-12501300932shifft_jis-ms"), MCD_T("0810029x-mac-ce1201251windows-12511528598iso_8859-8:19880900949ks_c_56011110000csmacintosh"), MCD_T("0601200cp12001201252windows-1252"), MCD_T("1052936hz-gb-23121201253windows-12531400949ks_c_5601_19871528599iso_8859-9:19890601201cp1201"), MCD_T("1201254windows-1254"),MCD_T("1000936csgb2312801201255windows-1255"), MCD_T("1201256windows-12561100932windows-31j"), MCD_T("1201257windows-12570601250cp12500601133cp1133"), MCD_T("0601251cp12511201258windows-12580601125cp1125"), MCD_T("0701254ms-turk0601252cp1252"),MCD_T("0601253cp12530601361cp1361"), MCD_T("0800949ks-c56010601254cp1254"),MCD_T("0651936euc-cn0601255cp1255"), MCD_T("0601256cp1256"),MCD_T("0601257cp12570600950csbig50800858ibm00858"), MCD_T("0601258cp1258"),MCD_T("0520105x-ia5"), MCD_T("0801250x-cp12501110006x-mac-greek0738598logical"), MCD_T("0801251x-cp1251"),MCD_T(""), MCD_T("1410001x-mac-japanese1200932cswindows31j"), MCD_T("0700936chinese0720127csascii0620932euc-jp"), MCD_T("0851936x-euc-cn0501200ucs-2"),MCD_T("0628597greek8"), MCD_T("0651949euc-kr"),MCD_T(""),MCD_T("0628591latin1"), MCD_T("0628592latin21100874iso-8859-11"), MCD_T("0628593latin31420127ansi_x3.4-19681420127ansi_x3.4-19861028591iso_8859-1"), MCD_T("0628594latin41028592iso_8859-20701200unicode1128603iso-8859-13"), MCD_T("1028593iso_8859-30628599latin51410082x-mac-croatian"), MCD_T("1028594iso_8859-41128605iso-8859-150565000utf-70851932x-euc-jp"), MCD_T("1300775cspc775baltic1028595iso_8859-50565001utf-80512000utf32"), MCD_T("1028596iso_8859-61710002x-mac-chinesetrad0601252x-ansi"), MCD_T("1028597iso_8859-70628605latin90501200utf160700154ptcp1541410010x-mac-romanian"), MCD_T("0900936iso-ir-581028598iso_8859-8"),MCD_T("1028599iso_8859-9"), MCD_T("1350221iso2022-jp-ms0400932sjis"),MCD_T("0751949cseuckr"), MCD_T("1420002x-chinese-eten"),MCD_T("1410007x-mac-cyrillic"), MCD_T("1000932shifft_jis"),MCD_T("0828596ecma-114"),MCD_T(""), MCD_T("0900932shift-jis"),MCD_T("0701256cp1256 1320107x-ia5-swedish"), MCD_T("0828597ecma-118"), MCD_T("1628596csisolatinarabic1710008x-mac-chinesesimp0600932x-sjis"),MCD_T(""), MCD_T("0754936gb18030"),MCD_T("1350221windows-502210712000cp12000"), MCD_T("0628596arabic0500936cn-gb0900932sjis-open0712001cp12001"),MCD_T(""), MCD_T(""),MCD_T("0700950cn-big50920127iso646-us1001133ibm-cp1133"),MCD_T(""), MCD_T("0800936csgb23120900949ks-c-56010310000mac"), MCD_T("1001257winbaltrim0750221cp502211020127iso-ir-6us"), MCD_T("1000932csshiftjis"),MCD_T("0300936gbk0765001cp65001"), MCD_T("1620127iso_646.irv:19911351932windows-519320920001x-cp20001") }; int x_GetEncodingCodePage( MCD_CSTR pszEncoding ) { // redo for completeness, the iconv set, UTF-32, and uppercase // Lookup strEncoding in EncodingNameTable and return Windows code page int nCodePage = -1; int nEncLen = MCD_PSZLEN( pszEncoding ); if ( ! nEncLen ) nCodePage = MCD_ACP; else if ( x_StrNCmp(pszEncoding,MCD_T("UTF-32"),6) == 0 ) nCodePage = MCD_UTF32; else if ( nEncLen < 100 ) { MCD_CHAR szEncodingLower[100]; for ( int nEncChar=0; nEncChar='A' && cEncChar<='Z')? (MCD_CHAR)(cEncChar+('a'-'A')) : cEncChar; } szEncodingLower[nEncLen] = '\0'; MCD_PCSZ pEntry = EncodingNameTable[x_Hash(szEncodingLower,sizeof(EncodingNameTable)/sizeof(MCD_PCSZ))]; while ( *pEntry ) { // e.g. entry: 0565001utf-8 means length 05, code page 65001, encoding name utf-8 int nEntryLen = (*pEntry - '0') * 10; ++pEntry; nEntryLen += (*pEntry - '0'); ++pEntry; MCD_PCSZ pCodePage = pEntry; pEntry += 5; if ( nEntryLen == nEncLen && x_StrNCmp(szEncodingLower,pEntry,nEntryLen) == 0 ) { // Convert digits to integer up to code name which always starts with alpha nCodePage = MCD_PSZTOL( pCodePage, NULL, 10 ); break; } pEntry += nEntryLen; } } return nCodePage; } #if ! defined(MARKUP_WCHAR) bool TextEncoding::CanConvert( MCD_CSTR pszToEncoding, MCD_CSTR pszFromEncoding ) { // Return true if MB to MB conversion is possible #if defined(MARKUP_ICONV) // iconv_open should fail if either encoding not supported or one is alias for other char szTo[100], szFrom[100]; iconv_t cd = iconv_open( IConvName(szTo,pszToEncoding), IConvName(szFrom,pszFromEncoding) ); if ( cd == (iconv_t)-1 ) return false; iconv_close(cd); #else int nToCP = x_GetEncodingCodePage( pszToEncoding ); int nFromCP = x_GetEncodingCodePage( pszFromEncoding ); if ( nToCP == -1 || nFromCP == -1 ) return false; #if defined(MARKUP_WINCONV) if ( nToCP == MCD_ACP || nFromCP == MCD_ACP ) // either ACP ANSI? { int nACP = GetACP(); if ( nToCP == MCD_ACP ) nToCP = nACP; if ( nFromCP == MCD_ACP ) nFromCP = nACP; } #else // no conversion API, but we can do AToUTF8 and UTF8ToA if ( nToCP != MCD_UTF8 && nFromCP != MCD_UTF8 ) // either UTF-8? return false; #endif // no conversion API if ( nToCP == nFromCP ) return false; #endif // not ICONV return true; } #endif // not WCHAR #if defined(MARKUP_ICONV) const char* TextEncoding::IConvName( char* szEncoding, MCD_CSTR pszEncoding ) { // Make upper case char-based name from strEncoding which consists only of characters in the ASCII range int nEncChar = 0; while ( pszEncoding[nEncChar] ) { char cEncChar = (char)pszEncoding[nEncChar]; szEncoding[nEncChar] = (cEncChar>='a' && cEncChar<='z')? (cEncChar-('a'-'A')) : cEncChar; ++nEncChar; } if ( nEncChar == 6 && x_StrNCmp(szEncoding,"UTF-16",6) == 0 ) { szEncoding[nEncChar++] = 'B'; szEncoding[nEncChar++] = 'E'; } szEncoding[nEncChar] = '\0'; return szEncoding; } int TextEncoding::IConv( void* pTo, int nToCharSize, int nFromCharSize ) { // Converts from m_pFrom to pTo char szTo[100], szFrom[100]; iconv_t cd = iconv_open( IConvName(szTo,m_strToEncoding), IConvName(szFrom,m_strFromEncoding) ); int nToLenBytes = 0; if ( cd != (iconv_t)-1 ) { size_t nFromLenRemaining = (size_t)m_nFromLen * nFromCharSize; size_t nToCountRemaining = (size_t)m_nToCount * nToCharSize; size_t nToCountRemainingBefore; char* pToChar = (char*)pTo; char* pFromChar = (char*)m_pFrom; char* pToTempBuffer = NULL; const size_t nTempBufferSize = 2048; size_t nResult; if ( ! pTo ) { pToTempBuffer = new char[nTempBufferSize]; pToChar = pToTempBuffer; nToCountRemaining = nTempBufferSize; } while ( nFromLenRemaining ) { nToCountRemainingBefore = nToCountRemaining; nResult = iconv( cd, &pFromChar, &nFromLenRemaining, &pToChar, &nToCountRemaining ); nToLenBytes += (int)(nToCountRemainingBefore - nToCountRemaining); if ( nResult == (size_t)-1 ) { int nErrno = errno; if ( nErrno == EILSEQ ) { // Bypass bad char, question mark denotes problem in source string pFromChar += nFromCharSize; nFromLenRemaining -= nFromCharSize; if ( nToCharSize == 1 ) *pToChar = '?'; else if ( nToCharSize == 2 ) *((unsigned short*)pToChar) = (unsigned short)'?'; else if ( nToCharSize == 4 ) *((unsigned int*)pToChar) = (unsigned int)'?'; pToChar += nToCharSize; nToCountRemaining -= nToCharSize; nToLenBytes += nToCharSize; size_t nInitFromLen = 0, nInitToCount = 0; iconv(cd, NULL, &nInitFromLen ,NULL, &nInitToCount ); } else if ( nErrno == EINVAL ) break; // incomplete character or shift sequence at end of input else if ( nErrno == E2BIG && !pToTempBuffer ) break; // output buffer full should only happen when using a temp buffer } else m_nFailedChars += nResult; if ( pToTempBuffer && nToCountRemaining < 10 ) { nToCountRemaining = nTempBufferSize; pToChar = pToTempBuffer; } } if ( pToTempBuffer ) delete[] pToTempBuffer; iconv_close(cd); } return nToLenBytes / nToCharSize; } #endif #if defined(MARKUP_WINCONV) bool x_NoDefaultChar( int nCP ) { // WideCharToMultiByte fails if lpUsedDefaultChar is non-NULL for these code pages: return (bool)(nCP == 65000 || nCP == 65001 || nCP == 50220 || nCP == 50221 || nCP == 50222 || nCP == 50225 || nCP == 50227 || nCP == 50229 || nCP == 52936 || nCP == 54936 || (nCP >= 57002 && nCP <= 57011) ); } #endif int TextEncoding::PerformConversion( void* pTo, MCD_CSTR pszToEncoding/*=NULL*/ ) { // If pTo is not NULL, it must be large enough to hold result, length of result is returned // m_nFailedChars will be set to >0 if characters not supported in strToEncoding int nToLen = 0; if ( pszToEncoding.pcsz ) m_strToEncoding = pszToEncoding; int nToCP = x_GetEncodingCodePage( m_strToEncoding ); if ( nToCP == -1 ) nToCP = MCD_ACP; int nFromCP = x_GetEncodingCodePage( m_strFromEncoding ); if ( nFromCP == -1 ) nFromCP = MCD_ACP; m_nFailedChars = 0; #if ! defined(MARKUP_WINCONV) && ! defined(MARKUP_ICONV) // Only non-Unicode encoding supported is locale charset, must call setlocale if ( nToCP != MCD_UTF8 && nToCP != MCD_UTF16 && nToCP != MCD_UTF32 ) nToCP = MCD_ACP; if ( nFromCP != MCD_UTF8 && nFromCP != MCD_UTF16 && nFromCP != MCD_UTF32 ) nFromCP = MCD_ACP; if ( nFromCP == MCD_ACP ) { const char* pA = (const char*)m_pFrom; int nALenRemaining = m_nFromLen; int nCharLen; wchar_t wcChar; char* pU = (char*)pTo; while ( nALenRemaining ) { nCharLen = mbtowc( &wcChar, pA, nALenRemaining ); if ( nCharLen < 1 ) { wcChar = (wchar_t)'?'; nCharLen = 1; } pA += nCharLen; nALenRemaining -= nCharLen; if ( nToCP == MCD_UTF8 ) CMarkup::EncodeCharUTF8( (int)wcChar, pU, nToLen ); else if ( nToCP == MCD_UTF16 ) CMarkup::EncodeCharUTF16( (int)wcChar, (unsigned short*)pU, nToLen ); else // UTF32 { if ( pU ) ((unsigned int*)pU)[nToLen] = (unsigned int)wcChar; ++nToLen; } } } else if ( nToCP == MCD_ACP ) { union pUnicodeUnion { const char* p8; const unsigned short* p16; const unsigned int* p32; } pU; pU.p8 = (const char*)m_pFrom; const char* pUEnd = pU.p8 + m_nFromLen; if ( nFromCP == MCD_UTF16 ) pUEnd = (char*)( pU.p16 + m_nFromLen ); else if ( nFromCP == MCD_UTF32 ) pUEnd = (char*)( pU.p32 + m_nFromLen ); int nCharLen; char* pA = (char*)pTo; char szA[8]; int nUChar; while ( pU.p8 != pUEnd ) { if ( nFromCP == MCD_UTF8 ) nUChar = CMarkup::DecodeCharUTF8( pU.p8, pUEnd ); else if ( nFromCP == MCD_UTF16 ) nUChar = CMarkup::DecodeCharUTF16( pU.p16, (const unsigned short*)pUEnd ); else // UTF32 nUChar = *(pU.p32)++; if ( nUChar == -1 ) nCharLen = -2; else if ( nUChar & ~0xffff ) nCharLen = -1; else nCharLen = wctomb( pA?pA:szA, (wchar_t)nUChar ); if ( nCharLen < 0 ) { if ( nCharLen == -1 ) ++m_nFailedChars; nCharLen = 1; if ( pA ) *pA = '?'; } if ( pA ) pA += nCharLen; nToLen += nCharLen; } } #endif // not WINCONV and not ICONV if ( nFromCP == MCD_UTF32 ) { const unsigned int* p32 = (const unsigned int*)m_pFrom; const unsigned int* p32End = p32 + m_nFromLen; if ( nToCP == MCD_UTF8 ) { char* p8 = (char*)pTo; while ( p32 != p32End ) CMarkup::EncodeCharUTF8( *p32++, p8, nToLen ); } else if ( nToCP == MCD_UTF16 ) { unsigned short* p16 = (unsigned short*)pTo; while ( p32 != p32End ) CMarkup::EncodeCharUTF16( (int)*p32++, p16, nToLen ); } else // to ANSI { // WINCONV not supported for 32To8, since only used for sizeof(wchar_t) == 4 #if defined(MARKUP_ICONV) nToLen = IConv( pTo, 1, 4 ); #endif // ICONV } } else if ( nFromCP == MCD_UTF16 ) { // UTF16To8 will be deprecated since weird output buffer size sensitivity not worth implementing here const unsigned short* p16 = (const unsigned short*)m_pFrom; const unsigned short* p16End = p16 + m_nFromLen; int nUChar; if ( nToCP == MCD_UTF32 ) { unsigned int* p32 = (unsigned int*)pTo; while ( p16 != p16End ) { nUChar = CMarkup::DecodeCharUTF16( p16, p16End ); if ( nUChar == -1 ) nUChar = '?'; if ( p32 ) p32[nToLen] = (unsigned int)nUChar; ++nToLen; } } #if defined(MARKUP_WINCONV) else // to UTF-8 or other multi-byte { nToLen = WideCharToMultiByte(nToCP,0,(const wchar_t*)m_pFrom,m_nFromLen,(char*)pTo, m_nToCount?m_nToCount+1:0,NULL,x_NoDefaultChar(nToCP)?NULL:&m_nFailedChars); } #else // not WINCONV else if ( nToCP == MCD_UTF8 ) { char* p8 = (char*)pTo; while ( p16 != p16End ) { nUChar = CMarkup::DecodeCharUTF16( p16, p16End ); if ( nUChar == -1 ) nUChar = '?'; CMarkup::EncodeCharUTF8( nUChar, p8, nToLen ); } } else // to ANSI { #if defined(MARKUP_ICONV) nToLen = IConv( pTo, 1, 2 ); #endif // ICONV } #endif // not WINCONV } else if ( nToCP == MCD_UTF16 ) // to UTF-16 from UTF-8/ANSI { #if defined(MARKUP_WINCONV) nToLen = MultiByteToWideChar(nFromCP,0,(const char*)m_pFrom,m_nFromLen,(wchar_t*)pTo,m_nToCount); #else // not WINCONV if ( nFromCP == MCD_UTF8 ) { const char* p8 = (const char*)m_pFrom; const char* p8End = p8 + m_nFromLen; int nUChar; unsigned short* p16 = (unsigned short*)pTo; while ( p8 != p8End ) { nUChar = CMarkup::DecodeCharUTF8( p8, p8End ); if ( nUChar == -1 ) nUChar = '?'; if ( p16 ) p16[nToLen] = (unsigned short)nUChar; ++nToLen; } } else // from ANSI { #if defined(MARKUP_ICONV) nToLen = IConv( pTo, 2, 1 ); #endif // ICONV } #endif // not WINCONV } else if ( nToCP == MCD_UTF32 ) // to UTF-32 from UTF-8/ANSI { if ( nFromCP == MCD_UTF8 ) { const char* p8 = (const char*)m_pFrom; const char* p8End = p8 + m_nFromLen; int nUChar; unsigned int* p32 = (unsigned int*)pTo; while ( p8 != p8End ) { nUChar = CMarkup::DecodeCharUTF8( p8, p8End ); if ( nUChar == -1 ) nUChar = '?'; if ( p32 ) p32[nToLen] = (unsigned int)nUChar; ++nToLen; } } else // from ANSI { // WINCONV not supported for ATo32, since only used for sizeof(wchar_t) == 4 #if defined(MARKUP_ICONV) // nToLen = IConv( pTo, 4, 1 ); // Linux: had trouble getting IConv to leave the BOM off of the UTF-32 output stream // So converting via UTF-16 with native endianness unsigned short* pwszUTF16 = new unsigned short[m_nFromLen]; MCD_STR strToEncoding = m_strToEncoding; m_strToEncoding = MCD_T("UTF-16BE"); short nEndianTest = 1; if ( ((char*)&nEndianTest)[0] ) // Little-endian? m_strToEncoding = MCD_T("UTF-16LE"); m_nToCount = m_nFromLen; int nUTF16Len = IConv( pwszUTF16, 2, 1 ); m_strToEncoding = strToEncoding; const unsigned short* p16 = (const unsigned short*)pwszUTF16; const unsigned short* p16End = p16 + nUTF16Len; int nUChar; unsigned int* p32 = (unsigned int*)pTo; while ( p16 != p16End ) { nUChar = CMarkup::DecodeCharUTF16( p16, p16End ); if ( nUChar == -1 ) nUChar = '?'; if ( p32 ) *p32++ = (unsigned int)nUChar; ++nToLen; } delete[] pwszUTF16; #endif // ICONV } } else { #if defined(MARKUP_ICONV) nToLen = IConv( pTo, 1, 1 ); #elif defined(MARKUP_WINCONV) wchar_t* pwszUTF16 = new wchar_t[m_nFromLen]; int nUTF16Len = MultiByteToWideChar(nFromCP,0,(const char*)m_pFrom,m_nFromLen,pwszUTF16,m_nFromLen); nToLen = WideCharToMultiByte(nToCP,0,pwszUTF16,nUTF16Len,(char*)pTo,m_nToCount,NULL, x_NoDefaultChar(nToCP)?NULL:&m_nFailedChars); delete[] pwszUTF16; #endif // WINCONV } // Store the length in case this is called again after allocating output buffer to fit m_nToCount = nToLen; return nToLen; } bool TextEncoding::FindRaggedEnd( int& nTruncBeforeBytes ) { // Check for ragged end UTF-16 or multi-byte according to m_strToEncoding, expects at least 40 bytes to work with bool bSuccess = true; nTruncBeforeBytes = 0; int nCP = x_GetEncodingCodePage( m_strFromEncoding ); if ( nCP == MCD_UTF16 ) { unsigned short* pUTF16Buffer = (unsigned short*)m_pFrom; const unsigned short* pUTF16Last = &pUTF16Buffer[m_nFromLen-1]; if ( CMarkup::DecodeCharUTF16(pUTF16Last,&pUTF16Buffer[m_nFromLen]) == -1 ) nTruncBeforeBytes = 2; } else // UTF-8, SBCS DBCS { if ( nCP == MCD_UTF8 ) { char* pUTF8Buffer = (char*)m_pFrom; char* pUTF8End = &pUTF8Buffer[m_nFromLen]; int nLast = m_nFromLen - 1; const char* pUTF8Last = &pUTF8Buffer[nLast]; while ( nLast > 0 && CMarkup::DecodeCharUTF8(pUTF8Last,pUTF8End) == -1 ) pUTF8Last = &pUTF8Buffer[--nLast]; nTruncBeforeBytes = (int)(pUTF8End - pUTF8Last); } else { // Do a conversion-based test unless we can determine it is not multi-byte // If m_strEncoding="" default code page then GetACP can tell us the code page, otherwise just do the test #if defined(MARKUP_WINCONV) if ( nCP == 0 ) nCP = GetACP(); #endif int nMultibyteCharsToTest = 2; switch ( nCP ) { case 54936: nMultibyteCharsToTest = 4; case 932: case 51932: case 20932: case 50220: case 50221: case 50222: case 10001: // Japanese case 949: case 51949: case 50225: case 1361: case 10003: case 20949: // Korean case 874: case 20001: case 20004: case 10021: case 20003: // Taiwan case 50930: case 50939: case 50931: case 50933: case 20833: case 50935: case 50937: // EBCDIC case 936: case 51936: case 20936: case 52936: // Chinese case 950: case 50227: case 10008: case 20000: case 20002: case 10002: // Chinese nCP = 0; break; } if ( nMultibyteCharsToTest > m_nFromLen ) nMultibyteCharsToTest = m_nFromLen; if ( nCP == 0 && nMultibyteCharsToTest ) { /* 1. convert the piece to Unicode with MultiByteToWideChar 2. Identify at least two Unicode code point boundaries at the end of the converted piece by stepping backwards from the end and re- converting the final 2 bytes, 3 bytes, 4 bytes etc, comparing the converted end string to the end of the entire converted piece to find a valid code point boundary. 3. Upon finding a code point boundary, I still want to make sure it will convert the same separately on either side of the divide as it does together, so separately convert the first byte and the remaining bytes and see if the result together is the same as the whole end, if not try the first two bytes and the remaining bytes. etc., until I find a useable dividing point. If none found, go back to step 2 and get a longer end string to try. */ m_strToEncoding = MCD_T("UTF-16"); m_nToCount = m_nFromLen*2; unsigned short* pUTF16Buffer = new unsigned short[m_nToCount]; int nUTF16Len = PerformConversion( (void*)pUTF16Buffer ); int nOriginalByteLen = m_nFromLen; // Guaranteed to have at least MARKUP_FILEBLOCKSIZE/2 bytes to work with const int nMaxBytesToTry = 40; unsigned short wsz16End[nMaxBytesToTry*2]; unsigned short wsz16EndDivided[nMaxBytesToTry*2]; const char* pszOriginalBytes = (const char*)m_pFrom; int nBoundariesFound = 0; bSuccess = false; while ( nTruncBeforeBytes < nMaxBytesToTry && ! bSuccess ) { ++nTruncBeforeBytes; m_pFrom = &pszOriginalBytes[nOriginalByteLen-nTruncBeforeBytes]; m_nFromLen = nTruncBeforeBytes; m_nToCount = nMaxBytesToTry*2; int nEndUTF16Len = PerformConversion( (void*)wsz16End ); if ( nEndUTF16Len && memcmp(wsz16End,&pUTF16Buffer[nUTF16Len-nEndUTF16Len],nEndUTF16Len*2) == 0 ) { ++nBoundariesFound; if ( nBoundariesFound > 2 ) { int nDivideAt = 1; while ( nDivideAt < nTruncBeforeBytes ) { m_pFrom = &pszOriginalBytes[nOriginalByteLen-nTruncBeforeBytes]; m_nFromLen = nDivideAt; m_nToCount = nMaxBytesToTry*2; int nDividedUTF16Len = PerformConversion( (void*)wsz16EndDivided ); if ( nDividedUTF16Len ) { m_pFrom = &pszOriginalBytes[nOriginalByteLen-nTruncBeforeBytes+nDivideAt]; m_nFromLen = nTruncBeforeBytes-nDivideAt; m_nToCount = nMaxBytesToTry*2-nDividedUTF16Len; nDividedUTF16Len += PerformConversion( (void*)&wsz16EndDivided[nDividedUTF16Len] ); if ( m_nToCount && nEndUTF16Len == nDividedUTF16Len && memcmp(wsz16End,wsz16EndDivided,nEndUTF16Len) == 0 ) { nTruncBeforeBytes -= nDivideAt; bSuccess = true; break; } } ++nDivideAt; } } } } delete [] pUTF16Buffer; } } } return bSuccess; } bool x_EndianSwapRequired( int nDocFlags ) { short nWord = 1; char cFirstByte = ((char*)&nWord)[0]; if ( cFirstByte ) // LE { if ( nDocFlags & CMarkup::MDF_UTF16BEFILE ) return true; } else if ( nDocFlags & CMarkup::MDF_UTF16LEFILE ) return true; return false; } void x_EndianSwapUTF16( unsigned short* pBuffer, int nCharLen ) { unsigned short cChar; while ( nCharLen-- ) { cChar = pBuffer[nCharLen]; pBuffer[nCharLen] = (unsigned short)((cChar<<8) | (cChar>>8)); } } ////////////////////////////////////////////////////////////////////// // Element position indexes // This is the primary means of storing the layout of the document // struct ElemPos { ElemPos() {}; ElemPos( const ElemPos& pos ) { *this = pos; }; int StartTagLen() const { return nStartTagLen; }; void SetStartTagLen( int n ) { nStartTagLen = n; }; void AdjustStartTagLen( int n ) { nStartTagLen += n; }; int EndTagLen() const { return nEndTagLen; }; void SetEndTagLen( int n ) { nEndTagLen = n; }; bool IsEmptyElement() { return (StartTagLen()==nLength)?true:false; }; int StartContent() const { return nStart + StartTagLen(); }; int ContentLen() const { return nLength - StartTagLen() - EndTagLen(); }; int StartAfter() const { return nStart + nLength; }; int Level() const { return nFlags & 0xffff; }; void SetLevel( int nLev ) { nFlags = (nFlags & ~0xffff) | nLev; }; void ClearVirtualParent() { memset(this,0,sizeof(ElemPos)); }; void SetEndTagLenUnparsed() { SetEndTagLen(1); }; bool IsUnparsed() { return EndTagLen() == 1; }; // Memory size: 8 32-bit integers == 32 bytes int nStart; int nLength; unsigned int nStartTagLen : 22; // 4MB limit for start tag unsigned int nEndTagLen : 10; // 1K limit for end tag int nFlags; // 16 bits flags, 16 bits level 65536 depth limit int iElemParent; int iElemChild; // first child int iElemNext; // next sibling int iElemPrev; // if this is first, iElemPrev points to last }; enum MarkupNodeFlagsInternal2 { MNF_REPLACE = 0x001000, MNF_QUOTED = 0x008000, MNF_EMPTY = 0x010000, MNF_DELETED = 0x020000, MNF_FIRST = 0x080000, MNF_PUBLIC = 0x300000, MNF_ILLFORMED = 0x800000, MNF_USER = 0xf000000 }; struct ElemPosTree { ElemPosTree() { Clear(); }; ~ElemPosTree() { Release(); }; enum { PA_SEGBITS = 16, PA_SEGMASK = 0xffff }; void ReleaseElemPosTree() { Release(); Clear(); }; void Release() ; // { // for (int n=0;n>PA_SEGBITS) + 1; }; ElemPos& GetRefElemPosAt(int i) const { return m_pSegs[i>>PA_SEGBITS][i&PA_SEGMASK]; }; void CopyElemPosTree( ElemPosTree* pOtherTree, int n ); void GrowElemPosTree( int nNewSize ); private: ElemPos** m_pSegs; int m_nSize; int m_nSegs; }; void ElemPosTree::Release() { for (int n=0;nm_pSegs[nSeg], nSegSize*sizeof(ElemPos) ); } } } void ElemPosTree::GrowElemPosTree( int nNewSize ) { // Called by x_AllocElemPos when the document is created or the array is filled // The ElemPosTree class is implemented using segments to reduce contiguous memory requirements // It reduces reallocations (copying of memory) since this only occurs within one segment // The "Grow By" algorithm ensures there are no reallocations after 2 segments // // Grow By: new size can be at most one more complete segment int nSeg = (m_nSize?m_nSize-1:0) >> PA_SEGBITS; int nNewSeg = (nNewSize-1) >> PA_SEGBITS; if ( nNewSeg > nSeg + 1 ) { nNewSeg = nSeg + 1; nNewSize = (nNewSeg+1) << PA_SEGBITS; } // Allocate array of segments if ( m_nSegs <= nNewSeg ) { int nNewSegments = 4 + nNewSeg * 2; char* pNewSegments = new char[nNewSegments*sizeof(char*)]; if ( SegsUsed() ) memcpy( pNewSegments, m_pSegs, SegsUsed()*sizeof(char*) ); if ( m_pSegs ) delete[] (char*)m_pSegs; m_pSegs = (ElemPos**)pNewSegments; m_nSegs = nNewSegments; } // Calculate segment sizes int nSegSize = m_nSize - (nSeg << PA_SEGBITS); int nNewSegSize = nNewSize - (nNewSeg << PA_SEGBITS); // Complete first segment int nFullSegSize = 1 << PA_SEGBITS; if ( nSeg < nNewSeg && nSegSize < nFullSegSize ) { char* pNewFirstSeg = new char[ nFullSegSize * sizeof(ElemPos) ]; if ( nSegSize ) { // Reallocate memcpy( pNewFirstSeg, m_pSegs[nSeg], nSegSize * sizeof(ElemPos) ); delete[] (char*)m_pSegs[nSeg]; } m_pSegs[nSeg] = (ElemPos*)pNewFirstSeg; } // New segment char* pNewSeg = new char[ nNewSegSize * sizeof(ElemPos) ]; if ( nNewSeg == nSeg && nSegSize ) { // Reallocate memcpy( pNewSeg, m_pSegs[nSeg], nSegSize * sizeof(ElemPos) ); delete[] (char*)m_pSegs[nSeg]; } m_pSegs[nNewSeg] = (ElemPos*)pNewSeg; m_nSize = nNewSize; } #define ELEM(i) m_pElemPosTree->GetRefElemPosAt(i) ////////////////////////////////////////////////////////////////////// // NodePos stores information about an element or node during document creation and parsing // struct NodePos { NodePos() {}; NodePos( int n ) { nNodeFlags=n; nNodeType=0; nStart=0; nLength=0; }; int nNodeType; int nStart; int nLength; int nNodeFlags; MCD_STR strMeta; }; ////////////////////////////////////////////////////////////////////// // "Is Char" defines // Quickly determine if a character matches a limited set // #define x_ISONEOF(c,f,l,s) ((c>=f&&c<=l)?(int)(s[c-f]):0) // classic whitespace " \t\n\r" #define x_ISWHITESPACE(c) x_ISONEOF(c,9,32,"\2\3\0\0\4\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\1") // end of word in a path " =/[]" #define x_ISENDPATHWORD(c) x_ISONEOF(c,32,93,"\1\0\0\0\0\0\0\0\0\0\0\0\0\0\0\3\0\0\0\0\0\0\0\0\0\0\0\0\0\2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\4\0\5") // end of a name " \t\n\r/>" #define x_ISENDNAME(c) x_ISONEOF(c,9,62,"\2\3\0\0\4\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\1\0\0\0\0\0\0\0\0\0\0\0\0\0\0\5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\1") // a small set of chars cannot be second last in attribute value " \t\n\r\"\'" #define x_ISNOTSECONDLASTINVAL(c) x_ISONEOF(c,9,39,"\2\3\0\0\4\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\1\0\5\0\0\0\0\1") // first char of doc type tag name "EAN" #define x_ISDOCTYPESTART(c) x_ISONEOF(c,65,78,"\2\0\0\0\1\0\0\0\0\0\0\0\0\3") // attrib special char "<&>\"\'" #define x_ISATTRIBSPECIAL(c) x_ISONEOF(c,34,62,"\4\0\0\0\2\5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\1\0\3") // parsed text special char "<&>" #define x_ISSPECIAL(c) x_ISONEOF(c,38,62,"\2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\1\0\3") // end of any name " \t\n\r<>=\\/?!\"';" #define x_ISENDANYNAME(c) x_ISONEOF(c,9,92,"\2\3\0\0\4\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\1\1\1\0\0\0\0\1\0\0\0\0\0\0\0\1\0\0\0\0\0\0\0\0\0\0\0\1\5\1\1\1\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\1") // end of unquoted attrib value " \t\n\r>" #define x_ISENDUNQUOTED(c) x_ISONEOF(c,9,62,"\2\3\0\0\4\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\1\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\5") // end of attrib name "= \t\n\r>/?" #define x_ISENDATTRIBNAME(c) x_ISONEOF(c,9,63,"\3\4\0\0\5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\1\0\0\0\0\0\0\0\0\0\0\0\0\0\1\1\1") // start of entity reference "A-Za-Z#_:" #define x_ISSTARTENTREF(c) x_ISONEOF(c,35,122,"\1\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\1\0\0\0\0\0\0\1\2\3\4\5\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\0\0\0\0\1\0\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1") // within entity reference "A-Za-Z0-9_:-." #define x_ISINENTREF(c) x_ISONEOF(c,45,122,"\1\1\0\1\1\1\1\1\1\1\1\1\1\1\0\0\0\0\0\0\1\2\3\4\5\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\0\0\0\0\1\0\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1") ////////////////////////////////////////////////////////////////////// // Token struct and tokenizing functions // TokenPos handles parsing operations on a constant text pointer // struct TokenPos { TokenPos( MCD_CSTR sz, int n, FilePos* p=NULL ) { Clear(); m_pDocText=sz; m_nTokenFlags=n; m_pReaderFilePos=p; }; void Clear() { m_nL=0; m_nR=-1; m_nNext=0; }; int Length() const { return m_nR - m_nL + 1; }; MCD_PCSZ GetTokenPtr() const { return &m_pDocText[m_nL]; }; MCD_STR GetTokenText() const { return MCD_STR( GetTokenPtr(), Length() ); }; MCD_CHAR NextChar() { m_nNext += MCD_CLEN(&m_pDocText[m_nNext]); return m_pDocText[m_nNext]; }; int WhitespaceToTag( int n ) { m_nNext = n; if (FindAny()&&m_pDocText[m_nNext]!='<') { m_nNext=n; m_nR=n-1; } return m_nNext; }; bool FindAny() { // Go to non-whitespace or end MCD_CHAR cNext = m_pDocText[m_nNext]; while ( cNext && x_ISWHITESPACE(cNext) ) cNext = m_pDocText[++m_nNext]; m_nL = m_nNext; m_nR = m_nNext-1; return m_pDocText[m_nNext]!='\0'; }; bool FindName() { if ( ! FindAny() ) // go to first non-whitespace return false; MCD_CHAR cNext = m_pDocText[m_nNext]; while ( cNext && ! x_ISENDANYNAME(cNext) ) cNext = NextChar(); if ( m_nNext == m_nL ) ++m_nNext; // it is a special char m_nR = m_nNext - 1; return true; } bool Match( MCD_CSTR szName ) { int nLen = Length(); return ( (x_StrNCmp( GetTokenPtr(), szName, nLen, m_nTokenFlags & CMarkup::MDF_IGNORECASE ) == 0) && ( szName[nLen] == '\0' || x_ISENDPATHWORD(szName[nLen]) ) ); }; bool FindAttrib( MCD_PCSZ pAttrib, int n = 0, MCD_STR* pstrAttrib = NULL ); int ParseNode( NodePos& node ); int m_nL; int m_nR; int m_nNext; MCD_PCSZ m_pDocText; int m_nTokenFlags; int m_nPreSpaceStart; int m_nPreSpaceLength; FilePos* m_pReaderFilePos; }; bool TokenPos::FindAttrib( MCD_PCSZ pAttrib, int n/*=0*/, MCD_STR* pstrAttrib/*=NULL*/ ) { // Return true if found, otherwise false and token.m_nNext is new insertion point // If pAttrib is NULL find attrib n and leave token at attrib name // If pAttrib is given, find matching attrib and leave token at value // support non-well-formed attributes e.g. href=/advanced_search?hl=en, nowrap // token also holds start and length of preceeding whitespace to support remove // int nTempPreSpaceStart; int nTempPreSpaceLength; MCD_CHAR cFirstChar, cNext; int nAttrib = -1; // starts at tag name int nFoundAttribNameR = 0; bool bAfterEqual = false; while ( 1 ) { // Starting at m_nNext, bypass whitespace and find the next token nTempPreSpaceStart = m_nNext; if ( ! FindAny() ) break; nTempPreSpaceLength = m_nNext - nTempPreSpaceStart; // Is it an opening quote? cFirstChar = m_pDocText[m_nNext]; if ( cFirstChar == '\"' || cFirstChar == '\'' ) { m_nTokenFlags |= MNF_QUOTED; // Move past opening quote ++m_nNext; m_nL = m_nNext; // Look for closing quote cNext = m_pDocText[m_nNext]; while ( cNext && cNext != cFirstChar ) cNext = NextChar(); // Set right to before closing quote m_nR = m_nNext - 1; // Set m_nNext past closing quote unless at end of document if ( cNext ) ++m_nNext; } else { m_nTokenFlags &= ~MNF_QUOTED; // Go until special char or whitespace m_nL = m_nNext; cNext = m_pDocText[m_nNext]; if ( bAfterEqual ) { while ( cNext && ! x_ISENDUNQUOTED(cNext) ) cNext = NextChar(); } else { while ( cNext && ! x_ISENDATTRIBNAME(cNext) ) cNext = NextChar(); } // Adjust end position if it is one special char if ( m_nNext == m_nL ) ++m_nNext; // it is a special char m_nR = m_nNext - 1; } if ( ! bAfterEqual && ! (m_nTokenFlags&MNF_QUOTED) ) { // Is it an equal sign? MCD_CHAR cChar = m_pDocText[m_nL]; if ( cChar == '=' ) { bAfterEqual = true; continue; } // Is it the end of the tag? if ( cChar == '>' || cChar == '/' || cChar == '?' ) { m_nNext = nTempPreSpaceStart; break; // attrib not found } if ( nFoundAttribNameR ) break; // Attribute name if ( nAttrib != -1 ) { if ( ! pAttrib ) { if ( nAttrib == n ) { // found by number if ( pstrAttrib ) { *pstrAttrib = GetTokenText(); nFoundAttribNameR = m_nR; } else return true; } } else if ( Match(pAttrib) ) { // Matched attrib name, go forward to value nFoundAttribNameR = m_nR; } if ( nFoundAttribNameR ) // either by n or name match { m_nPreSpaceStart = nTempPreSpaceStart; m_nPreSpaceLength = nTempPreSpaceLength; } } ++nAttrib; } else if ( nFoundAttribNameR ) break; bAfterEqual = false; } if ( nFoundAttribNameR ) { if ( ! bAfterEqual ) { // when attribute has no value the value is the attribute name m_nL = m_nPreSpaceStart + m_nPreSpaceLength; m_nR = nFoundAttribNameR; m_nNext = nFoundAttribNameR + 1; } return true; // found by name } return false; // not found } ////////////////////////////////////////////////////////////////////// // Element tag stack: an array of TagPos structs to track nested elements // This is used during parsing to match end tags with corresponding start tags // For x_ParseElem only ElemStack::iTop is used with PushIntoLevel, PopOutOfLevel, and Current // For file mode then the full capabilities are used to track counts of sibling tag names for path support // struct TagPos { TagPos() { Init(); }; void SetTagName( MCD_PCSZ pName, int n ) { MCD_STRASSIGN(strTagName,pName,n); }; void Init( int i=0, int n=1 ) { nCount=1; nTagNames=n; iNext=i; iPrev=0; nSlot=-1; iSlotPrev=0; iSlotNext=0; }; void IncCount() { if (nCount) ++nCount; }; MCD_STR strTagName; int nCount; int nTagNames; int iParent; int iNext; int iPrev; int nSlot; int iSlotNext; int iSlotPrev; }; struct ElemStack { enum { LS_TABLESIZE = 23 }; ElemStack() { iTop=0; iUsed=0; iPar=0; nLevel=0; nSize=0; pL=NULL; Alloc(7); pL[0].Init(); InitTable(); }; ~ElemStack() { if (pL) delete [] pL; }; TagPos& Current() { return pL[iTop]; }; void InitTable() { memset(anTable,0,sizeof(int)*LS_TABLESIZE); }; TagPos& NextParent( int& i ) { int iCur=i; i=pL[i].iParent; return pL[iCur]; }; TagPos& GetRefTagPosAt( int i ) { return pL[i]; }; void Push( MCD_PCSZ pName, int n ) { ++iUsed; if (iUsed==nSize) Alloc(nSize*2); pL[iUsed].SetTagName(pName,n); pL[iUsed].iParent=iPar; iTop=iUsed; }; void IntoLevel() { iPar = iTop; ++nLevel; }; void OutOfLevel() { if (iPar!=iTop) Pop(); iPar = pL[iTop].iParent; --nLevel; }; void PushIntoLevel( MCD_PCSZ pName, int n ) { ++iTop; if (iTop==nSize) Alloc(nSize*2); pL[iTop].SetTagName(pName,n); }; void PopOutOfLevel() { --iTop; }; void Pop() { iTop = iPar; while (iUsed && pL[iUsed].iParent==iPar) { if (pL[iUsed].nSlot!=-1) Unslot(pL[iUsed]); --iUsed; } }; void Slot( int n ) { pL[iUsed].nSlot=n; int i=anTable[n]; anTable[n]=iUsed; pL[iUsed].iSlotNext=i; if (i) pL[i].iSlotPrev=iUsed; }; void Unslot( TagPos& lp ) { int n=lp.iSlotNext,p=lp.iSlotPrev; if (n) pL[n].iSlotPrev=p; if (p) pL[p].iSlotNext=n; else anTable[lp.nSlot]=n; }; static int CalcSlot( MCD_PCSZ pName, int n, bool bIC ); void PushTagAndCount( TokenPos& token ); int iTop; int nLevel; int iPar; protected: void Alloc( int nNewSize ) { TagPos* pLNew = new TagPos[nNewSize]; Copy(pLNew); nSize=nNewSize; }; void Copy( TagPos* pLNew ) { for(int n=0;n= 'A' && *pName <= 'Z' ) nHash += ('a'-'A'); ++pName; } return nHash%LS_TABLESIZE; } void ElemStack::PushTagAndCount( TokenPos& token ) { // Check for a matching tag name at the top level and set current if found or add new one // Calculate hash of tag name, support ignore ASCII case for MDF_IGNORECASE int nSlot = -1; int iNext = 0; MCD_PCSZ pTagName = token.GetTokenPtr(); if ( iTop != iPar ) { // See if tag name is already used, first try previous sibling (almost always) iNext = iTop; if ( token.Match(Current().strTagName) ) { iNext = -1; Current().IncCount(); } else { nSlot = CalcSlot( pTagName, token.Length(), (token.m_nTokenFlags & CMarkup::MDF_IGNORECASE)?true:false ); int iLookup = anTable[nSlot]; while ( iLookup ) { TagPos& tag = pL[iLookup]; if ( tag.iParent == iPar && token.Match(tag.strTagName) ) { pL[tag.iPrev].iNext = tag.iNext; if ( tag.iNext ) pL[tag.iNext].iPrev = tag.iPrev; tag.nTagNames = Current().nTagNames; tag.iNext = iTop; tag.IncCount(); iTop = iLookup; iNext = -1; break; } iLookup = tag.iSlotNext; } } } if ( iNext != -1 ) { // Turn off in the rare case where a document uses unique tag names like record1, record2, etc, more than 256 int nTagNames = 0; if ( iNext ) nTagNames = Current().nTagNames; if ( nTagNames == 256 ) { MCD_STRASSIGN( (Current().strTagName), pTagName, (token.Length()) ); Current().nCount = 0; Unslot( Current() ); } else { Push( pTagName, token.Length() ); Current().Init( iNext, nTagNames+1 ); } if ( nSlot == -1 ) nSlot = CalcSlot( pTagName, token.Length(), (token.m_nTokenFlags & CMarkup::MDF_IGNORECASE)?true:false ); Slot( nSlot ); } } ////////////////////////////////////////////////////////////////////// // FilePos is created for a file while it is open // In file mode the file stays open between CMarkup calls and is stored in m_pFilePos // struct FilePos { FilePos() { m_fp=NULL; m_nDocFlags=0; m_nFileByteLen=0; m_nFileByteOffset=0; m_nOpFileByteLen=0; m_nBlockSizeBasis=MARKUP_FILEBLOCKSIZE; m_nFileCharUnitSize=0; m_nOpFileTextLen=0; m_pstrBuffer=NULL; m_nReadBufferStart=0; m_nReadBufferRemoved=0; m_nReadGatherStart=-1; }; bool FileOpen( MCD_CSTR_FILENAME szFileName ); bool FileRead( void* pBuffer ); bool FileReadText( MCD_STR& strDoc ); bool FileCheckRaggedEnd( void* pBuffer ); bool FileReadNextBuffer(); void FileGatherStart( int nStart ); int FileGatherEnd( MCD_STR& strSubDoc ); bool FileWrite( void* pBuffer, const void* pConstBuffer = NULL ); bool FileWriteText( const MCD_STR& strDoc, int nWriteStrLen = -1 ); bool FileFlush( MCD_STR& strBuffer, int nWriteStrLen = -1, bool bFflush = false ); bool FileClose(); void FileSpecifyEncoding( MCD_STR* pstrEncoding ); bool FileAtTop(); bool FileErrorAddResult(); FILE* m_fp; int m_nDocFlags; int m_nOpFileByteLen; int m_nBlockSizeBasis; MCD_INTFILEOFFSET m_nFileByteLen; MCD_INTFILEOFFSET m_nFileByteOffset; int m_nFileCharUnitSize; int m_nOpFileTextLen; MCD_STR m_strIOResult; MCD_STR m_strEncoding; MCD_STR* m_pstrBuffer; ElemStack m_elemstack; int m_nReadBufferStart; int m_nReadBufferRemoved; int m_nReadGatherStart; MCD_STR m_strReadGatherMarkup; }; struct BomTableStruct { const char* pszBom; int nBomLen; MCD_PCSZ pszBomEnc; int nBomFlag; } BomTable[] = { { "\xef\xbb\xbf", 3, MCD_T("UTF-8"), CMarkup::MDF_UTF8PREAMBLE }, { "\xff\xfe", 2, MCD_T("UTF-16LE"), CMarkup::MDF_UTF16LEFILE }, { "\xfe\xff", 2, MCD_T("UTF-16BE"), CMarkup::MDF_UTF16BEFILE }, { NULL,0,NULL,0 } }; bool FilePos::FileErrorAddResult() { // strerror has difficulties cross-platform // VC++ leaves MCD_STRERROR undefined and uses FormatMessage // Non-VC++ use strerror (even for MARKUP_WCHAR and convert) // additional notes: // _WIN32_WCE (Windows CE) has no strerror (Embedded VC++ uses FormatMessage) // _MSC_VER >= 1310 (VC++ 2003/7.1) has _wcserror (but not used) // const int nErrorBufferSize = 100; int nErr = 0; MCD_CHAR szError[nErrorBufferSize+1]; #if defined(MCD_STRERROR) // C error routine nErr = (int)errno; #if defined(MARKUP_WCHAR) char szMBError[nErrorBufferSize+1]; strncpy( szMBError, MCD_STRERROR, nErrorBufferSize ); szMBError[nErrorBufferSize] = '\0'; TextEncoding textencoding( MCD_T(""), (const void*)szMBError, strlen(szMBError) ); textencoding.m_nToCount = nErrorBufferSize; int nWideLen = textencoding.PerformConversion( (void*)szError, MCD_ENC ); szError[nWideLen] = '\0'; #else MCD_PSZNCPY( szError, MCD_STRERROR, nErrorBufferSize ); szError[nErrorBufferSize] = '\0'; #endif #else // no C error routine, use Windows API DWORD dwErr = ::GetLastError(); if ( ::FormatMessage(0x1200,0,dwErr,0,szError,nErrorBufferSize,0) < 1 ) szError[0] = '\0'; nErr = (int)dwErr; #endif // no C error routine MCD_STR strError = szError; for ( int nChar=0; nChar= nReadTop || pFileTop[nBomLen] != BomTable[nBomCheck].pszBom[nBomLen] ) break; ++nBomLen; } if ( nBomLen == BomTable[nBomCheck].nBomLen ) { m_nDocFlags |= BomTable[nBomCheck].nBomFlag; if ( nBomLen == 2 ) m_nFileCharUnitSize = 2; m_strEncoding = BomTable[nBomCheck].pszBomEnc; break; } ++nBomCheck; nBomLen = 0; } if ( nReadTop > nBomLen ) MCD_FSEEK( m_fp, nBomLen, SEEK_SET ); // Encoding check if ( ! nBomLen ) { MCD_STR strDeclCheck; #if defined(MARKUP_WCHAR) // WCHAR TextEncoding textencoding( MCD_T("UTF-8"), (const void*)pFileTop, nReadTop ); MCD_CHAR* pWideBuffer = MCD_GETBUFFER(strDeclCheck,nReadTop); textencoding.m_nToCount = nReadTop; int nDeclWideLen = textencoding.PerformConversion( (void*)pWideBuffer, MCD_ENC ); MCD_RELEASEBUFFER(strDeclCheck,pWideBuffer,nDeclWideLen); #else // not WCHAR MCD_STRASSIGN(strDeclCheck,pFileTop,nReadTop); #endif // not WCHAR m_strEncoding = CMarkup::GetDeclaredEncoding( strDeclCheck ); } // Assume markup files starting with < sign are UTF-8 if otherwise unknown if ( MCD_STRISEMPTY(m_strEncoding) && pFileTop[0] == '<' ) m_strEncoding = MCD_T("UTF-8"); } delete [] pFileTop; } } else if ( m_nDocFlags & CMarkup::MDF_WRITEFILE ) { if ( m_nDocFlags & CMarkup::MDF_APPENDFILE ) { // fopen for append does not move the file pointer to the end until first I/O operation MCD_FSEEK( m_fp, 0, SEEK_END ); m_nFileByteLen = MCD_FTELL( m_fp ); } int nBomCheck = 0; while ( BomTable[nBomCheck].pszBom ) { if ( m_nDocFlags & BomTable[nBomCheck].nBomFlag ) { nBomLen = BomTable[nBomCheck].nBomLen; if ( nBomLen == 2 ) m_nFileCharUnitSize = 2; m_strEncoding = BomTable[nBomCheck].pszBomEnc; if ( m_nFileByteLen ) // append nBomLen = 0; else // write BOM bSuccess = ( fwrite(BomTable[nBomCheck].pszBom,nBomLen,1,m_fp) == 1 ); break; } ++nBomCheck; } } if ( ! bSuccess ) return FileErrorAddResult(); if ( m_nDocFlags & CMarkup::MDF_APPENDFILE ) m_nFileByteOffset = m_nFileByteLen; else m_nFileByteOffset = (MCD_INTFILEOFFSET)nBomLen; if ( nBomLen ) x_AddResult( m_strIOResult, MCD_T("bom") ); return bSuccess; } bool FilePos::FileRead( void* pBuffer ) { bool bSuccess = ( fread( pBuffer,m_nOpFileByteLen,1,m_fp) == 1 ); m_nOpFileTextLen = m_nOpFileByteLen / m_nFileCharUnitSize; if ( bSuccess ) { m_nFileByteOffset += m_nOpFileByteLen; x_AddResult( m_strIOResult, MCD_T("read"), m_strEncoding, MRC_ENCODING|MRC_LENGTH, m_nOpFileTextLen ); // Microsoft components can produce apparently valid docs with some nulls at ends of values int nNullCount = 0; int nNullCheckCharsRemaining = m_nOpFileTextLen; char* pAfterNull = NULL; char* pNullScan = (char*)pBuffer; bool bSingleByteChar = m_nFileCharUnitSize == 1; while ( nNullCheckCharsRemaining-- ) { if ( bSingleByteChar? (! *pNullScan) : (! (*(unsigned short*)pNullScan)) ) { if ( pAfterNull && pNullScan != pAfterNull ) memmove( pAfterNull - (nNullCount*m_nFileCharUnitSize), pAfterNull, pNullScan - pAfterNull ); pAfterNull = pNullScan + m_nFileCharUnitSize; ++nNullCount; } pNullScan += m_nFileCharUnitSize; } if ( pAfterNull && pNullScan != pAfterNull ) memmove( pAfterNull - (nNullCount*m_nFileCharUnitSize), pAfterNull, pNullScan - pAfterNull ); if ( nNullCount ) { x_AddResult( m_strIOResult, MCD_T("nulls_removed"), NULL, MRC_COUNT, nNullCount ); m_nOpFileTextLen -= nNullCount; } // Big endian/little endian conversion if ( m_nFileCharUnitSize > 1 && x_EndianSwapRequired(m_nDocFlags) ) { x_EndianSwapUTF16( (unsigned short*)pBuffer, m_nOpFileTextLen ); x_AddResult( m_strIOResult, MCD_T("endian_swap") ); } } if ( ! bSuccess ) FileErrorAddResult(); return bSuccess; } bool FilePos::FileCheckRaggedEnd( void* pBuffer ) { // In file read mode, piece of file text in memory must end on a character boundary // This check must happen after the encoding has been decided, so after UTF-8 autodetection // If ragged, adjust file position, m_nOpFileTextLen and m_nOpFileByteLen int nTruncBeforeBytes = 0; TextEncoding textencoding( m_strEncoding, pBuffer, m_nOpFileTextLen ); if ( ! textencoding.FindRaggedEnd(nTruncBeforeBytes) ) { // Input must be garbled? decoding error before potentially ragged end, add error result and continue MCD_STR strEncoding = m_strEncoding; if ( MCD_STRISEMPTY(strEncoding) ) strEncoding = MCD_T("ANSI"); x_AddResult( m_strIOResult, MCD_T("truncation_error"), strEncoding, MRC_ENCODING ); } else if ( nTruncBeforeBytes ) { nTruncBeforeBytes *= -1; m_nFileByteOffset += nTruncBeforeBytes; MCD_FSEEK( m_fp, m_nFileByteOffset, SEEK_SET ); m_nOpFileByteLen += nTruncBeforeBytes; m_nOpFileTextLen += nTruncBeforeBytes / m_nFileCharUnitSize; x_AddResult( m_strIOResult, MCD_T("read"), NULL, MRC_MODIFY|MRC_LENGTH, m_nOpFileTextLen ); } return true; } bool FilePos::FileReadText( MCD_STR& strDoc ) { bool bSuccess = true; MCD_STRCLEAR( m_strIOResult ); if ( ! m_nOpFileByteLen ) { x_AddResult( m_strIOResult, MCD_T("read"), m_strEncoding, MRC_ENCODING|MRC_LENGTH, 0 ); return bSuccess; } // Only read up to end of file (a single read byte length cannot be over the capacity of int) bool bCheckRaggedEnd = true; MCD_INTFILEOFFSET nBytesRemaining = m_nFileByteLen - m_nFileByteOffset; if ( (MCD_INTFILEOFFSET)m_nOpFileByteLen >= nBytesRemaining ) { m_nOpFileByteLen = (int)nBytesRemaining; bCheckRaggedEnd = false; } if ( m_nDocFlags & (CMarkup::MDF_UTF16LEFILE | CMarkup::MDF_UTF16BEFILE) ) { int nUTF16Len = m_nOpFileByteLen / 2; #if defined(MARKUP_WCHAR) // WCHAR int nBufferSizeForGrow = nUTF16Len + nUTF16Len/100; // extra 1% #if MARKUP_SIZEOFWCHAR == 4 // sizeof(wchar_t) == 4 unsigned short* pUTF16Buffer = new unsigned short[nUTF16Len+1]; bSuccess = FileRead( pUTF16Buffer ); if ( bSuccess ) { if ( bCheckRaggedEnd ) FileCheckRaggedEnd( (void*)pUTF16Buffer ); TextEncoding textencoding( MCD_T("UTF-16"), (const void*)pUTF16Buffer, m_nOpFileTextLen ); textencoding.m_nToCount = nBufferSizeForGrow; MCD_CHAR* pUTF32Buffer = MCD_GETBUFFER(strDoc,nBufferSizeForGrow); int nUTF32Len = textencoding.PerformConversion( (void*)pUTF32Buffer, MCD_T("UTF-32") ); MCD_RELEASEBUFFER(strDoc,pUTF32Buffer,nUTF32Len); x_AddResult( m_strIOResult, MCD_T("converted_to"), MCD_T("UTF-32"), MRC_ENCODING|MRC_LENGTH, nUTF32Len ); } #else // sizeof(wchar_t) == 2 MCD_CHAR* pUTF16Buffer = MCD_GETBUFFER(strDoc,nBufferSizeForGrow); bSuccess = FileRead( pUTF16Buffer ); if ( bSuccess && bCheckRaggedEnd ) FileCheckRaggedEnd( (void*)pUTF16Buffer ); MCD_RELEASEBUFFER(strDoc,pUTF16Buffer,m_nOpFileTextLen); #endif // sizeof(wchar_t) == 2 #else // not WCHAR // Convert file from UTF-16; it needs to be in memory as UTF-8 or MBCS unsigned short* pUTF16Buffer = new unsigned short[nUTF16Len+1]; bSuccess = FileRead( pUTF16Buffer ); if ( bSuccess && bCheckRaggedEnd ) FileCheckRaggedEnd( (void*)pUTF16Buffer ); TextEncoding textencoding( MCD_T("UTF-16"), (const void*)pUTF16Buffer, m_nOpFileTextLen ); int nMBLen = textencoding.PerformConversion( NULL, MCD_ENC ); int nBufferSizeForGrow = nMBLen + nMBLen/100; // extra 1% MCD_CHAR* pMBBuffer = MCD_GETBUFFER(strDoc,nBufferSizeForGrow); textencoding.PerformConversion( (void*)pMBBuffer ); delete [] pUTF16Buffer; MCD_RELEASEBUFFER(strDoc,pMBBuffer,nMBLen); x_AddResult( m_strIOResult, MCD_T("converted_to"), MCD_ENC, MRC_ENCODING|MRC_LENGTH, nMBLen ); if ( textencoding.m_nFailedChars ) x_AddResult( m_strIOResult, MCD_T("conversion_loss") ); #endif // not WCHAR } else // single or multibyte file (i.e. not UTF-16) { #if defined(MARKUP_WCHAR) // WCHAR char* pBuffer = new char[m_nOpFileByteLen]; bSuccess = FileRead( pBuffer ); if ( MCD_STRISEMPTY(m_strEncoding) ) { int nNonASCII; bool bErrorAtEnd; if ( CMarkup::DetectUTF8(pBuffer,m_nOpFileByteLen,&nNonASCII,&bErrorAtEnd) || (bCheckRaggedEnd && bErrorAtEnd) ) { m_strEncoding = MCD_T("UTF-8"); x_AddResult( m_strIOResult, MCD_T("read"), m_strEncoding, MRC_MODIFY|MRC_ENCODING ); } x_AddResult( m_strIOResult, MCD_T("utf8_detection") ); } if ( bSuccess && bCheckRaggedEnd ) FileCheckRaggedEnd( (void*)pBuffer ); TextEncoding textencoding( m_strEncoding, (const void*)pBuffer, m_nOpFileTextLen ); int nWideLen = textencoding.PerformConversion( NULL, MCD_ENC ); int nBufferSizeForGrow = nWideLen + nWideLen/100; // extra 1% MCD_CHAR* pWideBuffer = MCD_GETBUFFER(strDoc,nBufferSizeForGrow); textencoding.PerformConversion( (void*)pWideBuffer ); MCD_RELEASEBUFFER( strDoc, pWideBuffer, nWideLen ); delete [] pBuffer; x_AddResult( m_strIOResult, MCD_T("converted_to"), MCD_ENC, MRC_ENCODING|MRC_LENGTH, nWideLen ); #else // not WCHAR // After loading a file with unknown multi-byte encoding bool bAssumeUnknownIsNative = false; if ( MCD_STRISEMPTY(m_strEncoding) ) { bAssumeUnknownIsNative = true; m_strEncoding = MCD_ENC; } if ( TextEncoding::CanConvert(MCD_ENC,m_strEncoding) ) { char* pBuffer = new char[m_nOpFileByteLen]; bSuccess = FileRead( pBuffer ); if ( bSuccess && bCheckRaggedEnd ) FileCheckRaggedEnd( (void*)pBuffer ); TextEncoding textencoding( m_strEncoding, (const void*)pBuffer, m_nOpFileTextLen ); int nMBLen = textencoding.PerformConversion( NULL, MCD_ENC ); int nBufferSizeForGrow = nMBLen + nMBLen/100; // extra 1% MCD_CHAR* pMBBuffer = MCD_GETBUFFER(strDoc,nBufferSizeForGrow); textencoding.PerformConversion( (void*)pMBBuffer ); MCD_RELEASEBUFFER( strDoc, pMBBuffer, nMBLen ); delete [] pBuffer; x_AddResult( m_strIOResult, MCD_T("converted_to"), MCD_ENC, MRC_ENCODING|MRC_LENGTH, nMBLen ); if ( textencoding.m_nFailedChars ) x_AddResult( m_strIOResult, MCD_T("conversion_loss") ); } else // load directly into string { int nBufferSizeForGrow = m_nOpFileByteLen + m_nOpFileByteLen/100; // extra 1% MCD_CHAR* pBuffer = MCD_GETBUFFER(strDoc,nBufferSizeForGrow); bSuccess = FileRead( pBuffer ); bool bConvertMB = false; if ( bAssumeUnknownIsNative ) { // Might need additional conversion if we assumed an encoding int nNonASCII; bool bErrorAtEnd; bool bIsUTF8 = CMarkup::DetectUTF8( pBuffer, m_nOpFileByteLen, &nNonASCII, &bErrorAtEnd ) || (bCheckRaggedEnd && bErrorAtEnd); MCD_STR strDetectedEncoding = bIsUTF8? MCD_T("UTF-8"): MCD_T(""); if ( nNonASCII && m_strEncoding != strDetectedEncoding ) // only need to convert non-ASCII bConvertMB = true; m_strEncoding = strDetectedEncoding; if ( bIsUTF8 ) x_AddResult( m_strIOResult, MCD_T("read"), m_strEncoding, MRC_MODIFY|MRC_ENCODING ); } if ( bSuccess && bCheckRaggedEnd ) FileCheckRaggedEnd( (void*)pBuffer ); MCD_RELEASEBUFFER( strDoc, pBuffer, m_nOpFileTextLen ); if ( bConvertMB ) { TextEncoding textencoding( m_strEncoding, MCD_2PCSZ(strDoc), m_nOpFileTextLen ); int nMBLen = textencoding.PerformConversion( NULL, MCD_ENC ); nBufferSizeForGrow = nMBLen + nMBLen/100; // extra 1% MCD_STR strConvDoc; pBuffer = MCD_GETBUFFER(strConvDoc,nBufferSizeForGrow); textencoding.PerformConversion( (void*)pBuffer ); MCD_RELEASEBUFFER( strConvDoc, pBuffer, nMBLen ); strDoc = strConvDoc; x_AddResult( m_strIOResult, MCD_T("converted_to"), MCD_ENC, MRC_ENCODING|MRC_LENGTH, nMBLen ); if ( textencoding.m_nFailedChars ) x_AddResult( m_strIOResult, MCD_T("conversion_loss") ); } if ( bAssumeUnknownIsNative ) x_AddResult( m_strIOResult, MCD_T("utf8_detection") ); } #endif // not WCHAR } return bSuccess; } bool FilePos::FileWrite( void* pBuffer, const void* pConstBuffer /*=NULL*/ ) { m_nOpFileByteLen = m_nOpFileTextLen * m_nFileCharUnitSize; if ( ! pConstBuffer ) pConstBuffer = pBuffer; unsigned short* pTempEndianBuffer = NULL; if ( x_EndianSwapRequired(m_nDocFlags) ) { if ( ! pBuffer ) { pTempEndianBuffer = new unsigned short[m_nOpFileTextLen]; memcpy( pTempEndianBuffer, pConstBuffer, m_nOpFileTextLen * 2 ); pBuffer = pTempEndianBuffer; pConstBuffer = pTempEndianBuffer; } x_EndianSwapUTF16( (unsigned short*)pBuffer, m_nOpFileTextLen ); x_AddResult( m_strIOResult, MCD_T("endian_swap") ); } bool bSuccess = ( fwrite( pConstBuffer, m_nOpFileByteLen, 1, m_fp ) == 1 ); if ( pTempEndianBuffer ) delete [] pTempEndianBuffer; if ( bSuccess ) { m_nFileByteOffset += m_nOpFileByteLen; x_AddResult( m_strIOResult, MCD_T("write"), m_strEncoding, MRC_ENCODING|MRC_LENGTH, m_nOpFileTextLen ); } else FileErrorAddResult(); return bSuccess; } bool FilePos::FileWriteText( const MCD_STR& strDoc, int nWriteStrLen/*=-1*/ ) { bool bSuccess = true; MCD_STRCLEAR( m_strIOResult ); MCD_PCSZ pDoc = MCD_2PCSZ(strDoc); if ( nWriteStrLen == -1 ) nWriteStrLen = MCD_STRLENGTH(strDoc); if ( ! nWriteStrLen ) { x_AddResult( m_strIOResult, MCD_T("write"), m_strEncoding, MRC_ENCODING|MRC_LENGTH, 0 ); return bSuccess; } if ( m_nDocFlags & (CMarkup::MDF_UTF16LEFILE | CMarkup::MDF_UTF16BEFILE) ) { #if defined(MARKUP_WCHAR) // WCHAR #if MARKUP_SIZEOFWCHAR == 4 // sizeof(wchar_t) == 4 TextEncoding textencoding( MCD_T("UTF-32"), (const void*)pDoc, nWriteStrLen ); m_nOpFileTextLen = textencoding.PerformConversion( NULL, MCD_T("UTF-16") ); unsigned short* pUTF16Buffer = new unsigned short[m_nOpFileTextLen]; textencoding.PerformConversion( (void*)pUTF16Buffer ); x_AddResult( m_strIOResult, MCD_T("converted_from"), MCD_T("UTF-32"), MRC_ENCODING|MRC_LENGTH, nWriteStrLen ); bSuccess = FileWrite( pUTF16Buffer ); delete [] pUTF16Buffer; #else // sizeof(wchar_t) == 2 m_nOpFileTextLen = nWriteStrLen; bSuccess = FileWrite( NULL, pDoc ); #endif #else // not WCHAR TextEncoding textencoding( MCD_ENC, (const void*)pDoc, nWriteStrLen ); m_nOpFileTextLen = textencoding.PerformConversion( NULL, MCD_T("UTF-16") ); unsigned short* pUTF16Buffer = new unsigned short[m_nOpFileTextLen]; textencoding.PerformConversion( (void*)pUTF16Buffer ); x_AddResult( m_strIOResult, MCD_T("converted_from"), MCD_ENC, MRC_ENCODING|MRC_LENGTH, nWriteStrLen ); bSuccess = FileWrite( pUTF16Buffer ); delete [] pUTF16Buffer; #endif // not WCHAR } else // single or multibyte file (i.e. not UTF-16) { #if ! defined(MARKUP_WCHAR) // not WCHAR if ( ! TextEncoding::CanConvert(m_strEncoding,MCD_ENC) ) { // Same or unsupported multi-byte to multi-byte, so save directly from string m_nOpFileTextLen = nWriteStrLen; bSuccess = FileWrite( NULL, pDoc ); return bSuccess; } #endif // not WCHAR TextEncoding textencoding( MCD_ENC, (const void*)pDoc, nWriteStrLen ); m_nOpFileTextLen = textencoding.PerformConversion( NULL, m_strEncoding ); char* pMBBuffer = new char[m_nOpFileTextLen]; textencoding.PerformConversion( (void*)pMBBuffer ); x_AddResult( m_strIOResult, MCD_T("converted_from"), MCD_ENC, MRC_ENCODING|MRC_LENGTH, nWriteStrLen ); if ( textencoding.m_nFailedChars ) x_AddResult( m_strIOResult, MCD_T("conversion_loss") ); bSuccess = FileWrite( pMBBuffer ); delete [] pMBBuffer; } return bSuccess; } bool FilePos::FileClose() { if ( m_fp ) { if ( fclose(m_fp) ) FileErrorAddResult(); m_fp = NULL; m_nDocFlags &= ~(CMarkup::MDF_WRITEFILE|CMarkup::MDF_READFILE|CMarkup::MDF_APPENDFILE); return true; } return false; } bool FilePos::FileReadNextBuffer() { // If not end of file, returns amount to subtract from offsets if ( m_nFileByteOffset < m_nFileByteLen ) { // Prepare to put this node at beginning MCD_STR& str = *m_pstrBuffer; int nDocLength = MCD_STRLENGTH( str ); int nRemove = m_nReadBufferStart; m_nReadBufferRemoved = nRemove; // Gather if ( m_nReadGatherStart != -1 ) { if ( m_nReadBufferStart > m_nReadGatherStart ) { // In case it is a large subdoc, reduce reallocs by using x_StrInsertReplace MCD_STR strAppend = MCD_STRMID( str, m_nReadGatherStart, m_nReadBufferStart - m_nReadGatherStart ); x_StrInsertReplace( m_strReadGatherMarkup, MCD_STRLENGTH(m_strReadGatherMarkup), 0, strAppend ); } m_nReadGatherStart = 0; } // Increase capacity if keeping more than half of nDocLength int nKeepLength = nDocLength - nRemove; if ( nKeepLength > nDocLength / 2 ) m_nBlockSizeBasis *= 2; if ( nRemove ) x_StrInsertReplace( str, 0, nRemove, MCD_STR() ); MCD_STR strRead; m_nOpFileByteLen = m_nBlockSizeBasis - nKeepLength; m_nOpFileByteLen += 4 - m_nOpFileByteLen % 4; // round up to 4-byte offset FileReadText( strRead ); x_StrInsertReplace( str, nKeepLength, 0, strRead ); m_nReadBufferStart = 0; // next time just elongate/increase capacity return true; } return false; } void FilePos::FileGatherStart( int nStart ) { m_nReadGatherStart = nStart; } int FilePos::FileGatherEnd( MCD_STR& strMarkup ) { int nStart = m_nReadGatherStart; m_nReadGatherStart = -1; strMarkup = m_strReadGatherMarkup; MCD_STRCLEAR( m_strReadGatherMarkup ); return nStart; } bool FilePos::FileFlush( MCD_STR& strBuffer, int nWriteStrLen/*=-1*/, bool bFflush/*=false*/ ) { bool bSuccess = true; MCD_STRCLEAR( m_strIOResult ); if ( nWriteStrLen == -1 ) nWriteStrLen = MCD_STRLENGTH( strBuffer ); if ( nWriteStrLen ) { if ( (! m_nFileByteOffset) && MCD_STRISEMPTY(m_strEncoding) && ! MCD_STRISEMPTY(strBuffer) ) { m_strEncoding = CMarkup::GetDeclaredEncoding( strBuffer ); if ( MCD_STRISEMPTY(m_strEncoding) ) m_strEncoding = MCD_T("UTF-8"); } bSuccess = FileWriteText( strBuffer, nWriteStrLen ); if ( bSuccess ) x_StrInsertReplace( strBuffer, 0, nWriteStrLen, MCD_STR() ); } if ( bFflush && bSuccess ) { if ( fflush(m_fp) ) bSuccess = FileErrorAddResult(); } return bSuccess; } ////////////////////////////////////////////////////////////////////// // PathPos encapsulates parsing of the path string used in Find methods // struct PathPos { PathPos( MCD_PCSZ pszPath, bool b ) { p=pszPath; bReader=b; i=0; iPathAttribName=0; iSave=0; nPathType=0; if (!ParsePath()) nPathType=-1; }; int GetTypeAndInc() { i=-1; if (p) { if (p[0]=='/') { if (p[1]=='/') i=2; else i=1; } else if (p[0]) i=0; } nPathType=i+1; return nPathType; }; int GetNumAndInc() { int n=0; while (p[i]>='0'&&p[i]<='9') n=n*10+(int)p[i++]-(int)'0'; return n; }; MCD_PCSZ GetValAndInc() { ++i; MCD_CHAR cEnd=']'; if (p[i]=='\''||p[i]=='\"') cEnd=p[i++]; int iVal=i; IncWord(cEnd); nLen=i-iVal; if (cEnd!=']') ++i; return &p[iVal]; }; int GetValOrWordLen() { return nLen; }; MCD_CHAR GetChar() { return p[i]; }; bool IsAtPathEnd() { return ((!p[i])||(iPathAttribName&&i+2>=iPathAttribName))?true:false; }; MCD_PCSZ GetPtr() { return &p[i]; }; void SaveOffset() { iSave=i; }; void RevertOffset() { i=iSave; }; void RevertOffsetAsName() { i=iSave; nPathType=1; }; MCD_PCSZ GetWordAndInc() { int iWord=i; IncWord(); nLen=i-iWord; return &p[iWord]; }; void IncWord() { while (p[i]&&!x_ISENDPATHWORD(p[i])) i+=MCD_CLEN(&p[i]); }; void IncWord( MCD_CHAR c ) { while (p[i]&&p[i]!=c) i+=MCD_CLEN(&p[i]); }; void IncChar() { ++i; }; void Inc( int n ) { i+=n; }; bool IsAnywherePath() { return nPathType == 3; }; bool IsAbsolutePath() { return nPathType == 2; }; bool IsPath() { return nPathType > 0; }; bool ValidPath() { return nPathType != -1; }; MCD_PCSZ GetPathAttribName() { if (iPathAttribName) return &p[iPathAttribName]; return NULL; }; bool AttribPredicateMatch( TokenPos& token ); private: bool ParsePath(); int nPathType; // -1 invalid, 0 empty, 1 name, 2 absolute path, 3 anywhere path bool bReader; MCD_PCSZ p; int i; int iPathAttribName; int iSave; int nLen; }; bool PathPos::ParsePath() { // Determine if the path seems to be in a valid format before attempting to find if ( GetTypeAndInc() ) { SaveOffset(); while ( 1 ) { if ( ! GetChar() ) return false; IncWord(); // Tag name if ( GetChar() == '[' ) // predicate { IncChar(); // [ if ( GetChar() >= '1' && GetChar() <= '9' ) GetNumAndInc(); else // attrib or child tag name { if ( GetChar() == '@' ) { IncChar(); // @ IncWord(); // attrib name if ( GetChar() == '=' ) GetValAndInc(); } else { if ( bReader ) return false; IncWord(); } } if ( GetChar() != ']' ) return false; IncChar(); // ] } // Another level of path if ( GetChar() == '/' ) { if ( IsAnywherePath() ) return false; // multiple levels not supported for // path IncChar(); if ( GetChar() == '@' ) { // FindGetData and FindSetData support paths ending in attribute IncChar(); // @ iPathAttribName = i; IncWord(); // attrib name if ( GetChar() ) return false; // it should have ended with attribute name break; } } else { if ( GetChar() ) return false; // not a slash, so it should have ended here break; } } RevertOffset(); } return true; } bool PathPos::AttribPredicateMatch( TokenPos& token ) { // Support attribute predicate matching in regular and file read mode // token.m_nNext must already be set to node.nStart + 1 or ELEM(i).nStart + 1 IncChar(); // @ if ( token.FindAttrib(GetPtr()) ) { IncWord(); if ( GetChar() == '=' ) { MCD_PCSZ pszVal = GetValAndInc(); MCD_STR strPathValue = CMarkup::UnescapeText( pszVal, GetValOrWordLen() ); MCD_STR strAttribValue = CMarkup::UnescapeText( token.GetTokenPtr(), token.Length(), token.m_nTokenFlags ); if ( strPathValue != strAttribValue ) return false; } return true; } return false; } ////////////////////////////////////////////////////////////////////// // A map is a table of SavedPos structs // struct SavedPos { // SavedPos is an entry in the SavedPosMap hash table SavedPos() { nSavedPosFlags=0; iPos=0; }; MCD_STR strName; int iPos; enum { SPM_MAIN = 1, SPM_CHILD = 2, SPM_USED = 4, SPM_LAST = 8 }; int nSavedPosFlags; }; struct SavedPosMap { // SavedPosMap is only created if SavePos/RestorePos are used SavedPosMap( int nSize ) { nMapSize=nSize; pTable = new SavedPos*[nSize]; memset(pTable,0,nSize*sizeof(SavedPos*)); }; ~SavedPosMap() { if (pTable) { for (int n=0;nm_pMaps ) { int nMap = 0; SavedPosMap* pMap = NULL; while ( pOtherMaps->m_pMaps[nMap] ) { SavedPosMap* pMapSrc = pOtherMaps->m_pMaps[nMap]; GetMap( pMap, nMap, pMapSrc->nMapSize ); for ( int nSlot=0; nSlot < pMap->nMapSize; ++nSlot ) { SavedPos* pCopySavedPos = pMapSrc->pTable[nSlot]; if ( pCopySavedPos ) { int nCount = 0; while ( pCopySavedPos[nCount].nSavedPosFlags & SavedPos::SPM_USED ) { ++nCount; if ( pCopySavedPos[nCount-1].nSavedPosFlags & SavedPos::SPM_LAST ) break; } if ( nCount ) { SavedPos* pNewSavedPos = new SavedPos[nCount]; for ( int nCopy=0; nCopypTable[nSlot] = pNewSavedPos; } } } ++nMap; } } } ////////////////////////////////////////////////////////////////////// // Core parser function // int TokenPos::ParseNode( NodePos& node ) { // Call this with m_nNext set to the start of the node or tag // Upon return m_nNext points to the char after the node or tag // m_nL and m_nR are set to name location if it is a tag with a name // node members set to node location, strMeta used for parse error // // comment // dtd // processing instruction // cdata section // element start tag // element end tag // // returns the nodetype or // 0 for end tag // -1 for bad node // -2 for end of document // enum ParseBits { PD_OPENTAG = 1, PD_BANG = 2, PD_DASH = 4, PD_BRACKET = 8, PD_TEXTORWS = 16, PD_DOCTYPE = 32, PD_INQUOTE_S = 64, PD_INQUOTE_D = 128, PD_EQUALS = 256, PD_NOQUOTEVAL = 512 }; int nParseFlags = 0; MCD_PCSZ pFindEnd = NULL; int nNodeType = -1; int nEndLen = 0; int nName = 0; int nNameLen = 0; unsigned int cDminus1 = 0, cDminus2 = 0; #define FINDNODETYPE(e,t) { pFindEnd=e; nEndLen=(sizeof(e)-1)/sizeof(MCD_CHAR); nNodeType=t; } #define FINDNODETYPENAME(e,t,n) { FINDNODETYPE(e,t) nName=(int)(pD-m_pDocText)+n; } #define FINDNODEBAD(e) { pFindEnd=MCD_T(">"); nEndLen=1; x_AddResult(node.strMeta,e,NULL,0,m_nNext); nNodeType=-1; } node.nStart = m_nNext; node.nNodeFlags = 0; MCD_PCSZ pD = &m_pDocText[m_nNext]; unsigned int cD; while ( 1 ) { cD = (unsigned int)*pD; if ( ! cD ) { m_nNext = (int)(pD - m_pDocText); if ( m_pReaderFilePos ) // read file mode { // Read buffer may only be removed on the first FileReadNextBuffer in this node int nRemovedAlready = m_pReaderFilePos->m_nReadBufferRemoved; if ( m_pReaderFilePos->FileReadNextBuffer() ) // more text in file? { int nNodeLength = m_nNext - node.nStart; int nRemove = m_pReaderFilePos->m_nReadBufferRemoved; if ( nRemove ) { node.nStart -= nRemove; if ( nName ) nName -= nRemove; else if ( nNameLen ) { m_nL -= nRemove; m_nR -= nRemove; } m_nNext -= nRemove; } int nNewOffset = node.nStart + nNodeLength; MCD_STR& str = *m_pReaderFilePos->m_pstrBuffer; m_pDocText = MCD_2PCSZ( str ); pD = &m_pDocText[nNewOffset]; cD = (unsigned int)*pD; // loaded char replaces null terminator } if (nRemovedAlready) // preserve m_nReadBufferRemoved for caller of ParseNode m_pReaderFilePos->m_nReadBufferRemoved = nRemovedAlready; } if ( ! cD ) { if ( m_nNext == node.nStart ) { node.nLength = 0; node.nNodeType = 0; return -2; // end of document } if ( nNodeType != CMarkup::MNT_WHITESPACE && nNodeType != CMarkup::MNT_TEXT ) { MCD_PCSZ pType = MCD_T("tag"); if ( (nParseFlags & PD_DOCTYPE) || nNodeType == CMarkup::MNT_DOCUMENT_TYPE ) pType = MCD_T("document_type"); else if ( nNodeType == CMarkup::MNT_ELEMENT ) pType = MCD_T("start_tag"); else if ( nNodeType == 0 ) pType = MCD_T("end_tag"); else if ( nNodeType == CMarkup::MNT_CDATA_SECTION ) pType = MCD_T("cdata_section"); else if ( nNodeType == CMarkup::MNT_PROCESSING_INSTRUCTION ) pType = MCD_T("processing_instruction"); else if ( nNodeType == CMarkup::MNT_COMMENT ) pType = MCD_T("comment"); nNodeType = -1; x_AddResult(node.strMeta,MCD_T("unterminated_tag_syntax"),pType,MRC_TYPE,node.nStart); } break; } } if ( nName ) { if ( x_ISENDNAME(cD) ) { nNameLen = (int)(pD - m_pDocText) - nName; m_nL = nName; m_nR = nName + nNameLen - 1; nName = 0; cDminus2 = 0; cDminus1 = 0; } else { pD += MCD_CLEN( pD ); continue; } } if ( pFindEnd ) { if ( cD == '>' && ! (nParseFlags & (PD_INQUOTE_S|PD_INQUOTE_D)) ) { m_nNext = (int)(pD - m_pDocText) + 1; if ( nEndLen == 1 ) { pFindEnd = NULL; if ( nNodeType == CMarkup::MNT_ELEMENT && cDminus1 == '/' ) { if ( (! cDminus2) || (!(nParseFlags&PD_NOQUOTEVAL)) || x_ISNOTSECONDLASTINVAL(cDminus2) ) node.nNodeFlags |= MNF_EMPTY; } } else if ( m_nNext - 1 > nEndLen ) { // Test for end of PI or comment MCD_PCSZ pEnd = pD - nEndLen + 1; MCD_PCSZ pInFindEnd = pFindEnd; int nLen = nEndLen; while ( --nLen && *pEnd++ == *pInFindEnd++ ); if ( nLen == 0 ) pFindEnd = NULL; } nParseFlags &= ~PD_NOQUOTEVAL; // make sure PD_NOQUOTEVAL is off if ( ! pFindEnd && ! (nParseFlags & PD_DOCTYPE) ) break; } else if ( cD == '<' && (nNodeType == CMarkup::MNT_TEXT || nNodeType == -1) ) { m_nNext = (int)(pD - m_pDocText); break; } else if ( nNodeType & CMarkup::MNT_ELEMENT ) { if ( (nParseFlags & (PD_INQUOTE_S|PD_INQUOTE_D|PD_NOQUOTEVAL)) ) { if ( cD == '\"' && (nParseFlags&PD_INQUOTE_D) ) nParseFlags ^= PD_INQUOTE_D; // off else if ( cD == '\'' && (nParseFlags&PD_INQUOTE_S) ) nParseFlags ^= PD_INQUOTE_S; // off else if ( (nParseFlags&PD_NOQUOTEVAL) && x_ISWHITESPACE(cD) ) nParseFlags ^= PD_NOQUOTEVAL; // off } else // not in attrib value { // Only set INQUOTE status when preceeded by equal sign if ( cD == '\"' && (nParseFlags&PD_EQUALS) ) nParseFlags ^= PD_INQUOTE_D|PD_EQUALS; // D on, equals off else if ( cD == '\'' && (nParseFlags&PD_EQUALS) ) nParseFlags ^= PD_INQUOTE_S|PD_EQUALS; // S on, equals off else if ( cD == '=' && cDminus1 != '=' && ! (nParseFlags&PD_EQUALS) ) nParseFlags ^= PD_EQUALS; // on else if ( (nParseFlags&PD_EQUALS) && ! x_ISWHITESPACE(cD) ) nParseFlags ^= PD_NOQUOTEVAL|PD_EQUALS; // no quote val on, equals off } cDminus2 = cDminus1; cDminus1 = cD; } else if ( nNodeType & CMarkup::MNT_DOCUMENT_TYPE ) { if ( cD == '\"' && ! (nParseFlags&PD_INQUOTE_S) ) nParseFlags ^= PD_INQUOTE_D; // toggle else if ( cD == '\'' && ! (nParseFlags&PD_INQUOTE_D) ) nParseFlags ^= PD_INQUOTE_S; // toggle } } else if ( nParseFlags ) { if ( nParseFlags & PD_TEXTORWS ) { if ( cD == '<' ) { m_nNext = (int)(pD - m_pDocText); nNodeType = CMarkup::MNT_WHITESPACE; break; } else if ( ! x_ISWHITESPACE(cD) ) { nParseFlags ^= PD_TEXTORWS; FINDNODETYPE( MCD_T("<"), CMarkup::MNT_TEXT ) } } else if ( nParseFlags & PD_OPENTAG ) { nParseFlags ^= PD_OPENTAG; if ( cD > 0x60 || ( cD > 0x40 && cD < 0x5b ) || cD == 0x5f || cD == 0x3a ) FINDNODETYPENAME( MCD_T(">"), CMarkup::MNT_ELEMENT, 0 ) else if ( cD == '/' ) FINDNODETYPENAME( MCD_T(">"), 0, 1 ) else if ( cD == '!' ) nParseFlags |= PD_BANG; else if ( cD == '?' ) FINDNODETYPENAME( MCD_T("?>"), CMarkup::MNT_PROCESSING_INSTRUCTION, 1 ) else FINDNODEBAD( MCD_T("first_tag_syntax") ) } else if ( nParseFlags & PD_BANG ) { nParseFlags ^= PD_BANG; if ( cD == '-' ) nParseFlags |= PD_DASH; else if ( nParseFlags & PD_DOCTYPE ) { if ( x_ISDOCTYPESTART(cD) ) // "), CMarkup::MNT_DOCUMENT_TYPE ) else FINDNODEBAD( MCD_T("doctype_tag_syntax") ) } else { if ( cD == '[' ) nParseFlags |= PD_BRACKET; else if ( cD == 'D' ) nParseFlags |= PD_DOCTYPE; else FINDNODEBAD( MCD_T("exclamation_tag_syntax") ) } } else if ( nParseFlags & PD_DASH ) { nParseFlags ^= PD_DASH; if ( cD == '-' ) FINDNODETYPE( MCD_T("-->"), CMarkup::MNT_COMMENT ) else FINDNODEBAD( MCD_T("comment_tag_syntax") ) } else if ( nParseFlags & PD_BRACKET ) { nParseFlags ^= PD_BRACKET; if ( cD == 'C' ) FINDNODETYPE( MCD_T("]]>"), CMarkup::MNT_CDATA_SECTION ) else FINDNODEBAD( MCD_T("cdata_section_syntax") ) } else if ( nParseFlags & PD_DOCTYPE ) { if ( cD == '<' ) nParseFlags |= PD_OPENTAG; else if ( cD == '>' ) { m_nNext = (int)(pD - m_pDocText) + 1; nNodeType = CMarkup::MNT_DOCUMENT_TYPE; break; } } } else if ( cD == '<' ) { nParseFlags |= PD_OPENTAG; } else { nNodeType = CMarkup::MNT_WHITESPACE; if ( x_ISWHITESPACE(cD) ) nParseFlags |= PD_TEXTORWS; else FINDNODETYPE( MCD_T("<"), CMarkup::MNT_TEXT ) } pD += MCD_CLEN( pD ); } node.nLength = m_nNext - node.nStart; node.nNodeType = nNodeType; return nNodeType; } ////////////////////////////////////////////////////////////////////// // CMarkup public methods // CMarkup::~CMarkup() { if ( m_pSavedPosMaps ) { delete m_pSavedPosMaps; m_pSavedPosMaps = NULL; } if ( m_pElemPosTree ) { delete m_pElemPosTree; m_pElemPosTree = NULL; } //_CrtDumpMemoryLeaks(); } void CMarkup::operator=( const CMarkup& markup ) { // Copying not supported during file mode because of file pointer if ( (m_nDocFlags & (MDF_READFILE|MDF_WRITEFILE)) || (markup.m_nDocFlags & (MDF_READFILE|MDF_WRITEFILE)) ) return; m_iPosParent = markup.m_iPosParent; m_iPos = markup.m_iPos; m_iPosChild = markup.m_iPosChild; m_iPosFree = markup.m_iPosFree; m_iPosDeleted = markup.m_iPosDeleted; m_nNodeType = markup.m_nNodeType; m_nNodeOffset = markup.m_nNodeOffset; m_nNodeLength = markup.m_nNodeLength; m_strDoc = markup.m_strDoc; m_strResult = markup.m_strResult; m_nDocFlags = markup.m_nDocFlags; m_pElemPosTree->CopyElemPosTree( markup.m_pElemPosTree, m_iPosFree ); m_pSavedPosMaps->CopySavedPosMaps( markup.m_pSavedPosMaps ); MARKUP_SETDEBUGSTATE; } bool CMarkup::SetDoc( MCD_PCSZ pDoc ) { // pDoc is markup text, not a filename! if ( m_nDocFlags & (MDF_READFILE|MDF_WRITEFILE) ) return false; // Set document text if ( pDoc ) m_strDoc = pDoc; else { MCD_STRCLEARSIZE( m_strDoc ); m_pElemPosTree->ReleaseElemPosTree(); } MCD_STRCLEAR(m_strResult); return x_ParseDoc(); } bool CMarkup::SetDoc( const MCD_STR& strDoc ) { // strDoc is markup text, not a filename! if ( m_nDocFlags & (MDF_READFILE|MDF_WRITEFILE) ) return false; m_strDoc = strDoc; MCD_STRCLEAR(m_strResult); return x_ParseDoc(); } bool CMarkup::IsWellFormed() { if ( m_nDocFlags & MDF_WRITEFILE ) return true; if ( m_nDocFlags & MDF_READFILE ) { if ( ! (ELEM(0).nFlags & MNF_ILLFORMED) ) return true; } else if ( m_pElemPosTree->GetSize() && ! (ELEM(0).nFlags & MNF_ILLFORMED) && ELEM(0).iElemChild && ! ELEM(ELEM(0).iElemChild).iElemNext ) return true; return false; } MCD_STR CMarkup::GetError() const { // For backwards compatibility, return a readable English string built from m_strResult // In release 11.0 you can use GetResult and examine result in XML format CMarkup mResult( m_strResult ); MCD_STR strError; int nSyntaxErrors = 0; while ( mResult.FindElem() ) { MCD_STR strItem; MCD_STR strID = mResult.GetTagName(); // Parse result if ( strID == MCD_T("root_has_sibling") ) strItem = MCD_T("root element has sibling"); else if ( strID == MCD_T("no_root_element") ) strItem = MCD_T("no root element"); else if ( strID == MCD_T("lone_end_tag") ) strItem = MCD_T("lone end tag '") + mResult.GetAttrib(MCD_T("tagname")) + MCD_T("' at offset ") + mResult.GetAttrib(MCD_T("offset")); else if ( strID == MCD_T("unended_start_tag") ) strItem = MCD_T("start tag '") + mResult.GetAttrib(MCD_T("tagname")) + MCD_T("' at offset ") + mResult.GetAttrib(MCD_T("offset")) + MCD_T(" expecting end tag at offset ") + mResult.GetAttrib(MCD_T("offset2")); else if ( strID == MCD_T("first_tag_syntax") ) strItem = MCD_T("tag syntax error at offset ") + mResult.GetAttrib(MCD_T("offset")) + MCD_T(" expecting tag name / ! or ?"); else if ( strID == MCD_T("exclamation_tag_syntax") ) strItem = MCD_T("tag syntax error at offset ") + mResult.GetAttrib(MCD_T("offset")) + MCD_T(" expecting 'DOCTYPE' [ or -"); else if ( strID == MCD_T("doctype_tag_syntax") ) strItem = MCD_T("tag syntax error at offset ") + mResult.GetAttrib(MCD_T("offset")) + MCD_T(" expecting markup declaration"); // ELEMENT ATTLIST ENTITY NOTATION else if ( strID == MCD_T("comment_tag_syntax") ) strItem = MCD_T("tag syntax error at offset ") + mResult.GetAttrib(MCD_T("offset")) + MCD_T(" expecting - to begin comment"); else if ( strID == MCD_T("cdata_section_syntax") ) strItem = MCD_T("tag syntax error at offset ") + mResult.GetAttrib(MCD_T("offset")) + MCD_T(" expecting 'CDATA'"); else if ( strID == MCD_T("unterminated_tag_syntax") ) strItem = MCD_T("unterminated tag at offset ") + mResult.GetAttrib(MCD_T("offset")); // Report only the first syntax or well-formedness error if ( ! MCD_STRISEMPTY(strItem) ) { ++nSyntaxErrors; if ( nSyntaxErrors > 1 ) continue; } // I/O results if ( strID == MCD_T("file_error") ) strItem = mResult.GetAttrib(MCD_T("msg")); else if ( strID == MCD_T("bom") ) strItem = MCD_T("BOM +"); else if ( strID == MCD_T("read") || strID == MCD_T("write") || strID == MCD_T("converted_to") || strID == MCD_T("converted_from") ) { if ( strID == MCD_T("converted_to") ) strItem = MCD_T("to "); MCD_STR strEncoding = mResult.GetAttrib( MCD_T("encoding") ); if ( ! MCD_STRISEMPTY(strEncoding) ) strItem += strEncoding + MCD_T(" "); strItem += MCD_T("length ") + mResult.GetAttrib(MCD_T("length")); if ( strID == MCD_T("converted_from") ) strItem += MCD_T(" to"); } else if ( strID == MCD_T("nulls_removed") ) strItem = MCD_T("removed ") + mResult.GetAttrib(MCD_T("count")) + MCD_T(" nulls"); else if ( strID == MCD_T("conversion_loss") ) strItem = MCD_T("(chars lost in conversion!)"); else if ( strID == MCD_T("utf8_detection") ) strItem = MCD_T("(used UTF-8 detection)"); else if ( strID == MCD_T("endian_swap") ) strItem = MCD_T("endian swap"); else if ( strID == MCD_T("truncation_error") ) strItem = MCD_T("encoding ") + mResult.GetAttrib(MCD_T("encoding")) + MCD_T(" adjustment error"); // Concatenate result item to error string if ( ! MCD_STRISEMPTY(strItem) ) { if ( ! MCD_STRISEMPTY(strError) ) strError += MCD_T(" "); strError += strItem; } } return strError; } bool CMarkup::Load( MCD_CSTR_FILENAME szFileName ) { if ( m_nDocFlags & (MDF_READFILE|MDF_WRITEFILE) ) return false; if ( ! ReadTextFile(szFileName, m_strDoc, &m_strResult, &m_nDocFlags) ) return false; return x_ParseDoc(); } bool CMarkup::ReadTextFile( MCD_CSTR_FILENAME szFileName, MCD_STR& strDoc, MCD_STR* pstrResult, int* pnDocFlags, MCD_STR* pstrEncoding ) { // Static utility method to load text file into strDoc // FilePos file; file.m_nDocFlags = (pnDocFlags?*pnDocFlags:0) | MDF_READFILE; bool bSuccess = file.FileOpen( szFileName ); if ( pstrResult ) *pstrResult = file.m_strIOResult; MCD_STRCLEAR(strDoc); if ( bSuccess ) { file.FileSpecifyEncoding( pstrEncoding ); file.m_nOpFileByteLen = (int)((MCD_INTFILEOFFSET)(file.m_nFileByteLen - file.m_nFileByteOffset)); bSuccess = file.FileReadText( strDoc ); file.FileClose(); if ( pstrResult ) *pstrResult += file.m_strIOResult; if ( pnDocFlags ) *pnDocFlags = file.m_nDocFlags; } return bSuccess; } bool CMarkup::Save( MCD_CSTR_FILENAME szFileName ) { if ( m_nDocFlags & (MDF_READFILE|MDF_WRITEFILE) ) return false; return WriteTextFile( szFileName, m_strDoc, &m_strResult, &m_nDocFlags ); } bool CMarkup::WriteTextFile( MCD_CSTR_FILENAME szFileName, const MCD_STR& strDoc, MCD_STR* pstrResult, int* pnDocFlags, MCD_STR* pstrEncoding ) { // Static utility method to save strDoc to text file // FilePos file; file.m_nDocFlags = (pnDocFlags?*pnDocFlags:0) | MDF_WRITEFILE; bool bSuccess = file.FileOpen( szFileName ); if ( pstrResult ) *pstrResult = file.m_strIOResult; if ( bSuccess ) { if ( MCD_STRISEMPTY(file.m_strEncoding) && ! MCD_STRISEMPTY(strDoc) ) { file.m_strEncoding = GetDeclaredEncoding( strDoc ); if ( MCD_STRISEMPTY(file.m_strEncoding) ) file.m_strEncoding = MCD_T("UTF-8"); // to do: MDF_ANSIFILE } file.FileSpecifyEncoding( pstrEncoding ); bSuccess = file.FileWriteText( strDoc ); file.FileClose(); if ( pstrResult ) *pstrResult += file.m_strIOResult; if ( pnDocFlags ) *pnDocFlags = file.m_nDocFlags; } return bSuccess; } bool CMarkup::FindElem( MCD_CSTR szName ) { if ( m_nDocFlags & MDF_WRITEFILE ) return false; if ( m_pElemPosTree->GetSize() ) { // Change current position only if found PathPos path( szName, false ); int iPos = x_FindElem( m_iPosParent, m_iPos, path ); if ( iPos ) { // Assign new position x_SetPos( ELEM(iPos).iElemParent, iPos, 0 ); return true; } } return false; } bool CMarkup::FindChildElem( MCD_CSTR szName ) { if ( m_nDocFlags & (MDF_READFILE|MDF_WRITEFILE) ) return false; // Shorthand: if no current main position, find first child under parent element if ( ! m_iPos ) FindElem(); // Change current child position only if found PathPos path( szName, false ); int iPosChild = x_FindElem( m_iPos, m_iPosChild, path ); if ( iPosChild ) { // Assign new position int iPos = ELEM(iPosChild).iElemParent; x_SetPos( ELEM(iPos).iElemParent, iPos, iPosChild ); return true; } return false; } MCD_STR CMarkup::EscapeText( MCD_CSTR szText, int nFlags ) { // Convert text as seen outside XML document to XML friendly // replacing special characters with ampersand escape codes // E.g. convert "6>7" to "6>7" // // < less than // & ampersand // > greater than // // and for attributes: // // ' apostrophe or single quote // " double quote // static MCD_PCSZ apReplace[] = { NULL,MCD_T("<"),MCD_T("&"),MCD_T(">"),MCD_T("""),MCD_T("'") }; MCD_STR strText; MCD_PCSZ pSource = szText; int nDestSize = MCD_PSZLEN(pSource); nDestSize += nDestSize / 10 + 7; MCD_BLDRESERVE(strText,nDestSize); MCD_CHAR cSource = *pSource; int nFound; int nCharLen; while ( cSource ) { MCD_BLDCHECK(strText,nDestSize,6); nFound = ((nFlags&MNF_ESCAPEQUOTES)?x_ISATTRIBSPECIAL(cSource):x_ISSPECIAL(cSource)); if ( nFound ) { bool bIgnoreAmpersand = false; if ( (nFlags&MNF_WITHREFS) && cSource == '&' ) { // Do not replace ampersand if it is start of any entity reference // &[#_:A-Za-zU][_:-.A-Za-z0-9U]*; where U is > 0x7f MCD_PCSZ pCheckEntity = pSource; ++pCheckEntity; MCD_CHAR c = *pCheckEntity; if ( x_ISSTARTENTREF(c) || ((unsigned int)c)>0x7f ) { while ( 1 ) { pCheckEntity += MCD_CLEN( pCheckEntity ); c = *pCheckEntity; if ( c == ';' ) { int nEntityLen = (int)(pCheckEntity - pSource) + 1; MCD_BLDAPPENDN(strText,pSource,nEntityLen); pSource = pCheckEntity; bIgnoreAmpersand = true; } else if ( x_ISINENTREF(c) || ((unsigned int)c)>0x7f ) continue; break; } } } if ( ! bIgnoreAmpersand ) { MCD_BLDAPPEND(strText,apReplace[nFound]); } ++pSource; // ASCII, so 1 byte } else { nCharLen = MCD_CLEN( pSource ); MCD_BLDAPPENDN(strText,pSource,nCharLen); pSource += nCharLen; } cSource = *pSource; } MCD_BLDRELEASE(strText); return strText; } // Predefined character entities // By default UnescapeText will decode standard HTML entities as well as the 5 in XML // To unescape only the 5 standard XML entities, use this short table instead: // MCD_PCSZ PredefEntityTable[4] = // { MCD_T("20060lt"),MCD_T("40034quot"),MCD_T("30038amp"),MCD_T("20062gt40039apos") }; // // This is a precompiled ASCII hash table for speed and minimum memory requirement // Each entry consists of a 1 digit code name length, 4 digit code point, and the code name // Each table slot can have multiple entries, table size 130 was chosen for even distribution // MCD_PCSZ PredefEntityTable[130] = { MCD_T("60216oslash60217ugrave60248oslash60249ugrave"), MCD_T("50937omega60221yacute58968lceil50969omega60253yacute"), MCD_T("50916delta50206icirc50948delta50238icirc68472weierp"),MCD_T("40185sup1"), MCD_T("68970lfloor40178sup2"), MCD_T("50922kappa60164curren50954kappa58212mdash40179sup3"), MCD_T("59830diams58211ndash"),MCD_T("68855otimes58969rceil"), MCD_T("50338oelig50212ocirc50244ocirc50339oelig58482trade"), MCD_T("50197aring50931sigma50229aring50963sigma"), MCD_T("50180acute68971rfloor50732tilde"),MCD_T("68249lsaquo"), MCD_T("58734infin68201thinsp"),MCD_T("50161iexcl"), MCD_T("50920theta50219ucirc50952theta50251ucirc"),MCD_T("58254oline"), MCD_T("58260frasl68727lowast"),MCD_T("59827clubs60191iquest68250rsaquo"), MCD_T("58629crarr50181micro"),MCD_T("58222bdquo"),MCD_T(""), MCD_T("58243prime60177plusmn58242prime"),MCD_T("40914beta40946beta"),MCD_T(""), MCD_T(""),MCD_T(""),MCD_T("50171laquo50215times"),MCD_T("40710circ"), MCD_T("49001lang"),MCD_T("58220ldquo40175macr"), MCD_T("40182para50163pound48476real"),MCD_T(""),MCD_T("58713notin50187raquo"), MCD_T("48773cong50223szlig50978upsih"), MCD_T("58776asymp58801equiv49002rang58218sbquo"), MCD_T("50222thorn48659darr48595darr40402fnof58221rdquo50254thorn"), MCD_T("40162cent58722minus"),MCD_T("58707exist40170ordf"),MCD_T(""), MCD_T("40921iota58709empty48660harr48596harr40953iota"),MCD_T(""), MCD_T("40196auml40228auml48226bull40167sect48838sube"),MCD_T(""), MCD_T("48656larr48592larr58853oplus"),MCD_T("30176deg58216lsquo40186ordm"), MCD_T("40203euml40039apos40235euml48712isin40160nbsp"), MCD_T("40918zeta40950zeta"),MCD_T("38743and48195emsp48719prod"), MCD_T("30935chi38745cap30967chi48194ensp"), MCD_T("40207iuml40239iuml48706part48869perp48658rarr48594rarr"), MCD_T("38736ang48836nsub58217rsquo"),MCD_T(""), MCD_T("48901sdot48657uarr48593uarr"),MCD_T("40169copy48364euro"), MCD_T("30919eta30951eta"),MCD_T("40214ouml40246ouml48839supe"),MCD_T(""), MCD_T(""),MCD_T("30038amp30174reg"),MCD_T("48733prop"),MCD_T(""), MCD_T("30208eth30934phi40220uuml30240eth30966phi40252uuml"),MCD_T(""),MCD_T(""), MCD_T(""),MCD_T("40376yuml40255yuml"),MCD_T(""),MCD_T("40034quot48204zwnj"), MCD_T("38746cup68756there4"),MCD_T("30929rho30961rho38764sim"), MCD_T("30932tau38834sub30964tau"),MCD_T("38747int38206lrm38207rlm"), MCD_T("30936psi30968psi30165yen"),MCD_T(""),MCD_T("28805ge30168uml"), MCD_T("30982piv"),MCD_T(""),MCD_T("30172not"),MCD_T(""),MCD_T("28804le"), MCD_T("30173shy"),MCD_T("39674loz28800ne38721sum"),MCD_T(""),MCD_T(""), MCD_T("38835sup"),MCD_T("28715ni"),MCD_T(""),MCD_T("20928pi20960pi38205zwj"), MCD_T(""),MCD_T("60923lambda20062gt60955lambda"),MCD_T(""),MCD_T(""), MCD_T("60199ccedil60231ccedil"),MCD_T(""),MCD_T("20060lt"), MCD_T("20926xi28744or20958xi"),MCD_T("20924mu20956mu"),MCD_T("20925nu20957nu"), MCD_T("68225dagger68224dagger"),MCD_T("80977thetasym"),MCD_T(""),MCD_T(""), MCD_T(""),MCD_T("78501alefsym"),MCD_T(""),MCD_T(""),MCD_T(""), MCD_T("60193aacute60195atilde60225aacute60227atilde"),MCD_T(""), MCD_T("70927omicron60247divide70959omicron"),MCD_T("60192agrave60224agrave"), MCD_T("60201eacute60233eacute60962sigmaf"),MCD_T("70917epsilon70949epsilon"), MCD_T(""),MCD_T("60200egrave60232egrave"),MCD_T("60205iacute60237iacute"), MCD_T(""),MCD_T(""),MCD_T("60204igrave68230hellip60236igrave"), MCD_T("60166brvbar"), MCD_T("60209ntilde68704forall58711nabla60241ntilde69824spades"), MCD_T("60211oacute60213otilde60189frac1260183middot60243oacute60245otilde"), MCD_T(""),MCD_T("50184cedil60188frac14"), MCD_T("50198aelig50194acirc60210ograve50226acirc50230aelig60242ograve"), MCD_T("50915gamma60190frac3450947gamma58465image58730radic"), MCD_T("60352scaron60353scaron"),MCD_T("60218uacute69829hearts60250uacute"), MCD_T("50913alpha50202ecirc70933upsilon50945alpha50234ecirc70965upsilon"), MCD_T("68240permil") }; MCD_STR CMarkup::UnescapeText( MCD_CSTR szText, int nTextLength /*=-1*/, int nFlags /*=0*/ ) { // Convert XML friendly text to text as seen outside XML document // ampersand escape codes replaced with special characters e.g. convert "6>7" to "6>7" // ampersand numeric codes replaced with character e.g. convert < to < // Conveniently the result is always the same or shorter in byte length // MCD_STR strText; MCD_PCSZ pSource = szText; if ( nTextLength == -1 ) nTextLength = MCD_PSZLEN(szText); MCD_BLDRESERVE(strText,nTextLength); MCD_CHAR szCodeName[10]; bool bAlterWhitespace = (nFlags & (MDF_TRIMWHITESPACE|MDF_COLLAPSEWHITESPACE))?true:false; bool bCollapseWhitespace = (nFlags & MDF_COLLAPSEWHITESPACE)?true:false; int nCharWhitespace = -1; // start of string int nCharLen; int nChar = 0; while ( nChar < nTextLength ) { if ( pSource[nChar] == '&' ) { if ( bAlterWhitespace ) nCharWhitespace = 0; // Get corresponding unicode code point int nUnicode = 0; // Look for terminating semi-colon within 9 ASCII characters int nCodeLen = 0; MCD_CHAR cCodeChar = pSource[nChar+1]; while ( nCodeLen < 9 && ((unsigned int)cCodeChar) < 128 && cCodeChar != ';' ) { if ( cCodeChar >= 'A' && cCodeChar <= 'Z') // upper case? cCodeChar += ('a' - 'A'); // make lower case szCodeName[nCodeLen] = cCodeChar; ++nCodeLen; cCodeChar = pSource[nChar+1+nCodeLen]; } if ( cCodeChar == ';' ) // found semi-colon? { // Decode szCodeName szCodeName[nCodeLen] = '\0'; if ( *szCodeName == '#' ) // numeric character reference? { // Is it a hex number? int nBase = 10; // decimal int nNumberOffset = 1; // after # if ( szCodeName[1] == 'x' ) { nNumberOffset = 2; // after #x nBase = 16; // hex } nUnicode = MCD_PSZTOL( &szCodeName[nNumberOffset], NULL, nBase ); } else // does not start with # { // Look for matching code name in PredefEntityTable MCD_PCSZ pEntry = PredefEntityTable[x_Hash(szCodeName,sizeof(PredefEntityTable)/sizeof(MCD_PCSZ))]; while ( *pEntry ) { // e.g. entry: 40039apos means length 4, code point 0039, code name apos int nEntryLen = (*pEntry - '0'); ++pEntry; MCD_PCSZ pCodePoint = pEntry; pEntry += 4; if ( nEntryLen == nCodeLen && x_StrNCmp(szCodeName,pEntry,nEntryLen) == 0 ) { // Convert digits to integer up to code name which always starts with alpha nUnicode = MCD_PSZTOL( pCodePoint, NULL, 10 ); break; } pEntry += nEntryLen; } } } // If a code point found, encode it into text if ( nUnicode ) { MCD_CHAR szChar[5]; nCharLen = 0; #if defined(MARKUP_WCHAR) // WCHAR #if MARKUP_SIZEOFWCHAR == 4 // sizeof(wchar_t) == 4 szChar[0] = (MCD_CHAR)nUnicode; nCharLen = 1; #else // sizeof(wchar_t) == 2 EncodeCharUTF16( nUnicode, (unsigned short*)szChar, nCharLen ); #endif #elif defined(MARKUP_MBCS) // MBCS/double byte #if defined(MARKUP_WINCONV) int nUsedDefaultChar = 0; wchar_t wszUTF16[2]; EncodeCharUTF16( nUnicode, (unsigned short*)wszUTF16, nCharLen ); nCharLen = WideCharToMultiByte( CP_ACP, 0, wszUTF16, nCharLen, szChar, 5, NULL, &nUsedDefaultChar ); if ( nUsedDefaultChar || nCharLen <= 0 ) nUnicode = 0; #else // not WINCONV wchar_t wcUnicode = (wchar_t)nUnicode; nCharLen = wctomb( szChar, wcUnicode ); if ( nCharLen <= 0 ) nUnicode = 0; #endif // not WINCONV #else // not WCHAR and not MBCS/double byte EncodeCharUTF8( nUnicode, szChar, nCharLen ); #endif // not WCHAR and not MBCS/double byte // Increment index past ampersand semi-colon if ( nUnicode ) // must check since MBCS case can clear it { MCD_BLDAPPENDN(strText,szChar,nCharLen); nChar += nCodeLen + 2; } } if ( ! nUnicode ) { // If the code is not converted, leave it as is MCD_BLDAPPEND1(strText,'&'); ++nChar; } } else if ( bAlterWhitespace && x_ISWHITESPACE(pSource[nChar]) ) { if ( nCharWhitespace == 0 && bCollapseWhitespace ) { nCharWhitespace = MCD_BLDLEN(strText); MCD_BLDAPPEND1(strText,' '); } else if ( nCharWhitespace != -1 && ! bCollapseWhitespace ) { if ( nCharWhitespace == 0 ) nCharWhitespace = MCD_BLDLEN(strText); MCD_BLDAPPEND1(strText,pSource[nChar]); } ++nChar; } else // not & { if ( bAlterWhitespace ) nCharWhitespace = 0; nCharLen = MCD_CLEN(&pSource[nChar]); MCD_BLDAPPENDN(strText,&pSource[nChar],nCharLen); nChar += nCharLen; } } if ( bAlterWhitespace && nCharWhitespace > 0 ) { MCD_BLDTRUNC(strText,nCharWhitespace); } MCD_BLDRELEASE(strText); return strText; } bool CMarkup::DetectUTF8( const char* pText, int nTextLen, int* pnNonASCII/*=NULL*/, bool* bErrorAtEnd/*=NULL*/ ) { // return true if ASCII or all non-ASCII byte sequences are valid UTF-8 pattern: // ASCII 0xxxxxxx // 2-byte 110xxxxx 10xxxxxx // 3-byte 1110xxxx 10xxxxxx 10xxxxxx // 4-byte 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx // *pnNonASCII is set (if pnNonASCII is not NULL) to the number of non-ASCII UTF-8 sequences // or if an invalid UTF-8 sequence is found, to 1 + the valid non-ASCII sequences up to the invalid sequence // *bErrorAtEnd is set (if bErrorAtEnd is not NULL) to true if the UTF-8 was cut off at the end in mid valid sequence int nUChar; if ( pnNonASCII ) *pnNonASCII = 0; const char* pTextEnd = pText + nTextLen; while ( *pText && pText != pTextEnd ) { if ( (unsigned char)(*pText) & 0x80 ) { if ( pnNonASCII ) ++(*pnNonASCII); nUChar = DecodeCharUTF8( pText, pTextEnd ); if ( nUChar == -1 ) { if ( bErrorAtEnd ) *bErrorAtEnd = (pTextEnd == pText)? true:false; return false; } } else ++pText; } if ( bErrorAtEnd ) *bErrorAtEnd = false; return true; } int CMarkup::DecodeCharUTF8( const char*& pszUTF8, const char* pszUTF8End/*=NULL*/ ) { // Return Unicode code point and increment pszUTF8 past 1-4 bytes // pszUTF8End can be NULL if pszUTF8 is null terminated int nUChar = (unsigned char)*pszUTF8; ++pszUTF8; if ( nUChar & 0x80 ) { int nExtraChars; if ( ! (nUChar & 0x20) ) { nExtraChars = 1; nUChar &= 0x1f; } else if ( ! (nUChar & 0x10) ) { nExtraChars = 2; nUChar &= 0x0f; } else if ( ! (nUChar & 0x08) ) { nExtraChars = 3; nUChar &= 0x07; } else return -1; while ( nExtraChars-- ) { if ( pszUTF8 == pszUTF8End || ! (*pszUTF8 & 0x80) ) return -1; nUChar = nUChar<<6; nUChar |= *pszUTF8 & 0x3f; ++pszUTF8; } } return nUChar; } void CMarkup::EncodeCharUTF16( int nUChar, unsigned short* pwszUTF16, int& nUTF16Len ) { // Write UTF-16 sequence to pwszUTF16 for Unicode code point nUChar and update nUTF16Len // Be sure pwszUTF16 has room for up to 2 wide chars if ( nUChar & ~0xffff ) { if ( pwszUTF16 ) { // Surrogate pair nUChar -= 0x10000; pwszUTF16[nUTF16Len++] = (unsigned short)(((nUChar>>10) & 0x3ff) | 0xd800); // W1 pwszUTF16[nUTF16Len++] = (unsigned short)((nUChar & 0x3ff) | 0xdc00); // W2 } else nUTF16Len += 2; } else { if ( pwszUTF16 ) pwszUTF16[nUTF16Len++] = (unsigned short)nUChar; else ++nUTF16Len; } } int CMarkup::DecodeCharUTF16( const unsigned short*& pwszUTF16, const unsigned short* pszUTF16End/*=NULL*/ ) { // Return Unicode code point and increment pwszUTF16 past 1 or 2 (if surrogrates) UTF-16 code points // pszUTF16End can be NULL if pszUTF16 is zero terminated int nUChar = *pwszUTF16; ++pwszUTF16; if ( (nUChar & ~0x000007ff) == 0xd800 ) // W1 { if ( pwszUTF16 == pszUTF16End || ! (*pwszUTF16) ) // W2 return -1; // incorrect UTF-16 nUChar = (((nUChar & 0x3ff) << 10) | (*pwszUTF16 & 0x3ff)) + 0x10000; ++pwszUTF16; } return nUChar; } void CMarkup::EncodeCharUTF8( int nUChar, char* pszUTF8, int& nUTF8Len ) { // Write UTF-8 sequence to pszUTF8 for Unicode code point nUChar and update nUTF8Len // Be sure pszUTF8 has room for up to 4 bytes if ( ! (nUChar & ~0x0000007f) ) // < 0x80 { if ( pszUTF8 ) pszUTF8[nUTF8Len++] = (char)nUChar; else ++nUTF8Len; } else if ( ! (nUChar & ~0x000007ff) ) // < 0x800 { if ( pszUTF8 ) { pszUTF8[nUTF8Len++] = (char)(((nUChar&0x7c0)>>6)|0xc0); pszUTF8[nUTF8Len++] = (char)((nUChar&0x3f)|0x80); } else nUTF8Len += 2; } else if ( ! (nUChar & ~0x0000ffff) ) // < 0x10000 { if ( pszUTF8 ) { pszUTF8[nUTF8Len++] = (char)(((nUChar&0xf000)>>12)|0xe0); pszUTF8[nUTF8Len++] = (char)(((nUChar&0xfc0)>>6)|0x80); pszUTF8[nUTF8Len++] = (char)((nUChar&0x3f)|0x80); } else nUTF8Len += 3; } else // < 0x110000 { if ( pszUTF8 ) { pszUTF8[nUTF8Len++] = (char)(((nUChar&0x1c0000)>>18)|0xf0); pszUTF8[nUTF8Len++] = (char)(((nUChar&0x3f000)>>12)|0x80); pszUTF8[nUTF8Len++] = (char)(((nUChar&0xfc0)>>6)|0x80); pszUTF8[nUTF8Len++] = (char)((nUChar&0x3f)|0x80); } else nUTF8Len += 4; } } int CMarkup::UTF16To8( char* pszUTF8, const unsigned short* pwszUTF16, int nUTF8Count ) { // Supports the same arguments as wcstombs // the pwszUTF16 source must be a NULL-terminated UTF-16 string // if pszUTF8 is NULL, the number of bytes required is returned and nUTF8Count is ignored // otherwise pszUTF8 is filled with the result string and NULL-terminated if nUTF8Count allows // nUTF8Count is the byte size of pszUTF8 and must be large enough for the NULL if NULL desired // and the number of bytes (excluding NULL) is returned // int nUChar, nUTF8Len = 0; while ( *pwszUTF16 ) { // Decode UTF-16 nUChar = DecodeCharUTF16( pwszUTF16, NULL ); if ( nUChar == -1 ) nUChar = '?'; // Encode UTF-8 if ( pszUTF8 && nUTF8Len + 4 > nUTF8Count ) { int nUTF8LenSoFar = nUTF8Len; EncodeCharUTF8( nUChar, NULL, nUTF8Len ); if ( nUTF8Len > nUTF8Count ) return nUTF8LenSoFar; nUTF8Len = nUTF8LenSoFar; } EncodeCharUTF8( nUChar, pszUTF8, nUTF8Len ); } if ( pszUTF8 && nUTF8Len < nUTF8Count ) pszUTF8[nUTF8Len] = 0; return nUTF8Len; } int CMarkup::UTF8To16( unsigned short* pwszUTF16, const char* pszUTF8, int nUTF8Count ) { // Supports the same arguments as mbstowcs // the pszUTF8 source must be a UTF-8 string which will be processed up to NULL-terminator or nUTF8Count // if pwszUTF16 is NULL, the number of UTF-16 chars required is returned // nUTF8Count is maximum UTF-8 bytes to convert and should include NULL if NULL desired in result // if pwszUTF16 is not NULL it is filled with the result string and it must be large enough // result will be NULL-terminated if NULL encountered in pszUTF8 before nUTF8Count // and the number of UTF-8 bytes converted is returned // const char* pszPosUTF8 = pszUTF8; const char* pszUTF8End = pszUTF8 + nUTF8Count; int nUChar, nUTF8Len = 0, nUTF16Len = 0; while ( pszPosUTF8 != pszUTF8End ) { nUChar = DecodeCharUTF8( pszPosUTF8, pszUTF8End ); if ( ! nUChar ) { if ( pwszUTF16 ) pwszUTF16[nUTF16Len] = 0; break; } else if ( nUChar == -1 ) nUChar = '?'; // Encode UTF-16 EncodeCharUTF16( nUChar, pwszUTF16, nUTF16Len ); } nUTF8Len = (int)(pszPosUTF8 - pszUTF8); if ( ! pwszUTF16 ) return nUTF16Len; return nUTF8Len; } #if ! defined(MARKUP_WCHAR) // not WCHAR MCD_STR CMarkup::UTF8ToA( MCD_CSTR pszUTF8, int* pnFailed/*=NULL*/ ) { // Converts from UTF-8 to locale ANSI charset MCD_STR strANSI; int nMBLen = (int)MCD_PSZLEN( pszUTF8 ); if ( pnFailed ) *pnFailed = 0; if ( nMBLen ) { TextEncoding textencoding( MCD_T("UTF-8"), (const void*)pszUTF8, nMBLen ); textencoding.m_nToCount = nMBLen; MCD_CHAR* pANSIBuffer = MCD_GETBUFFER(strANSI,textencoding.m_nToCount); nMBLen = textencoding.PerformConversion( (void*)pANSIBuffer ); MCD_RELEASEBUFFER(strANSI,pANSIBuffer,nMBLen); if ( pnFailed ) *pnFailed = textencoding.m_nFailedChars; } return strANSI; } MCD_STR CMarkup::AToUTF8( MCD_CSTR pszANSI ) { // Converts locale ANSI charset to UTF-8 MCD_STR strUTF8; int nMBLen = (int)MCD_PSZLEN( pszANSI ); if ( nMBLen ) { TextEncoding textencoding( MCD_T(""), (const void*)pszANSI, nMBLen ); textencoding.m_nToCount = nMBLen * 4; MCD_CHAR* pUTF8Buffer = MCD_GETBUFFER(strUTF8,textencoding.m_nToCount); nMBLen = textencoding.PerformConversion( (void*)pUTF8Buffer, MCD_T("UTF-8") ); MCD_RELEASEBUFFER(strUTF8,pUTF8Buffer,nMBLen); } return strUTF8; } #endif // not WCHAR MCD_STR CMarkup::GetDeclaredEncoding( MCD_CSTR szDoc ) { // Extract encoding attribute from XML Declaration, or HTML meta charset MCD_STR strEncoding; TokenPos token( szDoc, MDF_IGNORECASE ); NodePos node; bool bHtml = false; int nTypeFound = 0; while ( nTypeFound >= 0 ) { nTypeFound = token.ParseNode( node ); int nNext = token.m_nNext; if ( nTypeFound == MNT_PROCESSING_INSTRUCTION && node.nStart == 0 ) { token.m_nNext = node.nStart + 2; // after if ( token.FindAttrib(MCD_T("encoding")) ) strEncoding = token.GetTokenText(); break; } } else if ( nTypeFound == 0 ) // end tag { // Check for end of HTML head token.m_nNext = node.nStart + 2; // after int nAttribOffset = node.nStart + 1; token.m_nNext = nAttribOffset; if ( token.FindAttrib(MCD_T("http-equiv")) && token.Match(MCD_T("Content-Type")) ) { token.m_nNext = nAttribOffset; if ( token.FindAttrib(MCD_T("content")) ) { int nContentEndOffset = token.m_nNext; token.m_nNext = token.m_nL; while ( token.m_nNext < nContentEndOffset && token.FindName() ) { if ( token.Match(MCD_T("charset")) && token.FindName() && token.Match(MCD_T("=")) ) { token.FindName(); strEncoding = token.GetTokenText(); break; } } } break; } } } token.m_nNext = nNext; } return strEncoding; } int CMarkup::GetEncodingCodePage( MCD_CSTR pszEncoding ) { return x_GetEncodingCodePage( pszEncoding ); } int CMarkup::FindNode( int nType ) { // Change current node position only if a node is found // If nType is 0 find any node, otherwise find node of type nType // Return type of node or 0 if not found // Determine where in document to start scanning for node int nNodeOffset = m_nNodeOffset; if ( m_nNodeType > MNT_ELEMENT ) { // By-pass current node nNodeOffset += m_nNodeLength; } else // element or no current main position { // Set position to begin looking for node if ( m_iPos ) { // After element nNodeOffset = ELEM(m_iPos).StartAfter(); } else if ( m_iPosParent ) { // Immediately after start tag of parent if ( ELEM(m_iPosParent).IsEmptyElement() ) return 0; else nNodeOffset = ELEM(m_iPosParent).StartContent(); } } // Get nodes until we find what we're looking for int nTypeFound = 0; int iPosNew = m_iPos; TokenPos token( m_strDoc, m_nDocFlags ); NodePos node; token.m_nNext = nNodeOffset; do { nNodeOffset = token.m_nNext; nTypeFound = token.ParseNode( node ); if ( nTypeFound == 0 ) { // Check if we have reached the end of the parent element if ( m_iPosParent && nNodeOffset == ELEM(m_iPosParent).StartContent() + ELEM(m_iPosParent).ContentLen() ) return 0; nTypeFound = MNT_LONE_END_TAG; // otherwise it is a lone end tag } else if ( nTypeFound < 0 ) { if ( nTypeFound == -2 ) // end of document return 0; // -1 is node error nTypeFound = MNT_NODE_ERROR; } else if ( nTypeFound == MNT_ELEMENT ) { if ( iPosNew ) iPosNew = ELEM(iPosNew).iElemNext; else iPosNew = ELEM(m_iPosParent).iElemChild; if ( ! iPosNew ) return 0; if ( ! nType || (nType & nTypeFound) ) { // Found element node, move position to this element x_SetPos( m_iPosParent, iPosNew, 0 ); return m_nNodeType; } token.m_nNext = ELEM(iPosNew).StartAfter(); } } while ( nType && ! (nType & nTypeFound) ); m_iPos = iPosNew; m_iPosChild = 0; m_nNodeOffset = node.nStart; m_nNodeLength = node.nLength; m_nNodeType = nTypeFound; MARKUP_SETDEBUGSTATE; return m_nNodeType; } bool CMarkup::RemoveNode() { if ( m_nDocFlags & (MDF_READFILE|MDF_WRITEFILE) ) return false; if ( m_iPos || m_nNodeLength ) { x_RemoveNode( m_iPosParent, m_iPos, m_nNodeType, m_nNodeOffset, m_nNodeLength ); m_iPosChild = 0; MARKUP_SETDEBUGSTATE; return true; } return false; } MCD_STR CMarkup::GetTagName() const { // Return the tag name at the current main position MCD_STR strTagName; // This method is primarily for elements, however // it does return something for certain other nodes if ( m_nNodeLength ) { switch ( m_nNodeType ) { case MNT_PROCESSING_INSTRUCTION: case MNT_LONE_END_TAG: { // GetMap( pMap, nMap ); SavedPos savedpos; if ( szPosName ) savedpos.strName = szPosName; if ( m_iPosChild ) { savedpos.iPos = m_iPosChild; savedpos.nSavedPosFlags |= SavedPos::SPM_CHILD; } else if ( m_iPos ) { savedpos.iPos = m_iPos; savedpos.nSavedPosFlags |= SavedPos::SPM_MAIN; } else { savedpos.iPos = m_iPosParent; } savedpos.nSavedPosFlags |= SavedPos::SPM_USED; int nSlot = x_Hash( szPosName, pMap->nMapSize); SavedPos* pSavedPos = pMap->pTable[nSlot]; int nOffset = 0; if ( ! pSavedPos ) { pSavedPos = new SavedPos[2]; pSavedPos[1].nSavedPosFlags = SavedPos::SPM_LAST; pMap->pTable[nSlot] = pSavedPos; } else { while ( pSavedPos[nOffset].nSavedPosFlags & SavedPos::SPM_USED ) { if ( pSavedPos[nOffset].strName == (MCD_PCSZ)szPosName ) break; if ( pSavedPos[nOffset].nSavedPosFlags & SavedPos::SPM_LAST ) { int nNewSize = (nOffset + 6) * 2; SavedPos* pNewSavedPos = new SavedPos[nNewSize]; for ( int nCopy=0; nCopy<=nOffset; ++nCopy ) pNewSavedPos[nCopy] = pSavedPos[nCopy]; pNewSavedPos[nOffset].nSavedPosFlags ^= SavedPos::SPM_LAST; pNewSavedPos[nNewSize-1].nSavedPosFlags = SavedPos::SPM_LAST; delete [] pSavedPos; pSavedPos = pNewSavedPos; pMap->pTable[nSlot] = pSavedPos; ++nOffset; break; } ++nOffset; } } if ( pSavedPos[nOffset].nSavedPosFlags & SavedPos::SPM_LAST ) savedpos.nSavedPosFlags |= SavedPos::SPM_LAST; pSavedPos[nOffset] = savedpos; /* // To review hash table balance, uncomment and watch strBalance MCD_STR strBalance, strSlot; for ( nSlot=0; nSlot < pMap->nMapSize; ++nSlot ) { pSavedPos = pMap->pTable[nSlot]; int nCount = 0; while ( pSavedPos && pSavedPos->nSavedPosFlags & SavedPos::SPM_USED ) { ++nCount; if ( pSavedPos->nSavedPosFlags & SavedPos::SPM_LAST ) break; ++pSavedPos; } strSlot.Format( MCD_T("%d "), nCount ); strBalance += strSlot; } */ return true; } return false; } bool CMarkup::RestorePos( MCD_CSTR szPosName /*=""*/, int nMap /*=0*/ ) { if ( m_nDocFlags & (MDF_READFILE|MDF_WRITEFILE) ) return false; // Restore element position if found in saved position map if ( szPosName ) { SavedPosMap* pMap; m_pSavedPosMaps->GetMap( pMap, nMap ); int nSlot = x_Hash( szPosName, pMap->nMapSize ); SavedPos* pSavedPos = pMap->pTable[nSlot]; if ( pSavedPos ) { int nOffset = 0; while ( pSavedPos[nOffset].nSavedPosFlags & SavedPos::SPM_USED ) { if ( pSavedPos[nOffset].strName == (MCD_PCSZ)szPosName ) { int i = pSavedPos[nOffset].iPos; if ( pSavedPos[nOffset].nSavedPosFlags & SavedPos::SPM_CHILD ) x_SetPos( ELEM(ELEM(i).iElemParent).iElemParent, ELEM(i).iElemParent, i ); else if ( pSavedPos[nOffset].nSavedPosFlags & SavedPos::SPM_MAIN ) x_SetPos( ELEM(i).iElemParent, i, 0 ); else x_SetPos( i, 0, 0 ); return true; } if ( pSavedPos[nOffset].nSavedPosFlags & SavedPos::SPM_LAST ) break; ++nOffset; } } } return false; } bool CMarkup::SetMapSize( int nSize, int nMap /*=0*/ ) { if ( m_nDocFlags & (MDF_READFILE|MDF_WRITEFILE) ) return false; // Set saved position map hash table size before using it // Returns false if map already exists // Some prime numbers: 53, 101, 211, 503, 1009, 2003, 10007, 20011, 50021, 100003, 200003, 500009 SavedPosMap* pNewMap; return m_pSavedPosMaps->GetMap( pNewMap, nMap, nSize ); } bool CMarkup::RemoveElem() { if ( m_nDocFlags & (MDF_READFILE|MDF_WRITEFILE) ) return false; // Remove current main position element if ( m_iPos && m_nNodeType == MNT_ELEMENT ) { int iPos = x_RemoveElem( m_iPos ); x_SetPos( m_iPosParent, iPos, 0 ); return true; } return false; } bool CMarkup::RemoveChildElem() { if ( m_nDocFlags & (MDF_READFILE|MDF_WRITEFILE) ) return false; // Remove current child position element if ( m_iPosChild ) { int iPosChild = x_RemoveElem( m_iPosChild ); x_SetPos( m_iPosParent, m_iPos, iPosChild ); return true; } return false; } ////////////////////////////////////////////////////////////////////// // CMarkup private methods // void CMarkup::x_InitMarkup() { // Only called from CMarkup constructors m_pFilePos = NULL; m_pSavedPosMaps = new SavedPosMapArray; m_pElemPosTree = new ElemPosTree; // To always ignore case, define MARKUP_IGNORECASE #if defined(MARKUP_IGNORECASE) // ignore case m_nDocFlags = MDF_IGNORECASE; #else // not ignore case m_nDocFlags = 0; #endif // not ignore case } int CMarkup::x_GetParent( int i ) { return ELEM(i).iElemParent; } void CMarkup::x_SetPos( int iPosParent, int iPos, int iPosChild ) { m_iPosParent = iPosParent; m_iPos = iPos; m_iPosChild = iPosChild; m_nNodeOffset = 0; m_nNodeLength = 0; m_nNodeType = iPos?MNT_ELEMENT:0; MARKUP_SETDEBUGSTATE; } #if defined(_DEBUG) // DEBUG void CMarkup::x_SetDebugState() { // Set m_pDebugCur and m_pDebugPos to point into document MCD_PCSZ pD = MCD_2PCSZ(m_strDoc); // Node (non-element) position is determined differently in file mode if ( m_nNodeLength || (m_nNodeOffset && !m_pFilePos) || (m_pFilePos && (!m_iPos) && (!m_iPosParent) && ! m_pFilePos->FileAtTop()) ) { if ( ! m_nNodeLength ) m_pDebugCur = MCD_T("main position offset"); // file mode only else m_pDebugCur = MCD_T("main position node"); m_pDebugPos = &pD[m_nNodeOffset]; } else { if ( m_iPosChild ) { m_pDebugCur = MCD_T("child position element"); m_pDebugPos = &pD[ELEM(m_iPosChild).nStart]; } else if ( m_iPos ) { m_pDebugCur = MCD_T("main position element"); m_pDebugPos = &pD[ELEM(m_iPos).nStart]; } else if ( m_iPosParent ) { m_pDebugCur = MCD_T("parent position element"); m_pDebugPos = &pD[ELEM(m_iPosParent).nStart]; } else { m_pDebugCur = MCD_T("top of document"); m_pDebugPos = pD; } } } #endif // DEBUG int CMarkup::x_GetFreePos() { if ( m_iPosFree == m_pElemPosTree->GetSize() ) x_AllocElemPos(); return m_iPosFree++; } bool CMarkup::x_AllocElemPos( int nNewSize /*=0*/ ) { // Resize m_aPos when the document is created or the array is filled if ( ! nNewSize ) nNewSize = m_iPosFree + (m_iPosFree>>1); // Grow By: multiply size by 1.5 if ( m_pElemPosTree->GetSize() < nNewSize ) m_pElemPosTree->GrowElemPosTree( nNewSize ); return true; } bool CMarkup::x_ParseDoc() { // Reset indexes ResetPos(); m_pSavedPosMaps->ReleaseMaps(); // Starting size of position array: 1 element per 64 bytes of document // Tight fit when parsing small doc, only 0 to 2 reallocs when parsing large doc // Start at 8 when creating new document int nDocLen = MCD_STRLENGTH(m_strDoc); m_iPosFree = 1; x_AllocElemPos( nDocLen / 64 + 8 ); m_iPosDeleted = 0; // Parse document ELEM(0).ClearVirtualParent(); if ( nDocLen ) { TokenPos token( m_strDoc, m_nDocFlags ); int iPos = x_ParseElem( 0, token ); ELEM(0).nLength = nDocLen; if ( iPos > 0 ) { ELEM(0).iElemChild = iPos; if ( ELEM(iPos).iElemNext ) x_AddResult( m_strResult, MCD_T("root_has_sibling") ); } else x_AddResult( m_strResult, MCD_T("no_root_element") ); } ResetPos(); return IsWellFormed(); } int CMarkup::x_ParseElem( int iPosParent, TokenPos& token ) { // This is either called by x_ParseDoc or x_AddSubDoc or x_SetElemContent // Returns index of the first element encountered or zero if no elements // int iPosRoot = 0; int iPos = iPosParent; int iVirtualParent = iPosParent; int nRootDepth = ELEM(iPos).Level(); int nMatchLevel; int iPosMatch; int iTag; int nTypeFound; int iPosFirst; int iPosLast; ElemPos* pElem; ElemPos* pElemParent; ElemPos* pElemChild; // Loop through the nodes of the document ElemStack elemstack; NodePos node; token.m_nNext = 0; while ( 1 ) { nTypeFound = token.ParseNode( node ); nMatchLevel = 0; if ( nTypeFound == MNT_ELEMENT ) // start tag { iPos = x_GetFreePos(); if ( ! iPosRoot ) iPosRoot = iPos; pElem = &ELEM(iPos); pElem->iElemParent = iPosParent; pElem->iElemNext = 0; pElemParent = &ELEM(iPosParent); if ( pElemParent->iElemChild ) { iPosFirst = pElemParent->iElemChild; pElemChild = &ELEM(iPosFirst); iPosLast = pElemChild->iElemPrev; ELEM(iPosLast).iElemNext = iPos; pElem->iElemPrev = iPosLast; pElemChild->iElemPrev = iPos; pElem->nFlags = 0; } else { pElemParent->iElemChild = iPos; pElem->iElemPrev = iPos; pElem->nFlags = MNF_FIRST; } pElem->SetLevel( nRootDepth + elemstack.iTop ); pElem->iElemChild = 0; pElem->nStart = node.nStart; pElem->SetStartTagLen( node.nLength ); if ( node.nNodeFlags & MNF_EMPTY ) { iPos = iPosParent; pElem->SetEndTagLen( 0 ); pElem->nLength = node.nLength; } else { iPosParent = iPos; elemstack.PushIntoLevel( token.GetTokenPtr(), token.Length() ); } } else if ( nTypeFound == 0 ) // end tag { iPosMatch = iPos; iTag = elemstack.iTop; nMatchLevel = iTag; while ( nMatchLevel && ! token.Match(elemstack.GetRefTagPosAt(iTag--).strTagName) ) { --nMatchLevel; iPosMatch = ELEM(iPosMatch).iElemParent; } if ( nMatchLevel == 0 ) { // Not matched at all, it is a lone end tag, a non-element node ELEM(iVirtualParent).nFlags |= MNF_ILLFORMED; ELEM(iPos).nFlags |= MNF_ILLDATA; x_AddResult( m_strResult, MCD_T("lone_end_tag"), token.GetTokenText(), 0, node.nStart ); } else { pElem = &ELEM(iPosMatch); pElem->nLength = node.nStart - pElem->nStart + node.nLength; pElem->SetEndTagLen( node.nLength ); } } else if ( nTypeFound == -1 ) { ELEM(iVirtualParent).nFlags |= MNF_ILLFORMED; ELEM(iPos).nFlags |= MNF_ILLDATA; m_strResult += node.strMeta; } // Matched end tag, or end of document if ( nMatchLevel || nTypeFound == -2 ) { if ( elemstack.iTop > nMatchLevel ) ELEM(iVirtualParent).nFlags |= MNF_ILLFORMED; // Process any non-ended elements while ( elemstack.iTop > nMatchLevel ) { // Element with no end tag pElem = &ELEM(iPos); int iPosChild = pElem->iElemChild; iPosParent = pElem->iElemParent; pElem->SetEndTagLen( 0 ); pElem->nFlags |= MNF_NONENDED; pElem->iElemChild = 0; pElem->nLength = pElem->StartTagLen(); if ( pElem->nFlags & MNF_ILLDATA ) { pElem->nFlags ^= MNF_ILLDATA; ELEM(iPosParent).nFlags |= MNF_ILLDATA; } while ( iPosChild ) { ELEM(iPosChild).iElemParent = iPosParent; ELEM(iPosChild).iElemPrev = iPos; ELEM(iPos).iElemNext = iPosChild; iPos = iPosChild; iPosChild = ELEM(iPosChild).iElemNext; } // If end tag did not match, top node is end tag that did not match pElem // if end of document, any nodes below top have no end tag // second offset represents location where end tag was expected but end of document or other end tag was found // end tag that was found is token.GetTokenText() but not reported in error int nOffset2 = (nTypeFound==0)? token.m_nL-1: MCD_STRLENGTH(m_strDoc); x_AddResult( m_strResult, MCD_T("unended_start_tag"), elemstack.Current().strTagName, 0, pElem->nStart, nOffset2 ); iPos = iPosParent; elemstack.PopOutOfLevel(); } if ( nTypeFound == -2 ) break; iPosParent = ELEM(iPos).iElemParent; iPos = iPosParent; elemstack.PopOutOfLevel(); } } return iPosRoot; } int CMarkup::x_FindElem( int iPosParent, int iPos, PathPos& path ) const { // If pPath is NULL or empty, go to next sibling element // Otherwise go to next sibling element with matching path // if ( ! path.ValidPath() ) return 0; // Paths other than simple tag name are only supported in the developer version if ( path.IsAnywherePath() || path.IsAbsolutePath() ) return 0; if ( iPos ) iPos = ELEM(iPos).iElemNext; else iPos = ELEM(iPosParent).iElemChild; // Finished here if pPath not specified if ( ! path.IsPath() ) return iPos; // Search TokenPos token( m_strDoc, m_nDocFlags ); while ( iPos ) { // Compare tag name token.m_nNext = ELEM(iPos).nStart + 1; token.FindName(); // Locate tag name if ( token.Match(path.GetPtr()) ) return iPos; iPos = ELEM(iPos).iElemNext; } return 0; } MCD_STR CMarkup::x_GetPath( int iPos ) const { // In file mode, iPos is an index into m_pFilePos->m_elemstack or zero MCD_STR strPath; while ( iPos ) { MCD_STR strTagName; int iPosParent; int nCount = 0; if ( m_nDocFlags & (MDF_READFILE|MDF_WRITEFILE) ) { TagPos& tag = m_pFilePos->m_elemstack.GetRefTagPosAt(iPos); strTagName = tag.strTagName; nCount = tag.nCount; iPosParent = tag.iParent; } else { strTagName = x_GetTagName( iPos ); PathPos path( MCD_2PCSZ(strTagName), false ); iPosParent = ELEM(iPos).iElemParent; int iPosSib = 0; while ( iPosSib != iPos ) { path.RevertOffset(); iPosSib = x_FindElem( iPosParent, iPosSib, path ); ++nCount; } } if ( nCount == 1 ) strPath = MCD_T("/") + strTagName + strPath; else { MCD_CHAR szPred[25]; MCD_SPRINTF( MCD_SSZ(szPred), MCD_T("[%d]"), nCount ); strPath = MCD_T("/") + strTagName + szPred + strPath; } iPos = iPosParent; } return strPath; } MCD_STR CMarkup::x_GetTagName( int iPos ) const { // Return the tag name at specified element TokenPos token( m_strDoc, m_nDocFlags ); token.m_nNext = ELEM(iPos).nStart + 1; if ( ! iPos || ! token.FindName() ) return MCD_T(""); // Return substring of document return token.GetTokenText(); } MCD_STR CMarkup::x_GetAttrib( int iPos, MCD_PCSZ pAttrib ) const { // Return the value of the attrib TokenPos token( m_strDoc, m_nDocFlags ); if ( iPos && m_nNodeType == MNT_ELEMENT ) token.m_nNext = ELEM(iPos).nStart + 1; else if ( iPos == m_iPos && m_nNodeLength && m_nNodeType == MNT_PROCESSING_INSTRUCTION ) token.m_nNext = m_nNodeOffset + 2; else return MCD_T(""); if ( pAttrib && token.FindAttrib(pAttrib) ) return UnescapeText( token.GetTokenPtr(), token.Length(), m_nDocFlags ); return MCD_T(""); } bool CMarkup::x_SetAttrib( int iPos, MCD_PCSZ pAttrib, int nValue, int nFlags /*=0*/ ) { // Convert integer to string MCD_CHAR szVal[25]; MCD_SPRINTF( MCD_SSZ(szVal), MCD_T("%d"), nValue ); return x_SetAttrib( iPos, pAttrib, szVal, nFlags ); } bool CMarkup::x_SetAttrib( int iPos, MCD_PCSZ pAttrib, MCD_PCSZ pValue, int nFlags /*=0*/ ) { if ( m_nDocFlags & MDF_READFILE ) return false; int nNodeStart = 0; if ( iPos && m_nNodeType == MNT_ELEMENT ) nNodeStart = ELEM(iPos).nStart; else if ( iPos == m_iPos && m_nNodeLength && m_nNodeType == MNT_PROCESSING_INSTRUCTION ) nNodeStart = m_nNodeOffset; else return false; // Create insertion text depending on whether attribute already exists // Decision: for empty value leaving attrib="" instead of removing attrib TokenPos token( m_strDoc, m_nDocFlags ); token.m_nNext = nNodeStart + ((m_nNodeType == MNT_ELEMENT)?1:2); int nReplace = 0; int nInsertAt; MCD_STR strEscapedValue = EscapeText( pValue, MNF_ESCAPEQUOTES|nFlags ); int nEscapedValueLen = MCD_STRLENGTH( strEscapedValue ); MCD_STR strInsert; if ( token.FindAttrib(pAttrib) ) { // Replace value MCD_BLDRESERVE( strInsert, nEscapedValueLen + 2 ); MCD_BLDAPPEND1( strInsert, x_ATTRIBQUOTE ); MCD_BLDAPPENDN( strInsert, MCD_2PCSZ(strEscapedValue), nEscapedValueLen ); MCD_BLDAPPEND1( strInsert, x_ATTRIBQUOTE ); MCD_BLDRELEASE( strInsert ); nInsertAt = token.m_nL - ((token.m_nTokenFlags&MNF_QUOTED)?1:0); nReplace = token.Length() + ((token.m_nTokenFlags&MNF_QUOTED)?2:0); } else { // Insert string name value pair int nAttribNameLen = MCD_PSZLEN( pAttrib ); MCD_BLDRESERVE( strInsert, nAttribNameLen + nEscapedValueLen + 4 ); MCD_BLDAPPEND1( strInsert, ' ' ); MCD_BLDAPPENDN( strInsert, pAttrib, nAttribNameLen ); MCD_BLDAPPEND1( strInsert, '=' ); MCD_BLDAPPEND1( strInsert, x_ATTRIBQUOTE ); MCD_BLDAPPENDN( strInsert, MCD_2PCSZ(strEscapedValue), nEscapedValueLen ); MCD_BLDAPPEND1( strInsert, x_ATTRIBQUOTE ); MCD_BLDRELEASE( strInsert ); nInsertAt = token.m_nNext; } int nAdjust = MCD_STRLENGTH(strInsert) - nReplace; if ( m_nDocFlags & MDF_WRITEFILE ) { int nNewDocLength = MCD_STRLENGTH(m_strDoc) + nAdjust; MCD_STRCLEAR( m_strResult ); if ( nNodeStart && nNewDocLength > m_pFilePos->m_nBlockSizeBasis ) { int nDocCapacity = MCD_STRCAPACITY(m_strDoc); if ( nNewDocLength > nDocCapacity ) { m_pFilePos->FileFlush( *m_pFilePos->m_pstrBuffer, nNodeStart ); m_strResult = m_pFilePos->m_strIOResult; nInsertAt -= nNodeStart; m_nNodeOffset = 0; if ( m_nNodeType == MNT_ELEMENT ) ELEM(iPos).nStart = 0; } } } x_DocChange( nInsertAt, nReplace, strInsert ); if ( m_nNodeType == MNT_PROCESSING_INSTRUCTION ) { x_AdjustForNode( m_iPosParent, m_iPos, nAdjust ); m_nNodeLength += nAdjust; } else { ELEM(iPos).AdjustStartTagLen( nAdjust ); ELEM(iPos).nLength += nAdjust; x_Adjust( iPos, nAdjust ); } MARKUP_SETDEBUGSTATE; return true; } bool CMarkup::x_CreateNode( MCD_STR& strNode, int nNodeType, MCD_PCSZ pText ) { // Set strNode based on nNodeType and szData // Return false if szData would jeopardize well-formed document // switch ( nNodeType ) { case MNT_PROCESSING_INSTRUCTION: strNode = MCD_T(""); break; case MNT_COMMENT: strNode = MCD_T(""); break; case MNT_ELEMENT: strNode = MCD_T("<"); strNode += pText; strNode += MCD_T("/>"); break; case MNT_TEXT: case MNT_WHITESPACE: strNode = EscapeText( pText ); break; case MNT_DOCUMENT_TYPE: strNode = pText; break; case MNT_LONE_END_TAG: strNode = MCD_T(""); break; case MNT_CDATA_SECTION: if ( MCD_PSZSTR(pText,MCD_T("]]>")) != NULL ) return false; strNode = MCD_T(""); break; } return true; } MCD_STR CMarkup::x_EncodeCDATASection( MCD_PCSZ szData ) { // Split CDATA Sections if there are any end delimiters MCD_STR strData = MCD_T("") ); while ( pszEnd ) { strData += MCD_STR( pszNextStart, (int)(pszEnd - pszNextStart) ); strData += MCD_T("]]]]>"); pszNextStart = pszEnd + 3; pszEnd = MCD_PSZSTR( pszNextStart, MCD_T("]]>") ); } strData += pszNextStart; strData += MCD_T("]]>"); return strData; } bool CMarkup::x_SetData( int iPos, int nValue ) { // Convert integer to string MCD_CHAR szVal[25]; MCD_SPRINTF( MCD_SSZ(szVal), MCD_T("%d"), nValue ); return x_SetData( iPos, szVal, 0 ); } bool CMarkup::x_SetData( int iPos, MCD_PCSZ szData, int nFlags ) { if ( m_nDocFlags & MDF_READFILE ) return false; MCD_STR strInsert; if ( m_nDocFlags & MDF_WRITEFILE ) { if ( ! iPos || m_nNodeType != 1 || ! ELEM(iPos).IsEmptyElement() ) return false; // only set data on current empty element (no other kinds of nodes) } if ( iPos == m_iPos && m_nNodeLength ) { // Not an element if ( ! x_CreateNode(strInsert, m_nNodeType, szData) ) return false; x_DocChange( m_nNodeOffset, m_nNodeLength, strInsert ); x_AdjustForNode( m_iPosParent, iPos, MCD_STRLENGTH(strInsert) - m_nNodeLength ); m_nNodeLength = MCD_STRLENGTH(strInsert); MARKUP_SETDEBUGSTATE; return true; } // Set data in iPos element if ( ! iPos || ELEM(iPos).iElemChild ) return false; // Build strInsert from szData based on nFlags if ( nFlags & MNF_WITHCDATA ) strInsert = x_EncodeCDATASection( szData ); else strInsert = EscapeText( szData, nFlags ); // Insert NodePos node( MNF_WITHNOLINES|MNF_REPLACE ); node.strMeta = strInsert; int iPosBefore = 0; int nReplace = x_InsertNew( iPos, iPosBefore, node ); int nAdjust = MCD_STRLENGTH(node.strMeta) - nReplace; x_Adjust( iPos, nAdjust ); ELEM(iPos).nLength += nAdjust; if ( ELEM(iPos).nFlags & MNF_ILLDATA ) ELEM(iPos).nFlags &= ~MNF_ILLDATA; MARKUP_SETDEBUGSTATE; return true; } MCD_STR CMarkup::x_GetData( int iPos ) { if ( iPos == m_iPos && m_nNodeLength ) { if ( m_nNodeType == MNT_COMMENT ) return MCD_STRMID( m_strDoc, m_nNodeOffset+4, m_nNodeLength-7 ); else if ( m_nNodeType == MNT_PROCESSING_INSTRUCTION ) return MCD_STRMID( m_strDoc, m_nNodeOffset+2, m_nNodeLength-4 ); else if ( m_nNodeType == MNT_CDATA_SECTION ) return MCD_STRMID( m_strDoc, m_nNodeOffset+9, m_nNodeLength-12 ); else if ( m_nNodeType == MNT_TEXT ) return UnescapeText( &(MCD_2PCSZ(m_strDoc))[m_nNodeOffset], m_nNodeLength, m_nDocFlags ); else if ( m_nNodeType == MNT_LONE_END_TAG ) return MCD_STRMID( m_strDoc, m_nNodeOffset+2, m_nNodeLength-3 ); return MCD_STRMID( m_strDoc, m_nNodeOffset, m_nNodeLength ); } // Return a string representing data between start and end tag // Return empty string if there are any children elements MCD_STR strData; if ( iPos && ! ELEM(iPos).IsEmptyElement() ) { ElemPos* pElem = &ELEM(iPos); int nStartContent = pElem->StartContent(); if ( pElem->IsUnparsed() ) { TokenPos token( m_strDoc, m_nDocFlags, m_pFilePos ); token.m_nNext = nStartContent; NodePos node; m_pFilePos->m_nReadBufferStart = pElem->nStart; while ( 1 ) { m_pFilePos->m_nReadBufferRemoved = 0; // will be non-zero after ParseNode if read buffer shifted token.ParseNode( node ); if ( m_pFilePos->m_nReadBufferRemoved ) { pElem->nStart = 0; MARKUP_SETDEBUGSTATE; } if ( node.nNodeType == MNT_TEXT ) strData += UnescapeText( &token.m_pDocText[node.nStart], node.nLength, m_nDocFlags ); else if ( node.nNodeType == MNT_CDATA_SECTION ) strData += MCD_STRMID( m_strDoc, node.nStart+9, node.nLength-12 ); else if ( node.nNodeType == MNT_ELEMENT ) { MCD_STRCLEAR(strData); break; } else if ( node.nNodeType == 0 ) { if ( token.Match(m_pFilePos->m_elemstack.Current().strTagName) ) { pElem->SetEndTagLen( node.nLength ); pElem->nLength = node.nStart + node.nLength - pElem->nStart; m_pFilePos->m_elemstack.OutOfLevel(); } else { MCD_STRCLEAR(strData); } break; } } } else if ( ! pElem->iElemChild ) { // Quick scan for any tags inside content int nContentLen = pElem->ContentLen(); MCD_PCSZ pszContent = &(MCD_2PCSZ(m_strDoc))[nStartContent]; MCD_PCSZ pszTag = MCD_PSZCHR( pszContent, '<' ); if ( pszTag && ((int)(pszTag-pszContent) < nContentLen) ) { // Concatenate all CDATA Sections and text nodes, ignore other nodes TokenPos token( m_strDoc, m_nDocFlags ); token.m_nNext = nStartContent; NodePos node; while ( token.m_nNext < nStartContent + nContentLen ) { token.ParseNode( node ); if ( node.nNodeType == MNT_TEXT ) strData += UnescapeText( &token.m_pDocText[node.nStart], node.nLength, m_nDocFlags ); else if ( node.nNodeType == MNT_CDATA_SECTION ) strData += MCD_STRMID( m_strDoc, node.nStart+9, node.nLength-12 ); } } else // no tags strData = UnescapeText( &(MCD_2PCSZ(m_strDoc))[nStartContent], nContentLen, m_nDocFlags ); } } return strData; } MCD_STR CMarkup::x_GetElemContent( int iPos ) const { if ( ! (m_nDocFlags & (MDF_READFILE|MDF_WRITEFILE)) ) { ElemPos* pElem = &ELEM(iPos); if ( iPos && pElem->ContentLen() ) return MCD_STRMID( m_strDoc, pElem->StartContent(), pElem->ContentLen() ); } return MCD_T(""); } bool CMarkup::x_SetElemContent( MCD_PCSZ szContent ) { MCD_STRCLEAR(m_strResult); if ( m_nDocFlags & (MDF_READFILE|MDF_WRITEFILE) ) return false; // Set data in iPos element only if ( ! m_iPos ) return false; if ( m_nNodeLength ) return false; // not an element // Unlink all children int iPos = m_iPos; int iPosChild = ELEM(iPos).iElemChild; bool bHadChild = (iPosChild != 0); while ( iPosChild ) iPosChild = x_ReleaseSubDoc( iPosChild ); if ( bHadChild ) x_CheckSavedPos(); // Parse content bool bWellFormed = true; TokenPos token( szContent, m_nDocFlags ); int iPosVirtual = x_GetFreePos(); ELEM(iPosVirtual).ClearVirtualParent(); ELEM(iPosVirtual).SetLevel( ELEM(iPos).Level() + 1 ); iPosChild = x_ParseElem( iPosVirtual, token ); if ( ELEM(iPosVirtual).nFlags & MNF_ILLFORMED ) bWellFormed = false; ELEM(iPos).nFlags = (ELEM(iPos).nFlags & ~MNF_ILLDATA) | (ELEM(iPosVirtual).nFlags & MNF_ILLDATA); // Prepare insert and adjust offsets NodePos node( MNF_WITHNOLINES|MNF_REPLACE ); node.strMeta = szContent; int iPosBefore = 0; int nReplace = x_InsertNew( iPos, iPosBefore, node ); // Adjust and link in the inserted elements x_Adjust( iPosChild, node.nStart ); ELEM(iPosChild).nStart += node.nStart; ELEM(iPos).iElemChild = iPosChild; while ( iPosChild ) { ELEM(iPosChild).iElemParent = iPos; iPosChild = ELEM(iPosChild).iElemNext; } x_ReleasePos( iPosVirtual ); int nAdjust = MCD_STRLENGTH(node.strMeta) - nReplace; x_Adjust( iPos, nAdjust, true ); ELEM(iPos).nLength += nAdjust; x_SetPos( m_iPosParent, m_iPos, 0 ); return bWellFormed; } void CMarkup::x_DocChange( int nLeft, int nReplace, const MCD_STR& strInsert ) { x_StrInsertReplace( m_strDoc, nLeft, nReplace, strInsert ); } void CMarkup::x_Adjust( int iPos, int nShift, bool bAfterPos /*=false*/ ) { // Loop through affected elements and adjust indexes // Algorithm: // 1. update children unless bAfterPos // (if no children or bAfterPos is true, length of iPos not affected) // 2. update starts of next siblings and their children // 3. go up until there is a next sibling of a parent and update starts // 4. step 2 int iPosTop = ELEM(iPos).iElemParent; bool bPosFirst = bAfterPos; // mark as first to skip its children // Stop when we've reached the virtual parent (which has no tags) while ( ELEM(iPos).StartTagLen() ) { // Were we at containing parent of affected position? bool bPosTop = false; if ( iPos == iPosTop ) { // Move iPosTop up one towards root iPosTop = ELEM(iPos).iElemParent; bPosTop = true; } // Traverse to the next update position if ( ! bPosTop && ! bPosFirst && ELEM(iPos).iElemChild ) { // Depth first iPos = ELEM(iPos).iElemChild; } else if ( ELEM(iPos).iElemNext ) { iPos = ELEM(iPos).iElemNext; } else { // Look for next sibling of a parent of iPos // When going back up, parents have already been done except iPosTop while ( 1 ) { iPos = ELEM(iPos).iElemParent; if ( iPos == iPosTop ) break; if ( ELEM(iPos).iElemNext ) { iPos = ELEM(iPos).iElemNext; break; } } } bPosFirst = false; // Shift indexes at iPos if ( iPos != iPosTop ) ELEM(iPos).nStart += nShift; else ELEM(iPos).nLength += nShift; } } int CMarkup::x_InsertNew( int iPosParent, int& iPosRel, NodePos& node ) { // Parent empty tag or tags with no content? bool bEmptyParentTag = iPosParent && ELEM(iPosParent).IsEmptyElement(); bool bNoContentParentTags = iPosParent && ! ELEM(iPosParent).ContentLen(); if ( iPosRel && ! node.nLength ) // current position element? { node.nStart = ELEM(iPosRel).nStart; if ( ! (node.nNodeFlags & MNF_INSERT) ) // follow iPosRel node.nStart += ELEM(iPosRel).nLength; } else if ( bEmptyParentTag ) // parent has no separate end tag? { // Split empty parent element if ( ELEM(iPosParent).nFlags & MNF_NONENDED ) node.nStart = ELEM(iPosParent).StartContent(); else node.nStart = ELEM(iPosParent).StartContent() - 1; } else if ( node.nLength || (m_nDocFlags&MDF_WRITEFILE) ) // non-element node or a file mode zero length position? { if ( ! (node.nNodeFlags & MNF_INSERT) ) node.nStart += node.nLength; // after node or file mode position } else // no current node { // Insert relative to parent's content if ( node.nNodeFlags & (MNF_INSERT|MNF_REPLACE) ) node.nStart = ELEM(iPosParent).StartContent(); // beginning of parent's content else // in front of parent's end tag node.nStart = ELEM(iPosParent).StartAfter() - ELEM(iPosParent).EndTagLen(); } // Go up to start of next node, unless its splitting an empty element if ( ! (node.nNodeFlags&(MNF_WITHNOLINES|MNF_REPLACE)) && ! bEmptyParentTag ) { TokenPos token( m_strDoc, m_nDocFlags ); node.nStart = token.WhitespaceToTag( node.nStart ); } // Is insert relative to element position? (i.e. not other kind of node) if ( ! node.nLength ) { // Modify iPosRel to reflect position before if ( iPosRel ) { if ( node.nNodeFlags & MNF_INSERT ) { if ( ! (ELEM(iPosRel).nFlags & MNF_FIRST) ) iPosRel = ELEM(iPosRel).iElemPrev; else iPosRel = 0; } } else if ( ! (node.nNodeFlags & MNF_INSERT) ) { // If parent has a child, add after last child if ( ELEM(iPosParent).iElemChild ) iPosRel = ELEM(ELEM(iPosParent).iElemChild).iElemPrev; } } // Get node length (needed for x_AddNode and x_AddSubDoc in file write mode) node.nLength = MCD_STRLENGTH(node.strMeta); // Prepare end of lines if ( (! (node.nNodeFlags & MNF_WITHNOLINES)) && (bEmptyParentTag || bNoContentParentTags) ) node.nStart += MCD_EOLLEN; if ( ! (node.nNodeFlags & MNF_WITHNOLINES) ) node.strMeta += MCD_EOL; // Calculate insert offset and replace length int nReplace = 0; int nInsertAt = node.nStart; if ( bEmptyParentTag ) { MCD_STR strTagName = x_GetTagName( iPosParent ); MCD_STR strFormat; if ( node.nNodeFlags & MNF_WITHNOLINES ) strFormat = MCD_T(">"); else strFormat = MCD_T(">") MCD_EOL; strFormat += node.strMeta; strFormat += MCD_T(" m_pFilePos->m_nBlockSizeBasis ) { int nDocCapacity = MCD_STRCAPACITY(m_strDoc); if ( nNewDocLength > nDocCapacity ) { if ( bEmptyParentTag ) ELEM(iPosParent).nStart = 0; node.nStart -= nFlushTo; nInsertAt -= nFlushTo; m_pFilePos->FileFlush( m_strDoc, nFlushTo ); m_strResult = m_pFilePos->m_strIOResult; } } } x_DocChange( nInsertAt, nReplace, node.strMeta ); return nReplace; } bool CMarkup::x_AddElem( MCD_PCSZ pName, int nValue, int nFlags ) { // Convert integer to string MCD_CHAR szVal[25]; MCD_SPRINTF( MCD_SSZ(szVal), MCD_T("%d"), nValue ); return x_AddElem( pName, szVal, nFlags ); } bool CMarkup::x_AddElem( MCD_PCSZ pName, MCD_PCSZ pValue, int nFlags ) { if ( m_nDocFlags & MDF_READFILE ) return false; if ( nFlags & MNF_CHILD ) { // Adding a child element under main position if ( ! m_iPos || (m_nDocFlags & MDF_WRITEFILE) ) return false; } // Cannot have data in non-ended element if ( (nFlags&MNF_WITHNOEND) && pValue && pValue[0] ) return false; // Node and element structures NodePos node( nFlags ); int iPosParent = 0, iPosBefore = 0; int iPos = x_GetFreePos(); ElemPos* pElem = &ELEM(iPos); // Locate where to add element relative to current node if ( nFlags & MNF_CHILD ) { iPosParent = m_iPos; iPosBefore = m_iPosChild; } else { iPosParent = m_iPosParent; iPosBefore = m_iPos; node.nStart = m_nNodeOffset; node.nLength = m_nNodeLength; } // Create string for insert // If no pValue is specified, an empty element is created // i.e. either value or // int nLenName = MCD_PSZLEN(pName); if ( ! pValue || ! pValue[0] ) { // empty element MCD_BLDRESERVE( node.strMeta, nLenName + 4 ); MCD_BLDAPPEND1( node.strMeta, '<' ); MCD_BLDAPPENDN( node.strMeta, pName, nLenName ); if ( nFlags & MNF_WITHNOEND ) { MCD_BLDAPPEND1( node.strMeta, '>' ); } else { if ( nFlags & MNF_WITHXHTMLSPACE ) { MCD_BLDAPPENDN( node.strMeta, MCD_T(" />"), 3 ); } else { MCD_BLDAPPENDN( node.strMeta, MCD_T("/>"), 2 ); } } MCD_BLDRELEASE( node.strMeta ); pElem->nLength = MCD_STRLENGTH( node.strMeta ); pElem->SetStartTagLen( pElem->nLength ); pElem->SetEndTagLen( 0 ); } else { // value MCD_STR strValue; if ( nFlags & MNF_WITHCDATA ) strValue = x_EncodeCDATASection( pValue ); else strValue = EscapeText( pValue, nFlags ); int nLenValue = MCD_STRLENGTH(strValue); pElem->nLength = nLenName * 2 + nLenValue + 5; MCD_BLDRESERVE( node.strMeta, pElem->nLength ); MCD_BLDAPPEND1( node.strMeta, '<' ); MCD_BLDAPPENDN( node.strMeta, pName, nLenName ); MCD_BLDAPPEND1( node.strMeta, '>' ); MCD_BLDAPPENDN( node.strMeta, MCD_2PCSZ(strValue), nLenValue ); MCD_BLDAPPENDN( node.strMeta, MCD_T("' ); MCD_BLDRELEASE( node.strMeta ); pElem->SetEndTagLen( nLenName + 3 ); pElem->SetStartTagLen( nLenName + 2 ); } // Insert int nReplace = x_InsertNew( iPosParent, iPosBefore, node ); pElem->nStart = node.nStart; pElem->iElemChild = 0; if ( nFlags & MNF_WITHNOEND ) pElem->nFlags = MNF_NONENDED; else pElem->nFlags = 0; if ( m_nDocFlags & MDF_WRITEFILE ) { iPosParent = x_UnlinkPrevElem( iPosParent, iPosBefore, iPos ); TokenPos token( m_strDoc, m_nDocFlags ); token.m_nL = pElem->nStart + 1; token.m_nR = pElem->nStart + nLenName; m_pFilePos->m_elemstack.PushTagAndCount( token ); } else { x_LinkElem( iPosParent, iPosBefore, iPos ); x_Adjust( iPos, MCD_STRLENGTH(node.strMeta) - nReplace ); } if ( nFlags & MNF_CHILD ) x_SetPos( m_iPosParent, iPosParent, iPos ); else x_SetPos( iPosParent, iPos, 0 ); return true; } MCD_STR CMarkup::x_GetSubDoc( int iPos ) { if ( iPos && ! (m_nDocFlags&MDF_WRITEFILE) ) { if ( ! (m_nDocFlags&MDF_READFILE) ) { TokenPos token( m_strDoc, m_nDocFlags ); token.WhitespaceToTag( ELEM(iPos).StartAfter() ); token.m_nL = ELEM(iPos).nStart; return token.GetTokenText(); } } return MCD_T(""); } bool CMarkup::x_AddSubDoc( MCD_PCSZ pSubDoc, int nFlags ) { if ( m_nDocFlags & MDF_READFILE || ((nFlags & MNF_CHILD) && (m_nDocFlags & MDF_WRITEFILE)) ) return false; MCD_STRCLEAR(m_strResult); NodePos node( nFlags ); int iPosParent, iPosBefore; if ( nFlags & MNF_CHILD ) { // Add a subdocument under main position, before or after child if ( ! m_iPos ) return false; iPosParent = m_iPos; iPosBefore = m_iPosChild; } else { // Add a subdocument under parent position, before or after main iPosParent = m_iPosParent; iPosBefore = m_iPos; node.nStart = m_nNodeOffset; node.nLength = m_nNodeLength; } // Parse subdocument, generating indexes based on the subdocument string to be offset later bool bWellFormed = true; TokenPos token( pSubDoc, m_nDocFlags ); int iPosVirtual = x_GetFreePos(); ELEM(iPosVirtual).ClearVirtualParent(); ELEM(iPosVirtual).SetLevel( ELEM(iPosParent).Level() + 1 ); int iPos = x_ParseElem( iPosVirtual, token ); if ( (!iPos) || ELEM(iPosVirtual).nFlags & MNF_ILLFORMED ) bWellFormed = false; if ( ELEM(iPosVirtual).nFlags & MNF_ILLDATA ) ELEM(iPosParent).nFlags |= MNF_ILLDATA; // File write mode handling bool bBypassSubDoc = false; if ( m_nDocFlags & MDF_WRITEFILE ) { // Current position will bypass subdoc unless well-formed single element if ( (! bWellFormed) || ELEM(iPos).iElemChild || ELEM(iPos).iElemNext ) bBypassSubDoc = true; // Count tag names of top level elements (usually one) in given markup int iPosTop = iPos; while ( iPosTop ) { token.m_nNext = ELEM(iPosTop).nStart + 1; token.FindName(); m_pFilePos->m_elemstack.PushTagAndCount( token ); iPosTop = ELEM(iPosTop).iElemNext; } } // Extract subdocument without leading/trailing nodes int nExtractStart = 0; int iPosLast = ELEM(iPos).iElemPrev; if ( bWellFormed ) { nExtractStart = ELEM(iPos).nStart; int nExtractLength = ELEM(iPos).nLength; if ( iPos != iPosLast ) { nExtractLength = ELEM(iPosLast).nStart - nExtractStart + ELEM(iPosLast).nLength; bWellFormed = false; // treat as subdoc here, but return not well-formed } MCD_STRASSIGN(node.strMeta,&pSubDoc[nExtractStart],nExtractLength); } else { node.strMeta = pSubDoc; node.nNodeFlags |= MNF_WITHNOLINES; } // Insert int nReplace = x_InsertNew( iPosParent, iPosBefore, node ); // Clean up indexes if ( m_nDocFlags & MDF_WRITEFILE ) { if ( bBypassSubDoc ) { // Release indexes used in parsing the subdocument m_iPosParent = x_UnlinkPrevElem( iPosParent, iPosBefore, 0 ); m_iPosFree = 1; m_iPosDeleted = 0; m_iPos = 0; m_nNodeOffset = node.nStart + node.nLength; m_nNodeLength = 0; m_nNodeType = 0; MARKUP_SETDEBUGSTATE; return bWellFormed; } else // single element added { m_iPos = iPos; ElemPos* pElem = &ELEM(iPos); pElem->nStart = node.nStart; m_iPosParent = x_UnlinkPrevElem( iPosParent, iPosBefore, iPos ); x_ReleasePos( iPosVirtual ); } } else { // Adjust and link in the inserted elements // iPosVirtual will stop it from affecting rest of document int nAdjust = node.nStart - nExtractStart; if ( iPos && nAdjust ) { x_Adjust( iPos, nAdjust ); ELEM(iPos).nStart += nAdjust; } int iPosChild = iPos; while ( iPosChild ) { int iPosNext = ELEM(iPosChild).iElemNext; x_LinkElem( iPosParent, iPosBefore, iPosChild ); iPosBefore = iPosChild; iPosChild = iPosNext; } x_ReleasePos( iPosVirtual ); // Now adjust remainder of document x_Adjust( iPosLast, MCD_STRLENGTH(node.strMeta) - nReplace, true ); } // Set position to top element of subdocument if ( nFlags & MNF_CHILD ) x_SetPos( m_iPosParent, iPosParent, iPos ); else // Main x_SetPos( m_iPosParent, iPos, 0 ); return bWellFormed; } int CMarkup::x_RemoveElem( int iPos ) { // Determine whether any whitespace up to next tag TokenPos token( m_strDoc, m_nDocFlags ); int nAfterEnd = token.WhitespaceToTag( ELEM(iPos).StartAfter() ); // Remove from document, adjust affected indexes, and unlink int nLen = nAfterEnd - ELEM(iPos).nStart; x_DocChange( ELEM(iPos).nStart, nLen, MCD_STR() ); x_Adjust( iPos, - nLen, true ); int iPosPrev = x_UnlinkElem( iPos ); x_CheckSavedPos(); return iPosPrev; // new position } void CMarkup::x_LinkElem( int iPosParent, int iPosBefore, int iPos ) { // Update links between elements and initialize nFlags ElemPos* pElem = &ELEM(iPos); if ( m_nDocFlags & MDF_WRITEFILE ) { // In file write mode, only keep virtual parent 0 plus one element if ( iPosParent ) x_ReleasePos( iPosParent ); else if ( iPosBefore ) x_ReleasePos( iPosBefore ); iPosParent = 0; ELEM(iPosParent).iElemChild = iPos; pElem->iElemParent = iPosParent; pElem->iElemPrev = iPos; pElem->iElemNext = 0; pElem->nFlags |= MNF_FIRST; } else { pElem->iElemParent = iPosParent; if ( iPosBefore ) { // Link in after iPosBefore pElem->nFlags &= ~MNF_FIRST; pElem->iElemNext = ELEM(iPosBefore).iElemNext; if ( pElem->iElemNext ) ELEM(pElem->iElemNext).iElemPrev = iPos; else ELEM(ELEM(iPosParent).iElemChild).iElemPrev = iPos; ELEM(iPosBefore).iElemNext = iPos; pElem->iElemPrev = iPosBefore; } else { // Link in as first child pElem->nFlags |= MNF_FIRST; if ( ELEM(iPosParent).iElemChild ) { pElem->iElemNext = ELEM(iPosParent).iElemChild; pElem->iElemPrev = ELEM(pElem->iElemNext).iElemPrev; ELEM(pElem->iElemNext).iElemPrev = iPos; ELEM(pElem->iElemNext).nFlags ^= MNF_FIRST; } else { pElem->iElemNext = 0; pElem->iElemPrev = iPos; } ELEM(iPosParent).iElemChild = iPos; } if ( iPosParent ) pElem->SetLevel( ELEM(iPosParent).Level() + 1 ); } } int CMarkup::x_UnlinkElem( int iPos ) { // Fix links to remove element and mark as deleted // return previous position or zero if none ElemPos* pElem = &ELEM(iPos); // Find previous sibling and bypass removed element int iPosPrev = 0; if ( pElem->nFlags & MNF_FIRST ) { if ( pElem->iElemNext ) // set next as first child { ELEM(pElem->iElemParent).iElemChild = pElem->iElemNext; ELEM(pElem->iElemNext).iElemPrev = pElem->iElemPrev; ELEM(pElem->iElemNext).nFlags |= MNF_FIRST; } else // no children remaining ELEM(pElem->iElemParent).iElemChild = 0; } else { iPosPrev = pElem->iElemPrev; ELEM(iPosPrev).iElemNext = pElem->iElemNext; if ( pElem->iElemNext ) ELEM(pElem->iElemNext).iElemPrev = iPosPrev; else ELEM(ELEM(pElem->iElemParent).iElemChild).iElemPrev = iPosPrev; } x_ReleaseSubDoc( iPos ); return iPosPrev; } int CMarkup::x_UnlinkPrevElem( int iPosParent, int iPosBefore, int iPos ) { // In file write mode, only keep virtual parent 0 plus one element if currently at element if ( iPosParent ) { x_ReleasePos( iPosParent ); iPosParent = 0; } else if ( iPosBefore ) x_ReleasePos( iPosBefore ); ELEM(iPosParent).iElemChild = iPos; ELEM(iPosParent).nLength = MCD_STRLENGTH(m_strDoc); if ( iPos ) { ElemPos* pElem = &ELEM(iPos); pElem->iElemParent = iPosParent; pElem->iElemPrev = iPos; pElem->iElemNext = 0; pElem->nFlags |= MNF_FIRST; } return iPosParent; } int CMarkup::x_ReleasePos( int iPos ) { int iPosNext = ELEM(iPos).iElemNext; ELEM(iPos).iElemNext = m_iPosDeleted; ELEM(iPos).nFlags = MNF_DELETED; m_iPosDeleted = iPos; return iPosNext; } int CMarkup::x_ReleaseSubDoc( int iPos ) { // Mark position structures as deleted by depth first traversal // Tricky because iElemNext used in traversal is overwritten for linked list of deleted // Return value is what iElemNext was before being overwritten // int iPosNext = 0, iPosTop = iPos; while ( 1 ) { if ( ELEM(iPos).iElemChild ) iPos = ELEM(iPos).iElemChild; else { while ( 1 ) { iPosNext = x_ReleasePos( iPos ); if ( iPosNext || iPos == iPosTop ) break; iPos = ELEM(iPos).iElemParent; } if ( iPos == iPosTop ) break; iPos = iPosNext; } } return iPosNext; } void CMarkup::x_CheckSavedPos() { // Remove any saved positions now pointing to deleted elements // Must be done as part of element removal before position reassigned if ( m_pSavedPosMaps->m_pMaps ) { int nMap = 0; while ( m_pSavedPosMaps->m_pMaps[nMap] ) { SavedPosMap* pMap = m_pSavedPosMaps->m_pMaps[nMap]; for ( int nSlot = 0; nSlot < pMap->nMapSize; ++nSlot ) { SavedPos* pSavedPos = pMap->pTable[nSlot]; if ( pSavedPos ) { int nOffset = 0; int nSavedPosCount = 0; while ( 1 ) { if ( pSavedPos[nOffset].nSavedPosFlags & SavedPos::SPM_USED ) { int iPos = pSavedPos[nOffset].iPos; if ( ! (ELEM(iPos).nFlags & MNF_DELETED) ) { if ( nSavedPosCount < nOffset ) { pSavedPos[nSavedPosCount] = pSavedPos[nOffset]; pSavedPos[nSavedPosCount].nSavedPosFlags &= ~SavedPos::SPM_LAST; } ++nSavedPosCount; } } if ( pSavedPos[nOffset].nSavedPosFlags & SavedPos::SPM_LAST ) { while ( nSavedPosCount <= nOffset ) pSavedPos[nSavedPosCount++].nSavedPosFlags &= ~SavedPos::SPM_USED; break; } ++nOffset; } } } ++nMap; } } } void CMarkup::x_AdjustForNode( int iPosParent, int iPos, int nShift ) { // Adjust affected indexes bool bAfterPos = true; if ( ! iPos ) { // Change happened before or at first element under iPosParent // If there are any children of iPosParent, adjust from there // otherwise start at parent and adjust from there iPos = ELEM(iPosParent).iElemChild; if ( iPos ) { ELEM(iPos).nStart += nShift; bAfterPos = false; } else { iPos = iPosParent; ELEM(iPos).nLength += nShift; } } x_Adjust( iPos, nShift, bAfterPos ); } bool CMarkup::x_AddNode( int nNodeType, MCD_PCSZ pText, int nNodeFlags ) { if ( m_nDocFlags & MDF_READFILE ) return false; // Comments, DTDs, and processing instructions are followed by CRLF // Other nodes are usually concerned with mixed content, so no CRLF if ( ! (nNodeType & (MNT_PROCESSING_INSTRUCTION|MNT_COMMENT|MNT_DOCUMENT_TYPE)) ) nNodeFlags |= MNF_WITHNOLINES; // Add node of nNodeType after current node position NodePos node( nNodeFlags ); if ( ! x_CreateNode(node.strMeta, nNodeType, pText) ) return false; // Insert the new node relative to current node node.nStart = m_nNodeOffset; node.nLength = m_nNodeLength; node.nNodeType = nNodeType; int iPosBefore = m_iPos; int nReplace = x_InsertNew( m_iPosParent, iPosBefore, node ); // If its a new element, create an ElemPos int iPos = iPosBefore; ElemPos* pElem = NULL; if ( nNodeType == MNT_ELEMENT ) { // Set indexes iPos = x_GetFreePos(); pElem = &ELEM(iPos); pElem->nStart = node.nStart; pElem->SetStartTagLen( node.nLength ); pElem->SetEndTagLen( 0 ); pElem->nLength = node.nLength; node.nStart = 0; node.nLength = 0; pElem->iElemChild = 0; pElem->nFlags = 0; x_LinkElem( m_iPosParent, iPosBefore, iPos ); } if ( m_nDocFlags & MDF_WRITEFILE ) { m_iPosParent = x_UnlinkPrevElem( m_iPosParent, iPosBefore, iPos ); if ( nNodeType == MNT_ELEMENT ) { TokenPos token( m_strDoc, m_nDocFlags ); token.m_nL = pElem->nStart + 1; token.m_nR = pElem->nStart + pElem->nLength - 3; m_pFilePos->m_elemstack.PushTagAndCount( token ); } } else // need to adjust element positions after iPos x_AdjustForNode( m_iPosParent, iPos, MCD_STRLENGTH(node.strMeta) - nReplace ); // Store current position m_iPos = iPos; m_iPosChild = 0; m_nNodeOffset = node.nStart; m_nNodeLength = node.nLength; m_nNodeType = nNodeType; MARKUP_SETDEBUGSTATE; return true; } void CMarkup::x_RemoveNode( int iPosParent, int& iPos, int& nNodeType, int& nNodeOffset, int& nNodeLength ) { int iPosPrev = iPos; // Removing an element? if ( nNodeType == MNT_ELEMENT ) { nNodeOffset = ELEM(iPos).nStart; nNodeLength = ELEM(iPos).nLength; iPosPrev = x_UnlinkElem( iPos ); x_CheckSavedPos(); } // Find previous node type, offset and length int nPrevOffset = 0; if ( iPosPrev ) nPrevOffset = ELEM(iPosPrev).StartAfter(); else if ( iPosParent ) nPrevOffset = ELEM(iPosParent).StartContent(); TokenPos token( m_strDoc, m_nDocFlags ); NodePos node; token.m_nNext = nPrevOffset; int nPrevType = 0; while ( token.m_nNext < nNodeOffset ) { nPrevOffset = token.m_nNext; nPrevType = token.ParseNode( node ); } int nPrevLength = nNodeOffset - nPrevOffset; if ( ! nPrevLength ) { // Previous node is iPosPrev element nPrevOffset = 0; if ( iPosPrev ) nPrevType = MNT_ELEMENT; } // Remove node from document x_DocChange( nNodeOffset, nNodeLength, MCD_STR() ); x_AdjustForNode( iPosParent, iPosPrev, - nNodeLength ); // Was removed node a lone end tag? if ( nNodeType == MNT_LONE_END_TAG ) { // See if we can unset parent MNF_ILLDATA flag token.m_nNext = ELEM(iPosParent).StartContent(); int nEndOfContent = token.m_nNext + ELEM(iPosParent).ContentLen(); int iPosChild = ELEM(iPosParent).iElemChild; while ( token.m_nNext < nEndOfContent ) { if ( token.ParseNode(node) <= 0 ) break; if ( node.nNodeType == MNT_ELEMENT ) { token.m_nNext = ELEM(iPosChild).StartAfter(); iPosChild = ELEM(iPosChild).iElemNext; } } if ( token.m_nNext == nEndOfContent ) ELEM(iPosParent).nFlags &= ~MNF_ILLDATA; } nNodeType = nPrevType; nNodeOffset = nPrevOffset; nNodeLength = nPrevLength; iPos = iPosPrev; }