void Profile::read_from_configuration (Configuration* configuration) { TiXmlNode* node = 0; // insert initial mandatory declaration if not present TiXmlNode* decl = 0; for (TiXmlNode* child = xmlProfileDoc->FirstChild(); child && !decl; child = child->NextSibling() ) { decl = child->ToDeclaration (); } if (! decl) { node = xmlProfileDoc->InsertEndChild( TiXmlDeclaration( "1.0", "UTF-8", "no" ) ); assert (node); } // for each configuration variable in configuration for (std::map<std::string, Variable*>::const_iterator conf_it = configuration->begin(); conf_it != configuration->end(); conf_it ++) { // start from root of DOM node = xmlProfileDoc; // get the variable name and break it up in its component vector std::string variable_name = conf_it->second->get_name (); std::vector<std::string> variable_name_vector = Variable::string_to_vector (variable_name); // for each component in variable name vector for (size_t i = 0; i < variable_name_vector.size(); i++) { // check if component element exists TiXmlElement* existing = node->FirstChildElement (variable_name_vector[i].c_str()); if (existing) { // carry on with existing component node = existing; } else { // create missing component element and carry on with new component node = node->InsertEndChild (TiXmlElement (variable_name_vector[i].c_str())); assert (node); } } // check if a text node for element exists TiXmlText* text = 0; for(TiXmlNode* child = node->FirstChild(); child && !text; child = child->NextSibling() ) { text = child->ToText (); } if (text) { // text child already exists, so remove it to set new value node->RemoveChild (text); } node = node->InsertEndChild (TiXmlText (conf_it->second->get_value ().c_str ())); assert (node); } }
void XMLUtils::LoadXMLFile( TiXmlDocument& doc, bool condenseWhiteSpace, const wxString& path ) { if ( path.empty() ) { THROW_WXFBEX( _("LoadXMLFile needs a path") ) } if ( !::wxFileExists( path ) ) { THROW_WXFBEX( _("The file does not exist.\nFile: ") << path ) } TiXmlBase::SetCondenseWhiteSpace( condenseWhiteSpace ); doc.SetValue( std::string( path.mb_str( wxConvFile ) ) ); if ( !doc.LoadFile() ) { // Ask user to all wxFB to convert the file to UTF-8 and add the XML declaration wxString msg = _("This xml file could not be loaded. This could be the result of an unsupported encoding.\n"); msg += _("Would you like wxFormBuilder to backup the file and convert it to UTF-8\?\n"); msg += _("You will be prompted for the original encoding.\n\n"); msg += _("Path: "); msg += path; if ( wxNO == wxMessageBox( msg, _("Unable to load file"), wxICON_QUESTION | wxYES_NO | wxYES_DEFAULT, wxTheApp->GetTopWindow() ) ) { // User declined, give up THROW_WXFBEX( _("Unable to load file: ") << path ); } // User accepted, convert the file wxFontEncoding chosenEncoding = StringUtils::GetEncodingFromUser( _("Please choose the original encoding.") ); if ( wxFONTENCODING_MAX == chosenEncoding ) { THROW_WXFBEX( _("Unable to load file: ") << path ); } ConvertAndAddDeclaration( path, chosenEncoding ); LoadXMLFile( doc, condenseWhiteSpace, path ); } TiXmlDeclaration* declaration = NULL; TiXmlNode* firstChild = doc.FirstChild(); if ( firstChild ) { declaration = firstChild->ToDeclaration(); } LoadXMLFileImp( doc, condenseWhiteSpace, path, declaration ); }
void JXmlDocument::GetDeclaration(JString& version, JString& encoding, JString& standlone) { TiXmlNode* child = NULL; while( child = m_xmlDoc.IterateChildren(child) ){ if( IsDeclarationNode(child) ){ #ifdef UNICODE version = Utf8ToWideString(child->ToDeclaration()->Version()); encoding = Utf8ToWideString(child->ToDeclaration()->Encoding()); standlone = Utf8ToWideString(child->ToDeclaration()->Standalone()); #else version = child->ToDeclaration()->Version(); encoding = child->ToDeclaration()->Encoding(); standlone = child->ToDeclaration()->Standalone(); #endif break; } } }
const char* TiXmlDocument::Parse( const char* p, TiXmlParsingData* prevData, TiXmlEncoding encoding ) { ClearError(); // Parse away, at the document level. Since a document // contains nothing but other tags, most of what happens // here is skipping white space. if ( !p || !*p ) { SetError( TIXML_ERROR_DOCUMENT_EMPTY, 0, 0, TIXML_ENCODING_UNKNOWN ); return 0; } // Note that, for a document, this needs to come // before the while space skip, so that parsing // starts from the pointer we are given. location.Clear(); if ( prevData ) { location.row = prevData->cursor.row; location.col = prevData->cursor.col; } else { location.row = 0; location.col = 0; } TiXmlParsingData data( p, TabSize(), location.row, location.col ); location = data.Cursor(); if ( encoding == TIXML_ENCODING_UNKNOWN ) { // Check for the Microsoft UTF-8 lead bytes. const unsigned char* pU = (const unsigned char*)p; if ( *(pU+0) && *(pU+0) == TIXML_UTF_LEAD_0 && *(pU+1) && *(pU+1) == TIXML_UTF_LEAD_1 && *(pU+2) && *(pU+2) == TIXML_UTF_LEAD_2 ) { encoding = TIXML_ENCODING_UTF8; useMicrosoftBOM = true; } } p = SkipWhiteSpace( p, encoding ); if ( !p ) { SetError( TIXML_ERROR_DOCUMENT_EMPTY, 0, 0, TIXML_ENCODING_UNKNOWN ); return 0; } while ( p && *p ) { TiXmlNode* node = Identify( p, encoding ); if ( node ) { p = node->Parse( p, &data, encoding ); LinkEndChild( node ); } else { break; } // Did we get encoding info? if ( encoding == TIXML_ENCODING_UNKNOWN && node->ToDeclaration() ) { TiXmlDeclaration* dec = node->ToDeclaration(); const char* enc = dec->Encoding(); assert( enc ); if ( *enc == 0 ) encoding = TIXML_ENCODING_UTF8; else if ( StringEqual( enc, "UTF-8", true, TIXML_ENCODING_UNKNOWN ) ) encoding = TIXML_ENCODING_UTF8; else if ( StringEqual( enc, "UTF8", true, TIXML_ENCODING_UNKNOWN ) ) encoding = TIXML_ENCODING_UTF8; // incorrect, but be nice else encoding = TIXML_ENCODING_LEGACY; } p = SkipWhiteSpace( p, encoding ); } // Was this empty? if ( !firstChild ) { SetError( TIXML_ERROR_DOCUMENT_EMPTY, 0, 0, encoding ); return 0; } // All is well. return p; }
TiXmlDeclaration& updTiXmlDeclaration() { TiXmlNode* decl = m_tixml.FirstChild(); assert(decl && decl->Type()==TiXmlNode::DECLARATION); return *decl->ToDeclaration(); }
const char* TiXmlDocument::Parse ( const char* p, TiXmlParsingData* prevData, TiXmlEncoding encoding ) { ClearError(); // Parse away, at the document level. Since a document // contains nothing but other tags, most of what happens // here is skipping white space. // sherm 100319: I changed this so that untagged top-level text is // parsed as a Text node rather than a parsing error. CDATA text was // already allowed at the top level so this seems more consistent. if ( !p || !*p ) { SetError( TIXML_ERROR_DOCUMENT_EMPTY, 0, 0, TIXML_ENCODING_UNKNOWN ); return 0; } // Note that, for a document, this needs to come // before the while space skip, so that parsing // starts from the pointer we are given. location.Clear(); if ( prevData ) { location.row = prevData->cursor.row; location.col = prevData->cursor.col; } else { location.row = 0; location.col = 0; } TiXmlParsingData data( p, TabSize(), location.row, location.col ); location = data.Cursor(); if ( encoding == TIXML_ENCODING_UNKNOWN ) { // Check for the Microsoft UTF-8 lead bytes. const unsigned char* pU = (const unsigned char*)p; if ( *(pU+0) && *(pU+0) == TIXML_UTF_LEAD_0 && *(pU+1) && *(pU+1) == TIXML_UTF_LEAD_1 && *(pU+2) && *(pU+2) == TIXML_UTF_LEAD_2 ) { encoding = TIXML_ENCODING_UTF8; useMicrosoftBOM = true; } } // Remember the start of white space in case we end up reading a text // element in a "keep white space" mode. const char* pWithWhiteSpace = p; p = SkipWhiteSpace( p, encoding ); if ( !p ) { SetError( TIXML_ERROR_DOCUMENT_EMPTY, 0, 0, TIXML_ENCODING_UNKNOWN ); return 0; } // sherm 100319: ignore all but the first Declaration bool haveSeenDeclaration = false; while ( p && *p ) { TiXmlNode* node = 0; if ( *p != '<' ) { // sherm 100319: I added this case by stealing the code from // Element parsing; see above comment. // Take what we have, make a text element. TiXmlText* textNode = new TiXmlText( "" ); if ( !textNode ) { SetError( TIXML_ERROR_OUT_OF_MEMORY, 0, 0, encoding ); return 0; } if ( TiXmlBase::IsWhiteSpaceCondensed() ) { p = textNode->Parse( p, &data, encoding ); } else { // Special case: we want to keep the white space // so that leading spaces aren't removed. p = textNode->Parse( pWithWhiteSpace, &data, encoding ); } if ( !textNode->Blank() ) { LinkEndChild( textNode ); node = textNode; } else delete textNode; } else // We saw a '<', now identify what kind of tag it is. { TiXmlNode* node = Identify( p, encoding ); if ( node ) { p = node->Parse( p, &data, encoding ); if (node->ToDeclaration()) { if (haveSeenDeclaration) { delete node; node=0; // ignore duplicate Declaration } else haveSeenDeclaration = true; } if (node) LinkEndChild( node ); } else { // If Identify fails then no further parsing is possible. break; } } // Did we get encoding info? if ( encoding == TIXML_ENCODING_UNKNOWN && node && node->ToDeclaration() ) { TiXmlDeclaration* dec = node->ToDeclaration(); const char* enc = dec->Encoding(); assert( enc ); if ( *enc == 0 ) encoding = TIXML_ENCODING_UTF8; else if ( StringEqual( enc, "UTF-8", true, TIXML_ENCODING_UNKNOWN ) ) encoding = TIXML_ENCODING_UTF8; else if ( StringEqual( enc, "UTF8", true, TIXML_ENCODING_UNKNOWN ) ) encoding = TIXML_ENCODING_UTF8; // incorrect, but be nice else encoding = TIXML_ENCODING_LEGACY; } pWithWhiteSpace = p; p = SkipWhiteSpace( p, encoding ); } // Was this empty? if ( !firstChild ) { SetError( TIXML_ERROR_DOCUMENT_EMPTY, 0, 0, encoding ); return 0; } // All is well. return p; }