summaryrefslogtreecommitdiff
path: root/indra/llxml/llxmlnode.cpp
diff options
context:
space:
mode:
authorAnsariel <ansariel.hiller@phoenixviewer.com>2024-05-22 21:25:21 +0200
committerAndrey Lihatskiy <alihatskiy@productengine.com>2024-05-22 22:40:26 +0300
commite2e37cced861b98de8c1a7c9c0d3a50d2d90e433 (patch)
tree1bb897489ce524986f6196201c10ac0d8861aa5f /indra/llxml/llxmlnode.cpp
parent069ea06848f766466f1a281144c82a0f2bd79f3a (diff)
Fix line endlings
Diffstat (limited to 'indra/llxml/llxmlnode.cpp')
-rw-r--r--indra/llxml/llxmlnode.cpp6536
1 files changed, 3268 insertions, 3268 deletions
diff --git a/indra/llxml/llxmlnode.cpp b/indra/llxml/llxmlnode.cpp
index e7ea5a9fad..5e98af8412 100644
--- a/indra/llxml/llxmlnode.cpp
+++ b/indra/llxml/llxmlnode.cpp
@@ -1,3268 +1,3268 @@
-/**
- * @file llxmlnode.cpp
- * @author Tom Yedwab
- * @brief LLXMLNode implementation
- *
- * $LicenseInfo:firstyear=2005&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- *
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
- * $/LicenseInfo$
- */
-
-#include "linden_common.h"
-
-#include <iostream>
-#include <map>
-
-#include "llxmlnode.h"
-
-#include "v3color.h"
-#include "v4color.h"
-#include "v4coloru.h"
-#include "v3math.h"
-#include "v3dmath.h"
-#include "v4math.h"
-#include "llquaternion.h"
-#include "llstring.h"
-#include "lluuid.h"
-#include "lldir.h"
-
-// static
-bool LLXMLNode::sStripEscapedStrings = true;
-bool LLXMLNode::sStripWhitespaceValues = false;
-
-LLXMLNode::LLXMLNode() :
- mID(""),
- mParser(NULL),
- mIsAttribute(false),
- mVersionMajor(0),
- mVersionMinor(0),
- mLength(0),
- mPrecision(64),
- mType(TYPE_CONTAINER),
- mEncoding(ENCODING_DEFAULT),
- mLineNumber(-1),
- mParent(NULL),
- mChildren(NULL),
- mAttributes(),
- mPrev(NULL),
- mNext(NULL),
- mName(NULL),
- mValue(""),
- mDefault(NULL)
-{
-}
-
-LLXMLNode::LLXMLNode(const char* name, bool is_attribute) :
- mID(""),
- mParser(NULL),
- mIsAttribute(is_attribute),
- mVersionMajor(0),
- mVersionMinor(0),
- mLength(0),
- mPrecision(64),
- mType(TYPE_CONTAINER),
- mEncoding(ENCODING_DEFAULT),
- mLineNumber(-1),
- mParent(NULL),
- mChildren(NULL),
- mAttributes(),
- mPrev(NULL),
- mNext(NULL),
- mValue(""),
- mDefault(NULL)
-{
- mName = gStringTable.addStringEntry(name);
-}
-
-LLXMLNode::LLXMLNode(LLStringTableEntry* name, bool is_attribute) :
- mID(""),
- mParser(NULL),
- mIsAttribute(is_attribute),
- mVersionMajor(0),
- mVersionMinor(0),
- mLength(0),
- mPrecision(64),
- mType(TYPE_CONTAINER),
- mEncoding(ENCODING_DEFAULT),
- mLineNumber(-1),
- mParent(NULL),
- mChildren(NULL),
- mAttributes(),
- mPrev(NULL),
- mNext(NULL),
- mName(name),
- mValue(""),
- mDefault(NULL)
-{
-}
-
-// copy constructor (except for the children)
-LLXMLNode::LLXMLNode(const LLXMLNode& rhs) :
- mID(rhs.mID),
- mIsAttribute(rhs.mIsAttribute),
- mVersionMajor(rhs.mVersionMajor),
- mVersionMinor(rhs.mVersionMinor),
- mLength(rhs.mLength),
- mPrecision(rhs.mPrecision),
- mType(rhs.mType),
- mEncoding(rhs.mEncoding),
- mLineNumber(0),
- mParser(NULL),
- mParent(NULL),
- mChildren(NULL),
- mAttributes(),
- mPrev(NULL),
- mNext(NULL),
- mName(rhs.mName),
- mValue(rhs.mValue),
- mDefault(rhs.mDefault)
-{
-}
-
-// returns a new copy of this node and all its children
-LLXMLNodePtr LLXMLNode::deepCopy()
-{
- LLXMLNodePtr newnode = LLXMLNodePtr(new LLXMLNode(*this));
- if (mChildren.notNull())
- {
- for (LLXMLChildList::iterator iter = mChildren->map.begin();
- iter != mChildren->map.end(); ++iter)
- {
- LLXMLNodePtr temp_ptr_for_gcc(iter->second->deepCopy());
- newnode->addChild(temp_ptr_for_gcc);
- }
- }
- for (LLXMLAttribList::iterator iter = mAttributes.begin();
- iter != mAttributes.end(); ++iter)
- {
- LLXMLNodePtr temp_ptr_for_gcc(iter->second->deepCopy());
- newnode->addChild(temp_ptr_for_gcc);
- }
-
- return newnode;
-}
-
-// virtual
-LLXMLNode::~LLXMLNode()
-{
- // Strictly speaking none of this should be required execept 'delete mChildren'...
- // Sadly, that's only true if we hadn't had reference-counted smart pointers linked
- // in three different directions. This entire class is a frightening, hard-to-maintain
- // mess.
- if (mChildren.notNull())
- {
- for (LLXMLChildList::iterator iter = mChildren->map.begin();
- iter != mChildren->map.end(); ++iter)
- {
- LLXMLNodePtr child = iter->second;
- child->mParent = NULL;
- child->mNext = NULL;
- child->mPrev = NULL;
- }
- mChildren->map.clear();
- mChildren->head = NULL;
- mChildren->tail = NULL;
- mChildren = NULL;
- }
- for (LLXMLAttribList::iterator iter = mAttributes.begin();
- iter != mAttributes.end(); ++iter)
- {
- LLXMLNodePtr attr = iter->second;
- attr->mParent = NULL;
- attr->mNext = NULL;
- attr->mPrev = NULL;
- }
- llassert(mParent == NULL);
- mDefault = NULL;
-}
-
-bool LLXMLNode::isNull()
-{
- return (mName == NULL);
-}
-
-// protected
-bool LLXMLNode::removeChild(LLXMLNode *target_child)
-{
- if (!target_child)
- {
- return false;
- }
- if (target_child->mIsAttribute)
- {
- LLXMLAttribList::iterator children_itr = mAttributes.find(target_child->mName);
- if (children_itr != mAttributes.end())
- {
- target_child->mParent = NULL;
- mAttributes.erase(children_itr);
- return true;
- }
- }
- else if (mChildren.notNull())
- {
- LLXMLChildList::iterator children_itr = mChildren->map.find(target_child->mName);
- while (children_itr != mChildren->map.end())
- {
- if (target_child == children_itr->second)
- {
- if (target_child == mChildren->head)
- {
- mChildren->head = target_child->mNext;
- }
- if (target_child == mChildren->tail)
- {
- mChildren->tail = target_child->mPrev;
- }
-
- LLXMLNodePtr prev = target_child->mPrev;
- LLXMLNodePtr next = target_child->mNext;
- if (prev.notNull()) prev->mNext = next;
- if (next.notNull()) next->mPrev = prev;
-
- target_child->mPrev = NULL;
- target_child->mNext = NULL;
- target_child->mParent = NULL;
- mChildren->map.erase(children_itr);
- if (mChildren->map.empty())
- {
- mChildren = NULL;
- }
- return true;
- }
- else if (children_itr->first != target_child->mName)
- {
- break;
- }
- else
- {
- ++children_itr;
- }
- }
- }
- return false;
-}
-
-void LLXMLNode::addChild(LLXMLNodePtr& new_child)
-{
- if (new_child->mParent != NULL)
- {
- if (new_child->mParent == this)
- {
- return;
- }
- new_child->mParent->removeChild(new_child);
- }
-
- new_child->mParent = this;
- if (new_child->mIsAttribute)
- {
- LLXMLAttribList::iterator found_it = mAttributes.find(new_child->mName);
- if (found_it != mAttributes.end())
- {
- removeChild(found_it->second);
- }
- mAttributes.insert(std::make_pair(new_child->mName, new_child));
- }
- else
- {
- if (mChildren.isNull())
- {
- mChildren = new LLXMLChildren();
- mChildren->head = new_child;
- mChildren->tail = new_child;
- }
- mChildren->map.insert(std::make_pair(new_child->mName, new_child));
-
- if (mChildren->tail != new_child)
- {
- mChildren->tail->mNext = new_child;
- new_child->mPrev = mChildren->tail;
- mChildren->tail = new_child;
- }
- }
-
- new_child->updateDefault();
-}
-
-// virtual
-LLXMLNodePtr LLXMLNode::createChild(const char* name, bool is_attribute)
-{
- return createChild(gStringTable.addStringEntry(name), is_attribute);
-}
-
-// virtual
-LLXMLNodePtr LLXMLNode::createChild(LLStringTableEntry* name, bool is_attribute)
-{
- LLXMLNodePtr ret(new LLXMLNode(name, is_attribute));
- ret->mID.clear();
-
- addChild(ret);
- return ret;
-}
-
-bool LLXMLNode::deleteChild(LLXMLNode *child)
-{
- if (removeChild(child))
- {
- return true;
- }
- return false;
-}
-
-void LLXMLNode::setParent(LLXMLNodePtr& new_parent)
-{
- if (new_parent.notNull())
- {
- LLXMLNodePtr this_ptr(this);
- new_parent->addChild(this_ptr);
- }
- else
- {
- if (mParent != NULL)
- {
- LLXMLNodePtr old_parent = mParent;
- mParent = NULL;
- old_parent->removeChild(this);
- }
- }
-}
-
-
-void LLXMLNode::updateDefault()
-{
- if (mParent != NULL && !mParent->mDefault.isNull())
- {
- mDefault = NULL;
-
- // Find default value in parent's default tree
- if (!mParent->mDefault.isNull())
- {
- findDefault(mParent->mDefault);
- }
- }
-
- if (mChildren.notNull())
- {
- LLXMLChildList::const_iterator children_itr;
- LLXMLChildList::const_iterator children_end = mChildren->map.end();
- for (children_itr = mChildren->map.begin(); children_itr != children_end; ++children_itr)
- {
- LLXMLNodePtr child = (*children_itr).second;
- child->updateDefault();
- }
- }
-}
-
-void XMLCALL StartXMLNode(void *userData,
- const XML_Char *name,
- const XML_Char **atts)
-{
- // Create a new node
- LLXMLNode *new_node_ptr = new LLXMLNode(name, false);
-
- LLXMLNodePtr new_node = new_node_ptr;
- new_node->mID.clear();
- LLXMLNodePtr ptr_new_node = new_node;
-
- // Set the parent-child relationship with the current active node
- LLXMLNode* parent = (LLXMLNode *)userData;
-
- if (NULL == parent)
- {
- LL_WARNS() << "parent (userData) is NULL; aborting function" << LL_ENDL;
- return;
- }
-
- new_node_ptr->mParser = parent->mParser;
- new_node_ptr->setLineNumber(XML_GetCurrentLineNumber(*new_node_ptr->mParser));
-
- // Set the current active node to the new node
- XML_Parser *parser = parent->mParser;
- XML_SetUserData(*parser, (void *)new_node_ptr);
-
- // Parse attributes
- U32 pos = 0;
- while (atts[pos] != NULL)
- {
- std::string attr_name = atts[pos];
- std::string attr_value = atts[pos+1];
-
- // Special cases
- if ('i' == attr_name[0] && "id" == attr_name)
- {
- new_node->mID = attr_value;
- }
- else if ('v' == attr_name[0] && "version" == attr_name)
- {
- U32 version_major = 0;
- U32 version_minor = 0;
- if (sscanf(attr_value.c_str(), "%d.%d", &version_major, &version_minor) > 0)
- {
- new_node->mVersionMajor = version_major;
- new_node->mVersionMinor = version_minor;
- }
- }
- else if (('s' == attr_name[0] && "size" == attr_name) || ('l' == attr_name[0] && "length" == attr_name))
- {
- U32 length;
- if (sscanf(attr_value.c_str(), "%d", &length) > 0)
- {
- new_node->mLength = length;
- }
- }
- else if ('p' == attr_name[0] && "precision" == attr_name)
- {
- U32 precision;
- if (sscanf(attr_value.c_str(), "%d", &precision) > 0)
- {
- new_node->mPrecision = precision;
- }
- }
- else if ('t' == attr_name[0] && "type" == attr_name)
- {
- if ("boolean" == attr_value)
- {
- new_node->mType = LLXMLNode::TYPE_BOOLEAN;
- }
- else if ("integer" == attr_value)
- {
- new_node->mType = LLXMLNode::TYPE_INTEGER;
- }
- else if ("float" == attr_value)
- {
- new_node->mType = LLXMLNode::TYPE_FLOAT;
- }
- else if ("string" == attr_value)
- {
- new_node->mType = LLXMLNode::TYPE_STRING;
- }
- else if ("uuid" == attr_value)
- {
- new_node->mType = LLXMLNode::TYPE_UUID;
- }
- else if ("noderef" == attr_value)
- {
- new_node->mType = LLXMLNode::TYPE_NODEREF;
- }
- }
- else if ('e' == attr_name[0] && "encoding" == attr_name)
- {
- if ("decimal" == attr_value)
- {
- new_node->mEncoding = LLXMLNode::ENCODING_DECIMAL;
- }
- else if ("hex" == attr_value)
- {
- new_node->mEncoding = LLXMLNode::ENCODING_HEX;
- }
- /*else if (attr_value == "base32")
- {
- new_node->mEncoding = LLXMLNode::ENCODING_BASE32;
- }*/
- }
-
- // only one attribute child per description
- LLXMLNodePtr attr_node;
- if (!new_node->getAttribute(attr_name.c_str(), attr_node, false))
- {
- attr_node = new LLXMLNode(attr_name.c_str(), true);
- attr_node->setLineNumber(XML_GetCurrentLineNumber(*new_node_ptr->mParser));
- }
- attr_node->setValue(attr_value);
- new_node->addChild(attr_node);
-
- pos += 2;
- }
-
- if (parent)
- {
- parent->addChild(new_node);
- }
-}
-
-void XMLCALL EndXMLNode(void *userData,
- const XML_Char *name)
-{
- // [FUGLY] Set the current active node to the current node's parent
- LLXMLNode *node = (LLXMLNode *)userData;
- XML_Parser *parser = node->mParser;
- XML_SetUserData(*parser, (void *)node->mParent);
- // SJB: total hack:
- if (LLXMLNode::sStripWhitespaceValues)
- {
- std::string value = node->getValue();
- bool is_empty = true;
- for (std::string::size_type s = 0; s < value.length(); s++)
- {
- char c = value[s];
- if (c != ' ' && c != '\t' && c != '\n')
- {
- is_empty = false;
- break;
- }
- }
- if (is_empty)
- {
- value.clear();
- node->setValue(value);
- }
- }
-}
-
-void XMLCALL XMLData(void *userData,
- const XML_Char *s,
- int len)
-{
- LLXMLNode* current_node = (LLXMLNode *)userData;
- std::string value = current_node->getValue();
- if (LLXMLNode::sStripEscapedStrings)
- {
- if (s[0] == '\"' && s[len-1] == '\"')
- {
- // Special-case: Escaped string.
- std::string unescaped_string;
- for (S32 pos=1; pos<len-1; ++pos)
- {
- if (s[pos] == '\\' && s[pos+1] == '\\')
- {
- unescaped_string.append("\\");
- ++pos;
- }
- else if (s[pos] == '\\' && s[pos+1] == '\"')
- {
- unescaped_string.append("\"");
- ++pos;
- }
- else
- {
- unescaped_string.append(&s[pos], 1);
- }
- }
- value.append(unescaped_string);
- current_node->setValue(value);
- return;
- }
- }
- value.append(std::string(s, len));
- current_node->setValue(value);
-}
-
-
-
-// static
-bool LLXMLNode::updateNode(
- LLXMLNodePtr& node,
- LLXMLNodePtr& update_node)
-{
-
- if (!node || !update_node)
- {
- LL_WARNS() << "Node invalid" << LL_ENDL;
- return false;
- }
-
- //update the node value
- node->mValue = update_node->mValue;
-
- //update all attribute values
- LLXMLAttribList::const_iterator itor;
-
- for(itor = update_node->mAttributes.begin(); itor != update_node->mAttributes.end(); ++itor)
- {
- const LLStringTableEntry* attribNameEntry = (*itor).first;
- LLXMLNodePtr updateAttribNode = (*itor).second;
-
- LLXMLNodePtr attribNode;
-
- node->getAttribute(attribNameEntry, attribNode, 0);
-
- if (attribNode)
- {
- attribNode->mValue = updateAttribNode->mValue;
- }
- }
-
- //update all of node's children with updateNodes children that match name
- LLXMLNodePtr child = node->getFirstChild();
- LLXMLNodePtr last_child = child;
- LLXMLNodePtr updateChild;
-
- for (updateChild = update_node->getFirstChild(); updateChild.notNull();
- updateChild = updateChild->getNextSibling())
- {
- while(child.notNull())
- {
- std::string nodeName;
- std::string updateName;
-
- updateChild->getAttributeString("name", updateName);
- child->getAttributeString("name", nodeName);
-
-
- //if it's a combobox there's no name, but there is a value
- if (updateName.empty())
- {
- updateChild->getAttributeString("value", updateName);
- child->getAttributeString("value", nodeName);
- }
-
- if ((nodeName != "") && (updateName == nodeName))
- {
- updateNode(child, updateChild);
- last_child = child;
- child = child->getNextSibling();
- if (child.isNull())
- {
- child = node->getFirstChild();
- }
- break;
- }
-
- child = child->getNextSibling();
- if (child.isNull())
- {
- child = node->getFirstChild();
- }
- if (child == last_child)
- {
- break;
- }
- }
- }
-
- return true;
-}
-
-// static
-bool LLXMLNode::parseFile(const std::string& filename, LLXMLNodePtr& node, LLXMLNode* defaults_tree)
-{
- // Read file
- LL_DEBUGS("XMLNode") << "parsing XML file: " << filename << LL_ENDL;
- LLFILE* fp = LLFile::fopen(filename, "rb"); /* Flawfinder: ignore */
- if (fp == NULL)
- {
- node = NULL ;
- return false;
- }
- fseek(fp, 0, SEEK_END);
- U32 length = ftell(fp);
- fseek(fp, 0, SEEK_SET);
-
- U8* buffer = new U8[length+1];
- size_t nread = fread(buffer, 1, length, fp);
- buffer[nread] = 0;
- fclose(fp);
-
- bool rv = parseBuffer(buffer, nread, node, defaults_tree);
- delete [] buffer;
- return rv;
-}
-
-// static
-bool LLXMLNode::parseBuffer(
- U8* buffer,
- U32 length,
- LLXMLNodePtr& node,
- LLXMLNode* defaults)
-{
- // Init
- XML_Parser my_parser = XML_ParserCreate(NULL);
- XML_SetElementHandler(my_parser, StartXMLNode, EndXMLNode);
- XML_SetCharacterDataHandler(my_parser, XMLData);
-
- // Create a root node
- LLXMLNode *file_node_ptr = new LLXMLNode("XML", false);
- LLXMLNodePtr file_node = file_node_ptr;
-
- file_node->mParser = &my_parser;
-
- XML_SetUserData(my_parser, (void *)file_node_ptr);
-
- // Do the parsing
- if (XML_Parse(my_parser, (const char *)buffer, length, true) != XML_STATUS_OK)
- {
- LL_WARNS() << "Error parsing xml error code: "
- << XML_ErrorString(XML_GetErrorCode(my_parser))
- << " on line " << XML_GetCurrentLineNumber(my_parser)
- << LL_ENDL;
- }
-
- // Deinit
- XML_ParserFree(my_parser);
-
- if (!file_node->mChildren || file_node->mChildren->map.size() != 1)
- {
- LL_WARNS() << "Parse failure - wrong number of top-level nodes xml."
- << LL_ENDL;
- node = NULL ;
- return false;
- }
-
- LLXMLNode *return_node = file_node->mChildren->map.begin()->second;
-
- return_node->setDefault(defaults);
- return_node->updateDefault();
-
- node = return_node;
- return true;
-}
-
-// static
-bool LLXMLNode::parseStream(
- std::istream& str,
- LLXMLNodePtr& node,
- LLXMLNode* defaults)
-{
- // Init
- XML_Parser my_parser = XML_ParserCreate(NULL);
- XML_SetElementHandler(my_parser, StartXMLNode, EndXMLNode);
- XML_SetCharacterDataHandler(my_parser, XMLData);
-
- // Create a root node
- LLXMLNode *file_node_ptr = new LLXMLNode("XML", false);
- LLXMLNodePtr file_node = file_node_ptr;
-
- file_node->mParser = &my_parser;
-
- XML_SetUserData(my_parser, (void *)file_node_ptr);
-
- const int BUFSIZE = 1024;
- U8* buffer = new U8[BUFSIZE];
-
- while(str.good())
- {
- str.read((char*)buffer, BUFSIZE);
- int count = (int)str.gcount();
-
- if (XML_Parse(my_parser, (const char *)buffer, count, !str.good()) != XML_STATUS_OK)
- {
- LL_WARNS() << "Error parsing xml error code: "
- << XML_ErrorString(XML_GetErrorCode(my_parser))
- << " on lne " << XML_GetCurrentLineNumber(my_parser)
- << LL_ENDL;
- break;
- }
- }
-
- delete [] buffer;
-
- // Deinit
- XML_ParserFree(my_parser);
-
- if (!file_node->mChildren || file_node->mChildren->map.size() != 1)
- {
- LL_WARNS() << "Parse failure - wrong number of top-level nodes xml."
- << LL_ENDL;
- node = NULL;
- return false;
- }
-
- LLXMLNode *return_node = file_node->mChildren->map.begin()->second;
-
- return_node->setDefault(defaults);
- return_node->updateDefault();
-
- node = return_node;
- return true;
-}
-
-
-bool LLXMLNode::isFullyDefault()
-{
- if (mDefault.isNull())
- {
- return false;
- }
- bool has_default_value = (mValue == mDefault->mValue);
- bool has_default_attribute = (mIsAttribute == mDefault->mIsAttribute);
- bool has_default_type = mIsAttribute || (mType == mDefault->mType);
- bool has_default_encoding = mIsAttribute || (mEncoding == mDefault->mEncoding);
- bool has_default_precision = mIsAttribute || (mPrecision == mDefault->mPrecision);
- bool has_default_length = mIsAttribute || (mLength == mDefault->mLength);
-
- if (has_default_value
- && has_default_type
- && has_default_encoding
- && has_default_precision
- && has_default_length
- && has_default_attribute)
- {
- if (mChildren.notNull())
- {
- LLXMLChildList::const_iterator children_itr;
- LLXMLChildList::const_iterator children_end = mChildren->map.end();
- for (children_itr = mChildren->map.begin(); children_itr != children_end; ++children_itr)
- {
- LLXMLNodePtr child = (*children_itr).second;
- if (!child->isFullyDefault())
- {
- return false;
- }
- }
- }
- return true;
- }
-
- return false;
-}
-
-// static
-bool LLXMLNode::getLayeredXMLNode(LLXMLNodePtr& root,
- const std::vector<std::string>& paths)
-{
- if (paths.empty()) return false;
-
- std::string filename = paths.front();
- if (filename.empty())
- {
- return false;
- }
-
- if (!LLXMLNode::parseFile(filename, root, NULL))
- {
- LL_WARNS() << "Problem reading UI description file: " << filename << " " << errno << LL_ENDL;
- return false;
- }
-
- LLXMLNodePtr updateRoot;
-
- std::vector<std::string>::const_iterator itor;
-
- // We've already dealt with the first item, skip that one
- for (itor = paths.begin() + 1; itor != paths.end(); ++itor)
- {
- std::string layer_filename = *itor;
- if(layer_filename.empty() || layer_filename == filename)
- {
- // no localized version of this file, that's ok, keep looking
- continue;
- }
-
- if (!LLXMLNode::parseFile(layer_filename, updateRoot, NULL))
- {
- LL_WARNS() << "Problem reading localized UI description file: " << layer_filename << LL_ENDL;
- return false;
- }
-
- std::string nodeName;
- std::string updateName;
-
- updateRoot->getAttributeString("name", updateName);
- root->getAttributeString("name", nodeName);
-
- if (updateName == nodeName)
- {
- LLXMLNode::updateNode(root, updateRoot);
- }
- }
-
- return true;
-}
-
-// static
-void LLXMLNode::writeHeaderToFile(LLFILE *out_file)
-{
- fprintf(out_file, "<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"yes\" ?>\n");
-}
-
-void LLXMLNode::writeToFile(LLFILE *out_file, const std::string& indent, bool use_type_decorations)
-{
- if (isFullyDefault())
- {
- // Don't write out nodes that are an exact match to defaults
- return;
- }
-
- std::ostringstream ostream;
- writeToOstream(ostream, indent, use_type_decorations);
- std::string outstring = ostream.str();
- size_t written = fwrite(outstring.c_str(), 1, outstring.length(), out_file);
- if (written != outstring.length())
- {
- LL_WARNS() << "Short write" << LL_ENDL;
- }
-}
-
-void LLXMLNode::writeToOstream(std::ostream& output_stream, const std::string& indent, bool use_type_decorations)
-{
- if (isFullyDefault())
- {
- // Don't write out nodes that are an exact match to defaults
- return;
- }
-
- bool has_default_type = mDefault.isNull()?false:(mType == mDefault->mType);
- bool has_default_encoding = mDefault.isNull()?false:(mEncoding == mDefault->mEncoding);
- bool has_default_precision = mDefault.isNull()?false:(mPrecision == mDefault->mPrecision);
- bool has_default_length = mDefault.isNull()?false:(mLength == mDefault->mLength);
-
- // stream the name
- output_stream << indent << "<" << mName->mString << "\n";
-
- if (use_type_decorations)
- {
- // ID
- if (mID != "")
- {
- output_stream << indent << " id=\"" << mID << "\"\n";
- }
-
- // Type
- if (!has_default_type)
- {
- switch (mType)
- {
- case TYPE_BOOLEAN:
- output_stream << indent << " type=\"boolean\"\n";
- break;
- case TYPE_INTEGER:
- output_stream << indent << " type=\"integer\"\n";
- break;
- case TYPE_FLOAT:
- output_stream << indent << " type=\"float\"\n";
- break;
- case TYPE_STRING:
- output_stream << indent << " type=\"string\"\n";
- break;
- case TYPE_UUID:
- output_stream << indent << " type=\"uuid\"\n";
- break;
- case TYPE_NODEREF:
- output_stream << indent << " type=\"noderef\"\n";
- break;
- default:
- // default on switch(enum) eliminates a warning on linux
- break;
- };
- }
-
- // Encoding
- if (!has_default_encoding)
- {
- switch (mEncoding)
- {
- case ENCODING_DECIMAL:
- output_stream << indent << " encoding=\"decimal\"\n";
- break;
- case ENCODING_HEX:
- output_stream << indent << " encoding=\"hex\"\n";
- break;
- /*case ENCODING_BASE32:
- output_stream << indent << " encoding=\"base32\"\n";
- break;*/
- default:
- // default on switch(enum) eliminates a warning on linux
- break;
- };
- }
-
- // Precision
- if (!has_default_precision && (mType == TYPE_INTEGER || mType == TYPE_FLOAT))
- {
- output_stream << indent << " precision=\"" << mPrecision << "\"\n";
- }
-
- // Version
- if (mVersionMajor > 0 || mVersionMinor > 0)
- {
- output_stream << indent << " version=\"" << mVersionMajor << "." << mVersionMinor << "\"\n";
- }
-
- // Array length
- if (!has_default_length && mLength > 0)
- {
- output_stream << indent << " length=\"" << mLength << "\"\n";
- }
- }
-
- {
- // Write out attributes
- LLXMLAttribList::const_iterator attr_itr;
- LLXMLAttribList::const_iterator attr_end = mAttributes.end();
- for (attr_itr = mAttributes.begin(); attr_itr != attr_end; ++attr_itr)
- {
- LLXMLNodePtr child = (*attr_itr).second;
- if (child->mDefault.isNull() || child->mDefault->mValue != child->mValue)
- {
- std::string attr = child->mName->mString;
- if (use_type_decorations
- && (attr == "id" ||
- attr == "type" ||
- attr == "encoding" ||
- attr == "precision" ||
- attr == "version" ||
- attr == "length"))
- {
- continue; // skip built-in attributes
- }
-
- std::string attr_str = llformat(" %s=\"%s\"",
- attr.c_str(),
- escapeXML(child->mValue).c_str());
- output_stream << indent << attr_str << "\n";
- }
- }
- }
-
- // erase last \n before attaching final > or />
- output_stream.seekp(-1, std::ios::cur);
-
- if (mChildren.isNull() && mValue == "")
- {
- output_stream << " />\n";
- return;
- }
- else
- {
- output_stream << ">\n";
- if (mChildren.notNull())
- {
- // stream non-attributes
- std::string next_indent = indent + " ";
- for (LLXMLNode* child = getFirstChild(); child; child = child->getNextSibling())
- {
- child->writeToOstream(output_stream, next_indent, use_type_decorations);
- }
- }
- if (!mValue.empty())
- {
- std::string contents = getTextContents();
- output_stream << indent << " " << escapeXML(contents) << "\n";
- }
- output_stream << indent << "</" << mName->mString << ">\n";
- }
-}
-
-void LLXMLNode::findName(const std::string& name, LLXMLNodeList &results)
-{
- LLStringTableEntry* name_entry = gStringTable.checkStringEntry(name);
- if (name_entry == mName)
- {
- results.insert(std::make_pair(this->mName->mString, this));
- return;
- }
- if (mChildren.notNull())
- {
- LLXMLChildList::const_iterator children_itr;
- LLXMLChildList::const_iterator children_end = mChildren->map.end();
- for (children_itr = mChildren->map.begin(); children_itr != children_end; ++children_itr)
- {
- LLXMLNodePtr child = (*children_itr).second;
- child->findName(name_entry, results);
- }
- }
-}
-
-void LLXMLNode::findName(LLStringTableEntry* name, LLXMLNodeList &results)
-{
- if (name == mName)
- {
- results.insert(std::make_pair(this->mName->mString, this));
- return;
- }
- if (mChildren.notNull())
- {
- LLXMLChildList::const_iterator children_itr;
- LLXMLChildList::const_iterator children_end = mChildren->map.end();
- for (children_itr = mChildren->map.begin(); children_itr != children_end; ++children_itr)
- {
- LLXMLNodePtr child = (*children_itr).second;
- child->findName(name, results);
- }
- }
-}
-
-void LLXMLNode::findID(const std::string& id, LLXMLNodeList &results)
-{
- if (id == mID)
- {
- results.insert(std::make_pair(this->mName->mString, this));
- return;
- }
- if (mChildren.notNull())
- {
- LLXMLChildList::const_iterator children_itr;
- LLXMLChildList::const_iterator children_end = mChildren->map.end();
- for (children_itr = mChildren->map.begin(); children_itr != children_end; ++children_itr)
- {
- LLXMLNodePtr child = (*children_itr).second;
- child->findID(id, results);
- }
- }
-}
-
-void LLXMLNode::scrubToTree(LLXMLNode *tree)
-{
- if (!tree || tree->mChildren.isNull())
- {
- return;
- }
- if (mChildren.notNull())
- {
- std::vector<LLXMLNodePtr> to_delete_list;
- LLXMLChildList::iterator itor = mChildren->map.begin();
- while (itor != mChildren->map.end())
- {
- LLXMLNodePtr child = itor->second;
- LLXMLNodePtr child_tree = NULL;
- // Look for this child in the default's children
- bool found = false;
- LLXMLChildList::iterator itor2 = tree->mChildren->map.begin();
- while (itor2 != tree->mChildren->map.end())
- {
- if (child->mName == itor2->second->mName)
- {
- child_tree = itor2->second;
- found = true;
- }
- ++itor2;
- }
- if (!found)
- {
- to_delete_list.push_back(child);
- }
- else
- {
- child->scrubToTree(child_tree);
- }
- ++itor;
- }
- std::vector<LLXMLNodePtr>::iterator itor3;
- for (itor3=to_delete_list.begin(); itor3!=to_delete_list.end(); ++itor3)
- {
- LLXMLNodePtr ptr;
- (*itor3)->setParent(ptr);
- }
- }
-}
-
-bool LLXMLNode::getChild(const char* name, LLXMLNodePtr& node, bool use_default_if_missing)
-{
- return getChild(gStringTable.checkStringEntry(name), node, use_default_if_missing);
-}
-
-bool LLXMLNode::getChild(const LLStringTableEntry* name, LLXMLNodePtr& node, bool use_default_if_missing)
-{
- if (mChildren.notNull())
- {
- LLXMLChildList::const_iterator child_itr = mChildren->map.find(name);
- if (child_itr != mChildren->map.end())
- {
- node = (*child_itr).second;
- return true;
- }
- }
- if (use_default_if_missing && !mDefault.isNull())
- {
- return mDefault->getChild(name, node, false);
- }
- node = NULL;
- return false;
-}
-
-void LLXMLNode::getChildren(const char* name, LLXMLNodeList &children, bool use_default_if_missing) const
-{
- getChildren(gStringTable.checkStringEntry(name), children, use_default_if_missing);
-}
-
-void LLXMLNode::getChildren(const LLStringTableEntry* name, LLXMLNodeList &children, bool use_default_if_missing) const
-{
- if (mChildren.notNull())
- {
- LLXMLChildList::const_iterator child_itr = mChildren->map.find(name);
- if (child_itr != mChildren->map.end())
- {
- LLXMLChildList::const_iterator children_end = mChildren->map.end();
- while (child_itr != children_end)
- {
- LLXMLNodePtr child = (*child_itr).second;
- if (name != child->mName)
- {
- break;
- }
- children.insert(std::make_pair(child->mName->mString, child));
- child_itr++;
- }
- }
- }
- if (children.size() == 0 && use_default_if_missing && !mDefault.isNull())
- {
- mDefault->getChildren(name, children, false);
- }
-}
-
-// recursively walks the tree and returns all children at all nesting levels matching the name
-void LLXMLNode::getDescendants(const LLStringTableEntry* name, LLXMLNodeList &children) const
-{
- if (mChildren.notNull())
- {
- for (LLXMLChildList::const_iterator child_itr = mChildren->map.begin();
- child_itr != mChildren->map.end(); ++child_itr)
- {
- LLXMLNodePtr child = (*child_itr).second;
- if (name == child->mName)
- {
- children.insert(std::make_pair(child->mName->mString, child));
- }
- // and check each child as well
- child->getDescendants(name, children);
- }
- }
-}
-
-bool LLXMLNode::getAttribute(const char* name, LLXMLNodePtr& node, bool use_default_if_missing)
-{
- return getAttribute(gStringTable.checkStringEntry(name), node, use_default_if_missing);
-}
-
-bool LLXMLNode::getAttribute(const LLStringTableEntry* name, LLXMLNodePtr& node, bool use_default_if_missing)
-{
- LLXMLAttribList::const_iterator child_itr = mAttributes.find(name);
- if (child_itr != mAttributes.end())
- {
- node = (*child_itr).second;
- return true;
- }
- if (use_default_if_missing && !mDefault.isNull())
- {
- return mDefault->getAttribute(name, node, false);
- }
-
- return false;
-}
-
-bool LLXMLNode::setAttributeString(const char* attr, const std::string& value)
-{
- LLStringTableEntry* name = gStringTable.checkStringEntry(attr);
- LLXMLAttribList::const_iterator child_itr = mAttributes.find(name);
- if (child_itr != mAttributes.end())
- {
- LLXMLNodePtr node = (*child_itr).second;
- node->setValue(value);
- return true;
- }
- return false;
-}
-
-bool LLXMLNode::hasAttribute(const char* name )
-{
- LLXMLNodePtr node;
- return getAttribute(name, node);
-}
-
-bool LLXMLNode::getAttributeBOOL(const char* name, bool& value )
-{
- LLXMLNodePtr node;
- return (getAttribute(name, node) && node->getBoolValue(1, &value));
-}
-
-bool LLXMLNode::getAttributeU8(const char* name, U8& value )
-{
- LLXMLNodePtr node;
- return (getAttribute(name, node) && node->getByteValue(1, &value));
-}
-
-bool LLXMLNode::getAttributeS8(const char* name, S8& value )
-{
- LLXMLNodePtr node;
- S32 val;
- if (!(getAttribute(name, node) && node->getIntValue(1, &val)))
- {
- return false;
- }
- value = val;
- return true;
-}
-
-bool LLXMLNode::getAttributeU16(const char* name, U16& value )
-{
- LLXMLNodePtr node;
- U32 val;
- if (!(getAttribute(name, node) && node->getUnsignedValue(1, &val)))
- {
- return false;
- }
- value = val;
- return true;
-}
-
-bool LLXMLNode::getAttributeS16(const char* name, S16& value )
-{
- LLXMLNodePtr node;
- S32 val;
- if (!(getAttribute(name, node) && node->getIntValue(1, &val)))
- {
- return false;
- }
- value = val;
- return true;
-}
-
-bool LLXMLNode::getAttributeU32(const char* name, U32& value )
-{
- LLXMLNodePtr node;
- return (getAttribute(name, node) && node->getUnsignedValue(1, &value));
-}
-
-bool LLXMLNode::getAttributeS32(const char* name, S32& value )
-{
- LLXMLNodePtr node;
- return (getAttribute(name, node) && node->getIntValue(1, &value));
-}
-
-bool LLXMLNode::getAttributeF32(const char* name, F32& value )
-{
- LLXMLNodePtr node;
- return (getAttribute(name, node) && node->getFloatValue(1, &value));
-}
-
-bool LLXMLNode::getAttributeF64(const char* name, F64& value )
-{
- LLXMLNodePtr node;
- return (getAttribute(name, node) && node->getDoubleValue(1, &value));
-}
-
-bool LLXMLNode::getAttributeColor(const char* name, LLColor4& value )
-{
- LLXMLNodePtr node;
- return (getAttribute(name, node) && node->getFloatValue(4, value.mV));
-}
-
-bool LLXMLNode::getAttributeColor4(const char* name, LLColor4& value )
-{
- LLXMLNodePtr node;
- return (getAttribute(name, node) && node->getFloatValue(4, value.mV));
-}
-
-bool LLXMLNode::getAttributeColor4U(const char* name, LLColor4U& value )
-{
- LLXMLNodePtr node;
- return (getAttribute(name, node) && node->getByteValue(4, value.mV));
-}
-
-bool LLXMLNode::getAttributeVector3(const char* name, LLVector3& value )
-{
- LLXMLNodePtr node;
- return (getAttribute(name, node) && node->getFloatValue(3, value.mV));
-}
-
-bool LLXMLNode::getAttributeVector3d(const char* name, LLVector3d& value )
-{
- LLXMLNodePtr node;
- return (getAttribute(name, node) && node->getDoubleValue(3, value.mdV));
-}
-
-bool LLXMLNode::getAttributeQuat(const char* name, LLQuaternion& value )
-{
- LLXMLNodePtr node;
- return (getAttribute(name, node) && node->getFloatValue(4, value.mQ));
-}
-
-bool LLXMLNode::getAttributeUUID(const char* name, LLUUID& value )
-{
- LLXMLNodePtr node;
- return (getAttribute(name, node) && node->getUUIDValue(1, &value));
-}
-
-bool LLXMLNode::getAttributeString(const char* name, std::string& value )
-{
- LLXMLNodePtr node;
- if (!getAttribute(name, node))
- {
- return false;
- }
- value = node->getValue();
- return true;
-}
-
-LLXMLNodePtr LLXMLNode::getRoot()
-{
- if (mParent == NULL)
- {
- return this;
- }
- return mParent->getRoot();
-}
-
-/*static */
-const char *LLXMLNode::skipWhitespace(const char *str)
-{
- // skip whitespace characters
- while (str[0] == ' ' || str[0] == '\t' || str[0] == '\n') ++str;
- return str;
-}
-
-/*static */
-const char *LLXMLNode::skipNonWhitespace(const char *str)
-{
- // skip non-whitespace characters
- while (str[0] != ' ' && str[0] != '\t' && str[0] != '\n' && str[0] != 0) ++str;
- return str;
-}
-
-/*static */
-const char *LLXMLNode::parseInteger(const char *str, U64 *dest, bool *is_negative, U32 precision, Encoding encoding)
-{
- *dest = 0;
- *is_negative = false;
-
- str = skipWhitespace(str);
-
- if (str[0] == 0) return NULL;
-
- if (encoding == ENCODING_DECIMAL || encoding == ENCODING_DEFAULT)
- {
- if (str[0] == '+')
- {
- ++str;
- }
- if (str[0] == '-')
- {
- *is_negative = true;
- ++str;
- }
-
- str = skipWhitespace(str);
-
- U64 ret = 0;
- while (str[0] >= '0' && str[0] <= '9')
- {
- ret *= 10;
- ret += str[0] - '0';
- ++str;
- }
-
- if (str[0] == '.')
- {
- // If there is a fractional part, skip it
- str = skipNonWhitespace(str);
- }
-
- *dest = ret;
- return str;
- }
- if (encoding == ENCODING_HEX)
- {
- U64 ret = 0;
- str = skipWhitespace(str);
- for (U32 pos=0; pos<(precision/4); ++pos)
- {
- ret <<= 4;
- str = skipWhitespace(str);
- if (str[0] >= '0' && str[0] <= '9')
- {
- ret += str[0] - '0';
- }
- else if (str[0] >= 'a' && str[0] <= 'f')
- {
- ret += str[0] - 'a' + 10;
- }
- else if (str[0] >= 'A' && str[0] <= 'F')
- {
- ret += str[0] - 'A' + 10;
- }
- else
- {
- return NULL;
- }
- ++str;
- }
-
- *dest = ret;
- return str;
- }
- return NULL;
-}
-
-// 25 elements - decimal expansions of 1/(2^n), multiplied by 10 each iteration
-const U64 float_coeff_table[] =
- { 5, 25, 125, 625, 3125,
- 15625, 78125, 390625, 1953125, 9765625,
- 48828125, 244140625, 1220703125, 6103515625LL, 30517578125LL,
- 152587890625LL, 762939453125LL, 3814697265625LL, 19073486328125LL, 95367431640625LL,
- 476837158203125LL, 2384185791015625LL, 11920928955078125LL, 59604644775390625LL, 298023223876953125LL };
-
-// 36 elements - decimal expansions of 1/(2^n) after the last 28, truncated, no multiply each iteration
-const U64 float_coeff_table_2[] =
- { 149011611938476562LL,74505805969238281LL,
- 37252902984619140LL, 18626451492309570LL, 9313225746154785LL, 4656612873077392LL,
- 2328306436538696LL, 1164153218269348LL, 582076609134674LL, 291038304567337LL,
- 145519152283668LL, 72759576141834LL, 36379788070917LL, 18189894035458LL,
- 9094947017729LL, 4547473508864LL, 2273736754432LL, 1136868377216LL,
- 568434188608LL, 284217094304LL, 142108547152LL, 71054273576LL,
- 35527136788LL, 17763568394LL, 8881784197LL, 4440892098LL,
- 2220446049LL, 1110223024LL, 555111512LL, 277555756LL,
- 138777878, 69388939, 34694469, 17347234,
- 8673617, 4336808, 2168404, 1084202,
- 542101, 271050, 135525, 67762,
- };
-
-/*static */
-const char *LLXMLNode::parseFloat(const char *str, F64 *dest, U32 precision, Encoding encoding)
-{
- str = skipWhitespace(str);
-
- if (str[0] == 0) return NULL;
-
- if (encoding == ENCODING_DECIMAL || encoding == ENCODING_DEFAULT)
- {
- str = skipWhitespace(str);
-
- if (memcmp(str, "inf", 3) == 0)
- {
- *(U64 *)dest = 0x7FF0000000000000ll;
- return str + 3;
- }
- if (memcmp(str, "-inf", 4) == 0)
- {
- *(U64 *)dest = 0xFFF0000000000000ll;
- return str + 4;
- }
- if (memcmp(str, "1.#INF", 6) == 0)
- {
- *(U64 *)dest = 0x7FF0000000000000ll;
- return str + 6;
- }
- if (memcmp(str, "-1.#INF", 7) == 0)
- {
- *(U64 *)dest = 0xFFF0000000000000ll;
- return str + 7;
- }
-
- F64 negative = 1.0f;
- if (str[0] == '+')
- {
- ++str;
- }
- if (str[0] == '-')
- {
- negative = -1.0f;
- ++str;
- }
-
- const char* base_str = str;
- str = skipWhitespace(str);
-
- // Parse the integer part of the expression
- U64 int_part = 0;
- while (str[0] >= '0' && str[0] <= '9')
- {
- int_part *= 10;
- int_part += U64(str[0] - '0');
- ++str;
- }
-
- U64 f_part = 0;//, f_decimal = 1;
- if (str[0] == '.')
- {
- ++str;
- U64 remainder = 0;
- U32 pos = 0;
- // Parse the decimal part of the expression
- while (str[0] >= '0' && str[0] <= '9' && pos < 25)
- {
- remainder = (remainder*10) + U64(str[0] - '0');
- f_part <<= 1;
- //f_decimal <<= 1;
- // Check the n'th bit
- if (remainder >= float_coeff_table[pos])
- {
- remainder -= float_coeff_table[pos];
- f_part |= 1;
- }
- ++pos;
- ++str;
- }
- if (pos == 25)
- {
- // Drop any excessive digits
- while (str[0] >= '0' && str[0] <= '9')
- {
- ++str;
- }
- }
- else
- {
- while (pos < 25)
- {
- remainder *= 10;
- f_part <<= 1;
- //f_decimal <<= 1;
- // Check the n'th bit
- if (remainder >= float_coeff_table[pos])
- {
- remainder -= float_coeff_table[pos];
- f_part |= 1;
- }
- ++pos;
- }
- }
- pos = 0;
- while (pos < 36)
- {
- f_part <<= 1;
- //f_decimal <<= 1;
- if (remainder >= float_coeff_table_2[pos])
- {
- remainder -= float_coeff_table_2[pos];
- f_part |= 1;
- }
- ++pos;
- }
- }
-
- F64 ret = F64(int_part) + (F64(f_part)/F64(1LL<<61));
-
- F64 exponent = 1.f;
- if (str[0] == 'e')
- {
- // Scientific notation!
- ++str;
- U64 exp;
- bool is_negative;
- str = parseInteger(str, &exp, &is_negative, 64, ENCODING_DECIMAL);
- if (str == NULL)
- {
- exp = 1;
- }
- F64 exp_d = F64(exp) * (is_negative?-1:1);
- exponent = pow(10.0, exp_d);
- }
-
- if (str == base_str)
- {
- // no digits parsed
- return NULL;
- }
- else
- {
- *dest = ret*negative*exponent;
- return str;
- }
- }
- if (encoding == ENCODING_HEX)
- {
- U64 bytes_dest;
- bool is_negative;
- str = parseInteger(str, (U64 *)&bytes_dest, &is_negative, precision, ENCODING_HEX);
- // Upcast to F64
- switch (precision)
- {
- case 32:
- {
- U32 short_dest = (U32)bytes_dest;
- F32 ret_val = *(F32 *)&short_dest;
- *dest = ret_val;
- }
- break;
- case 64:
- *dest = *(F64 *)&bytes_dest;
- break;
- default:
- return NULL;
- }
- return str;
- }
- return NULL;
-}
-
-U32 LLXMLNode::getBoolValue(U32 expected_length, bool *array)
-{
- llassert(array);
-
- // Check type - accept booleans or strings
- if (mType != TYPE_BOOLEAN && mType != TYPE_STRING && mType != TYPE_UNKNOWN)
- {
- return 0;
- }
-
- std::string *str_array = new std::string[expected_length];
-
- U32 length = getStringValue(expected_length, str_array);
-
- U32 ret_length = 0;
- for (U32 i=0; i<length; ++i)
- {
- LLStringUtil::toLower(str_array[i]);
- if (str_array[i] == "false")
- {
- array[ret_length++] = false;
- }
- else if (str_array[i] == "true")
- {
- array[ret_length++] = true;
- }
- }
-
- delete[] str_array;
-
-#if LL_DEBUG
- if (ret_length != expected_length)
- {
- LL_DEBUGS() << "LLXMLNode::getBoolValue() failed for node named '"
- << mName->mString << "' -- expected " << expected_length << " but "
- << "only found " << ret_length << LL_ENDL;
- }
-#endif
- return ret_length;
-}
-
-U32 LLXMLNode::getByteValue(U32 expected_length, U8 *array, Encoding encoding)
-{
- llassert(array);
-
- // Check type - accept bytes or integers (below 256 only)
- if (mType != TYPE_INTEGER
- && mType != TYPE_UNKNOWN)
- {
- return 0;
- }
-
- if (mLength > 0 && mLength != expected_length)
- {
- LL_WARNS() << "XMLNode::getByteValue asked for " << expected_length
- << " elements, while node has " << mLength << LL_ENDL;
- return 0;
- }
-
- if (encoding == ENCODING_DEFAULT)
- {
- encoding = mEncoding;
- }
-
- const char *value_string = mValue.c_str();
-
- U32 i;
- for (i=0; i<expected_length; ++i)
- {
- U64 value;
- bool is_negative;
- value_string = parseInteger(value_string, &value, &is_negative, 8, encoding);
- if (value_string == NULL)
- {
- break;
- }
- if (value > 255 || is_negative)
- {
- LL_WARNS() << "getByteValue: Value outside of valid range." << LL_ENDL;
- break;
- }
- array[i] = U8(value);
- }
-#if LL_DEBUG
- if (i != expected_length)
- {
- LL_DEBUGS() << "LLXMLNode::getByteValue() failed for node named '"
- << mName->mString << "' -- expected " << expected_length << " but "
- << "only found " << i << LL_ENDL;
- }
-#endif
- return i;
-}
-
-U32 LLXMLNode::getIntValue(U32 expected_length, S32 *array, Encoding encoding)
-{
- llassert(array);
-
- // Check type - accept bytes or integers
- if (mType != TYPE_INTEGER && mType != TYPE_UNKNOWN)
- {
- return 0;
- }
-
- if (mLength > 0 && mLength != expected_length)
- {
- LL_WARNS() << "XMLNode::getIntValue asked for " << expected_length
- << " elements, while node has " << mLength << LL_ENDL;
- return 0;
- }
-
- if (encoding == ENCODING_DEFAULT)
- {
- encoding = mEncoding;
- }
-
- const char *value_string = mValue.c_str();
-
- U32 i = 0;
- for (i=0; i<expected_length; ++i)
- {
- U64 value;
- bool is_negative;
- value_string = parseInteger(value_string, &value, &is_negative, 32, encoding);
- if (value_string == NULL)
- {
- break;
- }
- if (value > 0x7fffffff)
- {
- LL_WARNS() << "getIntValue: Value outside of valid range." << LL_ENDL;
- break;
- }
- array[i] = S32(value) * (is_negative?-1:1);
- }
-
-#if LL_DEBUG
- if (i != expected_length)
- {
- LL_DEBUGS() << "LLXMLNode::getIntValue() failed for node named '"
- << mName->mString << "' -- expected " << expected_length << " but "
- << "only found " << i << LL_ENDL;
- }
-#endif
- return i;
-}
-
-U32 LLXMLNode::getUnsignedValue(U32 expected_length, U32 *array, Encoding encoding)
-{
- llassert(array);
-
- // Check type - accept bytes or integers
- if (mType != TYPE_INTEGER && mType != TYPE_UNKNOWN)
- {
- return 0;
- }
-
- if (mLength > 0 && mLength != expected_length)
- {
- LL_WARNS() << "XMLNode::getUnsignedValue asked for " << expected_length
- << " elements, while node has " << mLength << LL_ENDL;
- return 0;
- }
-
- if (encoding == ENCODING_DEFAULT)
- {
- encoding = mEncoding;
- }
-
- const char *value_string = mValue.c_str();
-
- U32 i = 0;
- // Int type
- for (i=0; i<expected_length; ++i)
- {
- U64 value;
- bool is_negative;
- value_string = parseInteger(value_string, &value, &is_negative, 32, encoding);
- if (value_string == NULL)
- {
- break;
- }
- if (is_negative || value > 0xffffffff)
- {
- LL_WARNS() << "getUnsignedValue: Value outside of valid range." << LL_ENDL;
- break;
- }
- array[i] = U32(value);
- }
-
-#if LL_DEBUG
- if (i != expected_length)
- {
- LL_DEBUGS() << "LLXMLNode::getUnsignedValue() failed for node named '"
- << mName->mString << "' -- expected " << expected_length << " but "
- << "only found " << i << LL_ENDL;
- }
-#endif
-
- return i;
-}
-
-U32 LLXMLNode::getLongValue(U32 expected_length, U64 *array, Encoding encoding)
-{
- llassert(array);
-
- // Check type - accept bytes or integers
- if (mType != TYPE_INTEGER && mType != TYPE_UNKNOWN)
- {
- return 0;
- }
-
- if (mLength > 0 && mLength != expected_length)
- {
- LL_WARNS() << "XMLNode::getLongValue asked for " << expected_length << " elements, while node has " << mLength << LL_ENDL;
- return 0;
- }
-
- if (encoding == ENCODING_DEFAULT)
- {
- encoding = mEncoding;
- }
-
- const char *value_string = mValue.c_str();
-
- U32 i = 0;
- // Int type
- for (i=0; i<expected_length; ++i)
- {
- U64 value;
- bool is_negative;
- value_string = parseInteger(value_string, &value, &is_negative, 64, encoding);
- if (value_string == NULL)
- {
- break;
- }
- if (is_negative)
- {
- LL_WARNS() << "getLongValue: Value outside of valid range." << LL_ENDL;
- break;
- }
- array[i] = value;
- }
-
-#if LL_DEBUG
- if (i != expected_length)
- {
- LL_DEBUGS() << "LLXMLNode::getLongValue() failed for node named '"
- << mName->mString << "' -- expected " << expected_length << " but "
- << "only found " << i << LL_ENDL;
- }
-#endif
-
- return i;
-}
-
-U32 LLXMLNode::getFloatValue(U32 expected_length, F32 *array, Encoding encoding)
-{
- llassert(array);
-
- // Check type - accept only floats or doubles
- if (mType != TYPE_FLOAT && mType != TYPE_UNKNOWN)
- {
- return 0;
- }
-
- if (mLength > 0 && mLength != expected_length)
- {
- LL_WARNS() << "XMLNode::getFloatValue asked for " << expected_length << " elements, while node has " << mLength << LL_ENDL;
- return 0;
- }
-
- if (encoding == ENCODING_DEFAULT)
- {
- encoding = mEncoding;
- }
-
- const char *value_string = mValue.c_str();
-
- U32 i;
- for (i=0; i<expected_length; ++i)
- {
- F64 value;
- value_string = parseFloat(value_string, &value, 32, encoding);
- if (value_string == NULL)
- {
- break;
- }
- array[i] = F32(value);
- }
-#if LL_DEBUG
- if (i != expected_length)
- {
- LL_DEBUGS() << "LLXMLNode::getFloatValue() failed for node named '"
- << mName->mString << "' -- expected " << expected_length << " but "
- << "only found " << i << LL_ENDL;
- }
-#endif
- return i;
-}
-
-U32 LLXMLNode::getDoubleValue(U32 expected_length, F64 *array, Encoding encoding)
-{
- llassert(array);
-
- // Check type - accept only floats or doubles
- if (mType != TYPE_FLOAT && mType != TYPE_UNKNOWN)
- {
- return 0;
- }
-
- if (mLength > 0 && mLength != expected_length)
- {
- LL_WARNS() << "XMLNode::getDoubleValue asked for " << expected_length << " elements, while node has " << mLength << LL_ENDL;
- return 0;
- }
-
- if (encoding == ENCODING_DEFAULT)
- {
- encoding = mEncoding;
- }
-
- const char *value_string = mValue.c_str();
-
- U32 i;
- for (i=0; i<expected_length; ++i)
- {
- F64 value;
- value_string = parseFloat(value_string, &value, 64, encoding);
- if (value_string == NULL)
- {
- break;
- }
- array[i] = value;
- }
-#if LL_DEBUG
- if (i != expected_length)
- {
- LL_DEBUGS() << "LLXMLNode::getDoubleValue() failed for node named '"
- << mName->mString << "' -- expected " << expected_length << " but "
- << "only found " << i << LL_ENDL;
- }
-#endif
- return i;
-}
-
-U32 LLXMLNode::getStringValue(U32 expected_length, std::string *array)
-{
- llassert(array);
-
- // Can always return any value as a string
-
- if (mLength > 0 && mLength != expected_length)
- {
- LL_WARNS() << "XMLNode::getStringValue asked for " << expected_length << " elements, while node has " << mLength << LL_ENDL;
- return 0;
- }
-
- U32 num_returned_strings = 0;
-
- // Array of strings is whitespace-separated
- const std::string sep(" \n\t");
-
- std::string::size_type n = 0;
- std::string::size_type m = 0;
- while(1)
- {
- if (num_returned_strings >= expected_length)
- {
- break;
- }
- n = mValue.find_first_not_of(sep, m);
- m = mValue.find_first_of(sep, n);
- if (m == std::string::npos)
- {
- break;
- }
- array[num_returned_strings++] = mValue.substr(n,m-n);
- }
- if (n != std::string::npos && num_returned_strings < expected_length)
- {
- array[num_returned_strings++] = mValue.substr(n);
- }
-#if LL_DEBUG
- if (num_returned_strings != expected_length)
- {
- LL_DEBUGS() << "LLXMLNode::getStringValue() failed for node named '"
- << mName->mString << "' -- expected " << expected_length << " but "
- << "only found " << num_returned_strings << LL_ENDL;
- }
-#endif
-
- return num_returned_strings;
-}
-
-U32 LLXMLNode::getUUIDValue(U32 expected_length, LLUUID *array)
-{
- llassert(array);
-
- // Check type
- if (mType != TYPE_UUID && mType != TYPE_UNKNOWN)
- {
- return 0;
- }
-
- const char *value_string = mValue.c_str();
-
- U32 i;
- for (i=0; i<expected_length; ++i)
- {
- LLUUID uuid_value;
- value_string = skipWhitespace(value_string);
-
- if (strlen(value_string) < (UUID_STR_LENGTH-1)) /* Flawfinder: ignore */
- {
- break;
- }
- char uuid_string[UUID_STR_LENGTH]; /* Flawfinder: ignore */
- memcpy(uuid_string, value_string, (UUID_STR_LENGTH-1)); /* Flawfinder: ignore */
- uuid_string[(UUID_STR_LENGTH-1)] = 0;
-
- if (!LLUUID::parseUUID(std::string(uuid_string), &uuid_value))
- {
- break;
- }
- value_string = &value_string[(UUID_STR_LENGTH-1)];
- array[i] = uuid_value;
- }
-#if LL_DEBUG
- if (i != expected_length)
- {
- LL_DEBUGS() << "LLXMLNode::getUUIDValue() failed for node named '"
- << mName->mString << "' -- expected " << expected_length << " but "
- << "only found " << i << LL_ENDL;
- }
-#endif
- return i;
-}
-
-U32 LLXMLNode::getNodeRefValue(U32 expected_length, LLXMLNode **array)
-{
- llassert(array);
-
- // Check type
- if (mType != TYPE_NODEREF && mType != TYPE_UNKNOWN)
- {
- return 0;
- }
-
- std::string *string_array = new std::string[expected_length];
-
- U32 num_strings = getStringValue(expected_length, string_array);
-
- U32 num_returned_refs = 0;
-
- LLXMLNodePtr root = getRoot();
- for (U32 strnum=0; strnum<num_strings; ++strnum)
- {
- LLXMLNodeList node_list;
- root->findID(string_array[strnum], node_list);
- if (node_list.empty())
- {
- LL_WARNS() << "XML: Could not find node ID: " << string_array[strnum] << LL_ENDL;
- }
- else if (node_list.size() > 1)
- {
- LL_WARNS() << "XML: Node ID not unique: " << string_array[strnum] << LL_ENDL;
- }
- else
- {
- LLXMLNodeList::const_iterator list_itr = node_list.begin();
- if (list_itr != node_list.end())
- {
- LLXMLNode* child = (*list_itr).second;
-
- array[num_returned_refs++] = child;
- }
- }
- }
-
- delete[] string_array;
-
- return num_returned_refs;
-}
-
-void LLXMLNode::setBoolValue(U32 length, const bool *array)
-{
- if (length == 0) return;
-
- std::string new_value;
- for (U32 pos=0; pos<length; ++pos)
- {
- if (pos > 0)
- {
- new_value = llformat("%s %s", new_value.c_str(), array[pos]?"true":"false");
- }
- else
- {
- new_value = array[pos]?"true":"false";
- }
- }
-
- mValue = new_value;
- mEncoding = ENCODING_DEFAULT;
- mLength = length;
- mType = TYPE_BOOLEAN;
-}
-
-void LLXMLNode::setByteValue(U32 length, const U8* const array, Encoding encoding)
-{
- if (length == 0) return;
-
- std::string new_value;
- if (encoding == ENCODING_DEFAULT || encoding == ENCODING_DECIMAL)
- {
- for (U32 pos=0; pos<length; ++pos)
- {
- if (pos > 0)
- {
- new_value.append(llformat(" %u", array[pos]));
- }
- else
- {
- new_value = llformat("%u", array[pos]);
- }
- }
- }
- if (encoding == ENCODING_HEX)
- {
- for (U32 pos=0; pos<length; ++pos)
- {
- if (pos > 0 && pos % 16 == 0)
- {
- new_value.append(llformat(" %02X", array[pos]));
- }
- else
- {
- new_value.append(llformat("%02X", array[pos]));
- }
- }
- }
- // TODO -- Handle Base32
-
- mValue = new_value;
- mEncoding = encoding;
- mLength = length;
- mType = TYPE_INTEGER;
- mPrecision = 8;
-}
-
-
-void LLXMLNode::setIntValue(U32 length, const S32 *array, Encoding encoding)
-{
- if (length == 0) return;
-
- std::string new_value;
- if (encoding == ENCODING_DEFAULT || encoding == ENCODING_DECIMAL)
- {
- for (U32 pos=0; pos<length; ++pos)
- {
- if (pos > 0)
- {
- new_value.append(llformat(" %d", array[pos]));
- }
- else
- {
- new_value = llformat("%d", array[pos]);
- }
- }
- mValue = new_value;
- }
- else if (encoding == ENCODING_HEX)
- {
- for (U32 pos=0; pos<length; ++pos)
- {
- if (pos > 0 && pos % 16 == 0)
- {
- new_value.append(llformat(" %08X", ((U32 *)array)[pos]));
- }
- else
- {
- new_value.append(llformat("%08X", ((U32 *)array)[pos]));
- }
- }
- mValue = new_value;
- }
- else
- {
- mValue = new_value;
- }
- // TODO -- Handle Base32
-
- mEncoding = encoding;
- mLength = length;
- mType = TYPE_INTEGER;
- mPrecision = 32;
-}
-
-void LLXMLNode::setUnsignedValue(U32 length, const U32* array, Encoding encoding)
-{
- if (length == 0) return;
-
- std::string new_value;
- if (encoding == ENCODING_DEFAULT || encoding == ENCODING_DECIMAL)
- {
- for (U32 pos=0; pos<length; ++pos)
- {
- if (pos > 0)
- {
- new_value.append(llformat(" %u", array[pos]));
- }
- else
- {
- new_value = llformat("%u", array[pos]);
- }
- }
- }
- if (encoding == ENCODING_HEX)
- {
- for (U32 pos=0; pos<length; ++pos)
- {
- if (pos > 0 && pos % 16 == 0)
- {
- new_value.append(llformat(" %08X", array[pos]));
- }
- else
- {
- new_value.append(llformat("%08X", array[pos]));
- }
- }
- mValue = new_value;
- }
- // TODO -- Handle Base32
-
- mValue = new_value;
- mEncoding = encoding;
- mLength = length;
- mType = TYPE_INTEGER;
- mPrecision = 32;
-}
-
-#if LL_WINDOWS
-#define PU64 "I64u"
-#else
-#define PU64 "llu"
-#endif
-
-void LLXMLNode::setLongValue(U32 length, const U64* array, Encoding encoding)
-{
- if (length == 0) return;
-
- std::string new_value;
- if (encoding == ENCODING_DEFAULT || encoding == ENCODING_DECIMAL)
- {
- for (U32 pos=0; pos<length; ++pos)
- {
- if (pos > 0)
- {
- new_value.append(llformat(" %" PU64, array[pos]));
- }
- else
- {
- new_value = llformat("%" PU64, array[pos]);
- }
- }
- mValue = new_value;
- }
- if (encoding == ENCODING_HEX)
- {
- for (U32 pos=0; pos<length; ++pos)
- {
- U32 upper_32 = U32(array[pos]>>32);
- U32 lower_32 = U32(array[pos]&0xffffffff);
- if (pos > 0 && pos % 8 == 0)
- {
- new_value.append(llformat(" %08X%08X", upper_32, lower_32));
- }
- else
- {
- new_value.append(llformat("%08X%08X", upper_32, lower_32));
- }
- }
- mValue = new_value;
- }
- else
- {
- mValue = new_value;
- }
- // TODO -- Handle Base32
-
- mEncoding = encoding;
- mLength = length;
- mType = TYPE_INTEGER;
- mPrecision = 64;
-}
-
-void LLXMLNode::setFloatValue(U32 length, const F32 *array, Encoding encoding, U32 precision)
-{
- if (length == 0) return;
-
- std::string new_value;
- if (encoding == ENCODING_DEFAULT || encoding == ENCODING_DECIMAL)
- {
- std::string format_string;
- if (precision > 0)
- {
- if (precision > 25)
- {
- precision = 25;
- }
- format_string = llformat( "%%.%dg", precision);
- }
- else
- {
- format_string = llformat( "%%g");
- }
-
- for (U32 pos=0; pos<length; ++pos)
- {
- if (pos > 0)
- {
- new_value.append(" ");
- new_value.append(llformat(format_string.c_str(), array[pos]));
- }
- else
- {
- new_value.assign(llformat(format_string.c_str(), array[pos]));
- }
- }
- mValue = new_value;
- }
- else if (encoding == ENCODING_HEX)
- {
- U32 *byte_array = (U32 *)array;
- setUnsignedValue(length, byte_array, ENCODING_HEX);
- }
- else
- {
- mValue = new_value;
- }
-
- mEncoding = encoding;
- mLength = length;
- mType = TYPE_FLOAT;
- mPrecision = 32;
-}
-
-void LLXMLNode::setDoubleValue(U32 length, const F64 *array, Encoding encoding, U32 precision)
-{
- if (length == 0) return;
-
- std::string new_value;
- if (encoding == ENCODING_DEFAULT || encoding == ENCODING_DECIMAL)
- {
- std::string format_string;
- if (precision > 0)
- {
- if (precision > 25)
- {
- precision = 25;
- }
- format_string = llformat( "%%.%dg", precision);
- }
- else
- {
- format_string = llformat( "%%g");
- }
- for (U32 pos=0; pos<length; ++pos)
- {
- if (pos > 0)
- {
- new_value.append(" ");
- new_value.append(llformat(format_string.c_str(), array[pos]));
- }
- else
- {
- new_value.assign(llformat(format_string.c_str(), array[pos]));
- }
- }
- mValue = new_value;
- }
- if (encoding == ENCODING_HEX)
- {
- U64 *byte_array = (U64 *)array;
- setLongValue(length, byte_array, ENCODING_HEX);
- }
- else
- {
- mValue = new_value;
- }
- // TODO -- Handle Base32
-
- mEncoding = encoding;
- mLength = length;
- mType = TYPE_FLOAT;
- mPrecision = 64;
-}
-
-// static
-std::string LLXMLNode::escapeXML(const std::string& xml)
-{
- std::string out;
- for (std::string::size_type i = 0; i < xml.size(); ++i)
- {
- char c = xml[i];
- switch(c)
- {
- case '"': out.append("&quot;"); break;
- case '\'': out.append("&apos;"); break;
- case '&': out.append("&amp;"); break;
- case '<': out.append("&lt;"); break;
- case '>': out.append("&gt;"); break;
- default: out.push_back(c); break;
- }
- }
- return out;
-}
-
-void LLXMLNode::setStringValue(U32 length, const std::string *strings)
-{
- if (length == 0) return;
-
- std::string new_value;
- for (U32 pos=0; pos<length; ++pos)
- {
- // *NOTE: Do not escape strings here - do it on output
- new_value.append( strings[pos] );
- if (pos < length-1) new_value.append(" ");
- }
-
- mValue = new_value;
- mEncoding = ENCODING_DEFAULT;
- mLength = length;
- mType = TYPE_STRING;
-}
-
-void LLXMLNode::setUUIDValue(U32 length, const LLUUID *array)
-{
- if (length == 0) return;
-
- std::string new_value;
- for (U32 pos=0; pos<length; ++pos)
- {
- new_value.append(array[pos].asString());
- if (pos < length-1) new_value.append(" ");
- }
-
- mValue = new_value;
- mEncoding = ENCODING_DEFAULT;
- mLength = length;
- mType = TYPE_UUID;
-}
-
-void LLXMLNode::setNodeRefValue(U32 length, const LLXMLNode **array)
-{
- if (length == 0) return;
-
- std::string new_value;
- for (U32 pos=0; pos<length; ++pos)
- {
- if (array[pos]->mID != "")
- {
- new_value.append(array[pos]->mID);
- }
- else
- {
- new_value.append("(null)");
- }
- if (pos < length-1) new_value.append(" ");
- }
-
- mValue = new_value;
- mEncoding = ENCODING_DEFAULT;
- mLength = length;
- mType = TYPE_NODEREF;
-}
-
-void LLXMLNode::setValue(const std::string& value)
-{
- if (TYPE_CONTAINER == mType)
- {
- mType = TYPE_UNKNOWN;
- }
- mValue = value;
-}
-
-void LLXMLNode::setDefault(LLXMLNode *default_node)
-{
- mDefault = default_node;
-}
-
-void LLXMLNode::findDefault(LLXMLNode *defaults_list)
-{
- if (defaults_list)
- {
- LLXMLNodeList children;
- defaults_list->getChildren(mName->mString, children);
-
- LLXMLNodeList::const_iterator children_itr;
- LLXMLNodeList::const_iterator children_end = children.end();
- for (children_itr = children.begin(); children_itr != children_end; ++children_itr)
- {
- LLXMLNode* child = (*children_itr).second;
- if (child->mVersionMajor == mVersionMajor &&
- child->mVersionMinor == mVersionMinor)
- {
- mDefault = child;
- return;
- }
- }
- }
- mDefault = NULL;
-}
-
-bool LLXMLNode::deleteChildren(const std::string& name)
-{
- U32 removed_count = 0;
- LLXMLNodeList node_list;
- findName(name, node_list);
- if (!node_list.empty())
- {
- // TODO -- use multimap::find()
- // TODO -- need to watch out for invalid iterators
- LLXMLNodeList::iterator children_itr;
- for (children_itr = node_list.begin(); children_itr != node_list.end(); ++children_itr)
- {
- LLXMLNode* child = (*children_itr).second;
- if (deleteChild(child))
- {
- removed_count++;
- }
- }
- }
- return removed_count > 0;
-}
-
-bool LLXMLNode::deleteChildren(LLStringTableEntry* name)
-{
- U32 removed_count = 0;
- LLXMLNodeList node_list;
- findName(name, node_list);
- if (!node_list.empty())
- {
- // TODO -- use multimap::find()
- // TODO -- need to watch out for invalid iterators
- LLXMLNodeList::iterator children_itr;
- for (children_itr = node_list.begin(); children_itr != node_list.end(); ++children_itr)
- {
- LLXMLNode* child = (*children_itr).second;
- if (deleteChild(child))
- {
- removed_count++;
- }
- }
- }
- return removed_count > 0;
-}
-
-void LLXMLNode::setAttributes(LLXMLNode::ValueType type, U32 precision, LLXMLNode::Encoding encoding, U32 length)
-{
- mType = type;
- mEncoding = encoding;
- mPrecision = precision;
- mLength = length;
-}
-
-void LLXMLNode::setName(const std::string& name)
-{
- setName(gStringTable.addStringEntry(name));
-}
-
-void LLXMLNode::setName(LLStringTableEntry* name)
-{
- LLXMLNode* old_parent = mParent;
- if (mParent)
- {
- // we need to remove and re-add to the parent so that
- // the multimap key agrees with this node's name
- mParent->removeChild(this);
- }
- mName = name;
- if (old_parent)
- {
- LLXMLNodePtr this_ptr(this);
- old_parent->addChild(this_ptr);
- }
-}
-
-// Unused
-// void LLXMLNode::appendValue(const std::string& value)
-// {
-// mValue.append(value);
-// }
-
-U32 LLXMLNode::getChildCount() const
-{
- if (mChildren.notNull())
- {
- return mChildren->map.size();
- }
- return 0;
-}
-
-//***************************************************
-// UNIT TESTING
-//***************************************************
-
-U32 get_rand(U32 max_value)
-{
- U32 random_num = rand() + ((U32)rand() << 16);
- return (random_num % max_value);
-}
-
-LLXMLNode *get_rand_node(LLXMLNode *node)
-{
- if (node->mChildren.notNull())
- {
- U32 num_children = node->mChildren->map.size();
- if (get_rand(2) == 0)
- {
- while (true)
- {
- S32 child_num = S32(get_rand(num_children*2)) - num_children;
- LLXMLChildList::iterator itor = node->mChildren->map.begin();
- while (child_num > 0)
- {
- --child_num;
- ++itor;
- }
- if (!itor->second->mIsAttribute)
- {
- return get_rand_node(itor->second);
- }
- }
- }
- }
- return node;
-}
-
-void LLXMLNode::createUnitTest(S32 max_num_children)
-{
- // Random ID
- std::string rand_id;
- U32 rand_id_len = get_rand(10)+5;
- for (U32 pos = 0; pos<rand_id_len; ++pos)
- {
- char c = 'a' + get_rand(26);
- rand_id.append(1, c);
- }
- mID = rand_id;
-
- if (max_num_children < 2)
- {
- setStringValue(1, &mID);
- return;
- }
-
- // Checksums
- U32 integer_checksum = 0;
- U64 long_checksum = 0;
- U32 bool_true_count = 0;
- LLUUID uuid_checksum;
- U32 noderef_checksum = 0;
- U32 float_checksum = 0;
-
- // Create a random number of children
- U32 num_children = get_rand(max_num_children)+1;
- for (U32 child_num=0; child_num<num_children; ++child_num)
- {
- // Random Name
- std::string child_name;
- U32 child_name_len = get_rand(10)+5;
- for (U32 pos = 0; pos<child_name_len; ++pos)
- {
- char c = 'a' + get_rand(26);
- child_name.append(1, c);
- }
-
- LLXMLNode *new_child = createChild(child_name.c_str(), false);
-
- // Random ID
- std::string child_id;
- U32 child_id_len = get_rand(10)+5;
- for (U32 pos=0; pos<child_id_len; ++pos)
- {
- char c = 'a' + get_rand(26);
- child_id.append(1, c);
- }
- new_child->mID = child_id;
-
- // Random Length
- U32 array_size = get_rand(28)+1;
-
- // Random Encoding
- Encoding new_encoding = get_rand(2)?ENCODING_DECIMAL:ENCODING_HEX;
-
- // Random Type
- int type = get_rand(8);
- switch (type)
- {
- case 0: // TYPE_CONTAINER
- new_child->createUnitTest(max_num_children/2);
- break;
- case 1: // TYPE_BOOLEAN
- {
- bool random_bool_values[30];
- for (U32 value=0; value<array_size; ++value)
- {
- random_bool_values[value] = get_rand(2);
- if (random_bool_values[value])
- {
- ++bool_true_count;
- }
- }
- new_child->setBoolValue(array_size, random_bool_values);
- }
- break;
- case 2: // TYPE_INTEGER (32-bit)
- {
- U32 random_int_values[30];
- for (U32 value=0; value<array_size; ++value)
- {
- random_int_values[value] = get_rand(0xffffffff);
- integer_checksum ^= random_int_values[value];
- }
- new_child->setUnsignedValue(array_size, random_int_values, new_encoding);
- }
- break;
- case 3: // TYPE_INTEGER (64-bit)
- {
- U64 random_int_values[30];
- for (U64 value=0; value<array_size; ++value)
- {
- random_int_values[value] = (U64(get_rand(0xffffffff)) << 32) + get_rand(0xffffffff);
- long_checksum ^= random_int_values[value];
- }
- new_child->setLongValue(array_size, random_int_values, new_encoding);
- }
- break;
- case 4: // TYPE_FLOAT (32-bit)
- {
- F32 random_float_values[30];
- for (U32 value=0; value<array_size; ++value)
- {
- S32 exponent = get_rand(256) - 128;
- S32 fractional_part = get_rand(0xffffffff);
- S32 sign = get_rand(2) * 2 - 1;
- random_float_values[value] = F32(fractional_part) / F32(0xffffffff) * exp(F32(exponent)) * F32(sign);
-
- U32 *float_bits = &((U32 *)random_float_values)[value];
- if (*float_bits == 0x80000000)
- {
- *float_bits = 0x00000000;
- }
- float_checksum ^= (*float_bits & 0xfffff000);
- }
- new_child->setFloatValue(array_size, random_float_values, new_encoding, 12);
- }
- break;
- case 5: // TYPE_FLOAT (64-bit)
- {
- F64 random_float_values[30];
- for (U32 value=0; value<array_size; ++value)
- {
- S32 exponent = get_rand(2048) - 1024;
- S32 fractional_part = get_rand(0xffffffff);
- S32 sign = get_rand(2) * 2 - 1;
- random_float_values[value] = F64(fractional_part) / F64(0xffffffff) * exp(F64(exponent)) * F64(sign);
-
- U64 *float_bits = &((U64 *)random_float_values)[value];
- if (*float_bits == 0x8000000000000000ll)
- {
- *float_bits = 0x0000000000000000ll;
- }
- float_checksum ^= ((*float_bits & 0xfffffff000000000ll) >> 32);
- }
- new_child->setDoubleValue(array_size, random_float_values, new_encoding, 12);
- }
- break;
- case 6: // TYPE_UUID
- {
- LLUUID random_uuid_values[30];
- for (U32 value=0; value<array_size; ++value)
- {
- random_uuid_values[value].generate();
- for (S32 byte=0; byte<UUID_BYTES; ++byte)
- {
- uuid_checksum.mData[byte] ^= random_uuid_values[value].mData[byte];
- }
- }
- new_child->setUUIDValue(array_size, random_uuid_values);
- }
- break;
- case 7: // TYPE_NODEREF
- {
- LLXMLNode *random_node_array[30];
- LLXMLNode *root = getRoot();
- for (U32 value=0; value<array_size; ++value)
- {
- random_node_array[value] = get_rand_node(root);
- const char *node_name = random_node_array[value]->mName->mString;
- for (U32 pos=0; pos<strlen(node_name); ++pos) /* Flawfinder: ignore */
- {
- U32 hash_contrib = U32(node_name[pos]) << ((pos % 4) * 8);
- noderef_checksum ^= hash_contrib;
- }
- }
- new_child->setNodeRefValue(array_size, (const LLXMLNode **)random_node_array);
- }
- break;
- }
- }
-
- createChild("integer_checksum", true)->setUnsignedValue(1, &integer_checksum, LLXMLNode::ENCODING_HEX);
- createChild("long_checksum", true)->setLongValue(1, &long_checksum, LLXMLNode::ENCODING_HEX);
- createChild("bool_true_count", true)->setUnsignedValue(1, &bool_true_count, LLXMLNode::ENCODING_HEX);
- createChild("uuid_checksum", true)->setUUIDValue(1, &uuid_checksum);
- createChild("noderef_checksum", true)->setUnsignedValue(1, &noderef_checksum, LLXMLNode::ENCODING_HEX);
- createChild("float_checksum", true)->setUnsignedValue(1, &float_checksum, LLXMLNode::ENCODING_HEX);
-}
-
-bool LLXMLNode::performUnitTest(std::string &error_buffer)
-{
- if (mChildren.isNull())
- {
- error_buffer.append(llformat("ERROR Node %s: No children found.\n", mName->mString));
- return false;
- }
-
- // Checksums
- U32 integer_checksum = 0;
- U32 bool_true_count = 0;
- LLUUID uuid_checksum;
- U32 noderef_checksum = 0;
- U32 float_checksum = 0;
- U64 long_checksum = 0;
-
- LLXMLChildList::iterator itor;
- for (itor=mChildren->map.begin(); itor!=mChildren->map.end(); ++itor)
- {
- LLXMLNode *node = itor->second;
- if (node->mIsAttribute)
- {
- continue;
- }
- if (node->mType == TYPE_CONTAINER)
- {
- if (!node->performUnitTest(error_buffer))
- {
- error_buffer.append(llformat("Child test failed for %s.\n", mName->mString));
- //return false;
- }
- continue;
- }
- if (node->mLength < 1 || node->mLength > 30)
- {
- error_buffer.append(llformat("ERROR Node %s: Invalid array length %d, child %s.\n", mName->mString, node->mLength, node->mName->mString));
- return false;
- }
- switch (node->mType)
- {
- case TYPE_CONTAINER:
- case TYPE_UNKNOWN:
- break;
- case TYPE_BOOLEAN:
- {
- bool bool_array[30];
- if (node->getBoolValue(node->mLength, bool_array) < node->mLength)
- {
- error_buffer.append(llformat("ERROR Node %s: Could not read boolean array, child %s.\n", mName->mString, node->mName->mString));
- return false;
- }
- for (U32 pos=0; pos<(U32)node->mLength; ++pos)
- {
- if (bool_array[pos])
- {
- ++bool_true_count;
- }
- }
- }
- break;
- case TYPE_INTEGER:
- {
- if (node->mPrecision == 32)
- {
- U32 integer_array[30];
- if (node->getUnsignedValue(node->mLength, integer_array, node->mEncoding) < node->mLength)
- {
- error_buffer.append(llformat("ERROR Node %s: Could not read integer array, child %s.\n", mName->mString, node->mName->mString));
- return false;
- }
- for (U32 pos=0; pos<(U32)node->mLength; ++pos)
- {
- integer_checksum ^= integer_array[pos];
- }
- }
- else
- {
- U64 integer_array[30];
- if (node->getLongValue(node->mLength, integer_array, node->mEncoding) < node->mLength)
- {
- error_buffer.append(llformat("ERROR Node %s: Could not read long integer array, child %s.\n", mName->mString, node->mName->mString));
- return false;
- }
- for (U32 pos=0; pos<(U32)node->mLength; ++pos)
- {
- long_checksum ^= integer_array[pos];
- }
- }
- }
- break;
- case TYPE_FLOAT:
- {
- if (node->mPrecision == 32)
- {
- F32 float_array[30];
- if (node->getFloatValue(node->mLength, float_array, node->mEncoding) < node->mLength)
- {
- error_buffer.append(llformat("ERROR Node %s: Could not read float array, child %s.\n", mName->mString, node->mName->mString));
- return false;
- }
- for (U32 pos=0; pos<(U32)node->mLength; ++pos)
- {
- U32 float_bits = ((U32 *)float_array)[pos];
- float_checksum ^= (float_bits & 0xfffff000);
- }
- }
- else
- {
- F64 float_array[30];
- if (node->getDoubleValue(node->mLength, float_array, node->mEncoding) < node->mLength)
- {
- error_buffer.append(llformat("ERROR Node %s: Could not read float array, child %s.\n", mName->mString, node->mName->mString));
- return false;
- }
- for (U32 pos=0; pos<(U32)node->mLength; ++pos)
- {
- U64 float_bits = ((U64 *)float_array)[pos];
- float_checksum ^= ((float_bits & 0xfffffff000000000ll) >> 32);
- }
- }
- }
- break;
- case TYPE_STRING:
- break;
- case TYPE_UUID:
- {
- LLUUID uuid_array[30];
- if (node->getUUIDValue(node->mLength, uuid_array) < node->mLength)
- {
- error_buffer.append(llformat("ERROR Node %s: Could not read uuid array, child %s.\n", mName->mString, node->mName->mString));
- return false;
- }
- for (U32 pos=0; pos<(U32)node->mLength; ++pos)
- {
- for (S32 byte=0; byte<UUID_BYTES; ++byte)
- {
- uuid_checksum.mData[byte] ^= uuid_array[pos].mData[byte];
- }
- }
- }
- break;
- case TYPE_NODEREF:
- {
- LLXMLNode *node_array[30];
- if (node->getNodeRefValue(node->mLength, node_array) < node->mLength)
- {
- error_buffer.append(llformat("ERROR Node %s: Could not read node ref array, child %s.\n", mName->mString, node->mName->mString));
- return false;
- }
- for (U32 pos=0; pos<node->mLength; ++pos)
- {
- const char *node_name = node_array[pos]->mName->mString;
- for (U32 pos2=0; pos2<strlen(node_name); ++pos2) /* Flawfinder: ignore */
- {
- U32 hash_contrib = U32(node_name[pos2]) << ((pos2 % 4) * 8);
- noderef_checksum ^= hash_contrib;
- }
- }
- }
- break;
- }
- }
-
- LLXMLNodePtr checksum_node;
-
- // Compare checksums
- {
- U32 node_integer_checksum = 0;
- if (!getAttribute("integer_checksum", checksum_node, false) ||
- checksum_node->getUnsignedValue(1, &node_integer_checksum, ENCODING_HEX) != 1)
- {
- error_buffer.append(llformat("ERROR Node %s: Integer checksum missing.\n", mName->mString));
- return false;
- }
- if (node_integer_checksum != integer_checksum)
- {
- error_buffer.append(llformat("ERROR Node %s: Integer checksum mismatch: read %X / calc %X.\n", mName->mString, node_integer_checksum, integer_checksum));
- return false;
- }
- }
-
- {
- U64 node_long_checksum = 0;
- if (!getAttribute("long_checksum", checksum_node, false) ||
- checksum_node->getLongValue(1, &node_long_checksum, ENCODING_HEX) != 1)
- {
- error_buffer.append(llformat("ERROR Node %s: Long Integer checksum missing.\n", mName->mString));
- return false;
- }
- if (node_long_checksum != long_checksum)
- {
- U32 *pp1 = (U32 *)&node_long_checksum;
- U32 *pp2 = (U32 *)&long_checksum;
- error_buffer.append(llformat("ERROR Node %s: Long Integer checksum mismatch: read %08X%08X / calc %08X%08X.\n", mName->mString, pp1[1], pp1[0], pp2[1], pp2[0]));
- return false;
- }
- }
-
- {
- U32 node_bool_true_count = 0;
- if (!getAttribute("bool_true_count", checksum_node, false) ||
- checksum_node->getUnsignedValue(1, &node_bool_true_count, ENCODING_HEX) != 1)
- {
- error_buffer.append(llformat("ERROR Node %s: Boolean checksum missing.\n", mName->mString));
- return false;
- }
- if (node_bool_true_count != bool_true_count)
- {
- error_buffer.append(llformat("ERROR Node %s: Boolean checksum mismatch: read %X / calc %X.\n", mName->mString, node_bool_true_count, bool_true_count));
- return false;
- }
- }
-
- {
- LLUUID node_uuid_checksum;
- if (!getAttribute("uuid_checksum", checksum_node, false) ||
- checksum_node->getUUIDValue(1, &node_uuid_checksum) != 1)
- {
- error_buffer.append(llformat("ERROR Node %s: UUID checksum missing.\n", mName->mString));
- return false;
- }
- if (node_uuid_checksum != uuid_checksum)
- {
- error_buffer.append(llformat("ERROR Node %s: UUID checksum mismatch: read %s / calc %s.\n", mName->mString, node_uuid_checksum.asString().c_str(), uuid_checksum.asString().c_str()));
- return false;
- }
- }
-
- {
- U32 node_noderef_checksum = 0;
- if (!getAttribute("noderef_checksum", checksum_node, false) ||
- checksum_node->getUnsignedValue(1, &node_noderef_checksum, ENCODING_HEX) != 1)
- {
- error_buffer.append(llformat("ERROR Node %s: Node Ref checksum missing.\n", mName->mString));
- return false;
- }
- if (node_noderef_checksum != noderef_checksum)
- {
- error_buffer.append(llformat("ERROR Node %s: Node Ref checksum mismatch: read %X / calc %X.\n", mName->mString, node_noderef_checksum, noderef_checksum));
- return false;
- }
- }
-
- {
- U32 node_float_checksum = 0;
- if (!getAttribute("float_checksum", checksum_node, false) ||
- checksum_node->getUnsignedValue(1, &node_float_checksum, ENCODING_HEX) != 1)
- {
- error_buffer.append(llformat("ERROR Node %s: Float checksum missing.\n", mName->mString));
- return false;
- }
- if (node_float_checksum != float_checksum)
- {
- error_buffer.append(llformat("ERROR Node %s: Float checksum mismatch: read %X / calc %X.\n", mName->mString, node_float_checksum, float_checksum));
- return false;
- }
- }
-
- return true;
-}
-
-LLXMLNodePtr LLXMLNode::getFirstChild() const
-{
- if (mChildren.isNull()) return NULL;
- LLXMLNodePtr ret = mChildren->head;
- return ret;
-}
-
-LLXMLNodePtr LLXMLNode::getNextSibling() const
-{
- LLXMLNodePtr ret = mNext;
- return ret;
-}
-
-std::string LLXMLNode::getSanitizedValue() const
-{
- if (mIsAttribute)
- {
- return getValue() ;
- }
- else
- {
- return getTextContents();
- }
-}
-
-
-std::string LLXMLNode::getTextContents() const
-{
- std::string msg;
- std::string contents = mValue;
- std::string::size_type n = contents.find_first_not_of(" \t\n");
- if (n != std::string::npos && contents[n] == '\"')
- {
- // Case 1: node has quoted text
- S32 num_lines = 0;
- while(1)
- {
- // mContents[n] == '"'
- ++n;
- std::string::size_type t = n;
- std::string::size_type m = 0;
- // fix-up escaped characters
- while(1)
- {
- m = contents.find_first_of("\\\"", t); // find first \ or "
- if ((m == std::string::npos) || (contents[m] == '\"'))
- {
- break;
- }
- contents.erase(m,1);
- t = m+1;
- }
- if (m == std::string::npos)
- {
- break;
- }
- // mContents[m] == '"'
- num_lines++;
- msg += contents.substr(n,m-n) + "\n";
- n = contents.find_first_of("\"", m+1);
- if (n == std::string::npos)
- {
- if (num_lines == 1)
- {
- msg.erase(msg.size()-1); // remove "\n" if only one line
- }
- break;
- }
- }
- }
- else
- {
- // Case 2: node has embedded text (beginning and trailing whitespace trimmed)
- std::string::size_type start = mValue.find_first_not_of(" \t\n");
- if (start != mValue.npos)
- {
- std::string::size_type end = mValue.find_last_not_of(" \t\n");
- if (end != mValue.npos)
- {
- msg = mValue.substr(start, end+1-start);
- }
- else
- {
- msg = mValue.substr(start);
- }
- }
- // Convert any internal CR to LF
- msg = utf8str_removeCRLF(msg);
- }
- return msg;
-}
-
-void LLXMLNode::setLineNumber(S32 line_number)
-{
- mLineNumber = line_number;
-}
-
-S32 LLXMLNode::getLineNumber()
-{
- return mLineNumber;
-}
+/**
+ * @file llxmlnode.cpp
+ * @author Tom Yedwab
+ * @brief LLXMLNode implementation
+ *
+ * $LicenseInfo:firstyear=2005&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
+ * $/LicenseInfo$
+ */
+
+#include "linden_common.h"
+
+#include <iostream>
+#include <map>
+
+#include "llxmlnode.h"
+
+#include "v3color.h"
+#include "v4color.h"
+#include "v4coloru.h"
+#include "v3math.h"
+#include "v3dmath.h"
+#include "v4math.h"
+#include "llquaternion.h"
+#include "llstring.h"
+#include "lluuid.h"
+#include "lldir.h"
+
+// static
+bool LLXMLNode::sStripEscapedStrings = true;
+bool LLXMLNode::sStripWhitespaceValues = false;
+
+LLXMLNode::LLXMLNode() :
+ mID(""),
+ mParser(NULL),
+ mIsAttribute(false),
+ mVersionMajor(0),
+ mVersionMinor(0),
+ mLength(0),
+ mPrecision(64),
+ mType(TYPE_CONTAINER),
+ mEncoding(ENCODING_DEFAULT),
+ mLineNumber(-1),
+ mParent(NULL),
+ mChildren(NULL),
+ mAttributes(),
+ mPrev(NULL),
+ mNext(NULL),
+ mName(NULL),
+ mValue(""),
+ mDefault(NULL)
+{
+}
+
+LLXMLNode::LLXMLNode(const char* name, bool is_attribute) :
+ mID(""),
+ mParser(NULL),
+ mIsAttribute(is_attribute),
+ mVersionMajor(0),
+ mVersionMinor(0),
+ mLength(0),
+ mPrecision(64),
+ mType(TYPE_CONTAINER),
+ mEncoding(ENCODING_DEFAULT),
+ mLineNumber(-1),
+ mParent(NULL),
+ mChildren(NULL),
+ mAttributes(),
+ mPrev(NULL),
+ mNext(NULL),
+ mValue(""),
+ mDefault(NULL)
+{
+ mName = gStringTable.addStringEntry(name);
+}
+
+LLXMLNode::LLXMLNode(LLStringTableEntry* name, bool is_attribute) :
+ mID(""),
+ mParser(NULL),
+ mIsAttribute(is_attribute),
+ mVersionMajor(0),
+ mVersionMinor(0),
+ mLength(0),
+ mPrecision(64),
+ mType(TYPE_CONTAINER),
+ mEncoding(ENCODING_DEFAULT),
+ mLineNumber(-1),
+ mParent(NULL),
+ mChildren(NULL),
+ mAttributes(),
+ mPrev(NULL),
+ mNext(NULL),
+ mName(name),
+ mValue(""),
+ mDefault(NULL)
+{
+}
+
+// copy constructor (except for the children)
+LLXMLNode::LLXMLNode(const LLXMLNode& rhs) :
+ mID(rhs.mID),
+ mIsAttribute(rhs.mIsAttribute),
+ mVersionMajor(rhs.mVersionMajor),
+ mVersionMinor(rhs.mVersionMinor),
+ mLength(rhs.mLength),
+ mPrecision(rhs.mPrecision),
+ mType(rhs.mType),
+ mEncoding(rhs.mEncoding),
+ mLineNumber(0),
+ mParser(NULL),
+ mParent(NULL),
+ mChildren(NULL),
+ mAttributes(),
+ mPrev(NULL),
+ mNext(NULL),
+ mName(rhs.mName),
+ mValue(rhs.mValue),
+ mDefault(rhs.mDefault)
+{
+}
+
+// returns a new copy of this node and all its children
+LLXMLNodePtr LLXMLNode::deepCopy()
+{
+ LLXMLNodePtr newnode = LLXMLNodePtr(new LLXMLNode(*this));
+ if (mChildren.notNull())
+ {
+ for (LLXMLChildList::iterator iter = mChildren->map.begin();
+ iter != mChildren->map.end(); ++iter)
+ {
+ LLXMLNodePtr temp_ptr_for_gcc(iter->second->deepCopy());
+ newnode->addChild(temp_ptr_for_gcc);
+ }
+ }
+ for (LLXMLAttribList::iterator iter = mAttributes.begin();
+ iter != mAttributes.end(); ++iter)
+ {
+ LLXMLNodePtr temp_ptr_for_gcc(iter->second->deepCopy());
+ newnode->addChild(temp_ptr_for_gcc);
+ }
+
+ return newnode;
+}
+
+// virtual
+LLXMLNode::~LLXMLNode()
+{
+ // Strictly speaking none of this should be required execept 'delete mChildren'...
+ // Sadly, that's only true if we hadn't had reference-counted smart pointers linked
+ // in three different directions. This entire class is a frightening, hard-to-maintain
+ // mess.
+ if (mChildren.notNull())
+ {
+ for (LLXMLChildList::iterator iter = mChildren->map.begin();
+ iter != mChildren->map.end(); ++iter)
+ {
+ LLXMLNodePtr child = iter->second;
+ child->mParent = NULL;
+ child->mNext = NULL;
+ child->mPrev = NULL;
+ }
+ mChildren->map.clear();
+ mChildren->head = NULL;
+ mChildren->tail = NULL;
+ mChildren = NULL;
+ }
+ for (LLXMLAttribList::iterator iter = mAttributes.begin();
+ iter != mAttributes.end(); ++iter)
+ {
+ LLXMLNodePtr attr = iter->second;
+ attr->mParent = NULL;
+ attr->mNext = NULL;
+ attr->mPrev = NULL;
+ }
+ llassert(mParent == NULL);
+ mDefault = NULL;
+}
+
+bool LLXMLNode::isNull()
+{
+ return (mName == NULL);
+}
+
+// protected
+bool LLXMLNode::removeChild(LLXMLNode *target_child)
+{
+ if (!target_child)
+ {
+ return false;
+ }
+ if (target_child->mIsAttribute)
+ {
+ LLXMLAttribList::iterator children_itr = mAttributes.find(target_child->mName);
+ if (children_itr != mAttributes.end())
+ {
+ target_child->mParent = NULL;
+ mAttributes.erase(children_itr);
+ return true;
+ }
+ }
+ else if (mChildren.notNull())
+ {
+ LLXMLChildList::iterator children_itr = mChildren->map.find(target_child->mName);
+ while (children_itr != mChildren->map.end())
+ {
+ if (target_child == children_itr->second)
+ {
+ if (target_child == mChildren->head)
+ {
+ mChildren->head = target_child->mNext;
+ }
+ if (target_child == mChildren->tail)
+ {
+ mChildren->tail = target_child->mPrev;
+ }
+
+ LLXMLNodePtr prev = target_child->mPrev;
+ LLXMLNodePtr next = target_child->mNext;
+ if (prev.notNull()) prev->mNext = next;
+ if (next.notNull()) next->mPrev = prev;
+
+ target_child->mPrev = NULL;
+ target_child->mNext = NULL;
+ target_child->mParent = NULL;
+ mChildren->map.erase(children_itr);
+ if (mChildren->map.empty())
+ {
+ mChildren = NULL;
+ }
+ return true;
+ }
+ else if (children_itr->first != target_child->mName)
+ {
+ break;
+ }
+ else
+ {
+ ++children_itr;
+ }
+ }
+ }
+ return false;
+}
+
+void LLXMLNode::addChild(LLXMLNodePtr& new_child)
+{
+ if (new_child->mParent != NULL)
+ {
+ if (new_child->mParent == this)
+ {
+ return;
+ }
+ new_child->mParent->removeChild(new_child);
+ }
+
+ new_child->mParent = this;
+ if (new_child->mIsAttribute)
+ {
+ LLXMLAttribList::iterator found_it = mAttributes.find(new_child->mName);
+ if (found_it != mAttributes.end())
+ {
+ removeChild(found_it->second);
+ }
+ mAttributes.insert(std::make_pair(new_child->mName, new_child));
+ }
+ else
+ {
+ if (mChildren.isNull())
+ {
+ mChildren = new LLXMLChildren();
+ mChildren->head = new_child;
+ mChildren->tail = new_child;
+ }
+ mChildren->map.insert(std::make_pair(new_child->mName, new_child));
+
+ if (mChildren->tail != new_child)
+ {
+ mChildren->tail->mNext = new_child;
+ new_child->mPrev = mChildren->tail;
+ mChildren->tail = new_child;
+ }
+ }
+
+ new_child->updateDefault();
+}
+
+// virtual
+LLXMLNodePtr LLXMLNode::createChild(const char* name, bool is_attribute)
+{
+ return createChild(gStringTable.addStringEntry(name), is_attribute);
+}
+
+// virtual
+LLXMLNodePtr LLXMLNode::createChild(LLStringTableEntry* name, bool is_attribute)
+{
+ LLXMLNodePtr ret(new LLXMLNode(name, is_attribute));
+ ret->mID.clear();
+
+ addChild(ret);
+ return ret;
+}
+
+bool LLXMLNode::deleteChild(LLXMLNode *child)
+{
+ if (removeChild(child))
+ {
+ return true;
+ }
+ return false;
+}
+
+void LLXMLNode::setParent(LLXMLNodePtr& new_parent)
+{
+ if (new_parent.notNull())
+ {
+ LLXMLNodePtr this_ptr(this);
+ new_parent->addChild(this_ptr);
+ }
+ else
+ {
+ if (mParent != NULL)
+ {
+ LLXMLNodePtr old_parent = mParent;
+ mParent = NULL;
+ old_parent->removeChild(this);
+ }
+ }
+}
+
+
+void LLXMLNode::updateDefault()
+{
+ if (mParent != NULL && !mParent->mDefault.isNull())
+ {
+ mDefault = NULL;
+
+ // Find default value in parent's default tree
+ if (!mParent->mDefault.isNull())
+ {
+ findDefault(mParent->mDefault);
+ }
+ }
+
+ if (mChildren.notNull())
+ {
+ LLXMLChildList::const_iterator children_itr;
+ LLXMLChildList::const_iterator children_end = mChildren->map.end();
+ for (children_itr = mChildren->map.begin(); children_itr != children_end; ++children_itr)
+ {
+ LLXMLNodePtr child = (*children_itr).second;
+ child->updateDefault();
+ }
+ }
+}
+
+void XMLCALL StartXMLNode(void *userData,
+ const XML_Char *name,
+ const XML_Char **atts)
+{
+ // Create a new node
+ LLXMLNode *new_node_ptr = new LLXMLNode(name, false);
+
+ LLXMLNodePtr new_node = new_node_ptr;
+ new_node->mID.clear();
+ LLXMLNodePtr ptr_new_node = new_node;
+
+ // Set the parent-child relationship with the current active node
+ LLXMLNode* parent = (LLXMLNode *)userData;
+
+ if (NULL == parent)
+ {
+ LL_WARNS() << "parent (userData) is NULL; aborting function" << LL_ENDL;
+ return;
+ }
+
+ new_node_ptr->mParser = parent->mParser;
+ new_node_ptr->setLineNumber(XML_GetCurrentLineNumber(*new_node_ptr->mParser));
+
+ // Set the current active node to the new node
+ XML_Parser *parser = parent->mParser;
+ XML_SetUserData(*parser, (void *)new_node_ptr);
+
+ // Parse attributes
+ U32 pos = 0;
+ while (atts[pos] != NULL)
+ {
+ std::string attr_name = atts[pos];
+ std::string attr_value = atts[pos+1];
+
+ // Special cases
+ if ('i' == attr_name[0] && "id" == attr_name)
+ {
+ new_node->mID = attr_value;
+ }
+ else if ('v' == attr_name[0] && "version" == attr_name)
+ {
+ U32 version_major = 0;
+ U32 version_minor = 0;
+ if (sscanf(attr_value.c_str(), "%d.%d", &version_major, &version_minor) > 0)
+ {
+ new_node->mVersionMajor = version_major;
+ new_node->mVersionMinor = version_minor;
+ }
+ }
+ else if (('s' == attr_name[0] && "size" == attr_name) || ('l' == attr_name[0] && "length" == attr_name))
+ {
+ U32 length;
+ if (sscanf(attr_value.c_str(), "%d", &length) > 0)
+ {
+ new_node->mLength = length;
+ }
+ }
+ else if ('p' == attr_name[0] && "precision" == attr_name)
+ {
+ U32 precision;
+ if (sscanf(attr_value.c_str(), "%d", &precision) > 0)
+ {
+ new_node->mPrecision = precision;
+ }
+ }
+ else if ('t' == attr_name[0] && "type" == attr_name)
+ {
+ if ("boolean" == attr_value)
+ {
+ new_node->mType = LLXMLNode::TYPE_BOOLEAN;
+ }
+ else if ("integer" == attr_value)
+ {
+ new_node->mType = LLXMLNode::TYPE_INTEGER;
+ }
+ else if ("float" == attr_value)
+ {
+ new_node->mType = LLXMLNode::TYPE_FLOAT;
+ }
+ else if ("string" == attr_value)
+ {
+ new_node->mType = LLXMLNode::TYPE_STRING;
+ }
+ else if ("uuid" == attr_value)
+ {
+ new_node->mType = LLXMLNode::TYPE_UUID;
+ }
+ else if ("noderef" == attr_value)
+ {
+ new_node->mType = LLXMLNode::TYPE_NODEREF;
+ }
+ }
+ else if ('e' == attr_name[0] && "encoding" == attr_name)
+ {
+ if ("decimal" == attr_value)
+ {
+ new_node->mEncoding = LLXMLNode::ENCODING_DECIMAL;
+ }
+ else if ("hex" == attr_value)
+ {
+ new_node->mEncoding = LLXMLNode::ENCODING_HEX;
+ }
+ /*else if (attr_value == "base32")
+ {
+ new_node->mEncoding = LLXMLNode::ENCODING_BASE32;
+ }*/
+ }
+
+ // only one attribute child per description
+ LLXMLNodePtr attr_node;
+ if (!new_node->getAttribute(attr_name.c_str(), attr_node, false))
+ {
+ attr_node = new LLXMLNode(attr_name.c_str(), true);
+ attr_node->setLineNumber(XML_GetCurrentLineNumber(*new_node_ptr->mParser));
+ }
+ attr_node->setValue(attr_value);
+ new_node->addChild(attr_node);
+
+ pos += 2;
+ }
+
+ if (parent)
+ {
+ parent->addChild(new_node);
+ }
+}
+
+void XMLCALL EndXMLNode(void *userData,
+ const XML_Char *name)
+{
+ // [FUGLY] Set the current active node to the current node's parent
+ LLXMLNode *node = (LLXMLNode *)userData;
+ XML_Parser *parser = node->mParser;
+ XML_SetUserData(*parser, (void *)node->mParent);
+ // SJB: total hack:
+ if (LLXMLNode::sStripWhitespaceValues)
+ {
+ std::string value = node->getValue();
+ bool is_empty = true;
+ for (std::string::size_type s = 0; s < value.length(); s++)
+ {
+ char c = value[s];
+ if (c != ' ' && c != '\t' && c != '\n')
+ {
+ is_empty = false;
+ break;
+ }
+ }
+ if (is_empty)
+ {
+ value.clear();
+ node->setValue(value);
+ }
+ }
+}
+
+void XMLCALL XMLData(void *userData,
+ const XML_Char *s,
+ int len)
+{
+ LLXMLNode* current_node = (LLXMLNode *)userData;
+ std::string value = current_node->getValue();
+ if (LLXMLNode::sStripEscapedStrings)
+ {
+ if (s[0] == '\"' && s[len-1] == '\"')
+ {
+ // Special-case: Escaped string.
+ std::string unescaped_string;
+ for (S32 pos=1; pos<len-1; ++pos)
+ {
+ if (s[pos] == '\\' && s[pos+1] == '\\')
+ {
+ unescaped_string.append("\\");
+ ++pos;
+ }
+ else if (s[pos] == '\\' && s[pos+1] == '\"')
+ {
+ unescaped_string.append("\"");
+ ++pos;
+ }
+ else
+ {
+ unescaped_string.append(&s[pos], 1);
+ }
+ }
+ value.append(unescaped_string);
+ current_node->setValue(value);
+ return;
+ }
+ }
+ value.append(std::string(s, len));
+ current_node->setValue(value);
+}
+
+
+
+// static
+bool LLXMLNode::updateNode(
+ LLXMLNodePtr& node,
+ LLXMLNodePtr& update_node)
+{
+
+ if (!node || !update_node)
+ {
+ LL_WARNS() << "Node invalid" << LL_ENDL;
+ return false;
+ }
+
+ //update the node value
+ node->mValue = update_node->mValue;
+
+ //update all attribute values
+ LLXMLAttribList::const_iterator itor;
+
+ for(itor = update_node->mAttributes.begin(); itor != update_node->mAttributes.end(); ++itor)
+ {
+ const LLStringTableEntry* attribNameEntry = (*itor).first;
+ LLXMLNodePtr updateAttribNode = (*itor).second;
+
+ LLXMLNodePtr attribNode;
+
+ node->getAttribute(attribNameEntry, attribNode, 0);
+
+ if (attribNode)
+ {
+ attribNode->mValue = updateAttribNode->mValue;
+ }
+ }
+
+ //update all of node's children with updateNodes children that match name
+ LLXMLNodePtr child = node->getFirstChild();
+ LLXMLNodePtr last_child = child;
+ LLXMLNodePtr updateChild;
+
+ for (updateChild = update_node->getFirstChild(); updateChild.notNull();
+ updateChild = updateChild->getNextSibling())
+ {
+ while(child.notNull())
+ {
+ std::string nodeName;
+ std::string updateName;
+
+ updateChild->getAttributeString("name", updateName);
+ child->getAttributeString("name", nodeName);
+
+
+ //if it's a combobox there's no name, but there is a value
+ if (updateName.empty())
+ {
+ updateChild->getAttributeString("value", updateName);
+ child->getAttributeString("value", nodeName);
+ }
+
+ if ((nodeName != "") && (updateName == nodeName))
+ {
+ updateNode(child, updateChild);
+ last_child = child;
+ child = child->getNextSibling();
+ if (child.isNull())
+ {
+ child = node->getFirstChild();
+ }
+ break;
+ }
+
+ child = child->getNextSibling();
+ if (child.isNull())
+ {
+ child = node->getFirstChild();
+ }
+ if (child == last_child)
+ {
+ break;
+ }
+ }
+ }
+
+ return true;
+}
+
+// static
+bool LLXMLNode::parseFile(const std::string& filename, LLXMLNodePtr& node, LLXMLNode* defaults_tree)
+{
+ // Read file
+ LL_DEBUGS("XMLNode") << "parsing XML file: " << filename << LL_ENDL;
+ LLFILE* fp = LLFile::fopen(filename, "rb"); /* Flawfinder: ignore */
+ if (fp == NULL)
+ {
+ node = NULL ;
+ return false;
+ }
+ fseek(fp, 0, SEEK_END);
+ U32 length = ftell(fp);
+ fseek(fp, 0, SEEK_SET);
+
+ U8* buffer = new U8[length+1];
+ size_t nread = fread(buffer, 1, length, fp);
+ buffer[nread] = 0;
+ fclose(fp);
+
+ bool rv = parseBuffer(buffer, nread, node, defaults_tree);
+ delete [] buffer;
+ return rv;
+}
+
+// static
+bool LLXMLNode::parseBuffer(
+ U8* buffer,
+ U32 length,
+ LLXMLNodePtr& node,
+ LLXMLNode* defaults)
+{
+ // Init
+ XML_Parser my_parser = XML_ParserCreate(NULL);
+ XML_SetElementHandler(my_parser, StartXMLNode, EndXMLNode);
+ XML_SetCharacterDataHandler(my_parser, XMLData);
+
+ // Create a root node
+ LLXMLNode *file_node_ptr = new LLXMLNode("XML", false);
+ LLXMLNodePtr file_node = file_node_ptr;
+
+ file_node->mParser = &my_parser;
+
+ XML_SetUserData(my_parser, (void *)file_node_ptr);
+
+ // Do the parsing
+ if (XML_Parse(my_parser, (const char *)buffer, length, true) != XML_STATUS_OK)
+ {
+ LL_WARNS() << "Error parsing xml error code: "
+ << XML_ErrorString(XML_GetErrorCode(my_parser))
+ << " on line " << XML_GetCurrentLineNumber(my_parser)
+ << LL_ENDL;
+ }
+
+ // Deinit
+ XML_ParserFree(my_parser);
+
+ if (!file_node->mChildren || file_node->mChildren->map.size() != 1)
+ {
+ LL_WARNS() << "Parse failure - wrong number of top-level nodes xml."
+ << LL_ENDL;
+ node = NULL ;
+ return false;
+ }
+
+ LLXMLNode *return_node = file_node->mChildren->map.begin()->second;
+
+ return_node->setDefault(defaults);
+ return_node->updateDefault();
+
+ node = return_node;
+ return true;
+}
+
+// static
+bool LLXMLNode::parseStream(
+ std::istream& str,
+ LLXMLNodePtr& node,
+ LLXMLNode* defaults)
+{
+ // Init
+ XML_Parser my_parser = XML_ParserCreate(NULL);
+ XML_SetElementHandler(my_parser, StartXMLNode, EndXMLNode);
+ XML_SetCharacterDataHandler(my_parser, XMLData);
+
+ // Create a root node
+ LLXMLNode *file_node_ptr = new LLXMLNode("XML", false);
+ LLXMLNodePtr file_node = file_node_ptr;
+
+ file_node->mParser = &my_parser;
+
+ XML_SetUserData(my_parser, (void *)file_node_ptr);
+
+ const int BUFSIZE = 1024;
+ U8* buffer = new U8[BUFSIZE];
+
+ while(str.good())
+ {
+ str.read((char*)buffer, BUFSIZE);
+ int count = (int)str.gcount();
+
+ if (XML_Parse(my_parser, (const char *)buffer, count, !str.good()) != XML_STATUS_OK)
+ {
+ LL_WARNS() << "Error parsing xml error code: "
+ << XML_ErrorString(XML_GetErrorCode(my_parser))
+ << " on lne " << XML_GetCurrentLineNumber(my_parser)
+ << LL_ENDL;
+ break;
+ }
+ }
+
+ delete [] buffer;
+
+ // Deinit
+ XML_ParserFree(my_parser);
+
+ if (!file_node->mChildren || file_node->mChildren->map.size() != 1)
+ {
+ LL_WARNS() << "Parse failure - wrong number of top-level nodes xml."
+ << LL_ENDL;
+ node = NULL;
+ return false;
+ }
+
+ LLXMLNode *return_node = file_node->mChildren->map.begin()->second;
+
+ return_node->setDefault(defaults);
+ return_node->updateDefault();
+
+ node = return_node;
+ return true;
+}
+
+
+bool LLXMLNode::isFullyDefault()
+{
+ if (mDefault.isNull())
+ {
+ return false;
+ }
+ bool has_default_value = (mValue == mDefault->mValue);
+ bool has_default_attribute = (mIsAttribute == mDefault->mIsAttribute);
+ bool has_default_type = mIsAttribute || (mType == mDefault->mType);
+ bool has_default_encoding = mIsAttribute || (mEncoding == mDefault->mEncoding);
+ bool has_default_precision = mIsAttribute || (mPrecision == mDefault->mPrecision);
+ bool has_default_length = mIsAttribute || (mLength == mDefault->mLength);
+
+ if (has_default_value
+ && has_default_type
+ && has_default_encoding
+ && has_default_precision
+ && has_default_length
+ && has_default_attribute)
+ {
+ if (mChildren.notNull())
+ {
+ LLXMLChildList::const_iterator children_itr;
+ LLXMLChildList::const_iterator children_end = mChildren->map.end();
+ for (children_itr = mChildren->map.begin(); children_itr != children_end; ++children_itr)
+ {
+ LLXMLNodePtr child = (*children_itr).second;
+ if (!child->isFullyDefault())
+ {
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+
+ return false;
+}
+
+// static
+bool LLXMLNode::getLayeredXMLNode(LLXMLNodePtr& root,
+ const std::vector<std::string>& paths)
+{
+ if (paths.empty()) return false;
+
+ std::string filename = paths.front();
+ if (filename.empty())
+ {
+ return false;
+ }
+
+ if (!LLXMLNode::parseFile(filename, root, NULL))
+ {
+ LL_WARNS() << "Problem reading UI description file: " << filename << " " << errno << LL_ENDL;
+ return false;
+ }
+
+ LLXMLNodePtr updateRoot;
+
+ std::vector<std::string>::const_iterator itor;
+
+ // We've already dealt with the first item, skip that one
+ for (itor = paths.begin() + 1; itor != paths.end(); ++itor)
+ {
+ std::string layer_filename = *itor;
+ if(layer_filename.empty() || layer_filename == filename)
+ {
+ // no localized version of this file, that's ok, keep looking
+ continue;
+ }
+
+ if (!LLXMLNode::parseFile(layer_filename, updateRoot, NULL))
+ {
+ LL_WARNS() << "Problem reading localized UI description file: " << layer_filename << LL_ENDL;
+ return false;
+ }
+
+ std::string nodeName;
+ std::string updateName;
+
+ updateRoot->getAttributeString("name", updateName);
+ root->getAttributeString("name", nodeName);
+
+ if (updateName == nodeName)
+ {
+ LLXMLNode::updateNode(root, updateRoot);
+ }
+ }
+
+ return true;
+}
+
+// static
+void LLXMLNode::writeHeaderToFile(LLFILE *out_file)
+{
+ fprintf(out_file, "<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"yes\" ?>\n");
+}
+
+void LLXMLNode::writeToFile(LLFILE *out_file, const std::string& indent, bool use_type_decorations)
+{
+ if (isFullyDefault())
+ {
+ // Don't write out nodes that are an exact match to defaults
+ return;
+ }
+
+ std::ostringstream ostream;
+ writeToOstream(ostream, indent, use_type_decorations);
+ std::string outstring = ostream.str();
+ size_t written = fwrite(outstring.c_str(), 1, outstring.length(), out_file);
+ if (written != outstring.length())
+ {
+ LL_WARNS() << "Short write" << LL_ENDL;
+ }
+}
+
+void LLXMLNode::writeToOstream(std::ostream& output_stream, const std::string& indent, bool use_type_decorations)
+{
+ if (isFullyDefault())
+ {
+ // Don't write out nodes that are an exact match to defaults
+ return;
+ }
+
+ bool has_default_type = mDefault.isNull()?false:(mType == mDefault->mType);
+ bool has_default_encoding = mDefault.isNull()?false:(mEncoding == mDefault->mEncoding);
+ bool has_default_precision = mDefault.isNull()?false:(mPrecision == mDefault->mPrecision);
+ bool has_default_length = mDefault.isNull()?false:(mLength == mDefault->mLength);
+
+ // stream the name
+ output_stream << indent << "<" << mName->mString << "\n";
+
+ if (use_type_decorations)
+ {
+ // ID
+ if (mID != "")
+ {
+ output_stream << indent << " id=\"" << mID << "\"\n";
+ }
+
+ // Type
+ if (!has_default_type)
+ {
+ switch (mType)
+ {
+ case TYPE_BOOLEAN:
+ output_stream << indent << " type=\"boolean\"\n";
+ break;
+ case TYPE_INTEGER:
+ output_stream << indent << " type=\"integer\"\n";
+ break;
+ case TYPE_FLOAT:
+ output_stream << indent << " type=\"float\"\n";
+ break;
+ case TYPE_STRING:
+ output_stream << indent << " type=\"string\"\n";
+ break;
+ case TYPE_UUID:
+ output_stream << indent << " type=\"uuid\"\n";
+ break;
+ case TYPE_NODEREF:
+ output_stream << indent << " type=\"noderef\"\n";
+ break;
+ default:
+ // default on switch(enum) eliminates a warning on linux
+ break;
+ };
+ }
+
+ // Encoding
+ if (!has_default_encoding)
+ {
+ switch (mEncoding)
+ {
+ case ENCODING_DECIMAL:
+ output_stream << indent << " encoding=\"decimal\"\n";
+ break;
+ case ENCODING_HEX:
+ output_stream << indent << " encoding=\"hex\"\n";
+ break;
+ /*case ENCODING_BASE32:
+ output_stream << indent << " encoding=\"base32\"\n";
+ break;*/
+ default:
+ // default on switch(enum) eliminates a warning on linux
+ break;
+ };
+ }
+
+ // Precision
+ if (!has_default_precision && (mType == TYPE_INTEGER || mType == TYPE_FLOAT))
+ {
+ output_stream << indent << " precision=\"" << mPrecision << "\"\n";
+ }
+
+ // Version
+ if (mVersionMajor > 0 || mVersionMinor > 0)
+ {
+ output_stream << indent << " version=\"" << mVersionMajor << "." << mVersionMinor << "\"\n";
+ }
+
+ // Array length
+ if (!has_default_length && mLength > 0)
+ {
+ output_stream << indent << " length=\"" << mLength << "\"\n";
+ }
+ }
+
+ {
+ // Write out attributes
+ LLXMLAttribList::const_iterator attr_itr;
+ LLXMLAttribList::const_iterator attr_end = mAttributes.end();
+ for (attr_itr = mAttributes.begin(); attr_itr != attr_end; ++attr_itr)
+ {
+ LLXMLNodePtr child = (*attr_itr).second;
+ if (child->mDefault.isNull() || child->mDefault->mValue != child->mValue)
+ {
+ std::string attr = child->mName->mString;
+ if (use_type_decorations
+ && (attr == "id" ||
+ attr == "type" ||
+ attr == "encoding" ||
+ attr == "precision" ||
+ attr == "version" ||
+ attr == "length"))
+ {
+ continue; // skip built-in attributes
+ }
+
+ std::string attr_str = llformat(" %s=\"%s\"",
+ attr.c_str(),
+ escapeXML(child->mValue).c_str());
+ output_stream << indent << attr_str << "\n";
+ }
+ }
+ }
+
+ // erase last \n before attaching final > or />
+ output_stream.seekp(-1, std::ios::cur);
+
+ if (mChildren.isNull() && mValue == "")
+ {
+ output_stream << " />\n";
+ return;
+ }
+ else
+ {
+ output_stream << ">\n";
+ if (mChildren.notNull())
+ {
+ // stream non-attributes
+ std::string next_indent = indent + " ";
+ for (LLXMLNode* child = getFirstChild(); child; child = child->getNextSibling())
+ {
+ child->writeToOstream(output_stream, next_indent, use_type_decorations);
+ }
+ }
+ if (!mValue.empty())
+ {
+ std::string contents = getTextContents();
+ output_stream << indent << " " << escapeXML(contents) << "\n";
+ }
+ output_stream << indent << "</" << mName->mString << ">\n";
+ }
+}
+
+void LLXMLNode::findName(const std::string& name, LLXMLNodeList &results)
+{
+ LLStringTableEntry* name_entry = gStringTable.checkStringEntry(name);
+ if (name_entry == mName)
+ {
+ results.insert(std::make_pair(this->mName->mString, this));
+ return;
+ }
+ if (mChildren.notNull())
+ {
+ LLXMLChildList::const_iterator children_itr;
+ LLXMLChildList::const_iterator children_end = mChildren->map.end();
+ for (children_itr = mChildren->map.begin(); children_itr != children_end; ++children_itr)
+ {
+ LLXMLNodePtr child = (*children_itr).second;
+ child->findName(name_entry, results);
+ }
+ }
+}
+
+void LLXMLNode::findName(LLStringTableEntry* name, LLXMLNodeList &results)
+{
+ if (name == mName)
+ {
+ results.insert(std::make_pair(this->mName->mString, this));
+ return;
+ }
+ if (mChildren.notNull())
+ {
+ LLXMLChildList::const_iterator children_itr;
+ LLXMLChildList::const_iterator children_end = mChildren->map.end();
+ for (children_itr = mChildren->map.begin(); children_itr != children_end; ++children_itr)
+ {
+ LLXMLNodePtr child = (*children_itr).second;
+ child->findName(name, results);
+ }
+ }
+}
+
+void LLXMLNode::findID(const std::string& id, LLXMLNodeList &results)
+{
+ if (id == mID)
+ {
+ results.insert(std::make_pair(this->mName->mString, this));
+ return;
+ }
+ if (mChildren.notNull())
+ {
+ LLXMLChildList::const_iterator children_itr;
+ LLXMLChildList::const_iterator children_end = mChildren->map.end();
+ for (children_itr = mChildren->map.begin(); children_itr != children_end; ++children_itr)
+ {
+ LLXMLNodePtr child = (*children_itr).second;
+ child->findID(id, results);
+ }
+ }
+}
+
+void LLXMLNode::scrubToTree(LLXMLNode *tree)
+{
+ if (!tree || tree->mChildren.isNull())
+ {
+ return;
+ }
+ if (mChildren.notNull())
+ {
+ std::vector<LLXMLNodePtr> to_delete_list;
+ LLXMLChildList::iterator itor = mChildren->map.begin();
+ while (itor != mChildren->map.end())
+ {
+ LLXMLNodePtr child = itor->second;
+ LLXMLNodePtr child_tree = NULL;
+ // Look for this child in the default's children
+ bool found = false;
+ LLXMLChildList::iterator itor2 = tree->mChildren->map.begin();
+ while (itor2 != tree->mChildren->map.end())
+ {
+ if (child->mName == itor2->second->mName)
+ {
+ child_tree = itor2->second;
+ found = true;
+ }
+ ++itor2;
+ }
+ if (!found)
+ {
+ to_delete_list.push_back(child);
+ }
+ else
+ {
+ child->scrubToTree(child_tree);
+ }
+ ++itor;
+ }
+ std::vector<LLXMLNodePtr>::iterator itor3;
+ for (itor3=to_delete_list.begin(); itor3!=to_delete_list.end(); ++itor3)
+ {
+ LLXMLNodePtr ptr;
+ (*itor3)->setParent(ptr);
+ }
+ }
+}
+
+bool LLXMLNode::getChild(const char* name, LLXMLNodePtr& node, bool use_default_if_missing)
+{
+ return getChild(gStringTable.checkStringEntry(name), node, use_default_if_missing);
+}
+
+bool LLXMLNode::getChild(const LLStringTableEntry* name, LLXMLNodePtr& node, bool use_default_if_missing)
+{
+ if (mChildren.notNull())
+ {
+ LLXMLChildList::const_iterator child_itr = mChildren->map.find(name);
+ if (child_itr != mChildren->map.end())
+ {
+ node = (*child_itr).second;
+ return true;
+ }
+ }
+ if (use_default_if_missing && !mDefault.isNull())
+ {
+ return mDefault->getChild(name, node, false);
+ }
+ node = NULL;
+ return false;
+}
+
+void LLXMLNode::getChildren(const char* name, LLXMLNodeList &children, bool use_default_if_missing) const
+{
+ getChildren(gStringTable.checkStringEntry(name), children, use_default_if_missing);
+}
+
+void LLXMLNode::getChildren(const LLStringTableEntry* name, LLXMLNodeList &children, bool use_default_if_missing) const
+{
+ if (mChildren.notNull())
+ {
+ LLXMLChildList::const_iterator child_itr = mChildren->map.find(name);
+ if (child_itr != mChildren->map.end())
+ {
+ LLXMLChildList::const_iterator children_end = mChildren->map.end();
+ while (child_itr != children_end)
+ {
+ LLXMLNodePtr child = (*child_itr).second;
+ if (name != child->mName)
+ {
+ break;
+ }
+ children.insert(std::make_pair(child->mName->mString, child));
+ child_itr++;
+ }
+ }
+ }
+ if (children.size() == 0 && use_default_if_missing && !mDefault.isNull())
+ {
+ mDefault->getChildren(name, children, false);
+ }
+}
+
+// recursively walks the tree and returns all children at all nesting levels matching the name
+void LLXMLNode::getDescendants(const LLStringTableEntry* name, LLXMLNodeList &children) const
+{
+ if (mChildren.notNull())
+ {
+ for (LLXMLChildList::const_iterator child_itr = mChildren->map.begin();
+ child_itr != mChildren->map.end(); ++child_itr)
+ {
+ LLXMLNodePtr child = (*child_itr).second;
+ if (name == child->mName)
+ {
+ children.insert(std::make_pair(child->mName->mString, child));
+ }
+ // and check each child as well
+ child->getDescendants(name, children);
+ }
+ }
+}
+
+bool LLXMLNode::getAttribute(const char* name, LLXMLNodePtr& node, bool use_default_if_missing)
+{
+ return getAttribute(gStringTable.checkStringEntry(name), node, use_default_if_missing);
+}
+
+bool LLXMLNode::getAttribute(const LLStringTableEntry* name, LLXMLNodePtr& node, bool use_default_if_missing)
+{
+ LLXMLAttribList::const_iterator child_itr = mAttributes.find(name);
+ if (child_itr != mAttributes.end())
+ {
+ node = (*child_itr).second;
+ return true;
+ }
+ if (use_default_if_missing && !mDefault.isNull())
+ {
+ return mDefault->getAttribute(name, node, false);
+ }
+
+ return false;
+}
+
+bool LLXMLNode::setAttributeString(const char* attr, const std::string& value)
+{
+ LLStringTableEntry* name = gStringTable.checkStringEntry(attr);
+ LLXMLAttribList::const_iterator child_itr = mAttributes.find(name);
+ if (child_itr != mAttributes.end())
+ {
+ LLXMLNodePtr node = (*child_itr).second;
+ node->setValue(value);
+ return true;
+ }
+ return false;
+}
+
+bool LLXMLNode::hasAttribute(const char* name )
+{
+ LLXMLNodePtr node;
+ return getAttribute(name, node);
+}
+
+bool LLXMLNode::getAttributeBOOL(const char* name, bool& value )
+{
+ LLXMLNodePtr node;
+ return (getAttribute(name, node) && node->getBoolValue(1, &value));
+}
+
+bool LLXMLNode::getAttributeU8(const char* name, U8& value )
+{
+ LLXMLNodePtr node;
+ return (getAttribute(name, node) && node->getByteValue(1, &value));
+}
+
+bool LLXMLNode::getAttributeS8(const char* name, S8& value )
+{
+ LLXMLNodePtr node;
+ S32 val;
+ if (!(getAttribute(name, node) && node->getIntValue(1, &val)))
+ {
+ return false;
+ }
+ value = val;
+ return true;
+}
+
+bool LLXMLNode::getAttributeU16(const char* name, U16& value )
+{
+ LLXMLNodePtr node;
+ U32 val;
+ if (!(getAttribute(name, node) && node->getUnsignedValue(1, &val)))
+ {
+ return false;
+ }
+ value = val;
+ return true;
+}
+
+bool LLXMLNode::getAttributeS16(const char* name, S16& value )
+{
+ LLXMLNodePtr node;
+ S32 val;
+ if (!(getAttribute(name, node) && node->getIntValue(1, &val)))
+ {
+ return false;
+ }
+ value = val;
+ return true;
+}
+
+bool LLXMLNode::getAttributeU32(const char* name, U32& value )
+{
+ LLXMLNodePtr node;
+ return (getAttribute(name, node) && node->getUnsignedValue(1, &value));
+}
+
+bool LLXMLNode::getAttributeS32(const char* name, S32& value )
+{
+ LLXMLNodePtr node;
+ return (getAttribute(name, node) && node->getIntValue(1, &value));
+}
+
+bool LLXMLNode::getAttributeF32(const char* name, F32& value )
+{
+ LLXMLNodePtr node;
+ return (getAttribute(name, node) && node->getFloatValue(1, &value));
+}
+
+bool LLXMLNode::getAttributeF64(const char* name, F64& value )
+{
+ LLXMLNodePtr node;
+ return (getAttribute(name, node) && node->getDoubleValue(1, &value));
+}
+
+bool LLXMLNode::getAttributeColor(const char* name, LLColor4& value )
+{
+ LLXMLNodePtr node;
+ return (getAttribute(name, node) && node->getFloatValue(4, value.mV));
+}
+
+bool LLXMLNode::getAttributeColor4(const char* name, LLColor4& value )
+{
+ LLXMLNodePtr node;
+ return (getAttribute(name, node) && node->getFloatValue(4, value.mV));
+}
+
+bool LLXMLNode::getAttributeColor4U(const char* name, LLColor4U& value )
+{
+ LLXMLNodePtr node;
+ return (getAttribute(name, node) && node->getByteValue(4, value.mV));
+}
+
+bool LLXMLNode::getAttributeVector3(const char* name, LLVector3& value )
+{
+ LLXMLNodePtr node;
+ return (getAttribute(name, node) && node->getFloatValue(3, value.mV));
+}
+
+bool LLXMLNode::getAttributeVector3d(const char* name, LLVector3d& value )
+{
+ LLXMLNodePtr node;
+ return (getAttribute(name, node) && node->getDoubleValue(3, value.mdV));
+}
+
+bool LLXMLNode::getAttributeQuat(const char* name, LLQuaternion& value )
+{
+ LLXMLNodePtr node;
+ return (getAttribute(name, node) && node->getFloatValue(4, value.mQ));
+}
+
+bool LLXMLNode::getAttributeUUID(const char* name, LLUUID& value )
+{
+ LLXMLNodePtr node;
+ return (getAttribute(name, node) && node->getUUIDValue(1, &value));
+}
+
+bool LLXMLNode::getAttributeString(const char* name, std::string& value )
+{
+ LLXMLNodePtr node;
+ if (!getAttribute(name, node))
+ {
+ return false;
+ }
+ value = node->getValue();
+ return true;
+}
+
+LLXMLNodePtr LLXMLNode::getRoot()
+{
+ if (mParent == NULL)
+ {
+ return this;
+ }
+ return mParent->getRoot();
+}
+
+/*static */
+const char *LLXMLNode::skipWhitespace(const char *str)
+{
+ // skip whitespace characters
+ while (str[0] == ' ' || str[0] == '\t' || str[0] == '\n') ++str;
+ return str;
+}
+
+/*static */
+const char *LLXMLNode::skipNonWhitespace(const char *str)
+{
+ // skip non-whitespace characters
+ while (str[0] != ' ' && str[0] != '\t' && str[0] != '\n' && str[0] != 0) ++str;
+ return str;
+}
+
+/*static */
+const char *LLXMLNode::parseInteger(const char *str, U64 *dest, bool *is_negative, U32 precision, Encoding encoding)
+{
+ *dest = 0;
+ *is_negative = false;
+
+ str = skipWhitespace(str);
+
+ if (str[0] == 0) return NULL;
+
+ if (encoding == ENCODING_DECIMAL || encoding == ENCODING_DEFAULT)
+ {
+ if (str[0] == '+')
+ {
+ ++str;
+ }
+ if (str[0] == '-')
+ {
+ *is_negative = true;
+ ++str;
+ }
+
+ str = skipWhitespace(str);
+
+ U64 ret = 0;
+ while (str[0] >= '0' && str[0] <= '9')
+ {
+ ret *= 10;
+ ret += str[0] - '0';
+ ++str;
+ }
+
+ if (str[0] == '.')
+ {
+ // If there is a fractional part, skip it
+ str = skipNonWhitespace(str);
+ }
+
+ *dest = ret;
+ return str;
+ }
+ if (encoding == ENCODING_HEX)
+ {
+ U64 ret = 0;
+ str = skipWhitespace(str);
+ for (U32 pos=0; pos<(precision/4); ++pos)
+ {
+ ret <<= 4;
+ str = skipWhitespace(str);
+ if (str[0] >= '0' && str[0] <= '9')
+ {
+ ret += str[0] - '0';
+ }
+ else if (str[0] >= 'a' && str[0] <= 'f')
+ {
+ ret += str[0] - 'a' + 10;
+ }
+ else if (str[0] >= 'A' && str[0] <= 'F')
+ {
+ ret += str[0] - 'A' + 10;
+ }
+ else
+ {
+ return NULL;
+ }
+ ++str;
+ }
+
+ *dest = ret;
+ return str;
+ }
+ return NULL;
+}
+
+// 25 elements - decimal expansions of 1/(2^n), multiplied by 10 each iteration
+const U64 float_coeff_table[] =
+ { 5, 25, 125, 625, 3125,
+ 15625, 78125, 390625, 1953125, 9765625,
+ 48828125, 244140625, 1220703125, 6103515625LL, 30517578125LL,
+ 152587890625LL, 762939453125LL, 3814697265625LL, 19073486328125LL, 95367431640625LL,
+ 476837158203125LL, 2384185791015625LL, 11920928955078125LL, 59604644775390625LL, 298023223876953125LL };
+
+// 36 elements - decimal expansions of 1/(2^n) after the last 28, truncated, no multiply each iteration
+const U64 float_coeff_table_2[] =
+ { 149011611938476562LL,74505805969238281LL,
+ 37252902984619140LL, 18626451492309570LL, 9313225746154785LL, 4656612873077392LL,
+ 2328306436538696LL, 1164153218269348LL, 582076609134674LL, 291038304567337LL,
+ 145519152283668LL, 72759576141834LL, 36379788070917LL, 18189894035458LL,
+ 9094947017729LL, 4547473508864LL, 2273736754432LL, 1136868377216LL,
+ 568434188608LL, 284217094304LL, 142108547152LL, 71054273576LL,
+ 35527136788LL, 17763568394LL, 8881784197LL, 4440892098LL,
+ 2220446049LL, 1110223024LL, 555111512LL, 277555756LL,
+ 138777878, 69388939, 34694469, 17347234,
+ 8673617, 4336808, 2168404, 1084202,
+ 542101, 271050, 135525, 67762,
+ };
+
+/*static */
+const char *LLXMLNode::parseFloat(const char *str, F64 *dest, U32 precision, Encoding encoding)
+{
+ str = skipWhitespace(str);
+
+ if (str[0] == 0) return NULL;
+
+ if (encoding == ENCODING_DECIMAL || encoding == ENCODING_DEFAULT)
+ {
+ str = skipWhitespace(str);
+
+ if (memcmp(str, "inf", 3) == 0)
+ {
+ *(U64 *)dest = 0x7FF0000000000000ll;
+ return str + 3;
+ }
+ if (memcmp(str, "-inf", 4) == 0)
+ {
+ *(U64 *)dest = 0xFFF0000000000000ll;
+ return str + 4;
+ }
+ if (memcmp(str, "1.#INF", 6) == 0)
+ {
+ *(U64 *)dest = 0x7FF0000000000000ll;
+ return str + 6;
+ }
+ if (memcmp(str, "-1.#INF", 7) == 0)
+ {
+ *(U64 *)dest = 0xFFF0000000000000ll;
+ return str + 7;
+ }
+
+ F64 negative = 1.0f;
+ if (str[0] == '+')
+ {
+ ++str;
+ }
+ if (str[0] == '-')
+ {
+ negative = -1.0f;
+ ++str;
+ }
+
+ const char* base_str = str;
+ str = skipWhitespace(str);
+
+ // Parse the integer part of the expression
+ U64 int_part = 0;
+ while (str[0] >= '0' && str[0] <= '9')
+ {
+ int_part *= 10;
+ int_part += U64(str[0] - '0');
+ ++str;
+ }
+
+ U64 f_part = 0;//, f_decimal = 1;
+ if (str[0] == '.')
+ {
+ ++str;
+ U64 remainder = 0;
+ U32 pos = 0;
+ // Parse the decimal part of the expression
+ while (str[0] >= '0' && str[0] <= '9' && pos < 25)
+ {
+ remainder = (remainder*10) + U64(str[0] - '0');
+ f_part <<= 1;
+ //f_decimal <<= 1;
+ // Check the n'th bit
+ if (remainder >= float_coeff_table[pos])
+ {
+ remainder -= float_coeff_table[pos];
+ f_part |= 1;
+ }
+ ++pos;
+ ++str;
+ }
+ if (pos == 25)
+ {
+ // Drop any excessive digits
+ while (str[0] >= '0' && str[0] <= '9')
+ {
+ ++str;
+ }
+ }
+ else
+ {
+ while (pos < 25)
+ {
+ remainder *= 10;
+ f_part <<= 1;
+ //f_decimal <<= 1;
+ // Check the n'th bit
+ if (remainder >= float_coeff_table[pos])
+ {
+ remainder -= float_coeff_table[pos];
+ f_part |= 1;
+ }
+ ++pos;
+ }
+ }
+ pos = 0;
+ while (pos < 36)
+ {
+ f_part <<= 1;
+ //f_decimal <<= 1;
+ if (remainder >= float_coeff_table_2[pos])
+ {
+ remainder -= float_coeff_table_2[pos];
+ f_part |= 1;
+ }
+ ++pos;
+ }
+ }
+
+ F64 ret = F64(int_part) + (F64(f_part)/F64(1LL<<61));
+
+ F64 exponent = 1.f;
+ if (str[0] == 'e')
+ {
+ // Scientific notation!
+ ++str;
+ U64 exp;
+ bool is_negative;
+ str = parseInteger(str, &exp, &is_negative, 64, ENCODING_DECIMAL);
+ if (str == NULL)
+ {
+ exp = 1;
+ }
+ F64 exp_d = F64(exp) * (is_negative?-1:1);
+ exponent = pow(10.0, exp_d);
+ }
+
+ if (str == base_str)
+ {
+ // no digits parsed
+ return NULL;
+ }
+ else
+ {
+ *dest = ret*negative*exponent;
+ return str;
+ }
+ }
+ if (encoding == ENCODING_HEX)
+ {
+ U64 bytes_dest;
+ bool is_negative;
+ str = parseInteger(str, (U64 *)&bytes_dest, &is_negative, precision, ENCODING_HEX);
+ // Upcast to F64
+ switch (precision)
+ {
+ case 32:
+ {
+ U32 short_dest = (U32)bytes_dest;
+ F32 ret_val = *(F32 *)&short_dest;
+ *dest = ret_val;
+ }
+ break;
+ case 64:
+ *dest = *(F64 *)&bytes_dest;
+ break;
+ default:
+ return NULL;
+ }
+ return str;
+ }
+ return NULL;
+}
+
+U32 LLXMLNode::getBoolValue(U32 expected_length, bool *array)
+{
+ llassert(array);
+
+ // Check type - accept booleans or strings
+ if (mType != TYPE_BOOLEAN && mType != TYPE_STRING && mType != TYPE_UNKNOWN)
+ {
+ return 0;
+ }
+
+ std::string *str_array = new std::string[expected_length];
+
+ U32 length = getStringValue(expected_length, str_array);
+
+ U32 ret_length = 0;
+ for (U32 i=0; i<length; ++i)
+ {
+ LLStringUtil::toLower(str_array[i]);
+ if (str_array[i] == "false")
+ {
+ array[ret_length++] = false;
+ }
+ else if (str_array[i] == "true")
+ {
+ array[ret_length++] = true;
+ }
+ }
+
+ delete[] str_array;
+
+#if LL_DEBUG
+ if (ret_length != expected_length)
+ {
+ LL_DEBUGS() << "LLXMLNode::getBoolValue() failed for node named '"
+ << mName->mString << "' -- expected " << expected_length << " but "
+ << "only found " << ret_length << LL_ENDL;
+ }
+#endif
+ return ret_length;
+}
+
+U32 LLXMLNode::getByteValue(U32 expected_length, U8 *array, Encoding encoding)
+{
+ llassert(array);
+
+ // Check type - accept bytes or integers (below 256 only)
+ if (mType != TYPE_INTEGER
+ && mType != TYPE_UNKNOWN)
+ {
+ return 0;
+ }
+
+ if (mLength > 0 && mLength != expected_length)
+ {
+ LL_WARNS() << "XMLNode::getByteValue asked for " << expected_length
+ << " elements, while node has " << mLength << LL_ENDL;
+ return 0;
+ }
+
+ if (encoding == ENCODING_DEFAULT)
+ {
+ encoding = mEncoding;
+ }
+
+ const char *value_string = mValue.c_str();
+
+ U32 i;
+ for (i=0; i<expected_length; ++i)
+ {
+ U64 value;
+ bool is_negative;
+ value_string = parseInteger(value_string, &value, &is_negative, 8, encoding);
+ if (value_string == NULL)
+ {
+ break;
+ }
+ if (value > 255 || is_negative)
+ {
+ LL_WARNS() << "getByteValue: Value outside of valid range." << LL_ENDL;
+ break;
+ }
+ array[i] = U8(value);
+ }
+#if LL_DEBUG
+ if (i != expected_length)
+ {
+ LL_DEBUGS() << "LLXMLNode::getByteValue() failed for node named '"
+ << mName->mString << "' -- expected " << expected_length << " but "
+ << "only found " << i << LL_ENDL;
+ }
+#endif
+ return i;
+}
+
+U32 LLXMLNode::getIntValue(U32 expected_length, S32 *array, Encoding encoding)
+{
+ llassert(array);
+
+ // Check type - accept bytes or integers
+ if (mType != TYPE_INTEGER && mType != TYPE_UNKNOWN)
+ {
+ return 0;
+ }
+
+ if (mLength > 0 && mLength != expected_length)
+ {
+ LL_WARNS() << "XMLNode::getIntValue asked for " << expected_length
+ << " elements, while node has " << mLength << LL_ENDL;
+ return 0;
+ }
+
+ if (encoding == ENCODING_DEFAULT)
+ {
+ encoding = mEncoding;
+ }
+
+ const char *value_string = mValue.c_str();
+
+ U32 i = 0;
+ for (i=0; i<expected_length; ++i)
+ {
+ U64 value;
+ bool is_negative;
+ value_string = parseInteger(value_string, &value, &is_negative, 32, encoding);
+ if (value_string == NULL)
+ {
+ break;
+ }
+ if (value > 0x7fffffff)
+ {
+ LL_WARNS() << "getIntValue: Value outside of valid range." << LL_ENDL;
+ break;
+ }
+ array[i] = S32(value) * (is_negative?-1:1);
+ }
+
+#if LL_DEBUG
+ if (i != expected_length)
+ {
+ LL_DEBUGS() << "LLXMLNode::getIntValue() failed for node named '"
+ << mName->mString << "' -- expected " << expected_length << " but "
+ << "only found " << i << LL_ENDL;
+ }
+#endif
+ return i;
+}
+
+U32 LLXMLNode::getUnsignedValue(U32 expected_length, U32 *array, Encoding encoding)
+{
+ llassert(array);
+
+ // Check type - accept bytes or integers
+ if (mType != TYPE_INTEGER && mType != TYPE_UNKNOWN)
+ {
+ return 0;
+ }
+
+ if (mLength > 0 && mLength != expected_length)
+ {
+ LL_WARNS() << "XMLNode::getUnsignedValue asked for " << expected_length
+ << " elements, while node has " << mLength << LL_ENDL;
+ return 0;
+ }
+
+ if (encoding == ENCODING_DEFAULT)
+ {
+ encoding = mEncoding;
+ }
+
+ const char *value_string = mValue.c_str();
+
+ U32 i = 0;
+ // Int type
+ for (i=0; i<expected_length; ++i)
+ {
+ U64 value;
+ bool is_negative;
+ value_string = parseInteger(value_string, &value, &is_negative, 32, encoding);
+ if (value_string == NULL)
+ {
+ break;
+ }
+ if (is_negative || value > 0xffffffff)
+ {
+ LL_WARNS() << "getUnsignedValue: Value outside of valid range." << LL_ENDL;
+ break;
+ }
+ array[i] = U32(value);
+ }
+
+#if LL_DEBUG
+ if (i != expected_length)
+ {
+ LL_DEBUGS() << "LLXMLNode::getUnsignedValue() failed for node named '"
+ << mName->mString << "' -- expected " << expected_length << " but "
+ << "only found " << i << LL_ENDL;
+ }
+#endif
+
+ return i;
+}
+
+U32 LLXMLNode::getLongValue(U32 expected_length, U64 *array, Encoding encoding)
+{
+ llassert(array);
+
+ // Check type - accept bytes or integers
+ if (mType != TYPE_INTEGER && mType != TYPE_UNKNOWN)
+ {
+ return 0;
+ }
+
+ if (mLength > 0 && mLength != expected_length)
+ {
+ LL_WARNS() << "XMLNode::getLongValue asked for " << expected_length << " elements, while node has " << mLength << LL_ENDL;
+ return 0;
+ }
+
+ if (encoding == ENCODING_DEFAULT)
+ {
+ encoding = mEncoding;
+ }
+
+ const char *value_string = mValue.c_str();
+
+ U32 i = 0;
+ // Int type
+ for (i=0; i<expected_length; ++i)
+ {
+ U64 value;
+ bool is_negative;
+ value_string = parseInteger(value_string, &value, &is_negative, 64, encoding);
+ if (value_string == NULL)
+ {
+ break;
+ }
+ if (is_negative)
+ {
+ LL_WARNS() << "getLongValue: Value outside of valid range." << LL_ENDL;
+ break;
+ }
+ array[i] = value;
+ }
+
+#if LL_DEBUG
+ if (i != expected_length)
+ {
+ LL_DEBUGS() << "LLXMLNode::getLongValue() failed for node named '"
+ << mName->mString << "' -- expected " << expected_length << " but "
+ << "only found " << i << LL_ENDL;
+ }
+#endif
+
+ return i;
+}
+
+U32 LLXMLNode::getFloatValue(U32 expected_length, F32 *array, Encoding encoding)
+{
+ llassert(array);
+
+ // Check type - accept only floats or doubles
+ if (mType != TYPE_FLOAT && mType != TYPE_UNKNOWN)
+ {
+ return 0;
+ }
+
+ if (mLength > 0 && mLength != expected_length)
+ {
+ LL_WARNS() << "XMLNode::getFloatValue asked for " << expected_length << " elements, while node has " << mLength << LL_ENDL;
+ return 0;
+ }
+
+ if (encoding == ENCODING_DEFAULT)
+ {
+ encoding = mEncoding;
+ }
+
+ const char *value_string = mValue.c_str();
+
+ U32 i;
+ for (i=0; i<expected_length; ++i)
+ {
+ F64 value;
+ value_string = parseFloat(value_string, &value, 32, encoding);
+ if (value_string == NULL)
+ {
+ break;
+ }
+ array[i] = F32(value);
+ }
+#if LL_DEBUG
+ if (i != expected_length)
+ {
+ LL_DEBUGS() << "LLXMLNode::getFloatValue() failed for node named '"
+ << mName->mString << "' -- expected " << expected_length << " but "
+ << "only found " << i << LL_ENDL;
+ }
+#endif
+ return i;
+}
+
+U32 LLXMLNode::getDoubleValue(U32 expected_length, F64 *array, Encoding encoding)
+{
+ llassert(array);
+
+ // Check type - accept only floats or doubles
+ if (mType != TYPE_FLOAT && mType != TYPE_UNKNOWN)
+ {
+ return 0;
+ }
+
+ if (mLength > 0 && mLength != expected_length)
+ {
+ LL_WARNS() << "XMLNode::getDoubleValue asked for " << expected_length << " elements, while node has " << mLength << LL_ENDL;
+ return 0;
+ }
+
+ if (encoding == ENCODING_DEFAULT)
+ {
+ encoding = mEncoding;
+ }
+
+ const char *value_string = mValue.c_str();
+
+ U32 i;
+ for (i=0; i<expected_length; ++i)
+ {
+ F64 value;
+ value_string = parseFloat(value_string, &value, 64, encoding);
+ if (value_string == NULL)
+ {
+ break;
+ }
+ array[i] = value;
+ }
+#if LL_DEBUG
+ if (i != expected_length)
+ {
+ LL_DEBUGS() << "LLXMLNode::getDoubleValue() failed for node named '"
+ << mName->mString << "' -- expected " << expected_length << " but "
+ << "only found " << i << LL_ENDL;
+ }
+#endif
+ return i;
+}
+
+U32 LLXMLNode::getStringValue(U32 expected_length, std::string *array)
+{
+ llassert(array);
+
+ // Can always return any value as a string
+
+ if (mLength > 0 && mLength != expected_length)
+ {
+ LL_WARNS() << "XMLNode::getStringValue asked for " << expected_length << " elements, while node has " << mLength << LL_ENDL;
+ return 0;
+ }
+
+ U32 num_returned_strings = 0;
+
+ // Array of strings is whitespace-separated
+ const std::string sep(" \n\t");
+
+ std::string::size_type n = 0;
+ std::string::size_type m = 0;
+ while(1)
+ {
+ if (num_returned_strings >= expected_length)
+ {
+ break;
+ }
+ n = mValue.find_first_not_of(sep, m);
+ m = mValue.find_first_of(sep, n);
+ if (m == std::string::npos)
+ {
+ break;
+ }
+ array[num_returned_strings++] = mValue.substr(n,m-n);
+ }
+ if (n != std::string::npos && num_returned_strings < expected_length)
+ {
+ array[num_returned_strings++] = mValue.substr(n);
+ }
+#if LL_DEBUG
+ if (num_returned_strings != expected_length)
+ {
+ LL_DEBUGS() << "LLXMLNode::getStringValue() failed for node named '"
+ << mName->mString << "' -- expected " << expected_length << " but "
+ << "only found " << num_returned_strings << LL_ENDL;
+ }
+#endif
+
+ return num_returned_strings;
+}
+
+U32 LLXMLNode::getUUIDValue(U32 expected_length, LLUUID *array)
+{
+ llassert(array);
+
+ // Check type
+ if (mType != TYPE_UUID && mType != TYPE_UNKNOWN)
+ {
+ return 0;
+ }
+
+ const char *value_string = mValue.c_str();
+
+ U32 i;
+ for (i=0; i<expected_length; ++i)
+ {
+ LLUUID uuid_value;
+ value_string = skipWhitespace(value_string);
+
+ if (strlen(value_string) < (UUID_STR_LENGTH-1)) /* Flawfinder: ignore */
+ {
+ break;
+ }
+ char uuid_string[UUID_STR_LENGTH]; /* Flawfinder: ignore */
+ memcpy(uuid_string, value_string, (UUID_STR_LENGTH-1)); /* Flawfinder: ignore */
+ uuid_string[(UUID_STR_LENGTH-1)] = 0;
+
+ if (!LLUUID::parseUUID(std::string(uuid_string), &uuid_value))
+ {
+ break;
+ }
+ value_string = &value_string[(UUID_STR_LENGTH-1)];
+ array[i] = uuid_value;
+ }
+#if LL_DEBUG
+ if (i != expected_length)
+ {
+ LL_DEBUGS() << "LLXMLNode::getUUIDValue() failed for node named '"
+ << mName->mString << "' -- expected " << expected_length << " but "
+ << "only found " << i << LL_ENDL;
+ }
+#endif
+ return i;
+}
+
+U32 LLXMLNode::getNodeRefValue(U32 expected_length, LLXMLNode **array)
+{
+ llassert(array);
+
+ // Check type
+ if (mType != TYPE_NODEREF && mType != TYPE_UNKNOWN)
+ {
+ return 0;
+ }
+
+ std::string *string_array = new std::string[expected_length];
+
+ U32 num_strings = getStringValue(expected_length, string_array);
+
+ U32 num_returned_refs = 0;
+
+ LLXMLNodePtr root = getRoot();
+ for (U32 strnum=0; strnum<num_strings; ++strnum)
+ {
+ LLXMLNodeList node_list;
+ root->findID(string_array[strnum], node_list);
+ if (node_list.empty())
+ {
+ LL_WARNS() << "XML: Could not find node ID: " << string_array[strnum] << LL_ENDL;
+ }
+ else if (node_list.size() > 1)
+ {
+ LL_WARNS() << "XML: Node ID not unique: " << string_array[strnum] << LL_ENDL;
+ }
+ else
+ {
+ LLXMLNodeList::const_iterator list_itr = node_list.begin();
+ if (list_itr != node_list.end())
+ {
+ LLXMLNode* child = (*list_itr).second;
+
+ array[num_returned_refs++] = child;
+ }
+ }
+ }
+
+ delete[] string_array;
+
+ return num_returned_refs;
+}
+
+void LLXMLNode::setBoolValue(U32 length, const bool *array)
+{
+ if (length == 0) return;
+
+ std::string new_value;
+ for (U32 pos=0; pos<length; ++pos)
+ {
+ if (pos > 0)
+ {
+ new_value = llformat("%s %s", new_value.c_str(), array[pos]?"true":"false");
+ }
+ else
+ {
+ new_value = array[pos]?"true":"false";
+ }
+ }
+
+ mValue = new_value;
+ mEncoding = ENCODING_DEFAULT;
+ mLength = length;
+ mType = TYPE_BOOLEAN;
+}
+
+void LLXMLNode::setByteValue(U32 length, const U8* const array, Encoding encoding)
+{
+ if (length == 0) return;
+
+ std::string new_value;
+ if (encoding == ENCODING_DEFAULT || encoding == ENCODING_DECIMAL)
+ {
+ for (U32 pos=0; pos<length; ++pos)
+ {
+ if (pos > 0)
+ {
+ new_value.append(llformat(" %u", array[pos]));
+ }
+ else
+ {
+ new_value = llformat("%u", array[pos]);
+ }
+ }
+ }
+ if (encoding == ENCODING_HEX)
+ {
+ for (U32 pos=0; pos<length; ++pos)
+ {
+ if (pos > 0 && pos % 16 == 0)
+ {
+ new_value.append(llformat(" %02X", array[pos]));
+ }
+ else
+ {
+ new_value.append(llformat("%02X", array[pos]));
+ }
+ }
+ }
+ // TODO -- Handle Base32
+
+ mValue = new_value;
+ mEncoding = encoding;
+ mLength = length;
+ mType = TYPE_INTEGER;
+ mPrecision = 8;
+}
+
+
+void LLXMLNode::setIntValue(U32 length, const S32 *array, Encoding encoding)
+{
+ if (length == 0) return;
+
+ std::string new_value;
+ if (encoding == ENCODING_DEFAULT || encoding == ENCODING_DECIMAL)
+ {
+ for (U32 pos=0; pos<length; ++pos)
+ {
+ if (pos > 0)
+ {
+ new_value.append(llformat(" %d", array[pos]));
+ }
+ else
+ {
+ new_value = llformat("%d", array[pos]);
+ }
+ }
+ mValue = new_value;
+ }
+ else if (encoding == ENCODING_HEX)
+ {
+ for (U32 pos=0; pos<length; ++pos)
+ {
+ if (pos > 0 && pos % 16 == 0)
+ {
+ new_value.append(llformat(" %08X", ((U32 *)array)[pos]));
+ }
+ else
+ {
+ new_value.append(llformat("%08X", ((U32 *)array)[pos]));
+ }
+ }
+ mValue = new_value;
+ }
+ else
+ {
+ mValue = new_value;
+ }
+ // TODO -- Handle Base32
+
+ mEncoding = encoding;
+ mLength = length;
+ mType = TYPE_INTEGER;
+ mPrecision = 32;
+}
+
+void LLXMLNode::setUnsignedValue(U32 length, const U32* array, Encoding encoding)
+{
+ if (length == 0) return;
+
+ std::string new_value;
+ if (encoding == ENCODING_DEFAULT || encoding == ENCODING_DECIMAL)
+ {
+ for (U32 pos=0; pos<length; ++pos)
+ {
+ if (pos > 0)
+ {
+ new_value.append(llformat(" %u", array[pos]));
+ }
+ else
+ {
+ new_value = llformat("%u", array[pos]);
+ }
+ }
+ }
+ if (encoding == ENCODING_HEX)
+ {
+ for (U32 pos=0; pos<length; ++pos)
+ {
+ if (pos > 0 && pos % 16 == 0)
+ {
+ new_value.append(llformat(" %08X", array[pos]));
+ }
+ else
+ {
+ new_value.append(llformat("%08X", array[pos]));
+ }
+ }
+ mValue = new_value;
+ }
+ // TODO -- Handle Base32
+
+ mValue = new_value;
+ mEncoding = encoding;
+ mLength = length;
+ mType = TYPE_INTEGER;
+ mPrecision = 32;
+}
+
+#if LL_WINDOWS
+#define PU64 "I64u"
+#else
+#define PU64 "llu"
+#endif
+
+void LLXMLNode::setLongValue(U32 length, const U64* array, Encoding encoding)
+{
+ if (length == 0) return;
+
+ std::string new_value;
+ if (encoding == ENCODING_DEFAULT || encoding == ENCODING_DECIMAL)
+ {
+ for (U32 pos=0; pos<length; ++pos)
+ {
+ if (pos > 0)
+ {
+ new_value.append(llformat(" %" PU64, array[pos]));
+ }
+ else
+ {
+ new_value = llformat("%" PU64, array[pos]);
+ }
+ }
+ mValue = new_value;
+ }
+ if (encoding == ENCODING_HEX)
+ {
+ for (U32 pos=0; pos<length; ++pos)
+ {
+ U32 upper_32 = U32(array[pos]>>32);
+ U32 lower_32 = U32(array[pos]&0xffffffff);
+ if (pos > 0 && pos % 8 == 0)
+ {
+ new_value.append(llformat(" %08X%08X", upper_32, lower_32));
+ }
+ else
+ {
+ new_value.append(llformat("%08X%08X", upper_32, lower_32));
+ }
+ }
+ mValue = new_value;
+ }
+ else
+ {
+ mValue = new_value;
+ }
+ // TODO -- Handle Base32
+
+ mEncoding = encoding;
+ mLength = length;
+ mType = TYPE_INTEGER;
+ mPrecision = 64;
+}
+
+void LLXMLNode::setFloatValue(U32 length, const F32 *array, Encoding encoding, U32 precision)
+{
+ if (length == 0) return;
+
+ std::string new_value;
+ if (encoding == ENCODING_DEFAULT || encoding == ENCODING_DECIMAL)
+ {
+ std::string format_string;
+ if (precision > 0)
+ {
+ if (precision > 25)
+ {
+ precision = 25;
+ }
+ format_string = llformat( "%%.%dg", precision);
+ }
+ else
+ {
+ format_string = llformat( "%%g");
+ }
+
+ for (U32 pos=0; pos<length; ++pos)
+ {
+ if (pos > 0)
+ {
+ new_value.append(" ");
+ new_value.append(llformat(format_string.c_str(), array[pos]));
+ }
+ else
+ {
+ new_value.assign(llformat(format_string.c_str(), array[pos]));
+ }
+ }
+ mValue = new_value;
+ }
+ else if (encoding == ENCODING_HEX)
+ {
+ U32 *byte_array = (U32 *)array;
+ setUnsignedValue(length, byte_array, ENCODING_HEX);
+ }
+ else
+ {
+ mValue = new_value;
+ }
+
+ mEncoding = encoding;
+ mLength = length;
+ mType = TYPE_FLOAT;
+ mPrecision = 32;
+}
+
+void LLXMLNode::setDoubleValue(U32 length, const F64 *array, Encoding encoding, U32 precision)
+{
+ if (length == 0) return;
+
+ std::string new_value;
+ if (encoding == ENCODING_DEFAULT || encoding == ENCODING_DECIMAL)
+ {
+ std::string format_string;
+ if (precision > 0)
+ {
+ if (precision > 25)
+ {
+ precision = 25;
+ }
+ format_string = llformat( "%%.%dg", precision);
+ }
+ else
+ {
+ format_string = llformat( "%%g");
+ }
+ for (U32 pos=0; pos<length; ++pos)
+ {
+ if (pos > 0)
+ {
+ new_value.append(" ");
+ new_value.append(llformat(format_string.c_str(), array[pos]));
+ }
+ else
+ {
+ new_value.assign(llformat(format_string.c_str(), array[pos]));
+ }
+ }
+ mValue = new_value;
+ }
+ if (encoding == ENCODING_HEX)
+ {
+ U64 *byte_array = (U64 *)array;
+ setLongValue(length, byte_array, ENCODING_HEX);
+ }
+ else
+ {
+ mValue = new_value;
+ }
+ // TODO -- Handle Base32
+
+ mEncoding = encoding;
+ mLength = length;
+ mType = TYPE_FLOAT;
+ mPrecision = 64;
+}
+
+// static
+std::string LLXMLNode::escapeXML(const std::string& xml)
+{
+ std::string out;
+ for (std::string::size_type i = 0; i < xml.size(); ++i)
+ {
+ char c = xml[i];
+ switch(c)
+ {
+ case '"': out.append("&quot;"); break;
+ case '\'': out.append("&apos;"); break;
+ case '&': out.append("&amp;"); break;
+ case '<': out.append("&lt;"); break;
+ case '>': out.append("&gt;"); break;
+ default: out.push_back(c); break;
+ }
+ }
+ return out;
+}
+
+void LLXMLNode::setStringValue(U32 length, const std::string *strings)
+{
+ if (length == 0) return;
+
+ std::string new_value;
+ for (U32 pos=0; pos<length; ++pos)
+ {
+ // *NOTE: Do not escape strings here - do it on output
+ new_value.append( strings[pos] );
+ if (pos < length-1) new_value.append(" ");
+ }
+
+ mValue = new_value;
+ mEncoding = ENCODING_DEFAULT;
+ mLength = length;
+ mType = TYPE_STRING;
+}
+
+void LLXMLNode::setUUIDValue(U32 length, const LLUUID *array)
+{
+ if (length == 0) return;
+
+ std::string new_value;
+ for (U32 pos=0; pos<length; ++pos)
+ {
+ new_value.append(array[pos].asString());
+ if (pos < length-1) new_value.append(" ");
+ }
+
+ mValue = new_value;
+ mEncoding = ENCODING_DEFAULT;
+ mLength = length;
+ mType = TYPE_UUID;
+}
+
+void LLXMLNode::setNodeRefValue(U32 length, const LLXMLNode **array)
+{
+ if (length == 0) return;
+
+ std::string new_value;
+ for (U32 pos=0; pos<length; ++pos)
+ {
+ if (array[pos]->mID != "")
+ {
+ new_value.append(array[pos]->mID);
+ }
+ else
+ {
+ new_value.append("(null)");
+ }
+ if (pos < length-1) new_value.append(" ");
+ }
+
+ mValue = new_value;
+ mEncoding = ENCODING_DEFAULT;
+ mLength = length;
+ mType = TYPE_NODEREF;
+}
+
+void LLXMLNode::setValue(const std::string& value)
+{
+ if (TYPE_CONTAINER == mType)
+ {
+ mType = TYPE_UNKNOWN;
+ }
+ mValue = value;
+}
+
+void LLXMLNode::setDefault(LLXMLNode *default_node)
+{
+ mDefault = default_node;
+}
+
+void LLXMLNode::findDefault(LLXMLNode *defaults_list)
+{
+ if (defaults_list)
+ {
+ LLXMLNodeList children;
+ defaults_list->getChildren(mName->mString, children);
+
+ LLXMLNodeList::const_iterator children_itr;
+ LLXMLNodeList::const_iterator children_end = children.end();
+ for (children_itr = children.begin(); children_itr != children_end; ++children_itr)
+ {
+ LLXMLNode* child = (*children_itr).second;
+ if (child->mVersionMajor == mVersionMajor &&
+ child->mVersionMinor == mVersionMinor)
+ {
+ mDefault = child;
+ return;
+ }
+ }
+ }
+ mDefault = NULL;
+}
+
+bool LLXMLNode::deleteChildren(const std::string& name)
+{
+ U32 removed_count = 0;
+ LLXMLNodeList node_list;
+ findName(name, node_list);
+ if (!node_list.empty())
+ {
+ // TODO -- use multimap::find()
+ // TODO -- need to watch out for invalid iterators
+ LLXMLNodeList::iterator children_itr;
+ for (children_itr = node_list.begin(); children_itr != node_list.end(); ++children_itr)
+ {
+ LLXMLNode* child = (*children_itr).second;
+ if (deleteChild(child))
+ {
+ removed_count++;
+ }
+ }
+ }
+ return removed_count > 0;
+}
+
+bool LLXMLNode::deleteChildren(LLStringTableEntry* name)
+{
+ U32 removed_count = 0;
+ LLXMLNodeList node_list;
+ findName(name, node_list);
+ if (!node_list.empty())
+ {
+ // TODO -- use multimap::find()
+ // TODO -- need to watch out for invalid iterators
+ LLXMLNodeList::iterator children_itr;
+ for (children_itr = node_list.begin(); children_itr != node_list.end(); ++children_itr)
+ {
+ LLXMLNode* child = (*children_itr).second;
+ if (deleteChild(child))
+ {
+ removed_count++;
+ }
+ }
+ }
+ return removed_count > 0;
+}
+
+void LLXMLNode::setAttributes(LLXMLNode::ValueType type, U32 precision, LLXMLNode::Encoding encoding, U32 length)
+{
+ mType = type;
+ mEncoding = encoding;
+ mPrecision = precision;
+ mLength = length;
+}
+
+void LLXMLNode::setName(const std::string& name)
+{
+ setName(gStringTable.addStringEntry(name));
+}
+
+void LLXMLNode::setName(LLStringTableEntry* name)
+{
+ LLXMLNode* old_parent = mParent;
+ if (mParent)
+ {
+ // we need to remove and re-add to the parent so that
+ // the multimap key agrees with this node's name
+ mParent->removeChild(this);
+ }
+ mName = name;
+ if (old_parent)
+ {
+ LLXMLNodePtr this_ptr(this);
+ old_parent->addChild(this_ptr);
+ }
+}
+
+// Unused
+// void LLXMLNode::appendValue(const std::string& value)
+// {
+// mValue.append(value);
+// }
+
+U32 LLXMLNode::getChildCount() const
+{
+ if (mChildren.notNull())
+ {
+ return mChildren->map.size();
+ }
+ return 0;
+}
+
+//***************************************************
+// UNIT TESTING
+//***************************************************
+
+U32 get_rand(U32 max_value)
+{
+ U32 random_num = rand() + ((U32)rand() << 16);
+ return (random_num % max_value);
+}
+
+LLXMLNode *get_rand_node(LLXMLNode *node)
+{
+ if (node->mChildren.notNull())
+ {
+ U32 num_children = node->mChildren->map.size();
+ if (get_rand(2) == 0)
+ {
+ while (true)
+ {
+ S32 child_num = S32(get_rand(num_children*2)) - num_children;
+ LLXMLChildList::iterator itor = node->mChildren->map.begin();
+ while (child_num > 0)
+ {
+ --child_num;
+ ++itor;
+ }
+ if (!itor->second->mIsAttribute)
+ {
+ return get_rand_node(itor->second);
+ }
+ }
+ }
+ }
+ return node;
+}
+
+void LLXMLNode::createUnitTest(S32 max_num_children)
+{
+ // Random ID
+ std::string rand_id;
+ U32 rand_id_len = get_rand(10)+5;
+ for (U32 pos = 0; pos<rand_id_len; ++pos)
+ {
+ char c = 'a' + get_rand(26);
+ rand_id.append(1, c);
+ }
+ mID = rand_id;
+
+ if (max_num_children < 2)
+ {
+ setStringValue(1, &mID);
+ return;
+ }
+
+ // Checksums
+ U32 integer_checksum = 0;
+ U64 long_checksum = 0;
+ U32 bool_true_count = 0;
+ LLUUID uuid_checksum;
+ U32 noderef_checksum = 0;
+ U32 float_checksum = 0;
+
+ // Create a random number of children
+ U32 num_children = get_rand(max_num_children)+1;
+ for (U32 child_num=0; child_num<num_children; ++child_num)
+ {
+ // Random Name
+ std::string child_name;
+ U32 child_name_len = get_rand(10)+5;
+ for (U32 pos = 0; pos<child_name_len; ++pos)
+ {
+ char c = 'a' + get_rand(26);
+ child_name.append(1, c);
+ }
+
+ LLXMLNode *new_child = createChild(child_name.c_str(), false);
+
+ // Random ID
+ std::string child_id;
+ U32 child_id_len = get_rand(10)+5;
+ for (U32 pos=0; pos<child_id_len; ++pos)
+ {
+ char c = 'a' + get_rand(26);
+ child_id.append(1, c);
+ }
+ new_child->mID = child_id;
+
+ // Random Length
+ U32 array_size = get_rand(28)+1;
+
+ // Random Encoding
+ Encoding new_encoding = get_rand(2)?ENCODING_DECIMAL:ENCODING_HEX;
+
+ // Random Type
+ int type = get_rand(8);
+ switch (type)
+ {
+ case 0: // TYPE_CONTAINER
+ new_child->createUnitTest(max_num_children/2);
+ break;
+ case 1: // TYPE_BOOLEAN
+ {
+ bool random_bool_values[30];
+ for (U32 value=0; value<array_size; ++value)
+ {
+ random_bool_values[value] = get_rand(2);
+ if (random_bool_values[value])
+ {
+ ++bool_true_count;
+ }
+ }
+ new_child->setBoolValue(array_size, random_bool_values);
+ }
+ break;
+ case 2: // TYPE_INTEGER (32-bit)
+ {
+ U32 random_int_values[30];
+ for (U32 value=0; value<array_size; ++value)
+ {
+ random_int_values[value] = get_rand(0xffffffff);
+ integer_checksum ^= random_int_values[value];
+ }
+ new_child->setUnsignedValue(array_size, random_int_values, new_encoding);
+ }
+ break;
+ case 3: // TYPE_INTEGER (64-bit)
+ {
+ U64 random_int_values[30];
+ for (U64 value=0; value<array_size; ++value)
+ {
+ random_int_values[value] = (U64(get_rand(0xffffffff)) << 32) + get_rand(0xffffffff);
+ long_checksum ^= random_int_values[value];
+ }
+ new_child->setLongValue(array_size, random_int_values, new_encoding);
+ }
+ break;
+ case 4: // TYPE_FLOAT (32-bit)
+ {
+ F32 random_float_values[30];
+ for (U32 value=0; value<array_size; ++value)
+ {
+ S32 exponent = get_rand(256) - 128;
+ S32 fractional_part = get_rand(0xffffffff);
+ S32 sign = get_rand(2) * 2 - 1;
+ random_float_values[value] = F32(fractional_part) / F32(0xffffffff) * exp(F32(exponent)) * F32(sign);
+
+ U32 *float_bits = &((U32 *)random_float_values)[value];
+ if (*float_bits == 0x80000000)
+ {
+ *float_bits = 0x00000000;
+ }
+ float_checksum ^= (*float_bits & 0xfffff000);
+ }
+ new_child->setFloatValue(array_size, random_float_values, new_encoding, 12);
+ }
+ break;
+ case 5: // TYPE_FLOAT (64-bit)
+ {
+ F64 random_float_values[30];
+ for (U32 value=0; value<array_size; ++value)
+ {
+ S32 exponent = get_rand(2048) - 1024;
+ S32 fractional_part = get_rand(0xffffffff);
+ S32 sign = get_rand(2) * 2 - 1;
+ random_float_values[value] = F64(fractional_part) / F64(0xffffffff) * exp(F64(exponent)) * F64(sign);
+
+ U64 *float_bits = &((U64 *)random_float_values)[value];
+ if (*float_bits == 0x8000000000000000ll)
+ {
+ *float_bits = 0x0000000000000000ll;
+ }
+ float_checksum ^= ((*float_bits & 0xfffffff000000000ll) >> 32);
+ }
+ new_child->setDoubleValue(array_size, random_float_values, new_encoding, 12);
+ }
+ break;
+ case 6: // TYPE_UUID
+ {
+ LLUUID random_uuid_values[30];
+ for (U32 value=0; value<array_size; ++value)
+ {
+ random_uuid_values[value].generate();
+ for (S32 byte=0; byte<UUID_BYTES; ++byte)
+ {
+ uuid_checksum.mData[byte] ^= random_uuid_values[value].mData[byte];
+ }
+ }
+ new_child->setUUIDValue(array_size, random_uuid_values);
+ }
+ break;
+ case 7: // TYPE_NODEREF
+ {
+ LLXMLNode *random_node_array[30];
+ LLXMLNode *root = getRoot();
+ for (U32 value=0; value<array_size; ++value)
+ {
+ random_node_array[value] = get_rand_node(root);
+ const char *node_name = random_node_array[value]->mName->mString;
+ for (U32 pos=0; pos<strlen(node_name); ++pos) /* Flawfinder: ignore */
+ {
+ U32 hash_contrib = U32(node_name[pos]) << ((pos % 4) * 8);
+ noderef_checksum ^= hash_contrib;
+ }
+ }
+ new_child->setNodeRefValue(array_size, (const LLXMLNode **)random_node_array);
+ }
+ break;
+ }
+ }
+
+ createChild("integer_checksum", true)->setUnsignedValue(1, &integer_checksum, LLXMLNode::ENCODING_HEX);
+ createChild("long_checksum", true)->setLongValue(1, &long_checksum, LLXMLNode::ENCODING_HEX);
+ createChild("bool_true_count", true)->setUnsignedValue(1, &bool_true_count, LLXMLNode::ENCODING_HEX);
+ createChild("uuid_checksum", true)->setUUIDValue(1, &uuid_checksum);
+ createChild("noderef_checksum", true)->setUnsignedValue(1, &noderef_checksum, LLXMLNode::ENCODING_HEX);
+ createChild("float_checksum", true)->setUnsignedValue(1, &float_checksum, LLXMLNode::ENCODING_HEX);
+}
+
+bool LLXMLNode::performUnitTest(std::string &error_buffer)
+{
+ if (mChildren.isNull())
+ {
+ error_buffer.append(llformat("ERROR Node %s: No children found.\n", mName->mString));
+ return false;
+ }
+
+ // Checksums
+ U32 integer_checksum = 0;
+ U32 bool_true_count = 0;
+ LLUUID uuid_checksum;
+ U32 noderef_checksum = 0;
+ U32 float_checksum = 0;
+ U64 long_checksum = 0;
+
+ LLXMLChildList::iterator itor;
+ for (itor=mChildren->map.begin(); itor!=mChildren->map.end(); ++itor)
+ {
+ LLXMLNode *node = itor->second;
+ if (node->mIsAttribute)
+ {
+ continue;
+ }
+ if (node->mType == TYPE_CONTAINER)
+ {
+ if (!node->performUnitTest(error_buffer))
+ {
+ error_buffer.append(llformat("Child test failed for %s.\n", mName->mString));
+ //return false;
+ }
+ continue;
+ }
+ if (node->mLength < 1 || node->mLength > 30)
+ {
+ error_buffer.append(llformat("ERROR Node %s: Invalid array length %d, child %s.\n", mName->mString, node->mLength, node->mName->mString));
+ return false;
+ }
+ switch (node->mType)
+ {
+ case TYPE_CONTAINER:
+ case TYPE_UNKNOWN:
+ break;
+ case TYPE_BOOLEAN:
+ {
+ bool bool_array[30];
+ if (node->getBoolValue(node->mLength, bool_array) < node->mLength)
+ {
+ error_buffer.append(llformat("ERROR Node %s: Could not read boolean array, child %s.\n", mName->mString, node->mName->mString));
+ return false;
+ }
+ for (U32 pos=0; pos<(U32)node->mLength; ++pos)
+ {
+ if (bool_array[pos])
+ {
+ ++bool_true_count;
+ }
+ }
+ }
+ break;
+ case TYPE_INTEGER:
+ {
+ if (node->mPrecision == 32)
+ {
+ U32 integer_array[30];
+ if (node->getUnsignedValue(node->mLength, integer_array, node->mEncoding) < node->mLength)
+ {
+ error_buffer.append(llformat("ERROR Node %s: Could not read integer array, child %s.\n", mName->mString, node->mName->mString));
+ return false;
+ }
+ for (U32 pos=0; pos<(U32)node->mLength; ++pos)
+ {
+ integer_checksum ^= integer_array[pos];
+ }
+ }
+ else
+ {
+ U64 integer_array[30];
+ if (node->getLongValue(node->mLength, integer_array, node->mEncoding) < node->mLength)
+ {
+ error_buffer.append(llformat("ERROR Node %s: Could not read long integer array, child %s.\n", mName->mString, node->mName->mString));
+ return false;
+ }
+ for (U32 pos=0; pos<(U32)node->mLength; ++pos)
+ {
+ long_checksum ^= integer_array[pos];
+ }
+ }
+ }
+ break;
+ case TYPE_FLOAT:
+ {
+ if (node->mPrecision == 32)
+ {
+ F32 float_array[30];
+ if (node->getFloatValue(node->mLength, float_array, node->mEncoding) < node->mLength)
+ {
+ error_buffer.append(llformat("ERROR Node %s: Could not read float array, child %s.\n", mName->mString, node->mName->mString));
+ return false;
+ }
+ for (U32 pos=0; pos<(U32)node->mLength; ++pos)
+ {
+ U32 float_bits = ((U32 *)float_array)[pos];
+ float_checksum ^= (float_bits & 0xfffff000);
+ }
+ }
+ else
+ {
+ F64 float_array[30];
+ if (node->getDoubleValue(node->mLength, float_array, node->mEncoding) < node->mLength)
+ {
+ error_buffer.append(llformat("ERROR Node %s: Could not read float array, child %s.\n", mName->mString, node->mName->mString));
+ return false;
+ }
+ for (U32 pos=0; pos<(U32)node->mLength; ++pos)
+ {
+ U64 float_bits = ((U64 *)float_array)[pos];
+ float_checksum ^= ((float_bits & 0xfffffff000000000ll) >> 32);
+ }
+ }
+ }
+ break;
+ case TYPE_STRING:
+ break;
+ case TYPE_UUID:
+ {
+ LLUUID uuid_array[30];
+ if (node->getUUIDValue(node->mLength, uuid_array) < node->mLength)
+ {
+ error_buffer.append(llformat("ERROR Node %s: Could not read uuid array, child %s.\n", mName->mString, node->mName->mString));
+ return false;
+ }
+ for (U32 pos=0; pos<(U32)node->mLength; ++pos)
+ {
+ for (S32 byte=0; byte<UUID_BYTES; ++byte)
+ {
+ uuid_checksum.mData[byte] ^= uuid_array[pos].mData[byte];
+ }
+ }
+ }
+ break;
+ case TYPE_NODEREF:
+ {
+ LLXMLNode *node_array[30];
+ if (node->getNodeRefValue(node->mLength, node_array) < node->mLength)
+ {
+ error_buffer.append(llformat("ERROR Node %s: Could not read node ref array, child %s.\n", mName->mString, node->mName->mString));
+ return false;
+ }
+ for (U32 pos=0; pos<node->mLength; ++pos)
+ {
+ const char *node_name = node_array[pos]->mName->mString;
+ for (U32 pos2=0; pos2<strlen(node_name); ++pos2) /* Flawfinder: ignore */
+ {
+ U32 hash_contrib = U32(node_name[pos2]) << ((pos2 % 4) * 8);
+ noderef_checksum ^= hash_contrib;
+ }
+ }
+ }
+ break;
+ }
+ }
+
+ LLXMLNodePtr checksum_node;
+
+ // Compare checksums
+ {
+ U32 node_integer_checksum = 0;
+ if (!getAttribute("integer_checksum", checksum_node, false) ||
+ checksum_node->getUnsignedValue(1, &node_integer_checksum, ENCODING_HEX) != 1)
+ {
+ error_buffer.append(llformat("ERROR Node %s: Integer checksum missing.\n", mName->mString));
+ return false;
+ }
+ if (node_integer_checksum != integer_checksum)
+ {
+ error_buffer.append(llformat("ERROR Node %s: Integer checksum mismatch: read %X / calc %X.\n", mName->mString, node_integer_checksum, integer_checksum));
+ return false;
+ }
+ }
+
+ {
+ U64 node_long_checksum = 0;
+ if (!getAttribute("long_checksum", checksum_node, false) ||
+ checksum_node->getLongValue(1, &node_long_checksum, ENCODING_HEX) != 1)
+ {
+ error_buffer.append(llformat("ERROR Node %s: Long Integer checksum missing.\n", mName->mString));
+ return false;
+ }
+ if (node_long_checksum != long_checksum)
+ {
+ U32 *pp1 = (U32 *)&node_long_checksum;
+ U32 *pp2 = (U32 *)&long_checksum;
+ error_buffer.append(llformat("ERROR Node %s: Long Integer checksum mismatch: read %08X%08X / calc %08X%08X.\n", mName->mString, pp1[1], pp1[0], pp2[1], pp2[0]));
+ return false;
+ }
+ }
+
+ {
+ U32 node_bool_true_count = 0;
+ if (!getAttribute("bool_true_count", checksum_node, false) ||
+ checksum_node->getUnsignedValue(1, &node_bool_true_count, ENCODING_HEX) != 1)
+ {
+ error_buffer.append(llformat("ERROR Node %s: Boolean checksum missing.\n", mName->mString));
+ return false;
+ }
+ if (node_bool_true_count != bool_true_count)
+ {
+ error_buffer.append(llformat("ERROR Node %s: Boolean checksum mismatch: read %X / calc %X.\n", mName->mString, node_bool_true_count, bool_true_count));
+ return false;
+ }
+ }
+
+ {
+ LLUUID node_uuid_checksum;
+ if (!getAttribute("uuid_checksum", checksum_node, false) ||
+ checksum_node->getUUIDValue(1, &node_uuid_checksum) != 1)
+ {
+ error_buffer.append(llformat("ERROR Node %s: UUID checksum missing.\n", mName->mString));
+ return false;
+ }
+ if (node_uuid_checksum != uuid_checksum)
+ {
+ error_buffer.append(llformat("ERROR Node %s: UUID checksum mismatch: read %s / calc %s.\n", mName->mString, node_uuid_checksum.asString().c_str(), uuid_checksum.asString().c_str()));
+ return false;
+ }
+ }
+
+ {
+ U32 node_noderef_checksum = 0;
+ if (!getAttribute("noderef_checksum", checksum_node, false) ||
+ checksum_node->getUnsignedValue(1, &node_noderef_checksum, ENCODING_HEX) != 1)
+ {
+ error_buffer.append(llformat("ERROR Node %s: Node Ref checksum missing.\n", mName->mString));
+ return false;
+ }
+ if (node_noderef_checksum != noderef_checksum)
+ {
+ error_buffer.append(llformat("ERROR Node %s: Node Ref checksum mismatch: read %X / calc %X.\n", mName->mString, node_noderef_checksum, noderef_checksum));
+ return false;
+ }
+ }
+
+ {
+ U32 node_float_checksum = 0;
+ if (!getAttribute("float_checksum", checksum_node, false) ||
+ checksum_node->getUnsignedValue(1, &node_float_checksum, ENCODING_HEX) != 1)
+ {
+ error_buffer.append(llformat("ERROR Node %s: Float checksum missing.\n", mName->mString));
+ return false;
+ }
+ if (node_float_checksum != float_checksum)
+ {
+ error_buffer.append(llformat("ERROR Node %s: Float checksum mismatch: read %X / calc %X.\n", mName->mString, node_float_checksum, float_checksum));
+ return false;
+ }
+ }
+
+ return true;
+}
+
+LLXMLNodePtr LLXMLNode::getFirstChild() const
+{
+ if (mChildren.isNull()) return NULL;
+ LLXMLNodePtr ret = mChildren->head;
+ return ret;
+}
+
+LLXMLNodePtr LLXMLNode::getNextSibling() const
+{
+ LLXMLNodePtr ret = mNext;
+ return ret;
+}
+
+std::string LLXMLNode::getSanitizedValue() const
+{
+ if (mIsAttribute)
+ {
+ return getValue() ;
+ }
+ else
+ {
+ return getTextContents();
+ }
+}
+
+
+std::string LLXMLNode::getTextContents() const
+{
+ std::string msg;
+ std::string contents = mValue;
+ std::string::size_type n = contents.find_first_not_of(" \t\n");
+ if (n != std::string::npos && contents[n] == '\"')
+ {
+ // Case 1: node has quoted text
+ S32 num_lines = 0;
+ while(1)
+ {
+ // mContents[n] == '"'
+ ++n;
+ std::string::size_type t = n;
+ std::string::size_type m = 0;
+ // fix-up escaped characters
+ while(1)
+ {
+ m = contents.find_first_of("\\\"", t); // find first \ or "
+ if ((m == std::string::npos) || (contents[m] == '\"'))
+ {
+ break;
+ }
+ contents.erase(m,1);
+ t = m+1;
+ }
+ if (m == std::string::npos)
+ {
+ break;
+ }
+ // mContents[m] == '"'
+ num_lines++;
+ msg += contents.substr(n,m-n) + "\n";
+ n = contents.find_first_of("\"", m+1);
+ if (n == std::string::npos)
+ {
+ if (num_lines == 1)
+ {
+ msg.erase(msg.size()-1); // remove "\n" if only one line
+ }
+ break;
+ }
+ }
+ }
+ else
+ {
+ // Case 2: node has embedded text (beginning and trailing whitespace trimmed)
+ std::string::size_type start = mValue.find_first_not_of(" \t\n");
+ if (start != mValue.npos)
+ {
+ std::string::size_type end = mValue.find_last_not_of(" \t\n");
+ if (end != mValue.npos)
+ {
+ msg = mValue.substr(start, end+1-start);
+ }
+ else
+ {
+ msg = mValue.substr(start);
+ }
+ }
+ // Convert any internal CR to LF
+ msg = utf8str_removeCRLF(msg);
+ }
+ return msg;
+}
+
+void LLXMLNode::setLineNumber(S32 line_number)
+{
+ mLineNumber = line_number;
+}
+
+S32 LLXMLNode::getLineNumber()
+{
+ return mLineNumber;
+}
generated by cgit v1.2.3 (git 2.25.1) at 2025-02-16 08:56:43 +0000