diff -r 417699dc19c9 -r c7e9f1c97567 xml/xmlparser/src/cxmlreader.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/xml/xmlparser/src/cxmlreader.cpp Mon Sep 13 13:16:40 2010 +0530 @@ -0,0 +1,1123 @@ +/* +* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: ?Description +* +*/ + + + +// INCLUDE FILES +#include "cxmlreader.h" + + +/* Dictionar Public ID's */ +#define WML_1_1_PUBLIC_ID 4 +#define WML_1_2_PUBLIC_ID 9 +#define WML_1_3_PUBLIC_ID 10 +#define XHTML_1_0_PUBLIC_ID 55 +#define SYNCML_1_0_PUBLIC_ID 0xFD1 +#define WAP_PROV_1_0_PUBLIC_ID 11 +#define SI_1_0_PUBLIC_ID 5 +#define SL_1_0_PUBLIC_ID 6 +#define PUSH_PROV_1_0_PUBLIC_ID 1 +extern "C" +{ + extern NW_WBXML_Dictionary_t NW_Wml_1_0_WBXMLDictionary; + extern NW_WBXML_Dictionary_t NW_Wml_1_1_WBXMLDictionary; + extern NW_WBXML_Dictionary_t NW_Wml_1_2_WBXMLDictionary; + extern NW_WBXML_Dictionary_t NW_Wml_1_3_WBXMLDictionary; + extern NW_WBXML_Dictionary_t NW_XHTML_WBXMLDictionary; + extern NW_WBXML_Dictionary_t NW_SyncML_1_0_WBXMLDictionary; + extern NW_WBXML_Dictionary_t NW_SL_WBXMLDictionary; +// extern NW_WBXML_Dictionary_t NW_wap_prov_doc_WBXMLDictionary; +// extern NW_WBXML_Dictionary_t SI_dictionary; +// extern NW_WBXML_Dictionary_t SL_dictionary; +// extern NW_WBXML_Dictionary_t push_nokprov_dictionary; +} +#define DICTIONARY_COUNT 7 + + +// ============================= LOCAL FUNCTIONS =============================== + +// ----------------------------------------------------------------------------- +// BeginElementCB +// BeginElement callback, stores elemntname in elemntlist +// ----------------------------------------------------------------------------- +// +NW_Status_t BeginElementCB(NW_XML_Reader_t* aReader, + const NW_XML_Reader_Interval_t* aName, + void* aParser) +{ + CXMLObserver *wObserver = (CXMLObserver*)aParser; + TPtrC wElementName( (TUint16*)aReader->pBuf + aName->charStart, aName->charStop - aName->charStart ); + TRAPD(error, wObserver->SetElementL(wElementName)); + if(error) + { + (wObserver->GetAttributes())->Reset(); + return NW_STAT_FAILURE; + } + // New element, reset attributes list + (wObserver->GetAttributes())->Reset(); + return NW_STAT_SUCCESS; +} + +// ----------------------------------------------------------------------------- +// EndElementCB. calls MXMLContentHandler::EndElement with elemntname, +// removes closed element from elemntlist. +// ----------------------------------------------------------------------------- +// +NW_Status_t EndElementCB(NW_XML_Reader_t* aReader, + const NW_XML_Reader_Interval_t* aName, + NW_Uint32 /*aEmpFlag*/, + void* aParser) +{ + _LIT(KEmpty,""); + TPtrC wEmpty(KEmpty); + CXMLObserver* wObserver = (CXMLObserver*)aParser; + wObserver->RemoveElement(); + MXMLContentHandler* aContentHandler = wObserver->GetContentHandler(); + TPtrC aElementName( (TUint16*)aReader->pBuf + aName->charStart, aName->charStop - aName->charStart ); + TInt result = aContentHandler->EndElement(wEmpty, wEmpty, aElementName); + aContentHandler->ReaderIndex( aReader->charIndex ); + return result ? NW_STAT_SUCCESS:NW_STAT_FAILURE; +} + +// ----------------------------------------------------------------------------- +// AttributesStartCB +// ----------------------------------------------------------------------------- +// +NW_Status_t AttributeStartCB (NW_XML_Reader_t*, + const NW_XML_Reader_Interval_t* /*pI_name*/, + void*) +{ + return NW_STAT_SUCCESS; +} + +// ----------------------------------------------------------------------------- +// AttreibuteValueCB Adds new attribute to attributes list. +// Adds URI to URI list if namespaces is used +// ----------------------------------------------------------------------------- +// +NW_Status_t AttributeValueCB(NW_XML_Reader_t* aReader, + const NW_XML_Reader_Interval_t* aName, + const NW_XML_Reader_Interval_t* aValue, + void* aParser) +{ + _LIT(KNamespace,"xmlns:"); + TPtrC wNamespace(KNamespace); + CXMLObserver* wObserver = (CXMLObserver*)aParser; + CXMLAttributes* wAttr = wObserver->GetAttributes(); + + // Append new attribute to attributes list + TPtrC wAttributeName( (TUint16*)aReader->pBuf + aName->charStart, aName->charStop - aName->charStart ); + TPtrC wAttributeValue( (TUint16*)aReader->pBuf + aValue->charStart, aValue->charStop - aValue->charStart ); + TRAPD(error,wAttr->AppendL(wAttributeName, wAttributeValue)); + if(error) + { + return NW_STAT_FAILURE; + } + // namespace declaration, store URI and extension + if(wAttributeName.Left(6).Match(wNamespace)!=KErrNotFound) + { + TPtrC wExtension = wAttributeName.Right(wAttributeName.Length()-6); + TRAP(error, wObserver->SetURIL(wAttributeValue, wExtension)); + if(error) + { + return NW_STAT_FAILURE; + } + } + return NW_STAT_SUCCESS; +} + +// ----------------------------------------------------------------------------- +// AttributesEndCB Calls MXMLContentHandler::StartElement with element name and +// attributes list. +// ----------------------------------------------------------------------------- +// +NW_Status_t AttributesEndCB(NW_XML_Reader_t* /*aReader*/, + NW_Uint32 /*aLength*/, + void* aParser) +{ + _LIT(KLocalName,""); + TPtrC wLocalName(KLocalName); + _LIT(KURI,""); + TPtrC wURI(KURI); + CXMLObserver* wObserver = (CXMLObserver*)aParser; + MXMLContentHandler* wContentHandler = wObserver->GetContentHandler(); + + TPtrC wElementName = wObserver->GetElement(); + CXMLAttributes* wAttributes = wObserver->GetAttributes(); + + // if using namespace, get URI and localname + TInt wIndex = wElementName.Locate(':'); + if(wIndex > 0) + { + wLocalName.Set(wElementName.Right(wElementName.Length()-wIndex-1)); + TPtrC temp = wElementName.Left(wIndex); + wURI.Set(wObserver->GetURI(temp)); + } + // Call StartElement, now that we have all the attributes + return wContentHandler->StartElement(wURI, wLocalName, wElementName, wAttributes) ? NW_STAT_SUCCESS:NW_STAT_FAILURE; +} + +// ----------------------------------------------------------------------------- +// CDataCB Reports actual CData as MXMLContentHandler::Characters (between +// MXMLContentHandler::StartCData and MXMLContentHandler::EndCData +// ----------------------------------------------------------------------------- +// +NW_Status_t CdataCB (NW_XML_Reader_t* aReader, + const NW_XML_Reader_Interval_t* aName, + void* aParser) +{ + CXMLObserver* wObserver = (CXMLObserver*)aParser; + MXMLContentHandler* aContentHandler = wObserver->GetContentHandler(); + TPtrC wChar( (TUint16*)aReader->pBuf + aName->charStart, aName->charStop - aName->charStart ); + + aContentHandler->StartCDATA(); + aContentHandler->Charecters( wChar, aName->charStart, (aName->charStop - aName->charStart) ); + return aContentHandler->EndCDATA()? NW_STAT_SUCCESS:NW_STAT_FAILURE; +} + +// ----------------------------------------------------------------------------- +// ContentCB Content reported as MXMLContentHandler::Characters +// ----------------------------------------------------------------------------- +// +NW_Status_t ContentCB (NW_XML_Reader_t* aReader, + const NW_XML_Reader_Interval_t* aValue, + void* aParser) +{ + + CXMLObserver* wObserver = (CXMLObserver*)aParser; + TPtrC wChar( (TUint16*)aReader->pBuf + aValue->charStart, aValue->charStop - aValue->charStart ); + + MXMLContentHandler* aContentHandler = wObserver->GetContentHandler(); + + return (aContentHandler->Charecters(wChar, aValue->charStart, (aValue->charStop - aValue->charStart)))?NW_STAT_SUCCESS:NW_STAT_FAILURE; +} + + +// ----------------------------------------------------------------------------- +// AttrEntityVarValCB Adds new attribute to attributes list. +// Adds URI to URI list if namespaces is used +// ----------------------------------------------------------------------------- +// +NW_Status_t AttrEntityVarValCB (NW_XML_Reader_t* aReader, + const NW_XML_Reader_Interval_t* aName, + NW_Uint8* aValue, + NW_Uint32 aValueByteLength, + void* aParser) + { + _LIT(KNamespace, "xmlns:"); + TPtrC wNamespace(KNamespace); + CXMLObserver* wObserver = (CXMLObserver*)aParser; + CXMLAttributes* wAttr = wObserver->GetAttributes(); + + // Append new attribute to attributes list + TPtrC wAttributeName( (TUint16*)aReader->pBuf + aName->charStart, aName->charStop - aName->charStart ); + TPtrC wAttributeValue( (TUint16*)aValue, aValueByteLength/2 ); + + TRAPD(error,wAttr->AppendL(wAttributeName, wAttributeValue)); + if(error) + { + return NW_STAT_FAILURE; + } + + // namespace declaration, store URI and extension + if(wAttributeName.Left(6).Match(wNamespace)!=KErrNotFound) + { + TPtrC wExtension = wAttributeName.Right(wAttributeName.Length()-6); + TRAP(error, wObserver->SetURIL(wAttributeValue, wExtension)); + if(error) + { + return NW_STAT_FAILURE; + } + } + return NW_STAT_SUCCESS; + } + + +// ----------------------------------------------------------------------------- +// EntityCB Entity reported as MXMLContentHandler::StartEntity +// ----------------------------------------------------------------------------- +// +NW_Status_t EntityCB (NW_XML_Reader_t* aReader, + NW_Uint32 aNumEntity, + void* aParser, + CXML_Uint8* aIntEntityValStr) +{ + + CXMLObserver *wObserver = (CXMLObserver*)aParser; + + NW_String_t *tempString = NW_String_new(); + // handle OOM + if(tempString == NULL) + { + return NW_STAT_FAILURE; + } + + if(aIntEntityValStr == NULL) + { + //It is character/predefined entities + NW_String_entityToString(aNumEntity, tempString, aReader->encoding); + } + + if(aIntEntityValStr != NULL) + { + //It is the internal entity + tempString->storage = aIntEntityValStr; + } + + TPtrC wTmpEntityPtr((TUint16*)tempString->storage); + TInt result(wObserver->GetContentHandler()->StartEntity(wTmpEntityPtr)); + + if (result == 0) + { + NW_String_delete(tempString); + return NW_STAT_FAILURE; + } + result = wObserver->GetContentHandler()->EndEntity(wTmpEntityPtr); + NW_String_delete(tempString); + + return (result?NW_STAT_SUCCESS:NW_STAT_FAILURE); + +} + +// ----------------------------------------------------------------------------- +// CommentCB +// ----------------------------------------------------------------------------- +// +NW_Status_t CommentCB (NW_XML_Reader_t* aReader, + const NW_XML_Reader_Interval_t* aName, + void* aParser ) +{ + CXMLObserver* wObserver = (CXMLObserver*)aParser; + TPtrC wComment( (TUint16*)aReader->pBuf + aName->charStart, aName->charStop - aName->charStart ); + return (wObserver->GetContentHandler())->Comment(wComment)?NW_STAT_SUCCESS:NW_STAT_FAILURE; +} + +// ----------------------------------------------------------------------------- +// StartDocumentCB +// ----------------------------------------------------------------------------- +// +NW_Status_t StartDocumentCB (NW_XML_Reader_t* /*aReader*/, + void* aParser ) + +{ + CXMLObserver* wObserver = (CXMLObserver*)aParser; + return (wObserver->GetContentHandler())->StartDocument()?NW_STAT_SUCCESS:NW_STAT_FAILURE; + +} + +// ----------------------------------------------------------------------------- +// EndDocumentCB +// ----------------------------------------------------------------------------- +// +NW_Status_t EndDocumentCB (NW_XML_Reader_t* /*aReader*/, + void* aParser) +{ + CXMLObserver* wObserver = (CXMLObserver*)aParser; + return (wObserver->GetContentHandler())->EndDocument()?NW_STAT_SUCCESS:NW_STAT_FAILURE; +} + +// ----------------------------------------------------------------------------- +// PiCB Report Processing Instruction with MXMLProcessingInstruction(Target, Data) +// ----------------------------------------------------------------------------- +// +NW_Status_t PiCB (NW_XML_Reader_t* aReader, + NW_PiFormTypeTag_t aTag, + const NW_XML_Reader_Interval_t* aName, + const NW_XML_Reader_Interval_t* aVersion, + const NW_XML_Reader_Interval_t* /*aEncoding*/, + const NW_XML_Reader_Interval_t* /*aStandalone*/, + const NW_XML_Reader_Interval_t* aContent, + void* aParser) +{ + CXMLObserver* wObserver = (CXMLObserver*)aParser; + TPtrC aTarget( (TUint16*)aReader->pBuf + aName->charStart, aName->charStop - aName->charStart ); + if(aTag==XMLDECL) + { + TPtrC aData( (TUint16*)aReader->pBuf + aVersion->charStart, aVersion->charStop - aVersion->charStart ); + return (wObserver->GetContentHandler())->ProcessingInstructions(aTarget, aData)?NW_STAT_SUCCESS:NW_STAT_FAILURE; + } + else + { + TPtrC aData( (TUint16*)aReader->pBuf + aContent->charStart, aContent->charStop - aContent->charStart ); + return (wObserver->GetContentHandler())->ProcessingInstructions(aTarget, aData)?NW_STAT_SUCCESS:NW_STAT_FAILURE; + } +} + + +// Binary Call backs + +// ----------------------------------------------------------------------------- +// Binary_StartDocument_CB +// ----------------------------------------------------------------------------- +// +NW_Status_t Binary_StartDocument_CB (NW_WBXML_Parser_t* /*aParser*/, + NW_WBXML_Document_t* /*aDocument*/, + void * aContext) +{ + CXMLObserver* wObserver = (CXMLObserver*)aContext; + return (wObserver->GetBinaryContentHandler())->StartDocument()?NW_STAT_SUCCESS:NW_STAT_FAILURE; +} + +// ----------------------------------------------------------------------------- +// Binary_EndDocument_CB +// ----------------------------------------------------------------------------- +// +NW_Status_t Binary_EndDocument_CB(NW_WBXML_Parser_t* /*aParser*/, + void * aContext) +{ + CXMLObserver* wObserver = (CXMLObserver*)aContext; + return (wObserver->GetBinaryContentHandler())->EndDocument()?NW_STAT_SUCCESS:NW_STAT_FAILURE; +} + +// ----------------------------------------------------------------------------- +// Binary_Pi_CB ?description. +// ----------------------------------------------------------------------------- +// +NW_Status_t Binary_Pi_CB (NW_WBXML_Parser_t* /*aParser*/, + void * aContext) +{ + CXMLObserver* wObserver = (CXMLObserver*)aContext; + return (wObserver->GetBinaryContentHandler())->ProcessingInstruction()?NW_STAT_SUCCESS:NW_STAT_FAILURE; +} + +// ----------------------------------------------------------------------------- +// Binary_Pi_End_CB +// ----------------------------------------------------------------------------- +// +NW_Status_t Binary_Pi_End_CB (NW_WBXML_Parser_t* /*aParser*/, + void* aContext) +{ + CXMLObserver *wObserver = (CXMLObserver*)aContext; + return (wObserver->GetBinaryContentHandler())->ProcessingInstructionEnd()?NW_STAT_SUCCESS:NW_STAT_FAILURE; +} + +// ----------------------------------------------------------------------------- +// Binary_Tag_Start_CB +// ----------------------------------------------------------------------------- +// +NW_Status_t Binary_Tag_Start_CB(NW_WBXML_Parser_t* /*aParser*/, + void *aContext) +{ + + CXMLObserver *wObserver = (CXMLObserver*)aContext; + return (wObserver->GetBinaryContentHandler())->TagStart()?NW_STAT_SUCCESS:NW_STAT_FAILURE; +} + +// ----------------------------------------------------------------------------- +// Binary_Tag_End_CB ?description. +// ----------------------------------------------------------------------------- +// +NW_Status_t Binary_Tag_End_CB(NW_WBXML_Parser_t* /*aParser*/, + void *aContext) +{ + CXMLObserver *wObserver = (CXMLObserver*)aContext; + return (wObserver->GetBinaryContentHandler())->TagEnd()?NW_STAT_SUCCESS:NW_STAT_FAILURE; +} + +// ----------------------------------------------------------------------------- +// Binary_Attr_Start_CB +// ----------------------------------------------------------------------------- +// +NW_Status_t Binary_Attr_Start_CB(NW_WBXML_Parser_t* /*aParser*/, + void *aContext) +{ + CXMLObserver *wObserver = (CXMLObserver*)aContext; + return (wObserver->GetBinaryContentHandler())->AttributeStart()?NW_STAT_SUCCESS:NW_STAT_FAILURE; +} + +// ----------------------------------------------------------------------------- +// Binary_Attr_Val_CB +// ----------------------------------------------------------------------------- +// +NW_Status_t Binary_Attr_Val_CB(NW_WBXML_Parser_t* /*aParser*/, + void *aContext) +{ + CXMLObserver *wObserver = (CXMLObserver*)aContext; + return (wObserver->GetBinaryContentHandler())->AttributeValue()?NW_STAT_SUCCESS:NW_STAT_FAILURE; +} + +// ----------------------------------------------------------------------------- +// Binary_Content_CB +// ----------------------------------------------------------------------------- +// +NW_Status_t Binary_Content_CB(NW_WBXML_Parser_t* /*aParser*/, + void *aContext) +{ + CXMLObserver *wObserver = (CXMLObserver*)aContext; + return (wObserver->GetBinaryContentHandler())->Content()?NW_STAT_SUCCESS:NW_STAT_FAILURE; +} + +// ----------------------------------------------------------------------------- +// Binary_CodePage_CB +// ----------------------------------------------------------------------------- +// +NW_Status_t Binary_CodePage_CB(NW_WBXML_Parser_t* /*aParser*/, + void* aContext) +{ + // Code page switch in WBXML doc + CXMLObserver *wObserver = (CXMLObserver*)aContext; + return (wObserver->GetBinaryContentHandler())->CodePageSwitch()?NW_STAT_SUCCESS:NW_STAT_FAILURE; +} + +// ----------------------------------------------------------------------------- +// Binary_Extension_CB +// ----------------------------------------------------------------------------- +// +NW_Status_t Binary_Extension_CB(NW_WBXML_Parser_t* /*aParser*/, + void* aContext) +{ + CXMLObserver *wObserver = (CXMLObserver*)aContext; + return (wObserver->GetBinaryContentHandler())->Extension()?NW_STAT_SUCCESS:NW_STAT_FAILURE; +} + +// ----------------------------------------------------------------------------- +// Binary_Token_CB +// ----------------------------------------------------------------------------- +// +NW_Status_t Binary_Token_CB(NW_WBXML_Parser_t* /*aParser*/, + NW_Uint8 aToken, + void *aContext) +{ + CXMLObserver *wObserver = (CXMLObserver*)aContext; + NW_String_UCS2Buff_t *wTemp = NW_WBXML_Dictionary_getTagByFqToken (aToken); + TPtrC wString((TUint16*)wTemp); + return (wObserver->GetBinaryContentHandler())->Token(aToken, wString)?NW_STAT_SUCCESS:NW_STAT_FAILURE; +} + +// ----------------------------------------------------------------------------- +// Binary_FQToken_CB +// ----------------------------------------------------------------------------- +// +NW_Status_t Binary_FQToken_CB(NW_WBXML_Parser_t* /*aParser*/, + NW_Uint32 aFQToken, + void *aContext) +{ + CXMLObserver *wObserver = (CXMLObserver*)aContext; + NW_Byte aToken = (NW_Byte) (aFQToken & NW_WBXML_MASK_TOKEN); + if( (aToken & NW_WBXML_MASK_TAG_ID) != NW_WBXML_LITERAL) + { + NW_String_UCS2Buff_t *wTemp = NW_WBXML_Dictionary_getTagByFqToken(aFQToken); + if(wTemp) + { + TPtrC wString((TUint16*)wTemp); + return (wObserver->GetBinaryContentHandler())->Token(aToken, wString)?NW_STAT_SUCCESS:NW_STAT_FAILURE; + } + return NW_STAT_FAILURE; + } + return NW_STAT_SUCCESS; +} + +// ----------------------------------------------------------------------------- +// Binary_InlineString_CB +// ----------------------------------------------------------------------------- +// +NW_Status_t Binary_InlineString_CB(NW_WBXML_Parser_t *aParser, + NW_Uint32 /*aIndex*/, + void *aContext) +{ + CXMLObserver *wObserver = (CXMLObserver*)aContext; + NW_String_t *tempString = NW_String_new(); + // handle OOM + if(tempString == NULL) + { + return NW_STAT_FAILURE; + } + NW_WBXML_Document_t *doc = aParser->doc; + + NW_WBXML_Parser_getStringInline(aParser, doc, tempString); + + /**! + * This was changed because of MNUI-68TAZP - German umlauts were displayed wrong. + * This was caused by NW_String_byteToUCS2Char() function - this is not recognize utf-8 encoding and treats + * all characters as a 1byte ASCII. In case of character encoded on more than 1 byte + * we get two or more separate symbols instead of one compound of these bytes. + * The CnvUtfConverter::ConvertToUnicodeFromUtf8() recognizes utf-8 properly. + + NW_Ucs2 *ucs2; + NW_String_byteToUCS2Char(tempString->storage, ((*tempString).length) & ~0x80000000, &ucs2); //VC, AM + // handle OOM + if(ucs2 == NULL) + { + NW_String_delete(tempString); + return NW_STAT_FAILURE; + } + TPtrC wString((TUint16*)ucs2); + NW_String_delete(tempString); + */ + + TPtrC8 string8(tempString->storage); + HBufC *string16=NULL; + TRAPD(err, string16 = HBufC::NewL(string8.Length())); + if(err) + { + NW_String_delete(tempString); + return NW_STAT_FAILURE; + } + TPtr wString(string16->Des()); + +#if defined(_UNICODE) + err = CnvUtfConverter::ConvertToUnicodeFromUtf8(wString,string8); + if(err != KErrNone) + { + NW_String_delete(tempString); + delete string16; + return NW_STAT_FAILURE; + } +#else + wString.Copy(string8); +#endif + + TInt result((wObserver->GetBinaryContentHandler())->InlineString(wString)); + + NW_String_delete(tempString); + delete string16; + + return (result?NW_STAT_SUCCESS:NW_STAT_FAILURE); +} + +// ----------------------------------------------------------------------------- +// Binary_TableString_CB +// ----------------------------------------------------------------------------- +// +NW_Status_t Binary_TableString_CB(NW_WBXML_Parser_t *aParser, + NW_Uint32 aIndex, + void *aContext) +{ + CXMLObserver *wObserver = (CXMLObserver*)aContext; + NW_String_t *tempString = NW_String_new(); + // handle OOM + if(tempString == NULL) + { + return NW_STAT_FAILURE; + } + NW_WBXML_Document_t *doc = aParser->doc; + NW_WBXML_Document_getTableString(doc, aIndex, tempString); + /**! + * This was changed because of MNUI-68TAZP - German umlauts were displayed wrong. + * This was caused by NW_String_byteToUCS2Char() function - this is not recognize utf-8 encoding and treats + * all characters as a 1byte ASCII. In case of character encoded on more than 1 byte + * we get two or more separate symbols instead of one compound of these bytes. + * The CnvUtfConverter::ConvertToUnicodeFromUtf8() recognizes utf-8 properly. + + NW_Ucs2 *ucs2; + NW_String_byteToUCS2Char(tempString->storage, ((*tempString).length) & ~0x80000000, &ucs2); //VC, AM + // handle OOM + if(ucs2 == NULL) + { + NW_String_delete(tempString); + return NW_STAT_FAILURE; + } + TPtrC wString((TUint16*)ucs2); + NW_String_delete(tempString); + */ + + TPtrC8 string8(tempString->storage); + HBufC *string16=NULL; + TRAPD(err, string16 = HBufC::NewL(string8.Length())); + if(err) + { + NW_String_delete(tempString); + return NW_STAT_FAILURE; + } + + TPtr wString(string16->Des()); + +#if defined(_UNICODE) + err = CnvUtfConverter::ConvertToUnicodeFromUtf8(wString,string8); + if(err != KErrNone) + { + NW_String_delete(tempString); + delete string16; + return NW_STAT_FAILURE; + } +#else + wString.Copy(string8); +#endif + + TInt result((wObserver->GetBinaryContentHandler())->TableString(wString)); + + NW_String_delete(tempString); + delete string16; + + return (result?NW_STAT_SUCCESS:NW_STAT_FAILURE); +} + +// ----------------------------------------------------------------------------- +// Binary_Binary_CB +// ----------------------------------------------------------------------------- +// +NW_Status_t Binary_Binary_CB(NW_WBXML_Parser_t* /*aParser*/, + NW_Uint32 aIndex, + void* aContext) +{ + CXMLObserver *wObserver = (CXMLObserver*)aContext; + return (wObserver->GetBinaryContentHandler())->Binary(aIndex)?NW_STAT_SUCCESS:NW_STAT_FAILURE; +} + +// ----------------------------------------------------------------------------- +// Binary_Opaque_CB +// ----------------------------------------------------------------------------- +// +NW_Status_t Binary_Opaque_CB(NW_WBXML_Parser_t *aParser, + NW_Uint32 aLength, + void * aContext) +{ + CXMLObserver *wObserver = (CXMLObserver*)aContext; + TPtrC wString((TUint16*)aParser->p, aLength); + return (wObserver->GetBinaryContentHandler())->Opaque(aLength, wString)?NW_STAT_SUCCESS:NW_STAT_FAILURE; +} + +// ----------------------------------------------------------------------------- +// Binary_Entity_CB +// ----------------------------------------------------------------------------- +// +NW_Status_t Binary_Entity_CB(NW_WBXML_Parser_t *aParser, + NW_Uint32 aIndex, + void* aContext) +{ + NW_String_t *tempString = NW_String_new(); + // handle OOM + if(tempString == NULL) + { + return NW_STAT_FAILURE; + } + NW_String_entityToString(aIndex, tempString, aParser->doc->charset); + NW_Ucs2 *ucs2; + NW_String_byteToUCS2Char(tempString->storage, tempString->length, &ucs2); + // handle OOM + if(ucs2 == NULL) + { + NW_String_delete(tempString); + return NW_STAT_FAILURE; + } + TPtrC wString((TUint16*)ucs2); + NW_String_delete(tempString); + + CXMLObserver *wObserver = (CXMLObserver*)aContext; + TInt result((wObserver->GetBinaryContentHandler())->Entity(aIndex, wString)); + delete (void*)wString.Ptr(); + + return (result?NW_STAT_SUCCESS:NW_STAT_FAILURE); +} + +// ----------------------------------------------------------------------------- +// Binary_Exception_CB For parse errors +// ----------------------------------------------------------------------------- +// +NW_Status_t Binary_Exception_CB(NW_WBXML_Parser_t* /*aParser*/, + NW_WBXML_Exception_t /*aException*/, + void* aContext) +{ + + CXMLObserver *wObserver = (CXMLObserver*)aContext; + return (wObserver->GetBinaryContentHandler())->Exception()?NW_STAT_SUCCESS:NW_STAT_FAILURE; +} + + + + +// ============================ MEMBER FUNCTIONS =============================== + + +// ----------------------------------------------------------------------------- +// CXMLReader::CXMLReader +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +CXMLReader::CXMLReader() +{ + +} + +// ----------------------------------------------------------------------------- +// CXMLReader::ConstructL +// Symbian 2nd phase constructor can leave. +// ----------------------------------------------------------------------------- +// +void CXMLReader::ConstructL() +{ + iParserObserver = CXMLObserver::NewL(); + // Default parser = XML , not WBXML + iIsBinary = FALSE; +} + +// ----------------------------------------------------------------------------- +// ?classname::NewL +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +CXMLReader* CXMLReader::NewL() +{ + CXMLReader* self = new( ELeave ) CXMLReader(); + + CleanupStack::PushL( self ); + self->ConstructL(); + CleanupStack::Pop(); + + return self; +} + +// Destructor +CXMLReader::~CXMLReader() +{ + if(iParserObserver) + { + delete iParserObserver; + } + +} + +// ----------------------------------------------------------------------------- +// CXMLReader::SetFeature +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TInt CXMLReader::SetFeature(TXMLFeature aFeature, TBool aStatus) +{ + TInt wReturn; + wReturn=0; + + switch(aFeature) + { + case EXMLBinary: + iIsBinary = aStatus; + wReturn = KErrNone; + break; + case EXMLValidation: + wReturn = KErrNotSupported; + break; + default: + wReturn = KErrNotSupported; + break; + } + return wReturn; +} + +// ----------------------------------------------------------------------------- +// CXMLReader::GetFeature +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TInt CXMLReader::GetFeature(TXMLFeature aFeature, TBool &aStatus) +{ + TInt wReturn; + wReturn=0; + + switch(aFeature) + { + case EXMLBinary: + aStatus = iIsBinary; + wReturn = KErrNone; + break; + case EXMLValidation: + aStatus = FALSE; + wReturn = KErrNotSupported; + break; + default: + wReturn = KErrNotSupported; + break; + } + return wReturn; +} + +// ----------------------------------------------------------------------------- +// CXMLReader::SetContentHandler +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TInt CXMLReader::SetContentHandler(MXMLContentHandler* aParserObserver) +{ + iParserObserver->SetContentHandler(aParserObserver); + return KErrNone; +} + +// ----------------------------------------------------------------------------- +// CXMLReader::SetContentHandler +// Set binary XML content handler +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TInt CXMLReader::SetContentHandler(MWBXMLContentHandler* aParserObserver) +{ + iParserObserver->SetContentHandler(aParserObserver); + return KErrNone; +} + +// ----------------------------------------------------------------------------- +// CXMLReader::Parse +// Reades the input file, and calls ParseL(RFile&). +// @ exception can Leave due to OOM +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CXMLReader::ParseL(RFs& aRFs, const TDesC& aFileToParse) +{ + RFile wXMLFile; + + //Open file + User::LeaveIfError(wXMLFile.Open(aRFs, aFileToParse, EFileRead | EFileShareReadersOnly)); + CleanupClosePushL(wXMLFile); + ParseL(wXMLFile); + CleanupStack::PopAndDestroy(); // wXMLFile +} + +// ----------------------------------------------------------------------------- +// CXMLReader::Parse +// Reades the input from the opened file into buffer, and calls RunL. +// @ exception can Leave due to OOM +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CXMLReader::ParseL(RFile& aOpenedFile) +{ + TInt wSize; + User::LeaveIfError(aOpenedFile.Size(wSize)); + + HBufC8 * binaryBuffer = HBufC8::NewLC(wSize); + TPtr8 binaryBufferPtr = binaryBuffer->Des(); + User::LeaveIfError(aOpenedFile.Read(binaryBufferPtr, wSize)); + + if(!iIsBinary) + { + TInt hichar = (CEditableText::EReversedByteOrderMark & 0xFF00)>>8; + TInt lochar = CEditableText::EReversedByteOrderMark & 0xFF; + TInt bytesPerChar = 1; + if(binaryBufferPtr.Ptr()[0] == hichar && binaryBufferPtr.Ptr()[1] == lochar) + { + bytesPerChar = 2; + } + + HBufC * dataBuffer = HBufC::NewLC(wSize/bytesPerChar); + TPtr dataBufferPtr = dataBuffer->Des(); + + if(bytesPerChar == 2) + { + dataBufferPtr.Set((TUint16*)binaryBufferPtr.Ptr()+1, + wSize/bytesPerChar-1, + wSize/bytesPerChar-1); + } + else + { + CnvUtfConverter::ConvertToUnicodeFromUtf8(dataBufferPtr, binaryBuffer->Des()); + } + User::LeaveIfError(ParseXML(dataBufferPtr)); + CleanupStack::Pop(); // dataBuffer + CleanupStack::PopAndDestroy(); // binaryBuffer + delete dataBuffer; + } + else + { + User::LeaveIfError(ParseWBXML(binaryBufferPtr)); + CleanupStack::PopAndDestroy(); // binaryBuffer + } +} + +// ----------------------------------------------------------------------------- +// CXMLReader::ParseL +// Copies aBuff into input buffer and calls RunL +// @ exception can Leave due to OOM +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CXMLReader::ParseL(const TDesC8& aBuff) // change the allocations +{ + + + if(!iIsBinary) + { + HBufC * dataBuffer = HBufC::NewLC(aBuff.Size()); + TPtr dataBufferPtr = dataBuffer->Des(); + CnvUtfConverter::ConvertToUnicodeFromUtf8(dataBufferPtr, aBuff); + User::LeaveIfError(ParseXML(dataBufferPtr)); + CleanupStack::PopAndDestroy(); // dataBuffer + } + else + { + User::LeaveIfError(ParseWBXML(aBuff)); + } +} + + + +// ----------------------------------------------------------------------------- +// CXMLReader::ParseXML +// +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TInt CXMLReader::ParseXML(const TDesC& aBuff) +{ + NW_Status_t status; + struct NW_XML_Parser_EventCallbacks_s cb; + struct NW_XML_Reader_s reader; + + Mem::FillZ(&cb, sizeof(NW_XML_Parser_EventCallbacks_s)); + + // cXML callbacks + cb.StartDocument_CB = StartDocumentCB; + cb.EndDocument_CB = EndDocumentCB; + cb.Tag_Start_CB = BeginElementCB; + cb.Attr_Start_CB = AttributeStartCB; + cb.Attr_VarVal_CB = AttributeValueCB; + cb.Attributes_End_CB = AttributesEndCB; + cb.Tag_End_CB = EndElementCB; + cb.Content_CB = ContentCB; + cb.Cdata_CB = CdataCB; + cb.Comment_CB = CommentCB; + cb.PiForm_CB = PiCB; + cb.pClientPointer = (void*)iParserObserver; + cb.Entity_CB = EntityCB; + cb.Attr_Entity_VarVal_CB = AttrEntityVarValCB; + + // Remove whitespace from beginning + TInt start(aBuff.Locate('<')); + + if (start == -1) + { + return KErrParseFailed; + } + + status = NW_XML_Reader_InitFromBuffer(&reader, aBuff.Right(aBuff.Length()-start).Size(), + (unsigned char*)aBuff.Right(aBuff.Length()-start).Ptr()); + NW_XML_Reader_SetEncoding(&reader, HTTP_iso_10646_ucs_2); + + // parse it! + status = NW_XML_Parse(&reader, &cb); + + ASSERT(!(reader.length % 2)); + TPtrC16 wChar((const TUint16*)reader.pBuf, reader.length / 2); + MXMLContentHandler* aContentHandler = iParserObserver->GetContentHandler(); + aContentHandler->DataBuffer(wChar); + + + if (!NW_STAT_IS_SUCCESS(status)) + { + return KErrParseFailed; + } + return KErrNone; +} + +// ----------------------------------------------------------------------------- +// CXMLReader::ParseWBXML +// +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TInt CXMLReader::ParseWBXML(const TDesC8& aBuff) +{ + // WBXML CallBacks + struct NW_WBXML_EventHandler_s binaryCB; + + Mem::FillZ(&binaryCB, sizeof(NW_WBXML_EventHandler_s)); + + // State change events + binaryCB.StartDocument_CB = Binary_StartDocument_CB; + binaryCB.EndDocument_CB = Binary_EndDocument_CB; + binaryCB.Pi_CB = Binary_Pi_CB; + binaryCB.Pi_End_CB = Binary_Pi_End_CB; + binaryCB.Tag_Start_CB = Binary_Tag_Start_CB; + binaryCB.Tag_End_CB = Binary_Tag_End_CB; + binaryCB.Attr_Start_CB = Binary_Attr_Start_CB; + binaryCB.Attr_Val_CB = Binary_Attr_Val_CB; + binaryCB.Content_CB = Binary_Content_CB; + binaryCB.CodePage_CB = Binary_CodePage_CB; + binaryCB.Extension_CB = Binary_Extension_CB; + // Handle data types + binaryCB.Token_CB = Binary_Token_CB; + binaryCB.FQToken_CB = Binary_FQToken_CB; + binaryCB.InlineString_CB = Binary_InlineString_CB; + binaryCB.TableString_CB = Binary_TableString_CB; + binaryCB.Binary_CB = Binary_Binary_CB; + binaryCB.Opaque_CB = Binary_Opaque_CB; + binaryCB.Entity_CB = Binary_Entity_CB; + // For parse errors + binaryCB.Exception_CB = Binary_Exception_CB; + + // init dictionarys + NW_WBXML_Dictionary_t *dictionaries[DICTIONARY_COUNT]; + dictionaries[0] = (NW_WBXML_Dictionary_t *)&NW_SyncML_1_0_WBXMLDictionary; + dictionaries[1] = (NW_WBXML_Dictionary_t *)&NW_Wml_1_0_WBXMLDictionary; + dictionaries[2] = (NW_WBXML_Dictionary_t *)&NW_Wml_1_1_WBXMLDictionary; + dictionaries[3] = (NW_WBXML_Dictionary_t *)&NW_Wml_1_2_WBXMLDictionary; + dictionaries[4] = (NW_WBXML_Dictionary_t *)&NW_Wml_1_3_WBXMLDictionary; + dictionaries[5] = (NW_WBXML_Dictionary_t *)&NW_XHTML_WBXMLDictionary; + dictionaries[6] = (NW_WBXML_Dictionary_t *)&NW_SL_WBXMLDictionary; +// dictionaries[7] = (NW_WBXML_Dictionary_t *)&SL_dictionary; +// dictionaries[8] = (NW_WBXML_Dictionary_t *)&NW_wap_prov_doc_WBXMLDictionary; +// dictionaries[9] = (NW_WBXML_Dictionary_t *)&push_nokprov_dictionary; + + if ((NW_WBXML_Dictionary_initialize (DICTIONARY_COUNT, dictionaries)) != NW_STAT_SUCCESS) + { + return KErrDictionaryInitFailed; + } + + NW_Status_t status; + + // create parser + NW_WBXML_Parser_t *parser = (NW_WBXML_Parser_t*)User::Alloc(sizeof(NW_WBXML_Parser_t)); + if(parser == NULL) + { + NW_WBXML_Dictionary_destroy(); + return KErrParseFailed; + } + NW_WBXML_Parser_newInPlace(parser); + + // create document + NW_WBXML_Document_t *doc = (NW_WBXML_Document_t*)User::Alloc(sizeof(NW_WBXML_Document_t)); + if(doc == NULL) + { + NW_WBXML_Dictionary_destroy(); + User::Free(parser); + parser = NULL; + return KErrParseFailed; + } + status = NW_WBXML_Document_construct(doc, SL_1_0_PUBLIC_ID); + if(status != NW_STAT_SUCCESS) + { + NW_WBXML_Dictionary_destroy(); + User::Free(parser); + parser = NULL; + User::Free(doc); + doc = NULL; + return KErrParseFailed; + } + + + status =NW_WBXML_Parser_registerHandler(parser, &binaryCB, (void*)iParserObserver); + + + if (status == NW_STAT_SUCCESS) + { + status = NW_WBXML_Parser_parseBuffer(parser, doc, (NW_Byte*)aBuff.Ptr(), (NW_Uint32)aBuff.Length()); + } + + NW_WBXML_Dictionary_destroy(); + + User::Free(parser); + parser = NULL; + NW_WBXML_Document_destruct(doc); + User::Free(doc); + doc = NULL; + if(status != NW_STAT_SUCCESS) + { + return KErrParseFailed; + } + return KErrNone; +} + +// End of File