summaryrefslogtreecommitdiff
path: root/indra/llxml
diff options
context:
space:
mode:
Diffstat (limited to 'indra/llxml')
-rw-r--r--indra/llxml/llxmlnode.cpp265
-rw-r--r--indra/llxml/llxmlnode.h96
-rw-r--r--indra/llxml/llxmlparser.cpp14
-rw-r--r--indra/llxml/llxmlparser.h2
-rw-r--r--indra/llxml/llxmltree.cpp98
-rw-r--r--indra/llxml/llxmltree.h76
6 files changed, 265 insertions, 286 deletions
diff --git a/indra/llxml/llxmlnode.cpp b/indra/llxml/llxmlnode.cpp
index 455df13e48..9c7ac66f01 100644
--- a/indra/llxml/llxmlnode.cpp
+++ b/indra/llxml/llxmlnode.cpp
@@ -44,13 +44,13 @@
#include "lldir.h"
// static
-BOOL LLXMLNode::sStripEscapedStrings = TRUE;
-BOOL LLXMLNode::sStripWhitespaceValues = FALSE;
+bool LLXMLNode::sStripEscapedStrings = true;
+bool LLXMLNode::sStripWhitespaceValues = false;
LLXMLNode::LLXMLNode() :
mID(""),
mParser(NULL),
- mIsAttribute(FALSE),
+ mIsAttribute(false),
mVersionMajor(0),
mVersionMinor(0),
mLength(0),
@@ -69,7 +69,7 @@ LLXMLNode::LLXMLNode() :
{
}
-LLXMLNode::LLXMLNode(const char* name, BOOL is_attribute) :
+LLXMLNode::LLXMLNode(const char* name, bool is_attribute) :
mID(""),
mParser(NULL),
mIsAttribute(is_attribute),
@@ -91,7 +91,7 @@ LLXMLNode::LLXMLNode(const char* name, BOOL is_attribute) :
mName = gStringTable.addStringEntry(name);
}
-LLXMLNode::LLXMLNode(LLStringTableEntry* name, BOOL is_attribute) :
+LLXMLNode::LLXMLNode(LLStringTableEntry* name, bool is_attribute) :
mID(""),
mParser(NULL),
mIsAttribute(is_attribute),
@@ -193,17 +193,17 @@ LLXMLNode::~LLXMLNode()
mDefault = NULL;
}
-BOOL LLXMLNode::isNull()
+bool LLXMLNode::isNull()
{
return (mName == NULL);
}
// protected
-BOOL LLXMLNode::removeChild(LLXMLNode *target_child)
+bool LLXMLNode::removeChild(LLXMLNode *target_child)
{
if (!target_child)
{
- return FALSE;
+ return false;
}
if (target_child->mIsAttribute)
{
@@ -212,7 +212,7 @@ BOOL LLXMLNode::removeChild(LLXMLNode *target_child)
{
target_child->mParent = NULL;
mAttributes.erase(children_itr);
- return TRUE;
+ return true;
}
}
else if (mChildren.notNull())
@@ -244,7 +244,7 @@ BOOL LLXMLNode::removeChild(LLXMLNode *target_child)
{
mChildren = NULL;
}
- return TRUE;
+ return true;
}
else if (children_itr->first != target_child->mName)
{
@@ -256,7 +256,7 @@ BOOL LLXMLNode::removeChild(LLXMLNode *target_child)
}
}
}
- return FALSE;
+ return false;
}
void LLXMLNode::addChild(LLXMLNodePtr& new_child)
@@ -302,13 +302,13 @@ void LLXMLNode::addChild(LLXMLNodePtr& new_child)
}
// virtual
-LLXMLNodePtr LLXMLNode::createChild(const char* name, BOOL is_attribute)
+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 LLXMLNode::createChild(LLStringTableEntry* name, bool is_attribute)
{
LLXMLNodePtr ret(new LLXMLNode(name, is_attribute));
ret->mID.clear();
@@ -317,13 +317,13 @@ LLXMLNodePtr LLXMLNode::createChild(LLStringTableEntry* name, BOOL is_attribute)
return ret;
}
-BOOL LLXMLNode::deleteChild(LLXMLNode *child)
+bool LLXMLNode::deleteChild(LLXMLNode *child)
{
if (removeChild(child))
{
- return TRUE;
+ return true;
}
- return FALSE;
+ return false;
}
void LLXMLNode::setParent(LLXMLNodePtr& new_parent)
@@ -375,7 +375,7 @@ void XMLCALL StartXMLNode(void *userData,
const XML_Char **atts)
{
// Create a new node
- LLXMLNode *new_node_ptr = new LLXMLNode(name, FALSE);
+ LLXMLNode *new_node_ptr = new LLXMLNode(name, false);
LLXMLNodePtr new_node = new_node_ptr;
new_node->mID.clear();
@@ -480,9 +480,9 @@ void XMLCALL StartXMLNode(void *userData,
// only one attribute child per description
LLXMLNodePtr attr_node;
- if (!new_node->getAttribute(attr_name.c_str(), attr_node, FALSE))
+ if (!new_node->getAttribute(attr_name.c_str(), attr_node, false))
{
- attr_node = new LLXMLNode(attr_name.c_str(), TRUE);
+ attr_node = new LLXMLNode(attr_name.c_str(), true);
attr_node->setLineNumber(XML_GetCurrentLineNumber(*new_node_ptr->mParser));
}
attr_node->setValue(attr_value);
@@ -508,13 +508,13 @@ void XMLCALL EndXMLNode(void *userData,
if (LLXMLNode::sStripWhitespaceValues)
{
std::string value = node->getValue();
- BOOL is_empty = TRUE;
+ 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;
+ is_empty = false;
break;
}
}
@@ -575,7 +575,7 @@ bool LLXMLNode::updateNode(
if (!node || !update_node)
{
LL_WARNS() << "Node invalid" << LL_ENDL;
- return FALSE;
+ return false;
}
//update the node value
@@ -647,7 +647,7 @@ bool LLXMLNode::updateNode(
}
}
- return TRUE;
+ return true;
}
// static
@@ -688,7 +688,7 @@ bool LLXMLNode::parseBuffer(
XML_SetCharacterDataHandler(my_parser, XMLData);
// Create a root node
- LLXMLNode *file_node_ptr = new LLXMLNode("XML", FALSE);
+ LLXMLNode *file_node_ptr = new LLXMLNode("XML", false);
LLXMLNodePtr file_node = file_node_ptr;
file_node->mParser = &my_parser;
@@ -696,7 +696,7 @@ bool LLXMLNode::parseBuffer(
XML_SetUserData(my_parser, (void *)file_node_ptr);
// Do the parsing
- if (XML_Parse(my_parser, (const char *)buffer, length, TRUE) != XML_STATUS_OK)
+ 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))
@@ -736,7 +736,7 @@ bool LLXMLNode::parseStream(
XML_SetCharacterDataHandler(my_parser, XMLData);
// Create a root node
- LLXMLNode *file_node_ptr = new LLXMLNode("XML", FALSE);
+ LLXMLNode *file_node_ptr = new LLXMLNode("XML", false);
LLXMLNodePtr file_node = file_node_ptr;
file_node->mParser = &my_parser;
@@ -784,18 +784,18 @@ bool LLXMLNode::parseStream(
}
-BOOL LLXMLNode::isFullyDefault()
+bool LLXMLNode::isFullyDefault()
{
if (mDefault.isNull())
{
- return FALSE;
+ 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);
+ 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
@@ -813,14 +813,14 @@ BOOL LLXMLNode::isFullyDefault()
LLXMLNodePtr child = (*children_itr).second;
if (!child->isFullyDefault())
{
- return FALSE;
+ return false;
}
}
}
- return TRUE;
+ return true;
}
- return FALSE;
+ return false;
}
// static
@@ -908,10 +908,10 @@ void LLXMLNode::writeToOstream(std::ostream& output_stream, const std::string& i
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);
+ 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";
@@ -1153,12 +1153,12 @@ void LLXMLNode::scrubToTree(LLXMLNode *tree)
}
}
-bool LLXMLNode::getChild(const char* name, LLXMLNodePtr& node, BOOL use_default_if_missing)
+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)
+bool LLXMLNode::getChild(const LLStringTableEntry* name, LLXMLNodePtr& node, bool use_default_if_missing)
{
if (mChildren.notNull())
{
@@ -1171,18 +1171,18 @@ bool LLXMLNode::getChild(const LLStringTableEntry* name, LLXMLNodePtr& node, BOO
}
if (use_default_if_missing && !mDefault.isNull())
{
- return mDefault->getChild(name, node, FALSE);
+ return mDefault->getChild(name, node, false);
}
node = NULL;
return false;
}
-void LLXMLNode::getChildren(const char* name, LLXMLNodeList &children, BOOL use_default_if_missing) const
+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
+void LLXMLNode::getChildren(const LLStringTableEntry* name, LLXMLNodeList &children, bool use_default_if_missing) const
{
if (mChildren.notNull())
{
@@ -1204,7 +1204,7 @@ void LLXMLNode::getChildren(const LLStringTableEntry* name, LLXMLNodeList &child
}
if (children.size() == 0 && use_default_if_missing && !mDefault.isNull())
{
- mDefault->getChildren(name, children, FALSE);
+ mDefault->getChildren(name, children, false);
}
}
@@ -1227,12 +1227,12 @@ void LLXMLNode::getDescendants(const LLStringTableEntry* name, LLXMLNodeList &ch
}
}
-bool LLXMLNode::getAttribute(const char* name, LLXMLNodePtr& node, BOOL use_default_if_missing)
+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)
+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())
@@ -1242,7 +1242,7 @@ bool LLXMLNode::getAttribute(const LLStringTableEntry* name, LLXMLNodePtr& node,
}
if (use_default_if_missing && !mDefault.isNull())
{
- return mDefault->getAttribute(name, node, FALSE);
+ return mDefault->getAttribute(name, node, false);
}
return false;
@@ -1261,42 +1261,25 @@ bool LLXMLNode::setAttributeString(const char* attr, const std::string& value)
return false;
}
-BOOL LLXMLNode::hasAttribute(const char* name )
+bool LLXMLNode::hasAttribute(const char* name )
{
LLXMLNodePtr node;
return getAttribute(name, node);
}
-// the structure of these getAttribute_ functions is ugly, but it's because the
-// underlying system is based on BOOL and LLString; if we change
-// so that they're based on more generic mechanisms, these will be
-// simplified.
-bool LLXMLNode::getAttribute_bool(const char* name, bool& value )
-{
- LLXMLNodePtr node;
- if (!getAttribute(name, node))
- {
- return false;
- }
- BOOL temp;
- bool retval = node->getBoolValue(1, &temp);
- value = temp;
- return retval;
-}
-
-BOOL LLXMLNode::getAttributeBOOL(const char* name, BOOL& value )
+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 )
+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 )
+bool LLXMLNode::getAttributeS8(const char* name, S8& value )
{
LLXMLNodePtr node;
S32 val;
@@ -1308,7 +1291,7 @@ BOOL LLXMLNode::getAttributeS8(const char* name, S8& value )
return true;
}
-BOOL LLXMLNode::getAttributeU16(const char* name, U16& value )
+bool LLXMLNode::getAttributeU16(const char* name, U16& value )
{
LLXMLNodePtr node;
U32 val;
@@ -1320,7 +1303,7 @@ BOOL LLXMLNode::getAttributeU16(const char* name, U16& value )
return true;
}
-BOOL LLXMLNode::getAttributeS16(const char* name, S16& value )
+bool LLXMLNode::getAttributeS16(const char* name, S16& value )
{
LLXMLNodePtr node;
S32 val;
@@ -1332,73 +1315,73 @@ BOOL LLXMLNode::getAttributeS16(const char* name, S16& value )
return true;
}
-BOOL LLXMLNode::getAttributeU32(const char* name, U32& value )
+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 )
+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 )
+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 )
+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 )
+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 )
+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 )
+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 )
+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 )
+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 )
+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 )
+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 )
+bool LLXMLNode::getAttributeString(const char* name, std::string& value )
{
LLXMLNodePtr node;
if (!getAttribute(name, node))
@@ -1435,10 +1418,10 @@ const char *LLXMLNode::skipNonWhitespace(const char *str)
}
/*static */
-const char *LLXMLNode::parseInteger(const char *str, U64 *dest, BOOL *is_negative, U32 precision, Encoding encoding)
+const char *LLXMLNode::parseInteger(const char *str, U64 *dest, bool *is_negative, U32 precision, Encoding encoding)
{
*dest = 0;
- *is_negative = FALSE;
+ *is_negative = false;
str = skipWhitespace(str);
@@ -1452,7 +1435,7 @@ const char *LLXMLNode::parseInteger(const char *str, U64 *dest, BOOL *is_negativ
}
if (str[0] == '-')
{
- *is_negative = TRUE;
+ *is_negative = true;
++str;
}
@@ -1653,7 +1636,7 @@ const char *LLXMLNode::parseFloat(const char *str, F64 *dest, U32 precision, Enc
// Scientific notation!
++str;
U64 exp;
- BOOL is_negative;
+ bool is_negative;
str = parseInteger(str, &exp, &is_negative, 64, ENCODING_DECIMAL);
if (str == NULL)
{
@@ -1677,7 +1660,7 @@ const char *LLXMLNode::parseFloat(const char *str, F64 *dest, U32 precision, Enc
if (encoding == ENCODING_HEX)
{
U64 bytes_dest;
- BOOL is_negative;
+ bool is_negative;
str = parseInteger(str, (U64 *)&bytes_dest, &is_negative, precision, ENCODING_HEX);
// Upcast to F64
switch (precision)
@@ -1700,7 +1683,7 @@ const char *LLXMLNode::parseFloat(const char *str, F64 *dest, U32 precision, Enc
return NULL;
}
-U32 LLXMLNode::getBoolValue(U32 expected_length, BOOL *array)
+U32 LLXMLNode::getBoolValue(U32 expected_length, bool *array)
{
llassert(array);
@@ -1720,11 +1703,11 @@ U32 LLXMLNode::getBoolValue(U32 expected_length, BOOL *array)
LLStringUtil::toLower(str_array[i]);
if (str_array[i] == "false")
{
- array[ret_length++] = FALSE;
+ array[ret_length++] = false;
}
else if (str_array[i] == "true")
{
- array[ret_length++] = TRUE;
+ array[ret_length++] = true;
}
}
@@ -1770,7 +1753,7 @@ U32 LLXMLNode::getByteValue(U32 expected_length, U8 *array, Encoding encoding)
for (i=0; i<expected_length; ++i)
{
U64 value;
- BOOL is_negative;
+ bool is_negative;
value_string = parseInteger(value_string, &value, &is_negative, 8, encoding);
if (value_string == NULL)
{
@@ -1822,7 +1805,7 @@ U32 LLXMLNode::getIntValue(U32 expected_length, S32 *array, Encoding encoding)
for (i=0; i<expected_length; ++i)
{
U64 value;
- BOOL is_negative;
+ bool is_negative;
value_string = parseInteger(value_string, &value, &is_negative, 32, encoding);
if (value_string == NULL)
{
@@ -1876,7 +1859,7 @@ U32 LLXMLNode::getUnsignedValue(U32 expected_length, U32 *array, Encoding encodi
for (i=0; i<expected_length; ++i)
{
U64 value;
- BOOL is_negative;
+ bool is_negative;
value_string = parseInteger(value_string, &value, &is_negative, 32, encoding);
if (value_string == NULL)
{
@@ -1930,7 +1913,7 @@ U32 LLXMLNode::getLongValue(U32 expected_length, U64 *array, Encoding encoding)
for (i=0; i<expected_length; ++i)
{
U64 value;
- BOOL is_negative;
+ bool is_negative;
value_string = parseInteger(value_string, &value, &is_negative, 64, encoding);
if (value_string == NULL)
{
@@ -2185,7 +2168,7 @@ U32 LLXMLNode::getNodeRefValue(U32 expected_length, LLXMLNode **array)
return num_returned_refs;
}
-void LLXMLNode::setBoolValue(U32 length, const BOOL *array)
+void LLXMLNode::setBoolValue(U32 length, const bool *array)
{
if (length == 0) return;
@@ -2614,7 +2597,7 @@ void LLXMLNode::findDefault(LLXMLNode *defaults_list)
mDefault = NULL;
}
-BOOL LLXMLNode::deleteChildren(const std::string& name)
+bool LLXMLNode::deleteChildren(const std::string& name)
{
U32 removed_count = 0;
LLXMLNodeList node_list;
@@ -2633,10 +2616,10 @@ BOOL LLXMLNode::deleteChildren(const std::string& name)
}
}
}
- return removed_count > 0 ? TRUE : FALSE;
+ return removed_count > 0;
}
-BOOL LLXMLNode::deleteChildren(LLStringTableEntry* name)
+bool LLXMLNode::deleteChildren(LLStringTableEntry* name)
{
U32 removed_count = 0;
LLXMLNodeList node_list;
@@ -2655,7 +2638,7 @@ BOOL LLXMLNode::deleteChildren(LLStringTableEntry* name)
}
}
}
- return removed_count > 0 ? TRUE : FALSE;
+ return removed_count > 0;
}
void LLXMLNode::setAttributes(LLXMLNode::ValueType type, U32 precision, LLXMLNode::Encoding encoding, U32 length)
@@ -2778,7 +2761,7 @@ void LLXMLNode::createUnitTest(S32 max_num_children)
child_name.append(1, c);
}
- LLXMLNode *new_child = createChild(child_name.c_str(), FALSE);
+ LLXMLNode *new_child = createChild(child_name.c_str(), false);
// Random ID
std::string child_id;
@@ -2805,7 +2788,7 @@ void LLXMLNode::createUnitTest(S32 max_num_children)
break;
case 1: // TYPE_BOOLEAN
{
- BOOL random_bool_values[30];
+ bool random_bool_values[30];
for (U32 value=0; value<array_size; ++value)
{
random_bool_values[value] = get_rand(2);
@@ -2913,20 +2896,20 @@ void LLXMLNode::createUnitTest(S32 max_num_children)
}
}
- 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);
+ 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)
+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;
+ return false;
}
// Checksums
@@ -2950,14 +2933,14 @@ BOOL LLXMLNode::performUnitTest(std::string &error_buffer)
if (!node->performUnitTest(error_buffer))
{
error_buffer.append(llformat("Child test failed for %s.\n", mName->mString));
- //return FALSE;
+ //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;
+ return false;
}
switch (node->mType)
{
@@ -2966,11 +2949,11 @@ BOOL LLXMLNode::performUnitTest(std::string &error_buffer)
break;
case TYPE_BOOLEAN:
{
- BOOL bool_array[30];
+ 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;
+ return false;
}
for (U32 pos=0; pos<(U32)node->mLength; ++pos)
{
@@ -2989,7 +2972,7 @@ BOOL LLXMLNode::performUnitTest(std::string &error_buffer)
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;
+ return false;
}
for (U32 pos=0; pos<(U32)node->mLength; ++pos)
{
@@ -3002,7 +2985,7 @@ BOOL LLXMLNode::performUnitTest(std::string &error_buffer)
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;
+ return false;
}
for (U32 pos=0; pos<(U32)node->mLength; ++pos)
{
@@ -3019,7 +3002,7 @@ BOOL LLXMLNode::performUnitTest(std::string &error_buffer)
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;
+ return false;
}
for (U32 pos=0; pos<(U32)node->mLength; ++pos)
{
@@ -3033,7 +3016,7 @@ BOOL LLXMLNode::performUnitTest(std::string &error_buffer)
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;
+ return false;
}
for (U32 pos=0; pos<(U32)node->mLength; ++pos)
{
@@ -3051,7 +3034,7 @@ BOOL LLXMLNode::performUnitTest(std::string &error_buffer)
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;
+ return false;
}
for (U32 pos=0; pos<(U32)node->mLength; ++pos)
{
@@ -3068,7 +3051,7 @@ BOOL LLXMLNode::performUnitTest(std::string &error_buffer)
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;
+ return false;
}
for (U32 pos=0; pos<node->mLength; ++pos)
{
@@ -3089,97 +3072,97 @@ BOOL LLXMLNode::performUnitTest(std::string &error_buffer)
// Compare checksums
{
U32 node_integer_checksum = 0;
- if (!getAttribute("integer_checksum", checksum_node, FALSE) ||
+ 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;
+ 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;
+ return false;
}
}
{
U64 node_long_checksum = 0;
- if (!getAttribute("long_checksum", checksum_node, FALSE) ||
+ 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;
+ 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;
+ return false;
}
}
{
U32 node_bool_true_count = 0;
- if (!getAttribute("bool_true_count", checksum_node, FALSE) ||
+ 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;
+ 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;
+ return false;
}
}
{
LLUUID node_uuid_checksum;
- if (!getAttribute("uuid_checksum", checksum_node, FALSE) ||
+ 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;
+ 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;
+ return false;
}
}
{
U32 node_noderef_checksum = 0;
- if (!getAttribute("noderef_checksum", checksum_node, FALSE) ||
+ 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;
+ 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;
+ return false;
}
}
{
U32 node_float_checksum = 0;
- if (!getAttribute("float_checksum", checksum_node, FALSE) ||
+ 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;
+ 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 false;
}
}
- return TRUE;
+ return true;
}
LLXMLNodePtr LLXMLNode::getFirstChild() const
diff --git a/indra/llxml/llxmlnode.h b/indra/llxml/llxmlnode.h
index 0b8da5dc5d..21a7dee4cc 100644
--- a/indra/llxml/llxmlnode.h
+++ b/indra/llxml/llxmlnode.h
@@ -57,9 +57,9 @@ struct CompareAttributes
bool operator()(const LLStringTableEntry* const lhs, const LLStringTableEntry* const rhs) const
{
if (lhs == NULL)
- return TRUE;
+ return true;
if (rhs == NULL)
- return FALSE;
+ return true;
return strcmp(lhs->mString, rhs->mString) < 0;
}
@@ -118,14 +118,14 @@ protected:
public:
LLXMLNode();
- LLXMLNode(const char* name, BOOL is_attribute);
- LLXMLNode(LLStringTableEntry* name, BOOL is_attribute);
+ LLXMLNode(const char* name, bool is_attribute);
+ LLXMLNode(LLStringTableEntry* name, bool is_attribute);
LLXMLNode(const LLXMLNode& rhs);
LLXMLNodePtr deepCopy();
- BOOL isNull();
+ bool isNull();
- BOOL deleteChild(LLXMLNode* child);
+ bool deleteChild(LLXMLNode* child);
void addChild(LLXMLNodePtr& new_child);
void setParent(LLXMLNodePtr& new_parent); // reparent if necessary
@@ -165,12 +165,12 @@ public:
void findID(const std::string& id, LLXMLNodeList &results);
- virtual LLXMLNodePtr createChild(const char* name, BOOL is_attribute);
- virtual LLXMLNodePtr createChild(LLStringTableEntry* name, BOOL is_attribute);
+ virtual LLXMLNodePtr createChild(const char* name, bool is_attribute);
+ virtual LLXMLNodePtr createChild(LLStringTableEntry* name, bool is_attribute);
// Getters
- U32 getBoolValue(U32 expected_length, BOOL *array);
+ U32 getBoolValue(U32 expected_length, bool *array);
U32 getByteValue(U32 expected_length, U8 *array, Encoding encoding = ENCODING_DEFAULT);
U32 getIntValue(U32 expected_length, S32 *array, Encoding encoding = ENCODING_DEFAULT);
U32 getUnsignedValue(U32 expected_length, U32 *array, Encoding encoding = ENCODING_DEFAULT);
@@ -181,29 +181,25 @@ public:
U32 getUUIDValue(U32 expected_length, LLUUID *array);
U32 getNodeRefValue(U32 expected_length, LLXMLNode **array);
- BOOL hasAttribute(const char* name );
-
- // these are designed to be more generic versions of the functions
- // rather than relying on LL-types
- bool getAttribute_bool(const char* name, bool& value );
-
- BOOL getAttributeBOOL(const char* name, BOOL& value );
- BOOL getAttributeU8(const char* name, U8& value );
- BOOL getAttributeS8(const char* name, S8& value );
- BOOL getAttributeU16(const char* name, U16& value );
- BOOL getAttributeS16(const char* name, S16& value );
- BOOL getAttributeU32(const char* name, U32& value );
- BOOL getAttributeS32(const char* name, S32& value );
- BOOL getAttributeF32(const char* name, F32& value );
- BOOL getAttributeF64(const char* name, F64& value );
- BOOL getAttributeColor(const char* name, LLColor4& value );
- BOOL getAttributeColor4(const char* name, LLColor4& value );
- BOOL getAttributeColor4U(const char* name, LLColor4U& value );
- BOOL getAttributeVector3(const char* name, LLVector3& value );
- BOOL getAttributeVector3d(const char* name, LLVector3d& value );
- BOOL getAttributeQuat(const char* name, LLQuaternion& value );
- BOOL getAttributeUUID(const char* name, LLUUID& value );
- BOOL getAttributeString(const char* name, std::string& value );
+ bool hasAttribute(const char* name );
+
+ bool getAttributeBOOL(const char* name, bool& value );
+ bool getAttributeU8(const char* name, U8& value );
+ bool getAttributeS8(const char* name, S8& value );
+ bool getAttributeU16(const char* name, U16& value );
+ bool getAttributeS16(const char* name, S16& value );
+ bool getAttributeU32(const char* name, U32& value );
+ bool getAttributeS32(const char* name, S32& value );
+ bool getAttributeF32(const char* name, F32& value );
+ bool getAttributeF64(const char* name, F64& value );
+ bool getAttributeColor(const char* name, LLColor4& value );
+ bool getAttributeColor4(const char* name, LLColor4& value );
+ bool getAttributeColor4U(const char* name, LLColor4U& value );
+ bool getAttributeVector3(const char* name, LLVector3& value );
+ bool getAttributeVector3d(const char* name, LLVector3d& value );
+ bool getAttributeQuat(const char* name, LLQuaternion& value );
+ bool getAttributeUUID(const char* name, LLUUID& value );
+ bool getAttributeString(const char* name, std::string& value );
const ValueType& getType() const { return mType; }
U32 getLength() const { return mLength; }
@@ -212,23 +208,23 @@ public:
std::string getSanitizedValue() const;
std::string getTextContents() const;
const LLStringTableEntry* getName() const { return mName; }
- BOOL hasName(const char* name) const { return mName == gStringTable.checkStringEntry(name); }
- BOOL hasName(const std::string& name) const { return mName == gStringTable.checkStringEntry(name.c_str()); }
+ bool hasName(const char* name) const { return mName == gStringTable.checkStringEntry(name); }
+ bool hasName(const std::string& name) const { return mName == gStringTable.checkStringEntry(name.c_str()); }
const std::string& getID() const { return mID; }
U32 getChildCount() const;
// getChild returns a Null LLXMLNode (not a NULL pointer) if there is no such child.
// This child has no value so any getTYPEValue() calls on it will return 0.
- bool getChild(const char* name, LLXMLNodePtr& node, BOOL use_default_if_missing = TRUE);
- bool getChild(const LLStringTableEntry* name, LLXMLNodePtr& node, BOOL use_default_if_missing = TRUE);
- void getChildren(const char* name, LLXMLNodeList &children, BOOL use_default_if_missing = TRUE) const;
- void getChildren(const LLStringTableEntry* name, LLXMLNodeList &children, BOOL use_default_if_missing = TRUE) const;
+ bool getChild(const char* name, LLXMLNodePtr& node, bool use_default_if_missing = true);
+ bool getChild(const LLStringTableEntry* name, LLXMLNodePtr& node, bool use_default_if_missing = true);
+ void getChildren(const char* name, LLXMLNodeList &children, bool use_default_if_missing = true) const;
+ void getChildren(const LLStringTableEntry* name, LLXMLNodeList &children, bool use_default_if_missing = true) const;
// recursively finds all children at any level matching name
void getDescendants(const LLStringTableEntry* name, LLXMLNodeList &children) const;
- bool getAttribute(const char* name, LLXMLNodePtr& node, BOOL use_default_if_missing = TRUE);
- bool getAttribute(const LLStringTableEntry* name, LLXMLNodePtr& node, BOOL use_default_if_missing = TRUE);
+ bool getAttribute(const char* name, LLXMLNodePtr& node, bool use_default_if_missing = true);
+ bool getAttribute(const LLStringTableEntry* name, LLXMLNodePtr& node, bool use_default_if_missing = true);
S32 getLineNumber();
@@ -242,7 +238,7 @@ public:
bool setAttributeString(const char* attr, const std::string& value);
- void setBoolValue(const BOOL value) { setBoolValue(1, &value); }
+ void setBoolValue(const bool value) { setBoolValue(1, &value); }
void setByteValue(const U8 value, Encoding encoding = ENCODING_DEFAULT) { setByteValue(1, &value, encoding); }
void setIntValue(const S32 value, Encoding encoding = ENCODING_DEFAULT) { setIntValue(1, &value, encoding); }
void setUnsignedValue(const U32 value, Encoding encoding = ENCODING_DEFAULT) { setUnsignedValue(1, &value, encoding); }
@@ -253,7 +249,7 @@ public:
void setUUIDValue(const LLUUID value) { setUUIDValue(1, &value); }
void setNodeRefValue(const LLXMLNode *value) { setNodeRefValue(1, &value); }
- void setBoolValue(U32 length, const BOOL *array);
+ void setBoolValue(U32 length, const bool *array);
void setByteValue(U32 length, const U8 *array, Encoding encoding = ENCODING_DEFAULT);
void setIntValue(U32 length, const S32 *array, Encoding encoding = ENCODING_DEFAULT);
void setUnsignedValue(U32 length, const U32* array, Encoding encoding = ENCODING_DEFAULT);
@@ -283,17 +279,17 @@ public:
// Delete any child nodes that aren't among the tree's children, recursive
void scrubToTree(LLXMLNode *tree);
- BOOL deleteChildren(const std::string& name);
- BOOL deleteChildren(LLStringTableEntry* name);
+ bool deleteChildren(const std::string& name);
+ bool deleteChildren(LLStringTableEntry* name);
void setAttributes(ValueType type, U32 precision, Encoding encoding, U32 length);
// void appendValue(const std::string& value); // Unused
// Unit Testing
void createUnitTest(S32 max_num_children);
- BOOL performUnitTest(std::string &error_buffer);
+ bool performUnitTest(std::string &error_buffer);
protected:
- BOOL removeChild(LLXMLNode* child);
+ bool removeChild(LLXMLNode* child);
public:
std::string mID; // The ID attribute of this node
@@ -315,8 +311,8 @@ public:
LLXMLNodePtr mPrev; // Double-linked list previous node
LLXMLNodePtr mNext; // Double-linked list next node
- static BOOL sStripEscapedStrings;
- static BOOL sStripWhitespaceValues;
+ static bool sStripEscapedStrings;
+ static bool sStripWhitespaceValues;
protected:
LLStringTableEntry *mName; // The name of this node
@@ -330,10 +326,10 @@ protected:
static const char *skipWhitespace(const char *str);
static const char *skipNonWhitespace(const char *str);
- static const char *parseInteger(const char *str, U64 *dest, BOOL *is_negative, U32 precision, Encoding encoding);
+ static const char *parseInteger(const char *str, U64 *dest, bool *is_negative, U32 precision, Encoding encoding);
static const char *parseFloat(const char *str, F64 *dest, U32 precision, Encoding encoding);
- BOOL isFullyDefault();
+ bool isFullyDefault();
};
#endif // LL_LLXMLNODE
diff --git a/indra/llxml/llxmlparser.cpp b/indra/llxml/llxmlparser.cpp
index 1bdc283f67..f4116626f6 100644
--- a/indra/llxml/llxmlparser.cpp
+++ b/indra/llxml/llxmlparser.cpp
@@ -66,17 +66,17 @@ LLXmlParser::~LLXmlParser()
}
-BOOL LLXmlParser::parseFile(const std::string &path)
+bool LLXmlParser::parseFile(const std::string &path)
{
llassert( !mDepth );
- BOOL success = TRUE;
+ bool success = true;
LLFILE* file = LLFile::fopen(path, "rb"); /* Flawfinder: ignore */
if( !file )
{
mAuxErrorString = llformat( "Couldn't open file %s", path.c_str());
- success = FALSE;
+ success = false;
}
else
{
@@ -90,7 +90,7 @@ BOOL LLXmlParser::parseFile(const std::string &path)
if( !buffer )
{
mAuxErrorString = llformat( "Unable to allocate XML buffer while reading file %s", path.c_str() );
- success = FALSE;
+ success = false;
goto exit_label;
}
@@ -98,14 +98,14 @@ BOOL LLXmlParser::parseFile(const std::string &path)
if( bytes_read <= 0 )
{
mAuxErrorString = llformat( "Error while reading file %s", path.c_str() );
- success = FALSE;
+ success = false;
goto exit_label;
}
- if( !XML_ParseBuffer(mParser, bytes_read, TRUE ) )
+ if( !XML_ParseBuffer(mParser, bytes_read, true ) )
{
mAuxErrorString = llformat( "Error while parsing file %s", path.c_str() );
- success = FALSE;
+ success = false;
}
exit_label:
diff --git a/indra/llxml/llxmlparser.h b/indra/llxml/llxmlparser.h
index a5b210404f..c5025ef450 100644
--- a/indra/llxml/llxmlparser.h
+++ b/indra/llxml/llxmlparser.h
@@ -43,7 +43,7 @@ public:
virtual ~LLXmlParser();
// Parses entire file
- BOOL parseFile(const std::string &path);
+ bool parseFile(const std::string &path);
// Parses some input. Returns 0 if a fatal error is detected.
// The last call must have isFinal true;
diff --git a/indra/llxml/llxmltree.cpp b/indra/llxml/llxmltree.cpp
index 4991e99a96..be3bcf2a66 100644
--- a/indra/llxml/llxmltree.cpp
+++ b/indra/llxml/llxmltree.cpp
@@ -61,13 +61,13 @@ void LLXmlTree::cleanup()
}
-BOOL LLXmlTree::parseFile(const std::string &path, BOOL keep_contents)
+bool LLXmlTree::parseFile(const std::string &path, bool keep_contents)
{
delete mRoot;
mRoot = NULL;
LLXmlTreeParser parser(this);
- BOOL success = parser.parseFile( path, &mRoot, keep_contents );
+ bool success = parser.parseFile( path, &mRoot, keep_contents );
if( !success )
{
S32 line_number = parser.getCurrentLineNumber();
@@ -135,7 +135,7 @@ void LLXmlTreeNode::dump( const std::string& prefix )
LL_CONT << LL_ENDL;
}
-BOOL LLXmlTreeNode::hasAttribute(const std::string& name)
+bool LLXmlTreeNode::hasAttribute(const std::string& name)
{
LLStdStringHandle canonical_name = LLXmlTree::sAttributeKeys.addString( name );
attribute_map_t::iterator iter = mAttributes.find(canonical_name);
@@ -205,106 +205,106 @@ bool LLXmlTreeNode::getFastAttributeBOOL(LLStdStringHandle canonical_name, bool&
return s && LLStringUtil::convertToBOOL( *s, value );
}
-BOOL LLXmlTreeNode::getFastAttributeU8(LLStdStringHandle canonical_name, U8& value)
+bool LLXmlTreeNode::getFastAttributeU8(LLStdStringHandle canonical_name, U8& value)
{
const std::string *s = getAttribute( canonical_name );
return s && LLStringUtil::convertToU8( *s, value );
}
-BOOL LLXmlTreeNode::getFastAttributeS8(LLStdStringHandle canonical_name, S8& value)
+bool LLXmlTreeNode::getFastAttributeS8(LLStdStringHandle canonical_name, S8& value)
{
const std::string *s = getAttribute( canonical_name );
return s && LLStringUtil::convertToS8( *s, value );
}
-BOOL LLXmlTreeNode::getFastAttributeS16(LLStdStringHandle canonical_name, S16& value)
+bool LLXmlTreeNode::getFastAttributeS16(LLStdStringHandle canonical_name, S16& value)
{
const std::string *s = getAttribute( canonical_name );
return s && LLStringUtil::convertToS16( *s, value );
}
-BOOL LLXmlTreeNode::getFastAttributeU16(LLStdStringHandle canonical_name, U16& value)
+bool LLXmlTreeNode::getFastAttributeU16(LLStdStringHandle canonical_name, U16& value)
{
const std::string *s = getAttribute( canonical_name );
return s && LLStringUtil::convertToU16( *s, value );
}
-BOOL LLXmlTreeNode::getFastAttributeU32(LLStdStringHandle canonical_name, U32& value)
+bool LLXmlTreeNode::getFastAttributeU32(LLStdStringHandle canonical_name, U32& value)
{
const std::string *s = getAttribute( canonical_name );
return s && LLStringUtil::convertToU32( *s, value );
}
-BOOL LLXmlTreeNode::getFastAttributeS32(LLStdStringHandle canonical_name, S32& value)
+bool LLXmlTreeNode::getFastAttributeS32(LLStdStringHandle canonical_name, S32& value)
{
const std::string *s = getAttribute( canonical_name );
return s && LLStringUtil::convertToS32( *s, value );
}
-BOOL LLXmlTreeNode::getFastAttributeF32(LLStdStringHandle canonical_name, F32& value)
+bool LLXmlTreeNode::getFastAttributeF32(LLStdStringHandle canonical_name, F32& value)
{
const std::string *s = getAttribute( canonical_name );
return s && LLStringUtil::convertToF32( *s, value );
}
-BOOL LLXmlTreeNode::getFastAttributeF64(LLStdStringHandle canonical_name, F64& value)
+bool LLXmlTreeNode::getFastAttributeF64(LLStdStringHandle canonical_name, F64& value)
{
const std::string *s = getAttribute( canonical_name );
return s && LLStringUtil::convertToF64( *s, value );
}
-BOOL LLXmlTreeNode::getFastAttributeColor(LLStdStringHandle canonical_name, LLColor4& value)
+bool LLXmlTreeNode::getFastAttributeColor(LLStdStringHandle canonical_name, LLColor4& value)
{
const std::string *s = getAttribute( canonical_name );
- return s ? LLColor4::parseColor(*s, &value) : FALSE;
+ return s ? LLColor4::parseColor(*s, &value) : false;
}
-BOOL LLXmlTreeNode::getFastAttributeColor4(LLStdStringHandle canonical_name, LLColor4& value)
+bool LLXmlTreeNode::getFastAttributeColor4(LLStdStringHandle canonical_name, LLColor4& value)
{
const std::string *s = getAttribute( canonical_name );
- return s ? LLColor4::parseColor4(*s, &value) : FALSE;
+ return s ? LLColor4::parseColor4(*s, &value) : false;
}
-BOOL LLXmlTreeNode::getFastAttributeColor4U(LLStdStringHandle canonical_name, LLColor4U& value)
+bool LLXmlTreeNode::getFastAttributeColor4U(LLStdStringHandle canonical_name, LLColor4U& value)
{
const std::string *s = getAttribute( canonical_name );
- return s ? LLColor4U::parseColor4U(*s, &value ) : FALSE;
+ return s ? LLColor4U::parseColor4U(*s, &value ) : false;
}
-BOOL LLXmlTreeNode::getFastAttributeVector3(LLStdStringHandle canonical_name, LLVector3& value)
+bool LLXmlTreeNode::getFastAttributeVector3(LLStdStringHandle canonical_name, LLVector3& value)
{
const std::string *s = getAttribute( canonical_name );
- return s ? LLVector3::parseVector3(*s, &value ) : FALSE;
+ return s ? LLVector3::parseVector3(*s, &value ) : false;
}
-BOOL LLXmlTreeNode::getFastAttributeVector3d(LLStdStringHandle canonical_name, LLVector3d& value)
+bool LLXmlTreeNode::getFastAttributeVector3d(LLStdStringHandle canonical_name, LLVector3d& value)
{
const std::string *s = getAttribute( canonical_name );
- return s ? LLVector3d::parseVector3d(*s, &value ) : FALSE;
+ return s ? LLVector3d::parseVector3d(*s, &value ) : false;
}
-BOOL LLXmlTreeNode::getFastAttributeQuat(LLStdStringHandle canonical_name, LLQuaternion& value)
+bool LLXmlTreeNode::getFastAttributeQuat(LLStdStringHandle canonical_name, LLQuaternion& value)
{
const std::string *s = getAttribute( canonical_name );
- return s ? LLQuaternion::parseQuat(*s, &value ) : FALSE;
+ return s ? LLQuaternion::parseQuat(*s, &value ) : false;
}
-BOOL LLXmlTreeNode::getFastAttributeUUID(LLStdStringHandle canonical_name, LLUUID& value)
+bool LLXmlTreeNode::getFastAttributeUUID(LLStdStringHandle canonical_name, LLUUID& value)
{
const std::string *s = getAttribute( canonical_name );
- return s ? LLUUID::parseUUID(*s, &value ) : FALSE;
+ return s ? LLUUID::parseUUID(*s, &value ) : false;
}
-BOOL LLXmlTreeNode::getFastAttributeString(LLStdStringHandle canonical_name, std::string& value)
+bool LLXmlTreeNode::getFastAttributeString(LLStdStringHandle canonical_name, std::string& value)
{
const std::string *s = getAttribute( canonical_name );
if( !s )
{
- return FALSE;
+ return false;
}
value = *s;
- return TRUE;
+ return true;
}
@@ -316,97 +316,97 @@ bool LLXmlTreeNode::getAttributeBOOL(const std::string& name, bool& value)
return getFastAttributeBOOL(canonical_name, value);
}
-BOOL LLXmlTreeNode::getAttributeU8(const std::string& name, U8& value)
+bool LLXmlTreeNode::getAttributeU8(const std::string& name, U8& value)
{
LLStdStringHandle canonical_name = LLXmlTree::sAttributeKeys.addString( name );
return getFastAttributeU8(canonical_name, value);
}
-BOOL LLXmlTreeNode::getAttributeS8(const std::string& name, S8& value)
+bool LLXmlTreeNode::getAttributeS8(const std::string& name, S8& value)
{
LLStdStringHandle canonical_name = LLXmlTree::sAttributeKeys.addString( name );
return getFastAttributeS8(canonical_name, value);
}
-BOOL LLXmlTreeNode::getAttributeS16(const std::string& name, S16& value)
+bool LLXmlTreeNode::getAttributeS16(const std::string& name, S16& value)
{
LLStdStringHandle canonical_name = LLXmlTree::sAttributeKeys.addString( name );
return getFastAttributeS16(canonical_name, value);
}
-BOOL LLXmlTreeNode::getAttributeU16(const std::string& name, U16& value)
+bool LLXmlTreeNode::getAttributeU16(const std::string& name, U16& value)
{
LLStdStringHandle canonical_name = LLXmlTree::sAttributeKeys.addString( name );
return getFastAttributeU16(canonical_name, value);
}
-BOOL LLXmlTreeNode::getAttributeU32(const std::string& name, U32& value)
+bool LLXmlTreeNode::getAttributeU32(const std::string& name, U32& value)
{
LLStdStringHandle canonical_name = LLXmlTree::sAttributeKeys.addString( name );
return getFastAttributeU32(canonical_name, value);
}
-BOOL LLXmlTreeNode::getAttributeS32(const std::string& name, S32& value)
+bool LLXmlTreeNode::getAttributeS32(const std::string& name, S32& value)
{
LLStdStringHandle canonical_name = LLXmlTree::sAttributeKeys.addString( name );
return getFastAttributeS32(canonical_name, value);
}
-BOOL LLXmlTreeNode::getAttributeF32(const std::string& name, F32& value)
+bool LLXmlTreeNode::getAttributeF32(const std::string& name, F32& value)
{
LLStdStringHandle canonical_name = LLXmlTree::sAttributeKeys.addString( name );
return getFastAttributeF32(canonical_name, value);
}
-BOOL LLXmlTreeNode::getAttributeF64(const std::string& name, F64& value)
+bool LLXmlTreeNode::getAttributeF64(const std::string& name, F64& value)
{
LLStdStringHandle canonical_name = LLXmlTree::sAttributeKeys.addString( name );
return getFastAttributeF64(canonical_name, value);
}
-BOOL LLXmlTreeNode::getAttributeColor(const std::string& name, LLColor4& value)
+bool LLXmlTreeNode::getAttributeColor(const std::string& name, LLColor4& value)
{
LLStdStringHandle canonical_name = LLXmlTree::sAttributeKeys.addString( name );
return getFastAttributeColor(canonical_name, value);
}
-BOOL LLXmlTreeNode::getAttributeColor4(const std::string& name, LLColor4& value)
+bool LLXmlTreeNode::getAttributeColor4(const std::string& name, LLColor4& value)
{
LLStdStringHandle canonical_name = LLXmlTree::sAttributeKeys.addString( name );
return getFastAttributeColor4(canonical_name, value);
}
-BOOL LLXmlTreeNode::getAttributeColor4U(const std::string& name, LLColor4U& value)
+bool LLXmlTreeNode::getAttributeColor4U(const std::string& name, LLColor4U& value)
{
LLStdStringHandle canonical_name = LLXmlTree::sAttributeKeys.addString( name );
return getFastAttributeColor4U(canonical_name, value);
}
-BOOL LLXmlTreeNode::getAttributeVector3(const std::string& name, LLVector3& value)
+bool LLXmlTreeNode::getAttributeVector3(const std::string& name, LLVector3& value)
{
LLStdStringHandle canonical_name = LLXmlTree::sAttributeKeys.addString( name );
return getFastAttributeVector3(canonical_name, value);
}
-BOOL LLXmlTreeNode::getAttributeVector3d(const std::string& name, LLVector3d& value)
+bool LLXmlTreeNode::getAttributeVector3d(const std::string& name, LLVector3d& value)
{
LLStdStringHandle canonical_name = LLXmlTree::sAttributeKeys.addString( name );
return getFastAttributeVector3d(canonical_name, value);
}
-BOOL LLXmlTreeNode::getAttributeQuat(const std::string& name, LLQuaternion& value)
+bool LLXmlTreeNode::getAttributeQuat(const std::string& name, LLQuaternion& value)
{
LLStdStringHandle canonical_name = LLXmlTree::sAttributeKeys.addString( name );
return getFastAttributeQuat(canonical_name, value);
}
-BOOL LLXmlTreeNode::getAttributeUUID(const std::string& name, LLUUID& value)
+bool LLXmlTreeNode::getAttributeUUID(const std::string& name, LLUUID& value)
{
LLStdStringHandle canonical_name = LLXmlTree::sAttributeKeys.addString( name );
return getFastAttributeUUID(canonical_name, value);
}
-BOOL LLXmlTreeNode::getAttributeString(const std::string& name, std::string& value)
+bool LLXmlTreeNode::getAttributeString(const std::string& name, std::string& value)
{
LLStdStringHandle canonical_name = LLXmlTree::sAttributeKeys.addString( name );
return getFastAttributeString(canonical_name, value);
@@ -506,8 +506,8 @@ LLXmlTreeParser::LLXmlTreeParser(LLXmlTree* tree)
: mTree(tree),
mRoot( NULL ),
mCurrent( NULL ),
- mDump( FALSE ),
- mKeepContents(FALSE)
+ mDump( false ),
+ mKeepContents(false)
{
}
@@ -515,14 +515,14 @@ LLXmlTreeParser::~LLXmlTreeParser()
{
}
-BOOL LLXmlTreeParser::parseFile(const std::string &path, LLXmlTreeNode** root, BOOL keep_contents)
+bool LLXmlTreeParser::parseFile(const std::string &path, LLXmlTreeNode** root, bool keep_contents)
{
llassert( !mRoot );
llassert( !mCurrent );
mKeepContents = keep_contents;
- BOOL success = LLXmlParser::parseFile(path);
+ bool success = LLXmlParser::parseFile(path);
*root = mRoot;
mRoot = NULL;
@@ -685,7 +685,7 @@ void LLXmlTreeParser::unparsedEntityDecl(
void test_llxmltree()
{
LLXmlTree tree;
- BOOL success = tree.parseFile( "test.xml" );
+ bool success = tree.parseFile( "test.xml" );
if( success )
{
tree.dump();
diff --git a/indra/llxml/llxmltree.h b/indra/llxml/llxmltree.h
index 5d33e2c660..5d15c4c7f5 100644
--- a/indra/llxml/llxmltree.h
+++ b/indra/llxml/llxmltree.h
@@ -55,7 +55,7 @@ public:
virtual ~LLXmlTree();
void cleanup();
- virtual BOOL parseFile(const std::string &path, BOOL keep_contents = TRUE);
+ virtual bool parseFile(const std::string &path, bool keep_contents = true);
LLXmlTreeNode* getRoot() { return mRoot; }
@@ -97,50 +97,50 @@ public:
{
return mName;
}
- BOOL hasName( const std::string& name )
+ bool hasName( const std::string& name )
{
return mName == name;
}
- BOOL hasAttribute( const std::string& name );
+ bool hasAttribute( const std::string& name );
// Fast versions use cannonical_name handlee to entru in LLXmlTree::sAttributeKeys string table
bool getFastAttributeBOOL( LLStdStringHandle cannonical_name, bool& value );
- BOOL getFastAttributeU8( LLStdStringHandle cannonical_name, U8& value );
- BOOL getFastAttributeS8( LLStdStringHandle cannonical_name, S8& value );
- BOOL getFastAttributeU16( LLStdStringHandle cannonical_name, U16& value );
- BOOL getFastAttributeS16( LLStdStringHandle cannonical_name, S16& value );
- BOOL getFastAttributeU32( LLStdStringHandle cannonical_name, U32& value );
- BOOL getFastAttributeS32( LLStdStringHandle cannonical_name, S32& value );
- BOOL getFastAttributeF32( LLStdStringHandle cannonical_name, F32& value );
- BOOL getFastAttributeF64( LLStdStringHandle cannonical_name, F64& value );
- BOOL getFastAttributeColor( LLStdStringHandle cannonical_name, LLColor4& value );
- BOOL getFastAttributeColor4( LLStdStringHandle cannonical_name, LLColor4& value );
- BOOL getFastAttributeColor4U( LLStdStringHandle cannonical_name, LLColor4U& value );
- BOOL getFastAttributeVector3( LLStdStringHandle cannonical_name, LLVector3& value );
- BOOL getFastAttributeVector3d( LLStdStringHandle cannonical_name, LLVector3d& value );
- BOOL getFastAttributeQuat( LLStdStringHandle cannonical_name, LLQuaternion& value );
- BOOL getFastAttributeUUID( LLStdStringHandle cannonical_name, LLUUID& value );
- BOOL getFastAttributeString( LLStdStringHandle cannonical_name, std::string& value );
+ bool getFastAttributeU8( LLStdStringHandle cannonical_name, U8& value );
+ bool getFastAttributeS8( LLStdStringHandle cannonical_name, S8& value );
+ bool getFastAttributeU16( LLStdStringHandle cannonical_name, U16& value );
+ bool getFastAttributeS16( LLStdStringHandle cannonical_name, S16& value );
+ bool getFastAttributeU32( LLStdStringHandle cannonical_name, U32& value );
+ bool getFastAttributeS32( LLStdStringHandle cannonical_name, S32& value );
+ bool getFastAttributeF32( LLStdStringHandle cannonical_name, F32& value );
+ bool getFastAttributeF64( LLStdStringHandle cannonical_name, F64& value );
+ bool getFastAttributeColor( LLStdStringHandle cannonical_name, LLColor4& value );
+ bool getFastAttributeColor4( LLStdStringHandle cannonical_name, LLColor4& value );
+ bool getFastAttributeColor4U( LLStdStringHandle cannonical_name, LLColor4U& value );
+ bool getFastAttributeVector3( LLStdStringHandle cannonical_name, LLVector3& value );
+ bool getFastAttributeVector3d( LLStdStringHandle cannonical_name, LLVector3d& value );
+ bool getFastAttributeQuat( LLStdStringHandle cannonical_name, LLQuaternion& value );
+ bool getFastAttributeUUID( LLStdStringHandle cannonical_name, LLUUID& value );
+ bool getFastAttributeString( LLStdStringHandle cannonical_name, std::string& value );
// Normal versions find 'name' in LLXmlTree::sAttributeKeys then call fast versions
virtual bool getAttributeBOOL( const std::string& name, bool& value );
- virtual BOOL getAttributeU8( const std::string& name, U8& value );
- virtual BOOL getAttributeS8( const std::string& name, S8& value );
- virtual BOOL getAttributeU16( const std::string& name, U16& value );
- virtual BOOL getAttributeS16( const std::string& name, S16& value );
- virtual BOOL getAttributeU32( const std::string& name, U32& value );
- virtual BOOL getAttributeS32( const std::string& name, S32& value );
- virtual BOOL getAttributeF32( const std::string& name, F32& value );
- virtual BOOL getAttributeF64( const std::string& name, F64& value );
- virtual BOOL getAttributeColor( const std::string& name, LLColor4& value );
- virtual BOOL getAttributeColor4( const std::string& name, LLColor4& value );
- virtual BOOL getAttributeColor4U( const std::string& name, LLColor4U& value );
- virtual BOOL getAttributeVector3( const std::string& name, LLVector3& value );
- virtual BOOL getAttributeVector3d( const std::string& name, LLVector3d& value );
- virtual BOOL getAttributeQuat( const std::string& name, LLQuaternion& value );
- virtual BOOL getAttributeUUID( const std::string& name, LLUUID& value );
- virtual BOOL getAttributeString( const std::string& name, std::string& value );
+ virtual bool getAttributeU8( const std::string& name, U8& value );
+ virtual bool getAttributeS8( const std::string& name, S8& value );
+ virtual bool getAttributeU16( const std::string& name, U16& value );
+ virtual bool getAttributeS16( const std::string& name, S16& value );
+ virtual bool getAttributeU32( const std::string& name, U32& value );
+ virtual bool getAttributeS32( const std::string& name, S32& value );
+ virtual bool getAttributeF32( const std::string& name, F32& value );
+ virtual bool getAttributeF64( const std::string& name, F64& value );
+ virtual bool getAttributeColor( const std::string& name, LLColor4& value );
+ virtual bool getAttributeColor4( const std::string& name, LLColor4& value );
+ virtual bool getAttributeColor4U( const std::string& name, LLColor4U& value );
+ virtual bool getAttributeVector3( const std::string& name, LLVector3& value );
+ virtual bool getAttributeVector3d( const std::string& name, LLVector3d& value );
+ virtual bool getAttributeQuat( const std::string& name, LLQuaternion& value );
+ virtual bool getAttributeUUID( const std::string& name, LLUUID& value );
+ virtual bool getAttributeString( const std::string& name, std::string& value );
const std::string& getContents()
{
@@ -199,7 +199,7 @@ public:
LLXmlTreeParser(LLXmlTree* tree);
virtual ~LLXmlTreeParser();
- BOOL parseFile(const std::string &path, LLXmlTreeNode** root, BOOL keep_contents );
+ bool parseFile(const std::string &path, LLXmlTreeNode** root, bool keep_contents );
protected:
const std::string& tabs();
@@ -227,8 +227,8 @@ protected:
LLXmlTree* mTree;
LLXmlTreeNode* mRoot;
LLXmlTreeNode* mCurrent;
- BOOL mDump; // Dump parse tree to LL_INFOS() as it is read.
- BOOL mKeepContents;
+ bool mDump; // Dump parse tree to LL_INFOS() as it is read.
+ bool mKeepContents;
};
#endif // LL_LLXMLTREE_H
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-23 05:28:31 +0000