strepsirrhini/office-gobmx
9
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
office-gobmx/configmgr/source/xcuparser.cxx
Sebastian Spaeth 8694d2bc19 Add vim/emacs modelines to all source files 
Fixes #fdo30794
Based on bin/add-modelines script (originally posted in mail
1286706307.1871.1399280959@webmail.messagingengine.com)

Signed-off-by: Sebastian Spaeth <Sebastian@SSpaeth.de>
2010-10-13 10:57:58 +02:00

1128 lines
42 KiB
C++
Raw Blame History

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*************************************************************************
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* Copyright 2000, 2010 Oracle and/or its affiliates.
*
* OpenOffice.org - a multi-platform office productivity suite
*
* This file is part of OpenOffice.org.
*
* OpenOffice.org is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License version 3
* only, as published by the Free Software Foundation.
*
* OpenOffice.org 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 version 3 for more details
* (a copy is included in the LICENSE file that accompanied this code).
*
* You should have received a copy of the GNU Lesser General Public License
* version 3 along with OpenOffice.org. If not, see
* <http://www.openoffice.org/license.html>
* for a copy of the LGPLv3 License.
*
************************************************************************/
#include "precompiled_configmgr.hxx"
#include "sal/config.h"
#include <algorithm>
#include "com/sun/star/uno/Any.hxx"
#include "com/sun/star/uno/Reference.hxx"
#include "com/sun/star/uno/RuntimeException.hpp"
#include "com/sun/star/uno/XInterface.hpp"
#include "osl/diagnose.h"
#include "rtl/ref.hxx"
#include "rtl/strbuf.hxx"
#include "rtl/string.h"
#include "rtl/string.hxx"
#include "rtl/ustring.h"
#include "rtl/ustring.hxx"
#include "data.hxx"
#include "localizedpropertynode.hxx"
#include "localizedvaluenode.hxx"
#include "groupnode.hxx"
#include "modifications.hxx"
#include "node.hxx"
#include "nodemap.hxx"
#include "partial.hxx"
#include "path.hxx"
#include "propertynode.hxx"
#include "setnode.hxx"
#include "span.hxx"
#include "xcuparser.hxx"
#include "xmldata.hxx"
#include "xmlreader.hxx"
namespace configmgr {
namespace {
namespace css = com::sun::star;
}
XcuParser::XcuParser(
int layer, Data & data, Partial const * partial,
Modifications * broadcastModifications, Additions * additions):
valueParser_(layer), data_(data),
partial_(partial), broadcastModifications_(broadcastModifications),
additions_(additions), recordModifications_(layer == Data::NO_LAYER),
trackPath_(
partial_ != 0 || broadcastModifications_ != 0 || additions_ != 0 ||
recordModifications_)
{}
XcuParser::~XcuParser() {}
XmlReader::Text XcuParser::getTextMode() {
return valueParser_.getTextMode();
}
bool XcuParser::startElement(
XmlReader & reader, XmlReader::Namespace ns, Span const & name)
{
if (valueParser_.startElement(reader, ns, name)) {
return true;
}
if (state_.empty()) {
if (ns == XmlReader::NAMESPACE_OOR &&
name.equals(RTL_CONSTASCII_STRINGPARAM("component-data")))
{
handleComponentData(reader);
} else if (ns == XmlReader::NAMESPACE_OOR &&
name.equals(RTL_CONSTASCII_STRINGPARAM("items")))
{
state_.push(State(rtl::Reference< Node >(), false));
} else {
throw css::uno::RuntimeException(
(rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM("bad root element <")) +
xmldata::convertFromUtf8(name) +
rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("> in ")) +
reader.getUrl()),
css::uno::Reference< css::uno::XInterface >());
}
} else if (state_.top().ignore) {
state_.push(State(false));
} else if (!state_.top().node.is()) {
if (ns == XmlReader::NAMESPACE_NONE &&
name.equals(RTL_CONSTASCII_STRINGPARAM("item")))
{
handleItem(reader);
} else {
throw css::uno::RuntimeException(
(rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM("bad items node member <")) +
xmldata::convertFromUtf8(name) +
rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("> in ")) +
reader.getUrl()),
css::uno::Reference< css::uno::XInterface >());
}
} else {
switch (state_.top().node->kind()) {
case Node::KIND_PROPERTY:
if (ns == XmlReader::NAMESPACE_NONE &&
name.equals(RTL_CONSTASCII_STRINGPARAM("value")))
{
handlePropValue(
reader,
dynamic_cast< PropertyNode * >(state_.top().node.get()));
} else {
throw css::uno::RuntimeException(
(rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM(
"bad property node member <")) +
xmldata::convertFromUtf8(name) +
rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("> in ")) +
reader.getUrl()),
css::uno::Reference< css::uno::XInterface >());
}
break;
case Node::KIND_LOCALIZED_PROPERTY:
if (ns == XmlReader::NAMESPACE_NONE &&
name.equals(RTL_CONSTASCII_STRINGPARAM("value")))
{
handleLocpropValue(
reader,
dynamic_cast< LocalizedPropertyNode * >(
state_.top().node.get()));
} else {
throw css::uno::RuntimeException(
(rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM(
"bad localized property node member <")) +
xmldata::convertFromUtf8(name) +
rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("> in ")) +
reader.getUrl()),
css::uno::Reference< css::uno::XInterface >());
}
break;
case Node::KIND_LOCALIZED_VALUE:
throw css::uno::RuntimeException(
(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("bad member <")) +
xmldata::convertFromUtf8(name) +
rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("> in ")) +
reader.getUrl()),
css::uno::Reference< css::uno::XInterface >());
case Node::KIND_GROUP:
if (ns == XmlReader::NAMESPACE_NONE &&
name.equals(RTL_CONSTASCII_STRINGPARAM("prop")))
{
handleGroupProp(
reader,
dynamic_cast< GroupNode * >(state_.top().node.get()));
} else if (ns == XmlReader::NAMESPACE_NONE &&
name.equals(RTL_CONSTASCII_STRINGPARAM("node")))
{
handleGroupNode(reader, state_.top().node);
} else {
throw css::uno::RuntimeException(
(rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM(
"bad group node member <")) +
xmldata::convertFromUtf8(name) +
rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("> in ")) +
reader.getUrl()),
css::uno::Reference< css::uno::XInterface >());
}
break;
case Node::KIND_SET:
if (ns == XmlReader::NAMESPACE_NONE &&
name.equals(RTL_CONSTASCII_STRINGPARAM("node")))
{
handleSetNode(
reader, dynamic_cast< SetNode * >(state_.top().node.get()));
} else if (ns == XmlReader::NAMESPACE_NONE &&
name.equals(RTL_CONSTASCII_STRINGPARAM("prop")))
{
OSL_TRACE(
"configmgr bad set node <prop> member in %s",
rtl::OUStringToOString(
reader.getUrl(), RTL_TEXTENCODING_UTF8).getStr());
state_.push(State(true)); // ignored
} else {
throw css::uno::RuntimeException(
(rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM("bad set node member <")) +
xmldata::convertFromUtf8(name) +
rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("> in ")) +
reader.getUrl()),
css::uno::Reference< css::uno::XInterface >());
}
break;
}
}
return true;
}
void XcuParser::endElement(XmlReader const &) {
if (valueParser_.endElement()) {
return;
}
OSL_ASSERT(!state_.empty());
bool pop = state_.top().pop;
rtl::Reference< Node > insert;
rtl::OUString name;
if (state_.top().insert) {
insert = state_.top().node;
OSL_ASSERT(insert.is());
name = state_.top().name;
}
state_.pop();
if (insert.is()) {
OSL_ASSERT(!state_.empty() && state_.top().node.is());
state_.top().node->getMembers()[name] = insert;
}
if (pop && !path_.empty()) {
path_.pop_back();
// </item> will pop less than <item> pushed, but that is harmless,
// as the next <item> will reset path_
}
}
void XcuParser::characters(Span const & text) {
valueParser_.characters(text);
}
XcuParser::Operation XcuParser::parseOperation(Span const & text) {
OSL_ASSERT(text.is());
if (text.equals(RTL_CONSTASCII_STRINGPARAM("modify"))) {
return OPERATION_MODIFY;
}
if (text.equals(RTL_CONSTASCII_STRINGPARAM("replace"))) {
return OPERATION_REPLACE;
}
if (text.equals(RTL_CONSTASCII_STRINGPARAM("fuse"))) {
return OPERATION_FUSE;
}
if (text.equals(RTL_CONSTASCII_STRINGPARAM("remove"))) {
return OPERATION_REMOVE;
}
throw css::uno::RuntimeException(
(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("invalid op ")) +
xmldata::convertFromUtf8(text)),
css::uno::Reference< css::uno::XInterface >());
}
void XcuParser::handleComponentData(XmlReader & reader) {
rtl::OStringBuffer buf;
buf.append('.');
bool hasPackage = false;
bool hasName = false;
Operation op = OPERATION_MODIFY;
bool finalized = false;
for (;;) {
XmlReader::Namespace attrNs;
Span attrLn;
if (!reader.nextAttribute(&attrNs, &attrLn)) {
break;
}
if (attrNs == XmlReader::NAMESPACE_OOR &&
attrLn.equals(RTL_CONSTASCII_STRINGPARAM("package")))
{
if (hasPackage) {
throw css::uno::RuntimeException(
(rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM(
"multiple component-update package attributes"
" in ")) +
reader.getUrl()),
css::uno::Reference< css::uno::XInterface >());
}
hasPackage = true;
Span s(reader.getAttributeValue(false));
buf.insert(0, s.begin, s.length);
} else if (attrNs == XmlReader::NAMESPACE_OOR &&
attrLn.equals(RTL_CONSTASCII_STRINGPARAM("name")))
{
if (hasName) {
throw css::uno::RuntimeException(
(rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM(
"multiple component-update name attributes in ")) +
reader.getUrl()),
css::uno::Reference< css::uno::XInterface >());
}
hasName = true;
Span s(reader.getAttributeValue(false));
buf.append(s.begin, s.length);
} else if (attrNs == XmlReader::NAMESPACE_OOR &&
attrLn.equals(RTL_CONSTASCII_STRINGPARAM("op")))
{
op = parseOperation(reader.getAttributeValue(true));
} else if (attrNs == XmlReader::NAMESPACE_OOR &&
attrLn.equals(RTL_CONSTASCII_STRINGPARAM("finalized")))
{
finalized = xmldata::parseBoolean(reader.getAttributeValue(true));
}
}
if (!hasPackage) {
throw css::uno::RuntimeException(
(rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM(
"no component-data package attribute in ")) +
reader.getUrl()),
css::uno::Reference< css::uno::XInterface >());
}
if (!hasName) {
throw css::uno::RuntimeException(
(rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM(
"no component-data name attribute in ")) +
reader.getUrl()),
css::uno::Reference< css::uno::XInterface >());
}
componentName_ = xmldata::convertFromUtf8(
Span(buf.getStr(), buf.getLength()));
if (trackPath_) {
OSL_ASSERT(path_.empty());
path_.push_back(componentName_);
if (partial_ != 0 && partial_->contains(path_) == Partial::CONTAINS_NOT)
{
state_.push(State(true)); // ignored
return;
}
}
rtl::Reference< Node > node(
Data::findNode(
valueParser_.getLayer(), data_.components, componentName_));
if (!node.is()) {
OSL_TRACE(
"configmgr unknown component %s in %s",
rtl::OUStringToOString(
componentName_, RTL_TEXTENCODING_UTF8).getStr(),
rtl::OUStringToOString(
reader.getUrl(), RTL_TEXTENCODING_UTF8).getStr());
state_.push(State(true)); // ignored
return;
}
switch (op) {
case OPERATION_MODIFY:
case OPERATION_FUSE:
break;
default:
throw css::uno::RuntimeException(
(rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM(
"invalid operation on root node in ")) +
reader.getUrl()),
css::uno::Reference< css::uno::XInterface >());
}
int finalizedLayer = std::min(
finalized ? valueParser_.getLayer() : Data::NO_LAYER,
node->getFinalized());
node->setFinalized(finalizedLayer);
state_.push(State(node, finalizedLayer < valueParser_.getLayer()));
}
void XcuParser::handleItem(XmlReader & reader) {
Span attrPath;
for (;;) {
XmlReader::Namespace attrNs;
Span attrLn;
if (!reader.nextAttribute(&attrNs, &attrLn)) {
break;
}
if (attrNs == XmlReader::NAMESPACE_OOR &&
attrLn.equals(RTL_CONSTASCII_STRINGPARAM("path")))
{
attrPath = reader.getAttributeValue(false);
}
}
if (!attrPath.is()) {
throw css::uno::RuntimeException(
(rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM("missing path attribute in ")) +
reader.getUrl()),
css::uno::Reference< css::uno::XInterface >());
}
rtl::OUString path(xmldata::convertFromUtf8(attrPath));
int finalizedLayer;
rtl::Reference< Node > node(
data_.resolvePathRepresentation(
path, 0, &path_, &finalizedLayer));
if (!node.is()) {
OSL_TRACE(
"configmgr unknown item %s in %s",
rtl::OUStringToOString(path, RTL_TEXTENCODING_UTF8).getStr(),
rtl::OUStringToOString(
reader.getUrl(), RTL_TEXTENCODING_UTF8).getStr());
state_.push(State(true)); // ignored
return;
}
OSL_ASSERT(!path_.empty());
componentName_ = path_.front();
if (trackPath_) {
if (partial_ != 0 && partial_->contains(path_) == Partial::CONTAINS_NOT)
{
state_.push(State(true)); // ignored
return;
}
} else {
path_.clear();
}
switch (node->kind()) {
case Node::KIND_PROPERTY:
case Node::KIND_LOCALIZED_VALUE:
OSL_TRACE(
"configmgr item of bad type %s in %s",
rtl::OUStringToOString(path, RTL_TEXTENCODING_UTF8).getStr(),
rtl::OUStringToOString(
reader.getUrl(), RTL_TEXTENCODING_UTF8).getStr());
state_.push(State(true)); // ignored
return;
case Node::KIND_LOCALIZED_PROPERTY:
valueParser_.type_ = dynamic_cast< LocalizedPropertyNode * >(
node.get())->getStaticType();
break;
default:
break;
}
state_.push(State(node, finalizedLayer < valueParser_.getLayer()));
}
void XcuParser::handlePropValue(XmlReader & reader, PropertyNode * prop) {
bool nil = false;
rtl::OString separator;
rtl::OUString external;
for (;;) {
XmlReader::Namespace attrNs;
Span attrLn;
if (!reader.nextAttribute(&attrNs, &attrLn)) {
break;
}
if (attrNs == XmlReader::NAMESPACE_XSI &&
attrLn.equals(RTL_CONSTASCII_STRINGPARAM("nil")))
{
nil = xmldata::parseBoolean(reader.getAttributeValue(true));
} else if (attrNs == XmlReader::NAMESPACE_OOR &&
attrLn.equals(RTL_CONSTASCII_STRINGPARAM("type")))
{
Type type = xmldata::parseType(
reader, reader.getAttributeValue(true));
if (valueParser_.type_ != TYPE_ANY && type != valueParser_.type_) {
throw css::uno::RuntimeException(
(rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM("invalid value type in ")) +
reader.getUrl()),
css::uno::Reference< css::uno::XInterface >());
}
valueParser_.type_ = type;
} else if (attrNs == XmlReader::NAMESPACE_OOR &&
attrLn.equals(RTL_CONSTASCII_STRINGPARAM("separator")))
{
Span s(reader.getAttributeValue(false));
if (s.length == 0) {
throw css::uno::RuntimeException(
(rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM(
"bad oor:separator attribute in ")) +
reader.getUrl()),
css::uno::Reference< css::uno::XInterface >());
}
separator = rtl::OString(s.begin, s.length);
} else if (attrNs == XmlReader::NAMESPACE_OOR &&
attrLn.equals(RTL_CONSTASCII_STRINGPARAM("external")))
{
external = xmldata::convertFromUtf8(reader.getAttributeValue(true));
if (external.getLength() == 0) {
throw css::uno::RuntimeException(
(rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM(
"bad oor:external attribute value in ")) +
reader.getUrl()),
css::uno::Reference< css::uno::XInterface >());
}
}
}
if (nil) {
if (!prop->isNillable()) {
throw css::uno::RuntimeException(
(rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM(
"xsi:nil attribute for non-nillable prop in ")) +
reader.getUrl()),
css::uno::Reference< css::uno::XInterface >());
}
if (external.getLength() != 0) {
throw css::uno::RuntimeException(
(rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM(
"xsi:nil and oor:external attributes for prop in ")) +
reader.getUrl()),
css::uno::Reference< css::uno::XInterface >());
}
prop->setValue(valueParser_.getLayer(), css::uno::Any());
state_.push(State(false));
} else if (external.getLength() == 0) {
valueParser_.separator_ = separator;
valueParser_.start(prop);
} else {
prop->setExternal(valueParser_.getLayer(), external);
state_.push(State(false));
}
}
void XcuParser::handleLocpropValue(
XmlReader & reader, LocalizedPropertyNode * locprop)
{
rtl::OUString name;
bool nil = false;
rtl::OString separator;
Operation op = OPERATION_FUSE;
for (;;) {
XmlReader::Namespace attrNs;
Span attrLn;
if (!reader.nextAttribute(&attrNs, &attrLn)) {
break;
}
if (attrNs == XmlReader::NAMESPACE_XML &&
attrLn.equals(RTL_CONSTASCII_STRINGPARAM("lang")))
{
name = xmldata::convertFromUtf8(reader.getAttributeValue(false));
} else if (attrNs == XmlReader::NAMESPACE_XSI &&
attrLn.equals(RTL_CONSTASCII_STRINGPARAM("nil")))
{
nil = xmldata::parseBoolean(reader.getAttributeValue(true));
} else if (attrNs == XmlReader::NAMESPACE_OOR &&
attrLn.equals(RTL_CONSTASCII_STRINGPARAM("type")))
{
Type type = xmldata::parseType(
reader, reader.getAttributeValue(true));
if (valueParser_.type_ != TYPE_ANY && type != valueParser_.type_) {
throw css::uno::RuntimeException(
(rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM("invalid value type in ")) +
reader.getUrl()),
css::uno::Reference< css::uno::XInterface >());
}
valueParser_.type_ = type;
} else if (attrNs == XmlReader::NAMESPACE_OOR &&
attrLn.equals(RTL_CONSTASCII_STRINGPARAM("separator")))
{
Span s(reader.getAttributeValue(false));
if (s.length == 0) {
throw css::uno::RuntimeException(
(rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM(
"bad oor:separator attribute in ")) +
reader.getUrl()),
css::uno::Reference< css::uno::XInterface >());
}
separator = rtl::OString(s.begin, s.length);
} else if (attrNs == XmlReader::NAMESPACE_OOR &&
attrLn.equals(RTL_CONSTASCII_STRINGPARAM("op")))
{
op = parseOperation(reader.getAttributeValue(true));
}
}
if (trackPath_) {
path_.push_back(name);
if (partial_ != 0 &&
partial_->contains(path_) != Partial::CONTAINS_NODE)
{
state_.push(State(true)); // ignored
return;
}
}
NodeMap::iterator i(locprop->getMembers().find(name));
if (i != locprop->getMembers().end() &&
i->second->getLayer() > valueParser_.getLayer())
{
state_.push(State(true)); // ignored
return;
}
if (nil && !locprop->isNillable()) {
throw css::uno::RuntimeException(
(rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM(
"xsi:nil attribute for non-nillable prop in ")) +
reader.getUrl()),
css::uno::Reference< css::uno::XInterface >());
}
switch (op) {
case OPERATION_FUSE:
{
bool pop = false;
if (nil) {
if (i == locprop->getMembers().end()) {
locprop->getMembers()[name] = new LocalizedValueNode(
valueParser_.getLayer(), css::uno::Any());
} else {
dynamic_cast< LocalizedValueNode * >(
i->second.get())->setValue(
valueParser_.getLayer(), css::uno::Any());
}
state_.push(State(true));
} else {
valueParser_.separator_ = separator;
valueParser_.start(locprop, name);
pop = true;
}
if (trackPath_) {
recordModification(false);
if (pop) {
path_.pop_back();
}
}
}
break;
case OPERATION_REMOVE:
//TODO: only allow if parent.op == OPERATION_FUSE
//TODO: disallow removing when e.g. lang=""?
if (i != locprop->getMembers().end()) {
locprop->getMembers().erase(i);
}
state_.push(State(true));
recordModification(false);
break;
default:
throw css::uno::RuntimeException(
(rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM(
"bad op attribute for value element in ")) +
reader.getUrl()),
css::uno::Reference< css::uno::XInterface >());
}
}
void XcuParser::handleGroupProp(XmlReader & reader, GroupNode * group) {
bool hasName = false;
rtl::OUString name;
Type type = TYPE_ERROR;
Operation op = OPERATION_MODIFY;
bool finalized = false;
for (;;) {
XmlReader::Namespace attrNs;
Span attrLn;
if (!reader.nextAttribute(&attrNs, &attrLn)) {
break;
}
if (attrNs == XmlReader::NAMESPACE_OOR &&
attrLn.equals(RTL_CONSTASCII_STRINGPARAM("name")))
{
hasName = true;
name = xmldata::convertFromUtf8(reader.getAttributeValue(false));
} else if (attrNs == XmlReader::NAMESPACE_OOR &&
attrLn.equals(RTL_CONSTASCII_STRINGPARAM("type")))
{
type = xmldata::parseType(reader, reader.getAttributeValue(true));
} else if (attrNs == XmlReader::NAMESPACE_OOR &&
attrLn.equals(RTL_CONSTASCII_STRINGPARAM("op")))
{
op = parseOperation(reader.getAttributeValue(true));
} else if (attrNs == XmlReader::NAMESPACE_OOR &&
attrLn.equals(RTL_CONSTASCII_STRINGPARAM("finalized")))
{
finalized = xmldata::parseBoolean(reader.getAttributeValue(true));
}
}
if (!hasName) {
throw css::uno::RuntimeException(
(rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM("no prop name attribute in ")) +
reader.getUrl()),
css::uno::Reference< css::uno::XInterface >());
}
if (trackPath_) {
path_.push_back(name);
//TODO: This ignores locprop values for which specific include paths
// exist (i.e., for which contains(locprop path) = CONTAINS_SUBNODES):
if (partial_ != 0 &&
partial_->contains(path_) != Partial::CONTAINS_NODE)
{
state_.push(State(true)); // ignored
return;
}
}
NodeMap::iterator i(group->getMembers().find(name));
if (i == group->getMembers().end()) {
handleUnknownGroupProp(reader, group, name, type, op, finalized);
} else {
switch (i->second->kind()) {
case Node::KIND_PROPERTY:
handlePlainGroupProp(reader, group, i, name, type, op, finalized);
break;
case Node::KIND_LOCALIZED_PROPERTY:
handleLocalizedGroupProp(
reader,
dynamic_cast< LocalizedPropertyNode * >(i->second.get()), name,
type, op, finalized);
break;
default:
throw css::uno::RuntimeException(
(rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM("inappropriate prop ")) +
name + rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(" in ")) +
reader.getUrl()),
css::uno::Reference< css::uno::XInterface >());
}
}
}
void XcuParser::handleUnknownGroupProp(
XmlReader const & reader, GroupNode * group, rtl::OUString const & name,
Type type, Operation operation, bool finalized)
{
switch (operation) {
case OPERATION_REPLACE:
case OPERATION_FUSE:
if (group->isExtensible()) {
if (type == TYPE_ERROR) {
throw css::uno::RuntimeException(
(rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM(
"missing type attribute for prop ")) +
name + rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(" in ")) +
reader.getUrl()),
css::uno::Reference< css::uno::XInterface >());
}
valueParser_.type_ = type;
rtl::Reference< Node > prop(
new PropertyNode(
valueParser_.getLayer(), TYPE_ANY, true, css::uno::Any(),
true));
if (finalized) {
prop->setFinalized(valueParser_.getLayer());
}
state_.push(State(prop, name, state_.top().locked));
recordModification(false);
break;
}
// fall through
default:
OSL_TRACE(
"configmgr unknown property %s in %s",
rtl::OUStringToOString(name, RTL_TEXTENCODING_UTF8).getStr(),
rtl::OUStringToOString(
reader.getUrl(), RTL_TEXTENCODING_UTF8).getStr());
state_.push(State(true)); // ignored
break;
}
}
void XcuParser::handlePlainGroupProp(
XmlReader const & reader, GroupNode * group,
NodeMap::iterator const & propertyIndex, rtl::OUString const & name,
Type type, Operation operation, bool finalized)
{
PropertyNode * property = dynamic_cast< PropertyNode * >(
propertyIndex->second.get());
if (property->getLayer() > valueParser_.getLayer()) {
state_.push(State(true)); // ignored
return;
}
int finalizedLayer = std::min(
finalized ? valueParser_.getLayer() : Data::NO_LAYER,
property->getFinalized());
property->setFinalized(finalizedLayer);
if (type != TYPE_ERROR && property->getStaticType() != TYPE_ANY &&
type != property->getStaticType())
{
throw css::uno::RuntimeException(
(rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM("invalid type for prop ")) +
name + rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(" in ")) +
reader.getUrl()),
css::uno::Reference< css::uno::XInterface >());
}
valueParser_.type_ = type == TYPE_ERROR ? property->getStaticType() : type;
switch (operation) {
case OPERATION_MODIFY:
case OPERATION_REPLACE:
case OPERATION_FUSE:
state_.push(
State(
property,
(state_.top().locked ||
finalizedLayer < valueParser_.getLayer())));
recordModification(false);
break;
case OPERATION_REMOVE:
if (!property->isExtension()) {
throw css::uno::RuntimeException(
(rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM(
"invalid remove of non-extension prop ")) +
name + rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(" in ")) +
reader.getUrl()),
css::uno::Reference< css::uno::XInterface >());
}
group->getMembers().erase(propertyIndex);
state_.push(State(true)); // ignore children
recordModification(false);
break;
}
}
void XcuParser::handleLocalizedGroupProp(
XmlReader const & reader, LocalizedPropertyNode * property,
rtl::OUString const & name, Type type, Operation operation, bool finalized)
{
if (property->getLayer() > valueParser_.getLayer()) {
state_.push(State(true)); // ignored
return;
}
int finalizedLayer = std::min(
finalized ? valueParser_.getLayer() : Data::NO_LAYER,
property->getFinalized());
property->setFinalized(finalizedLayer);
if (type != TYPE_ERROR && property->getStaticType() != TYPE_ANY &&
type != property->getStaticType())
{
throw css::uno::RuntimeException(
(rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM("invalid type for prop ")) +
name + rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(" in ")) +
reader.getUrl()),
css::uno::Reference< css::uno::XInterface >());
}
valueParser_.type_ = type == TYPE_ERROR ? property->getStaticType() : type;
switch (operation) {
case OPERATION_MODIFY:
case OPERATION_FUSE:
state_.push(
State(
property,
(state_.top().locked ||
finalizedLayer < valueParser_.getLayer())));
break;
case OPERATION_REPLACE:
{
rtl::Reference< Node > replacement(
new LocalizedPropertyNode(
valueParser_.getLayer(), property->getStaticType(),
property->isNillable()));
replacement->setFinalized(property->getFinalized());
state_.push(
State(
replacement, name,
(state_.top().locked ||
finalizedLayer < valueParser_.getLayer())));
recordModification(false);
}
break;
case OPERATION_REMOVE:
throw css::uno::RuntimeException(
(rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM(
"invalid remove of non-extension prop ")) +
name + rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(" in ")) +
reader.getUrl()),
css::uno::Reference< css::uno::XInterface >());
}
}
void XcuParser::handleGroupNode(
XmlReader & reader, rtl::Reference< Node > const & group)
{
bool hasName = false;
rtl::OUString name;
Operation op = OPERATION_MODIFY;
bool finalized = false;
for (;;) {
XmlReader::Namespace attrNs;
Span attrLn;
if (!reader.nextAttribute(&attrNs, &attrLn)) {
break;
}
if (attrNs == XmlReader::NAMESPACE_OOR &&
attrLn.equals(RTL_CONSTASCII_STRINGPARAM("name")))
{
hasName = true;
name = xmldata::convertFromUtf8(reader.getAttributeValue(false));
} else if (attrNs == XmlReader::NAMESPACE_OOR &&
attrLn.equals(RTL_CONSTASCII_STRINGPARAM("op")))
{
op = parseOperation(reader.getAttributeValue(true));
} else if (attrNs == XmlReader::NAMESPACE_OOR &&
attrLn.equals(RTL_CONSTASCII_STRINGPARAM("finalized")))
{
finalized = xmldata::parseBoolean(reader.getAttributeValue(true));
}
}
if (!hasName) {
throw css::uno::RuntimeException(
(rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM("no node name attribute in ")) +
reader.getUrl()),
css::uno::Reference< css::uno::XInterface >());
}
if (trackPath_) {
path_.push_back(name);
if (partial_ != 0 && partial_->contains(path_) == Partial::CONTAINS_NOT)
{
state_.push(State(true)); // ignored
return;
}
}
rtl::Reference< Node > child(
Data::findNode(valueParser_.getLayer(), group->getMembers(), name));
if (!child.is()) {
OSL_TRACE(
"configmgr unknown node %s in %s",
rtl::OUStringToOString(name, RTL_TEXTENCODING_UTF8).getStr(),
rtl::OUStringToOString(
reader.getUrl(), RTL_TEXTENCODING_UTF8).getStr());
state_.push(State(true)); // ignored
return;
}
if (op != OPERATION_MODIFY && op != OPERATION_FUSE) {
throw css::uno::RuntimeException(
(rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM(
"invalid operation on group node in ")) +
reader.getUrl()),
css::uno::Reference< css::uno::XInterface >());
}
int finalizedLayer = std::min(
finalized ? valueParser_.getLayer() : Data::NO_LAYER,
child->getFinalized());
child->setFinalized(finalizedLayer);
state_.push(
State(
child,
state_.top().locked || finalizedLayer < valueParser_.getLayer()));
}
void XcuParser::handleSetNode(XmlReader & reader, SetNode * set) {
bool hasName = false;
rtl::OUString name;
rtl::OUString component(componentName_);
bool hasNodeType = false;
rtl::OUString nodeType;
Operation op = OPERATION_MODIFY;
bool finalized = false;
bool mandatory = false;
for (;;) {
XmlReader::Namespace attrNs;
Span attrLn;
if (!reader.nextAttribute(&attrNs, &attrLn)) {
break;
}
if (attrNs == XmlReader::NAMESPACE_OOR &&
attrLn.equals(RTL_CONSTASCII_STRINGPARAM("name")))
{
hasName = true;
name = xmldata::convertFromUtf8(reader.getAttributeValue(false));
} else if (attrNs == XmlReader::NAMESPACE_OOR &&
attrLn.equals(RTL_CONSTASCII_STRINGPARAM("component")))
{
component = xmldata::convertFromUtf8(
reader.getAttributeValue(false));
} else if (attrNs == XmlReader::NAMESPACE_OOR &&
attrLn.equals(RTL_CONSTASCII_STRINGPARAM("node-type")))
{
hasNodeType = true;
nodeType = xmldata::convertFromUtf8(
reader.getAttributeValue(false));
} else if (attrNs == XmlReader::NAMESPACE_OOR &&
attrLn.equals(RTL_CONSTASCII_STRINGPARAM("op")))
{
op = parseOperation(reader.getAttributeValue(true));
} else if (attrNs == XmlReader::NAMESPACE_OOR &&
attrLn.equals(RTL_CONSTASCII_STRINGPARAM("finalized")))
{
finalized = xmldata::parseBoolean(reader.getAttributeValue(true));
} else if (attrNs == XmlReader::NAMESPACE_OOR &&
attrLn.equals(RTL_CONSTASCII_STRINGPARAM("mandatory")))
{
mandatory = xmldata::parseBoolean(reader.getAttributeValue(true));
}
}
if (!hasName) {
throw css::uno::RuntimeException(
(rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM("no node name attribute in ")) +
reader.getUrl()),
css::uno::Reference< css::uno::XInterface >());
}
if (trackPath_) {
path_.push_back(name);
if (partial_ != 0 && partial_->contains(path_) == Partial::CONTAINS_NOT)
{
state_.push(State(true)); // ignored
return;
}
}
rtl::OUString templateName(
xmldata::parseTemplateReference(
component, hasNodeType, nodeType, &set->getDefaultTemplateName()));
if (!set->isValidTemplate(templateName)) {
throw css::uno::RuntimeException(
(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("set member node ")) +
name +
rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM(" references invalid template ")) +
templateName + rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(" in ")) +
reader.getUrl()),
css::uno::Reference< css::uno::XInterface >());
}
rtl::Reference< Node > tmpl(
data_.getTemplate(valueParser_.getLayer(), templateName));
if (!tmpl.is()) {
throw css::uno::RuntimeException(
(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("set member node ")) +
name +
rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM(
" references undefined template ")) +
templateName + rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(" in ")) +
reader.getUrl()),
css::uno::Reference< css::uno::XInterface >());
}
int finalizedLayer = finalized ? valueParser_.getLayer() : Data::NO_LAYER;
int mandatoryLayer = mandatory ? valueParser_.getLayer() : Data::NO_LAYER;
NodeMap::iterator i(set->getMembers().find(name));
if (i != set->getMembers().end()) {
finalizedLayer = std::min(finalizedLayer, i->second->getFinalized());
i->second->setFinalized(finalizedLayer);
mandatoryLayer = std::min(mandatoryLayer, i->second->getMandatory());
i->second->setMandatory(mandatoryLayer);
if (i->second->getLayer() > valueParser_.getLayer()) {
state_.push(State(true)); // ignored
return;
}
}
switch (op) {
case OPERATION_MODIFY:
if (i == set->getMembers().end()) {
OSL_TRACE("ignoring modify of unknown set member node");
state_.push(State(true)); // ignored
} else {
state_.push(
State(
i->second,
(state_.top().locked ||
finalizedLayer < valueParser_.getLayer())));
}
break;
case OPERATION_REPLACE:
if (state_.top().locked || finalizedLayer < valueParser_.getLayer()) {
state_.push(State(true)); // ignored
} else {
rtl::Reference< Node > member(tmpl->clone(true));
member->setLayer(valueParser_.getLayer());
member->setFinalized(finalizedLayer);
member->setMandatory(mandatoryLayer);
state_.push(State(member, name, false));
recordModification(i == set->getMembers().end());
}
break;
case OPERATION_FUSE:
if (i == set->getMembers().end()) {
if (state_.top().locked || finalizedLayer < valueParser_.getLayer())
{
state_.push(State(true)); // ignored
} else {
rtl::Reference< Node > member(tmpl->clone(true));
member->setLayer(valueParser_.getLayer());
member->setFinalized(finalizedLayer);
member->setMandatory(mandatoryLayer);
state_.push(State(member, name, false));
recordModification(true);
}
} else {
state_.push(
State(
i->second,
(state_.top().locked ||
finalizedLayer < valueParser_.getLayer())));
}
break;
case OPERATION_REMOVE:
// Ignore removal of unknown members, members finalized in a lower
// layer, and members made mandatory in this or a lower layer:
if (i != set->getMembers().end() && !state_.top().locked &&
finalizedLayer >= valueParser_.getLayer() &&
mandatoryLayer > valueParser_.getLayer())
{
set->getMembers().erase(i);
}
state_.push(State(true));
recordModification(false);
break;
}
}
void XcuParser::recordModification(bool addition) {
if (broadcastModifications_ != 0) {
broadcastModifications_->add(path_);
}
if (addition && additions_ != 0) {
additions_->push_back(path_);
}
if (recordModifications_) {
data_.modifications.add(path_);
}
}
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
Reference in a new issue View git blame Copy permalink