971 lines
29 KiB
C++
971 lines
29 KiB
C++
/**
|
|
* @file llxuiparser.cpp
|
|
* @brief Utility functions for handling XUI structures in XML
|
|
*
|
|
* $LicenseInfo:firstyear=2003&license=viewergpl$
|
|
*
|
|
* Copyright (c) 2003-2009, Linden Research, Inc.
|
|
*
|
|
* Second Life Viewer Source Code
|
|
* The source code in this file ("Source Code") is provided by Linden Lab
|
|
* to you under the terms of the GNU General Public License, version 2.0
|
|
* ("GPL"), unless you have obtained a separate licensing agreement
|
|
* ("Other License"), formally executed by you and Linden Lab. Terms of
|
|
* the GPL can be found in doc/GPL-license.txt in this distribution, or
|
|
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
|
|
*
|
|
* There are special exceptions to the terms and conditions of the GPL as
|
|
* it is applied to this Source Code. View the full text of the exception
|
|
* in the file doc/FLOSS-exception.txt in this software distribution, or
|
|
* online at
|
|
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
|
|
*
|
|
* By copying, modifying or distributing this software, you acknowledge
|
|
* that you have read and understood your obligations described above,
|
|
* and agree to abide by those obligations.
|
|
*
|
|
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
|
|
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
|
|
* COMPLETENESS OR PERFORMANCE.
|
|
* $/LicenseInfo$
|
|
*/
|
|
|
|
#include "linden_common.h"
|
|
|
|
#include "llxuiparser.h"
|
|
|
|
#include "llxmlnode.h"
|
|
#include <fstream>
|
|
#include <boost/tokenizer.hpp>
|
|
|
|
#include "lluicolor.h"
|
|
|
|
const S32 MAX_STRING_ATTRIBUTE_SIZE = 40;
|
|
|
|
//
|
|
// LLXSDWriter
|
|
//
|
|
LLXSDWriter::LLXSDWriter()
|
|
{
|
|
registerInspectFunc<bool>(boost::bind(&LLXSDWriter::writeAttribute, this, "xs:boolean", _1, _2, _3, _4));
|
|
registerInspectFunc<std::string>(boost::bind(&LLXSDWriter::writeAttribute, this, "xs:string", _1, _2, _3, _4));
|
|
registerInspectFunc<U8>(boost::bind(&LLXSDWriter::writeAttribute, this, "xs:unsignedByte", _1, _2, _3, _4));
|
|
registerInspectFunc<S8>(boost::bind(&LLXSDWriter::writeAttribute, this, "xs:signedByte", _1, _2, _3, _4));
|
|
registerInspectFunc<U16>(boost::bind(&LLXSDWriter::writeAttribute, this, "xs:unsignedShort", _1, _2, _3, _4));
|
|
registerInspectFunc<S16>(boost::bind(&LLXSDWriter::writeAttribute, this, "xs:signedShort", _1, _2, _3, _4));
|
|
registerInspectFunc<U32>(boost::bind(&LLXSDWriter::writeAttribute, this, "xs:unsignedInt", _1, _2, _3, _4));
|
|
registerInspectFunc<S32>(boost::bind(&LLXSDWriter::writeAttribute, this, "xs:integer", _1, _2, _3, _4));
|
|
registerInspectFunc<F32>(boost::bind(&LLXSDWriter::writeAttribute, this, "xs:float", _1, _2, _3, _4));
|
|
registerInspectFunc<F64>(boost::bind(&LLXSDWriter::writeAttribute, this, "xs:double", _1, _2, _3, _4));
|
|
registerInspectFunc<LLColor4>(boost::bind(&LLXSDWriter::writeAttribute, this, "xs:string", _1, _2, _3, _4));
|
|
registerInspectFunc<LLUIColor>(boost::bind(&LLXSDWriter::writeAttribute, this, "xs:string", _1, _2, _3, _4));
|
|
registerInspectFunc<LLUUID>(boost::bind(&LLXSDWriter::writeAttribute, this, "xs:string", _1, _2, _3, _4));
|
|
registerInspectFunc<LLSD>(boost::bind(&LLXSDWriter::writeAttribute, this, "xs:string", _1, _2, _3, _4));
|
|
}
|
|
|
|
void LLXSDWriter::writeXSD(const std::string& type_name, LLXMLNodePtr node, const LLInitParam::BaseBlock& block, const std::string& xml_namespace)
|
|
{
|
|
mSchemaNode = node;
|
|
node->setName("xs:schema");
|
|
node->createChild("attributeFormDefault", true)->setStringValue("unqualified");
|
|
node->createChild("elementFormDefault", true)->setStringValue("qualified");
|
|
node->createChild("targetNamespace", true)->setStringValue(xml_namespace);
|
|
node->createChild("xmlns:xs", true)->setStringValue("http://www.w3.org/2001/XMLSchema");
|
|
node->createChild("xmlns", true)->setStringValue(xml_namespace);
|
|
|
|
node = node->createChild("xs:complexType", false);
|
|
node->createChild("name", true)->setStringValue(type_name);
|
|
node->createChild("mixed", true)->setStringValue("true");
|
|
|
|
mAttributeNode = node;
|
|
mElementNode = node->createChild("xs:choice", false);
|
|
mElementNode->createChild("minOccurs", true)->setStringValue("0");
|
|
mElementNode->createChild("maxOccurs", true)->setStringValue("unbounded");
|
|
block.inspectBlock(*this);
|
|
|
|
// duplicate element choices
|
|
LLXMLNodeList children;
|
|
mElementNode->getChildren("xs:element", children, FALSE);
|
|
for (LLXMLNodeList::iterator child_it = children.begin(); child_it != children.end(); ++child_it)
|
|
{
|
|
LLXMLNodePtr child_copy = child_it->second->deepCopy();
|
|
std::string child_name;
|
|
child_copy->getAttributeString("name", child_name);
|
|
child_copy->setAttributeString("name", type_name + "." + child_name);
|
|
mElementNode->addChild(child_copy);
|
|
}
|
|
|
|
LLXMLNodePtr element_declaration_node = mSchemaNode->createChild("xs:element", false);
|
|
element_declaration_node->createChild("name", true)->setStringValue(type_name);
|
|
element_declaration_node->createChild("type", true)->setStringValue(type_name);
|
|
}
|
|
|
|
void LLXSDWriter::writeAttribute(const std::string& type, const Parser::name_stack_t& stack, S32 min_count, S32 max_count, const std::vector<std::string>* possible_values)
|
|
{
|
|
name_stack_t non_empty_names;
|
|
std::string attribute_name;
|
|
for (name_stack_t::const_iterator it = stack.begin();
|
|
it != stack.end();
|
|
++it)
|
|
{
|
|
const std::string& name = it->first;
|
|
if (!name.empty())
|
|
{
|
|
non_empty_names.push_back(*it);
|
|
}
|
|
}
|
|
|
|
for (name_stack_t::const_iterator it = non_empty_names.begin();
|
|
it != non_empty_names.end();
|
|
++it)
|
|
{
|
|
if (!attribute_name.empty())
|
|
{
|
|
attribute_name += ".";
|
|
}
|
|
attribute_name += it->first;
|
|
}
|
|
|
|
// only flag non-nested attributes as mandatory, nested attributes have variant syntax
|
|
// that can't be properly constrained in XSD
|
|
// e.g. <foo mandatory.value="bar"/> vs <foo><mandatory value="bar"/></foo>
|
|
bool attribute_mandatory = min_count == 1 && max_count == 1 && non_empty_names.size() == 1;
|
|
|
|
// don't bother supporting "Multiple" params as xml attributes
|
|
if (max_count <= 1)
|
|
{
|
|
// add compound attribute to root node
|
|
addAttributeToSchema(mAttributeNode, attribute_name, type, attribute_mandatory, possible_values);
|
|
}
|
|
|
|
// now generated nested elements for compound attributes
|
|
if (non_empty_names.size() > 1 && !attribute_mandatory)
|
|
{
|
|
std::string element_name;
|
|
|
|
// traverse all but last element, leaving that as an attribute name
|
|
name_stack_t::const_iterator end_it = non_empty_names.end();
|
|
end_it--;
|
|
|
|
for (name_stack_t::const_iterator it = non_empty_names.begin();
|
|
it != end_it;
|
|
++it)
|
|
{
|
|
if (it != non_empty_names.begin())
|
|
{
|
|
element_name += ".";
|
|
}
|
|
element_name += it->first;
|
|
}
|
|
|
|
std::string short_attribute_name = non_empty_names.back().first;
|
|
|
|
LLXMLNodePtr complex_type_node;
|
|
|
|
// find existing element node here, starting at tail of child list
|
|
if (mElementNode->mChildren.notNull())
|
|
{
|
|
for(LLXMLNodePtr element = mElementNode->mChildren->tail;
|
|
element.notNull();
|
|
element = element->mPrev)
|
|
{
|
|
std::string name;
|
|
if(element->getAttributeString("name", name) && name == element_name)
|
|
{
|
|
complex_type_node = element->mChildren->head;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
//create complex_type node
|
|
//
|
|
//<xs:element
|
|
// maxOccurs="1"
|
|
// minOccurs="0"
|
|
// name="name">
|
|
// <xs:complexType>
|
|
// </xs:complexType>
|
|
//</xs:element>
|
|
if(complex_type_node.isNull())
|
|
{
|
|
complex_type_node = mElementNode->createChild("xs:element", false);
|
|
|
|
complex_type_node->createChild("minOccurs", true)->setIntValue(min_count);
|
|
complex_type_node->createChild("maxOccurs", true)->setIntValue(max_count);
|
|
complex_type_node->createChild("name", true)->setStringValue(element_name);
|
|
complex_type_node = complex_type_node->createChild("xs:complexType", false);
|
|
}
|
|
|
|
addAttributeToSchema(complex_type_node, short_attribute_name, type, false, possible_values);
|
|
}
|
|
}
|
|
|
|
void LLXSDWriter::addAttributeToSchema(LLXMLNodePtr type_declaration_node, const std::string& attribute_name, const std::string& type, bool mandatory, const std::vector<std::string>* possible_values)
|
|
{
|
|
if (!attribute_name.empty())
|
|
{
|
|
LLXMLNodePtr new_enum_type_node;
|
|
if (possible_values != NULL)
|
|
{
|
|
// custom attribute type, for example
|
|
//<xs:simpleType>
|
|
// <xs:restriction
|
|
// base="xs:string">
|
|
// <xs:enumeration
|
|
// value="a" />
|
|
// <xs:enumeration
|
|
// value="b" />
|
|
// </xs:restriction>
|
|
// </xs:simpleType>
|
|
new_enum_type_node = new LLXMLNode("xs:simpleType", false);
|
|
|
|
LLXMLNodePtr restriction_node = new_enum_type_node->createChild("xs:restriction", false);
|
|
restriction_node->createChild("base", true)->setStringValue("xs:string");
|
|
|
|
for (std::vector<std::string>::const_iterator it = possible_values->begin();
|
|
it != possible_values->end();
|
|
++it)
|
|
{
|
|
LLXMLNodePtr enum_node = restriction_node->createChild("xs:enumeration", false);
|
|
enum_node->createChild("value", true)->setStringValue(*it);
|
|
}
|
|
}
|
|
|
|
string_set_t& attributes_written = mAttributesWritten[type_declaration_node];
|
|
|
|
string_set_t::iterator found_it = attributes_written.lower_bound(attribute_name);
|
|
|
|
// attribute not yet declared
|
|
if (found_it == attributes_written.end() || attributes_written.key_comp()(attribute_name, *found_it))
|
|
{
|
|
attributes_written.insert(found_it, attribute_name);
|
|
|
|
LLXMLNodePtr attribute_node = type_declaration_node->createChild("xs:attribute", false);
|
|
|
|
// attribute name
|
|
attribute_node->createChild("name", true)->setStringValue(attribute_name);
|
|
|
|
if (new_enum_type_node.notNull())
|
|
{
|
|
attribute_node->addChild(new_enum_type_node);
|
|
}
|
|
else
|
|
{
|
|
// simple attribute type
|
|
attribute_node->createChild("type", true)->setStringValue(type);
|
|
}
|
|
|
|
// required or optional
|
|
attribute_node->createChild("use", true)->setStringValue(mandatory ? "required" : "optional");
|
|
}
|
|
// attribute exists...handle collision of same name attributes with potentially different types
|
|
else
|
|
{
|
|
LLXMLNodePtr attribute_declaration;
|
|
if (type_declaration_node.notNull())
|
|
{
|
|
for(LLXMLNodePtr node = type_declaration_node->mChildren->tail;
|
|
node.notNull();
|
|
node = node->mPrev)
|
|
{
|
|
std::string name;
|
|
if (node->getAttributeString("name", name) && name == attribute_name)
|
|
{
|
|
attribute_declaration = node;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool new_type_is_enum = new_enum_type_node.notNull();
|
|
bool existing_type_is_enum = !attribute_declaration->hasAttribute("type");
|
|
|
|
// either type is enum, revert to string in collision
|
|
// don't bother to check for enum equivalence
|
|
if (new_type_is_enum || existing_type_is_enum)
|
|
{
|
|
if (attribute_declaration->hasAttribute("type"))
|
|
{
|
|
attribute_declaration->setAttributeString("type", "xs:string");
|
|
}
|
|
else
|
|
{
|
|
attribute_declaration->createChild("type", true)->setStringValue("xs:string");
|
|
}
|
|
attribute_declaration->deleteChildren("xs:simpleType");
|
|
}
|
|
else
|
|
{
|
|
// check for collision of different standard types
|
|
std::string existing_type;
|
|
attribute_declaration->getAttributeString("type", existing_type);
|
|
// if current type is not the same as the new type, revert to strnig
|
|
if (existing_type != type)
|
|
{
|
|
// ...than use most general type, string
|
|
attribute_declaration->setAttributeString("type", "string");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// LLXUIXSDWriter
|
|
//
|
|
void LLXUIXSDWriter::writeXSD(const std::string& type_name, const std::string& path, const LLInitParam::BaseBlock& block)
|
|
{
|
|
std::string file_name(path);
|
|
file_name += type_name + ".xsd";
|
|
LLXMLNodePtr root_nodep = new LLXMLNode();
|
|
|
|
LLXSDWriter::writeXSD(type_name, root_nodep, block, "http://www.lindenlab.com/xui");
|
|
|
|
// add includes for all possible children
|
|
const std::type_info* type = *LLWidgetTypeRegistry::instance().getValue(type_name);
|
|
const widget_registry_t* widget_registryp = LLChildRegistryRegistry::instance().getValue(type);
|
|
|
|
// add choices for valid children
|
|
if (widget_registryp)
|
|
{
|
|
// add include declarations for all valid children
|
|
for (widget_registry_t::Registrar::registry_map_t::const_iterator it = widget_registryp->currentRegistrar().beginItems();
|
|
it != widget_registryp->currentRegistrar().endItems();
|
|
++it)
|
|
{
|
|
std::string widget_name = it->first;
|
|
if (widget_name == type_name)
|
|
{
|
|
continue;
|
|
}
|
|
LLXMLNodePtr nodep = new LLXMLNode("xs:include", false);
|
|
nodep->createChild("schemaLocation", true)->setStringValue(widget_name + ".xsd");
|
|
|
|
// add to front of schema
|
|
mSchemaNode->addChild(nodep, mSchemaNode);
|
|
}
|
|
|
|
for (widget_registry_t::Registrar::registry_map_t::const_iterator it = widget_registryp->currentRegistrar().beginItems();
|
|
it != widget_registryp->currentRegistrar().endItems();
|
|
++it)
|
|
{
|
|
std::string widget_name = it->first;
|
|
//<xs:element name="widget_name" type="widget_name">
|
|
LLXMLNodePtr widget_node = mElementNode->createChild("xs:element", false);
|
|
widget_node->createChild("name", true)->setStringValue(widget_name);
|
|
widget_node->createChild("type", true)->setStringValue(widget_name);
|
|
}
|
|
}
|
|
|
|
LLFILE* xsd_file = LLFile::fopen(file_name.c_str(), "w");
|
|
LLXMLNode::writeHeaderToFile(xsd_file);
|
|
root_nodep->writeToFile(xsd_file);
|
|
fclose(xsd_file);
|
|
}
|
|
|
|
//
|
|
// LLXUIParser
|
|
//
|
|
LLXUIParser::LLXUIParser()
|
|
: mLastWriteGeneration(-1),
|
|
mCurReadDepth(0)
|
|
{
|
|
registerParserFuncs<bool>(boost::bind(&LLXUIParser::readBoolValue, this, _1),
|
|
boost::bind(&LLXUIParser::writeBoolValue, this, _1, _2));
|
|
registerParserFuncs<std::string>(boost::bind(&LLXUIParser::readStringValue, this, _1),
|
|
boost::bind(&LLXUIParser::writeStringValue, this, _1, _2));
|
|
registerParserFuncs<U8>(boost::bind(&LLXUIParser::readU8Value, this, _1),
|
|
boost::bind(&LLXUIParser::writeU8Value, this, _1, _2));
|
|
registerParserFuncs<S8>(boost::bind(&LLXUIParser::readS8Value, this, _1),
|
|
boost::bind(&LLXUIParser::writeS8Value, this, _1, _2));
|
|
registerParserFuncs<U16>(boost::bind(&LLXUIParser::readU16Value, this, _1),
|
|
boost::bind(&LLXUIParser::writeU16Value, this, _1, _2));
|
|
registerParserFuncs<S16>(boost::bind(&LLXUIParser::readS16Value, this, _1),
|
|
boost::bind(&LLXUIParser::writeS16Value, this, _1, _2));
|
|
registerParserFuncs<U32>(boost::bind(&LLXUIParser::readU32Value, this, _1),
|
|
boost::bind(&LLXUIParser::writeU32Value, this, _1, _2));
|
|
registerParserFuncs<S32>(boost::bind(&LLXUIParser::readS32Value, this, _1),
|
|
boost::bind(&LLXUIParser::writeS32Value, this, _1, _2));
|
|
registerParserFuncs<F32>(boost::bind(&LLXUIParser::readF32Value, this, _1),
|
|
boost::bind(&LLXUIParser::writeF32Value, this, _1, _2));
|
|
registerParserFuncs<F64>(boost::bind(&LLXUIParser::readF64Value, this, _1),
|
|
boost::bind(&LLXUIParser::writeF64Value, this, _1, _2));
|
|
registerParserFuncs<LLColor4>(boost::bind(&LLXUIParser::readColor4Value, this, _1),
|
|
boost::bind(&LLXUIParser::writeColor4Value, this, _1, _2));
|
|
registerParserFuncs<LLUIColor>(boost::bind(&LLXUIParser::readUIColorValue, this, _1),
|
|
boost::bind(&LLXUIParser::writeUIColorValue, this, _1, _2));
|
|
registerParserFuncs<LLUUID>(boost::bind(&LLXUIParser::readUUIDValue, this, _1),
|
|
boost::bind(&LLXUIParser::writeUUIDValue, this, _1, _2));
|
|
registerParserFuncs<LLSD>(boost::bind(&LLXUIParser::readSDValue, this, _1),
|
|
boost::bind(&LLXUIParser::writeSDValue, this, _1, _2));
|
|
}
|
|
|
|
static LLFastTimer::DeclareTimer FTM_PARSE_XUI("XUI Parsing");
|
|
|
|
void LLXUIParser::readXUI(LLXMLNodePtr node, LLInitParam::BaseBlock& block, const std::string& filename, bool silent)
|
|
{
|
|
LLFastTimer timer(FTM_PARSE_XUI);
|
|
mNameStack.clear();
|
|
mCurFileName = filename;
|
|
mCurReadDepth = 0;
|
|
setParseSilently(silent);
|
|
|
|
if (node.isNull())
|
|
{
|
|
parserWarning("Invalid node");
|
|
}
|
|
else
|
|
{
|
|
readXUIImpl(node, std::string(node->getName()->mString), block);
|
|
}
|
|
}
|
|
|
|
bool LLXUIParser::readXUIImpl(LLXMLNodePtr nodep, const std::string& scope, LLInitParam::BaseBlock& block)
|
|
{
|
|
typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
|
|
boost::char_separator<char> sep(".");
|
|
|
|
bool values_parsed = false;
|
|
|
|
// submit attributes for current node
|
|
values_parsed |= readAttributes(nodep, block);
|
|
|
|
// treat text contents of xml node as "value" parameter
|
|
std::string text_contents = nodep->getSanitizedValue();
|
|
if (!text_contents.empty())
|
|
{
|
|
mCurReadNode = nodep;
|
|
mNameStack.push_back(std::make_pair(std::string("value"), newParseGeneration()));
|
|
// child nodes are not necessarily valid parameters (could be a child widget)
|
|
// so don't complain once we've recursed
|
|
bool silent = mCurReadDepth > 0;
|
|
if (!block.submitValue(mNameStack, *this, true))
|
|
{
|
|
mNameStack.pop_back();
|
|
block.submitValue(mNameStack, *this, silent);
|
|
}
|
|
else
|
|
{
|
|
mNameStack.pop_back();
|
|
}
|
|
}
|
|
|
|
// then traverse children
|
|
// child node must start with last name of parent node (our "scope")
|
|
// for example: "<button><button.param nested_param1="foo"><param.nested_param2 nested_param3="bar"/></button.param></button>"
|
|
// which equates to the following nesting:
|
|
// button
|
|
// param
|
|
// nested_param1
|
|
// nested_param2
|
|
// nested_param3
|
|
mCurReadDepth++;
|
|
for(LLXMLNodePtr childp = nodep->getFirstChild(); childp.notNull();)
|
|
{
|
|
std::string child_name(childp->getName()->mString);
|
|
S32 num_tokens_pushed = 0;
|
|
|
|
// for non "dotted" child nodes check to see if child node maps to another widget type
|
|
// and if not, treat as a child element of the current node
|
|
// e.g. <button><rect left="10"/></button> will interpret <rect> as "button.rect"
|
|
// since there is no widget named "rect"
|
|
if (child_name.find(".") == std::string::npos)
|
|
{
|
|
mNameStack.push_back(std::make_pair(child_name, newParseGeneration()));
|
|
num_tokens_pushed++;
|
|
}
|
|
else
|
|
{
|
|
// parse out "dotted" name into individual tokens
|
|
tokenizer name_tokens(child_name, sep);
|
|
|
|
tokenizer::iterator name_token_it = name_tokens.begin();
|
|
if(name_token_it == name_tokens.end())
|
|
{
|
|
childp = childp->getNextSibling();
|
|
continue;
|
|
}
|
|
|
|
// check for proper nesting
|
|
if(!scope.empty() && *name_token_it != scope)
|
|
{
|
|
childp = childp->getNextSibling();
|
|
continue;
|
|
}
|
|
|
|
// now ignore first token
|
|
++name_token_it;
|
|
|
|
// copy remaining tokens on to our running token list
|
|
for(tokenizer::iterator token_to_push = name_token_it; token_to_push != name_tokens.end(); ++token_to_push)
|
|
{
|
|
mNameStack.push_back(std::make_pair(*token_to_push, newParseGeneration()));
|
|
num_tokens_pushed++;
|
|
}
|
|
}
|
|
|
|
// recurse and visit children XML nodes
|
|
if(readXUIImpl(childp, mNameStack.empty() ? scope : mNameStack.back().first, block))
|
|
{
|
|
// child node successfully parsed, remove from DOM
|
|
|
|
values_parsed = true;
|
|
LLXMLNodePtr node_to_remove = childp;
|
|
childp = childp->getNextSibling();
|
|
|
|
nodep->deleteChild(node_to_remove);
|
|
}
|
|
else
|
|
{
|
|
childp = childp->getNextSibling();
|
|
}
|
|
|
|
while(num_tokens_pushed-- > 0)
|
|
{
|
|
mNameStack.pop_back();
|
|
}
|
|
}
|
|
mCurReadDepth--;
|
|
return values_parsed;
|
|
}
|
|
|
|
bool LLXUIParser::readAttributes(LLXMLNodePtr nodep, LLInitParam::BaseBlock& block)
|
|
{
|
|
typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
|
|
boost::char_separator<char> sep(".");
|
|
|
|
bool any_parsed = false;
|
|
|
|
for(LLXMLAttribList::const_iterator attribute_it = nodep->mAttributes.begin();
|
|
attribute_it != nodep->mAttributes.end();
|
|
++attribute_it)
|
|
{
|
|
S32 num_tokens_pushed = 0;
|
|
std::string attribute_name(attribute_it->first->mString);
|
|
mCurReadNode = attribute_it->second;
|
|
|
|
tokenizer name_tokens(attribute_name, sep);
|
|
// copy remaining tokens on to our running token list
|
|
for(tokenizer::iterator token_to_push = name_tokens.begin(); token_to_push != name_tokens.end(); ++token_to_push)
|
|
{
|
|
mNameStack.push_back(std::make_pair(*token_to_push, newParseGeneration()));
|
|
num_tokens_pushed++;
|
|
}
|
|
|
|
// child nodes are not necessarily valid attributes, so don't complain once we've recursed
|
|
bool silent = mCurReadDepth > 0;
|
|
any_parsed |= block.submitValue(mNameStack, *this, silent);
|
|
|
|
while(num_tokens_pushed-- > 0)
|
|
{
|
|
mNameStack.pop_back();
|
|
}
|
|
}
|
|
|
|
return any_parsed;
|
|
}
|
|
|
|
void LLXUIParser::writeXUI(LLXMLNodePtr node, const LLInitParam::BaseBlock &block, const LLInitParam::BaseBlock* diff_block)
|
|
{
|
|
mWriteRootNode = node;
|
|
block.serializeBlock(*this, Parser::name_stack_t(), diff_block);
|
|
mOutNodes.clear();
|
|
}
|
|
|
|
// go from a stack of names to a specific XML node
|
|
LLXMLNodePtr LLXUIParser::getNode(const name_stack_t& stack)
|
|
{
|
|
name_stack_t name_stack;
|
|
for (name_stack_t::const_iterator it = stack.begin();
|
|
it != stack.end();
|
|
++it)
|
|
{
|
|
if (!it->first.empty())
|
|
{
|
|
name_stack.push_back(*it);
|
|
}
|
|
}
|
|
|
|
LLXMLNodePtr out_node = mWriteRootNode;
|
|
|
|
name_stack_t::const_iterator next_it = name_stack.begin();
|
|
for (name_stack_t::const_iterator it = name_stack.begin();
|
|
it != name_stack.end();
|
|
it = next_it)
|
|
{
|
|
++next_it;
|
|
if (it->first.empty())
|
|
{
|
|
continue;
|
|
}
|
|
|
|
out_nodes_t::iterator found_it = mOutNodes.lower_bound(it->second);
|
|
|
|
// node with this name not yet written
|
|
if (found_it == mOutNodes.end() || mOutNodes.key_comp()(found_it->first, it->second))
|
|
{
|
|
// make an attribute if we are the last element on the name stack
|
|
bool is_attribute = next_it == name_stack.end();
|
|
LLXMLNodePtr new_node = new LLXMLNode(it->first.c_str(), is_attribute);
|
|
out_node->addChild(new_node);
|
|
mOutNodes.insert(found_it, std::make_pair(it->second, new_node));
|
|
out_node = new_node;
|
|
}
|
|
else
|
|
{
|
|
out_node = found_it->second;
|
|
}
|
|
}
|
|
|
|
return (out_node == mWriteRootNode ? LLXMLNodePtr(NULL) : out_node);
|
|
}
|
|
|
|
|
|
bool LLXUIParser::readBoolValue(void* val_ptr)
|
|
{
|
|
S32 value;
|
|
bool success = mCurReadNode->getBoolValue(1, &value);
|
|
*((bool*)val_ptr) = (value != FALSE);
|
|
return success;
|
|
}
|
|
|
|
bool LLXUIParser::writeBoolValue(const void* val_ptr, const name_stack_t& stack)
|
|
{
|
|
LLXMLNodePtr node = getNode(stack);
|
|
if (node.notNull())
|
|
{
|
|
node->setBoolValue(*((bool*)val_ptr));
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool LLXUIParser::readStringValue(void* val_ptr)
|
|
{
|
|
*((std::string*)val_ptr) = mCurReadNode->getSanitizedValue();
|
|
return true;
|
|
}
|
|
|
|
bool LLXUIParser::writeStringValue(const void* val_ptr, const name_stack_t& stack)
|
|
{
|
|
LLXMLNodePtr node = getNode(stack);
|
|
if (node.notNull())
|
|
{
|
|
const std::string* string_val = reinterpret_cast<const std::string*>(val_ptr);
|
|
if (string_val->find('\n') != std::string::npos
|
|
|| string_val->size() > MAX_STRING_ATTRIBUTE_SIZE)
|
|
{
|
|
// don't write strings with newlines into attributes
|
|
std::string attribute_name = node->getName()->mString;
|
|
LLXMLNodePtr parent_node = node->mParent;
|
|
parent_node->deleteChild(node);
|
|
// write results in text contents of node
|
|
if (attribute_name == "value")
|
|
{
|
|
// "value" is implicit, just write to parent
|
|
node = parent_node;
|
|
}
|
|
else
|
|
{
|
|
// create a child that is not an attribute, but with same name
|
|
node = parent_node->createChild(attribute_name.c_str(), false);
|
|
}
|
|
}
|
|
node->setStringValue(*string_val);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool LLXUIParser::readU8Value(void* val_ptr)
|
|
{
|
|
return mCurReadNode->getByteValue(1, (U8*)val_ptr);
|
|
}
|
|
|
|
bool LLXUIParser::writeU8Value(const void* val_ptr, const name_stack_t& stack)
|
|
{
|
|
LLXMLNodePtr node = getNode(stack);
|
|
if (node.notNull())
|
|
{
|
|
node->setUnsignedValue(*((U8*)val_ptr));
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool LLXUIParser::readS8Value(void* val_ptr)
|
|
{
|
|
S32 value;
|
|
if(mCurReadNode->getIntValue(1, &value))
|
|
{
|
|
*((S8*)val_ptr) = value;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool LLXUIParser::writeS8Value(const void* val_ptr, const name_stack_t& stack)
|
|
{
|
|
LLXMLNodePtr node = getNode(stack);
|
|
if (node.notNull())
|
|
{
|
|
node->setIntValue(*((S8*)val_ptr));
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool LLXUIParser::readU16Value(void* val_ptr)
|
|
{
|
|
U32 value;
|
|
if(mCurReadNode->getUnsignedValue(1, &value))
|
|
{
|
|
*((U16*)val_ptr) = value;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool LLXUIParser::writeU16Value(const void* val_ptr, const name_stack_t& stack)
|
|
{
|
|
LLXMLNodePtr node = getNode(stack);
|
|
if (node.notNull())
|
|
{
|
|
node->setUnsignedValue(*((U16*)val_ptr));
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool LLXUIParser::readS16Value(void* val_ptr)
|
|
{
|
|
S32 value;
|
|
if(mCurReadNode->getIntValue(1, &value))
|
|
{
|
|
*((S16*)val_ptr) = value;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool LLXUIParser::writeS16Value(const void* val_ptr, const name_stack_t& stack)
|
|
{
|
|
LLXMLNodePtr node = getNode(stack);
|
|
if (node.notNull())
|
|
{
|
|
node->setIntValue(*((S16*)val_ptr));
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool LLXUIParser::readU32Value(void* val_ptr)
|
|
{
|
|
return mCurReadNode->getUnsignedValue(1, (U32*)val_ptr);
|
|
}
|
|
|
|
bool LLXUIParser::writeU32Value(const void* val_ptr, const name_stack_t& stack)
|
|
{
|
|
LLXMLNodePtr node = getNode(stack);
|
|
if (node.notNull())
|
|
{
|
|
node->setUnsignedValue(*((U32*)val_ptr));
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool LLXUIParser::readS32Value(void* val_ptr)
|
|
{
|
|
return mCurReadNode->getIntValue(1, (S32*)val_ptr);
|
|
}
|
|
|
|
bool LLXUIParser::writeS32Value(const void* val_ptr, const name_stack_t& stack)
|
|
{
|
|
LLXMLNodePtr node = getNode(stack);
|
|
if (node.notNull())
|
|
{
|
|
node->setIntValue(*((S32*)val_ptr));
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool LLXUIParser::readF32Value(void* val_ptr)
|
|
{
|
|
return mCurReadNode->getFloatValue(1, (F32*)val_ptr);
|
|
}
|
|
|
|
bool LLXUIParser::writeF32Value(const void* val_ptr, const name_stack_t& stack)
|
|
{
|
|
LLXMLNodePtr node = getNode(stack);
|
|
if (node.notNull())
|
|
{
|
|
node->setFloatValue(*((F32*)val_ptr));
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool LLXUIParser::readF64Value(void* val_ptr)
|
|
{
|
|
return mCurReadNode->getDoubleValue(1, (F64*)val_ptr);
|
|
}
|
|
|
|
bool LLXUIParser::writeF64Value(const void* val_ptr, const name_stack_t& stack)
|
|
{
|
|
LLXMLNodePtr node = getNode(stack);
|
|
if (node.notNull())
|
|
{
|
|
node->setDoubleValue(*((F64*)val_ptr));
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool LLXUIParser::readColor4Value(void* val_ptr)
|
|
{
|
|
LLColor4* colorp = (LLColor4*)val_ptr;
|
|
if(mCurReadNode->getFloatValue(4, colorp->mV) >= 3)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool LLXUIParser::writeColor4Value(const void* val_ptr, const name_stack_t& stack)
|
|
{
|
|
LLXMLNodePtr node = getNode(stack);
|
|
if (node.notNull())
|
|
{
|
|
LLColor4 color = *((LLColor4*)val_ptr);
|
|
node->setFloatValue(4, color.mV);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool LLXUIParser::readUIColorValue(void* val_ptr)
|
|
{
|
|
LLUIColor* param = (LLUIColor*)val_ptr;
|
|
LLColor4 color;
|
|
bool success = mCurReadNode->getFloatValue(4, color.mV) >= 3;
|
|
if (success)
|
|
{
|
|
param->set(color);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool LLXUIParser::writeUIColorValue(const void* val_ptr, const name_stack_t& stack)
|
|
{
|
|
LLXMLNodePtr node = getNode(stack);
|
|
if (node.notNull())
|
|
{
|
|
LLUIColor color = *((LLUIColor*)val_ptr);
|
|
//RN: don't write out the color that is represented by a function
|
|
// rely on param block exporting to get the reference to the color settings
|
|
if (color.isReference()) return false;
|
|
node->setFloatValue(4, color.get().mV);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool LLXUIParser::readUUIDValue(void* val_ptr)
|
|
{
|
|
LLUUID temp_id;
|
|
// LLUUID::set is destructive, so use temporary value
|
|
if (temp_id.set(mCurReadNode->getSanitizedValue()))
|
|
{
|
|
*(LLUUID*)(val_ptr) = temp_id;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool LLXUIParser::writeUUIDValue(const void* val_ptr, const name_stack_t& stack)
|
|
{
|
|
LLXMLNodePtr node = getNode(stack);
|
|
if (node.notNull())
|
|
{
|
|
node->setStringValue(((LLUUID*)val_ptr)->asString());
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool LLXUIParser::readSDValue(void* val_ptr)
|
|
{
|
|
*((LLSD*)val_ptr) = LLSD(mCurReadNode->getSanitizedValue());
|
|
return true;
|
|
}
|
|
|
|
bool LLXUIParser::writeSDValue(const void* val_ptr, const name_stack_t& stack)
|
|
{
|
|
LLXMLNodePtr node = getNode(stack);
|
|
if (node.notNull())
|
|
{
|
|
std::string string_val = ((LLSD*)val_ptr)->asString();
|
|
if (string_val.find('\n') != std::string::npos || string_val.size() > MAX_STRING_ATTRIBUTE_SIZE)
|
|
{
|
|
// don't write strings with newlines into attributes
|
|
std::string attribute_name = node->getName()->mString;
|
|
LLXMLNodePtr parent_node = node->mParent;
|
|
parent_node->deleteChild(node);
|
|
// write results in text contents of node
|
|
if (attribute_name == "value")
|
|
{
|
|
// "value" is implicit, just write to parent
|
|
node = parent_node;
|
|
}
|
|
else
|
|
{
|
|
node = parent_node->createChild(attribute_name.c_str(), false);
|
|
}
|
|
}
|
|
|
|
node->setStringValue(string_val);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/*virtual*/ std::string LLXUIParser::getCurrentElementName()
|
|
{
|
|
std::string full_name;
|
|
for (name_stack_t::iterator it = mNameStack.begin();
|
|
it != mNameStack.end();
|
|
++it)
|
|
{
|
|
full_name += it->first + "."; // build up dotted names: "button.param.nestedparam."
|
|
}
|
|
|
|
return full_name;
|
|
}
|
|
|
|
void LLXUIParser::parserWarning(const std::string& message)
|
|
{
|
|
#ifdef LL_WINDOWS
|
|
// use Visual Studo friendly formatting of output message for easy access to originating xml
|
|
llutf16string utf16str = utf8str_to_utf16str(llformat("%s(%d):\t%s", mCurFileName.c_str(), mCurReadNode->getLineNumber(), message.c_str()).c_str());
|
|
utf16str += '\n';
|
|
OutputDebugString(utf16str.c_str());
|
|
#else
|
|
Parser::parserWarning(message);
|
|
#endif
|
|
}
|
|
|
|
void LLXUIParser::parserError(const std::string& message)
|
|
{
|
|
#ifdef LL_WINDOWS
|
|
llutf16string utf16str = utf8str_to_utf16str(llformat("%s(%d):\t%s", mCurFileName.c_str(), mCurReadNode->getLineNumber(), message.c_str()).c_str());
|
|
utf16str += '\n';
|
|
OutputDebugString(utf16str.c_str());
|
|
#else
|
|
Parser::parserError(message);
|
|
#endif
|
|
}
|