summaryrefslogtreecommitdiffstats
path: root/unoidl/source/unoidl-check.cxx
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-15 05:54:39 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-15 05:54:39 +0000
commit267c6f2ac71f92999e969232431ba04678e7437e (patch)
tree358c9467650e1d0a1d7227a21dac2e3d08b622b2 /unoidl/source/unoidl-check.cxx
parentInitial commit. (diff)
downloadlibreoffice-267c6f2ac71f92999e969232431ba04678e7437e.tar.xz
libreoffice-267c6f2ac71f92999e969232431ba04678e7437e.zip
Adding upstream version 4:24.2.0.upstream/4%24.2.0
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'unoidl/source/unoidl-check.cxx')
-rw-r--r--unoidl/source/unoidl-check.cxx1167
1 files changed, 1167 insertions, 0 deletions
diff --git a/unoidl/source/unoidl-check.cxx b/unoidl/source/unoidl-check.cxx
new file mode 100644
index 0000000000..fdeb74441f
--- /dev/null
+++ b/unoidl/source/unoidl-check.cxx
@@ -0,0 +1,1167 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#include <sal/config.h>
+
+#include <algorithm>
+#include <cassert>
+#include <cstdlib>
+#include <iostream>
+#include <string_view>
+#include <utility>
+#include <vector>
+
+#include <osl/file.hxx>
+#include <osl/process.h>
+#include <rtl/character.hxx>
+#include <rtl/process.h>
+#include <rtl/ref.hxx>
+#include <rtl/ustring.hxx>
+#include <sal/main.h>
+#include <sal/types.h>
+#include <unoidl/unoidl.hxx>
+
+namespace unoidl {
+
+static bool operator ==(ConstantValue const & lhs, ConstantValue const & rhs) {
+ if (lhs.type == rhs.type) {
+ switch (lhs.type) {
+ case ConstantValue::TYPE_BOOLEAN:
+ return lhs.booleanValue == rhs.booleanValue;
+ case ConstantValue::TYPE_BYTE:
+ return lhs.byteValue == rhs.byteValue;
+ case ConstantValue::TYPE_SHORT:
+ return lhs.shortValue == rhs.shortValue;
+ case ConstantValue::TYPE_UNSIGNED_SHORT:
+ return lhs.unsignedShortValue == rhs.unsignedShortValue;
+ case ConstantValue::TYPE_LONG:
+ return lhs.longValue == rhs.longValue;
+ case ConstantValue::TYPE_UNSIGNED_LONG:
+ return lhs.unsignedLongValue == rhs.unsignedLongValue;
+ case ConstantValue::TYPE_HYPER:
+ return lhs.hyperValue == rhs.hyperValue;
+ case ConstantValue::TYPE_UNSIGNED_HYPER:
+ return lhs.unsignedHyperValue == rhs.unsignedHyperValue;
+ case ConstantValue::TYPE_FLOAT:
+ return lhs.floatValue == rhs.floatValue;
+ case ConstantValue::TYPE_DOUBLE:
+ return lhs.doubleValue == rhs.doubleValue;
+ }
+ }
+ return false;
+}
+
+static bool operator !=(ConstantValue const & lhs, ConstantValue const & rhs) {
+ return !(lhs == rhs);
+}
+
+static bool operator ==(
+ SingleInterfaceBasedServiceEntity::Constructor::Parameter const & lhs,
+ SingleInterfaceBasedServiceEntity::Constructor::Parameter const & rhs)
+{
+ return lhs.name == rhs.name && lhs.type == rhs.type && lhs.rest == rhs.rest;
+}
+
+}
+
+namespace {
+
+void badUsage() {
+ std::cerr
+ << "Usage:" << std::endl << std::endl
+ << (" unoidl-check [--ignore-unpublished] [<extra registries A>]"
+ " <registry A> --")
+ << std::endl << " [<extra registries B>] <registry B>" << std::endl
+ << std::endl
+ << ("where each <registry> is either a new- or legacy-format .rdb file,"
+ " a single .idl")
+ << std::endl
+ << ("file, or a root directory of an .idl file tree. Check that each"
+ " entity from")
+ << std::endl
+ << "<registry A> is also present in <registry B> in a compatible form."
+ << std::endl;
+ std::exit(EXIT_FAILURE);
+}
+
+bool getArgument(
+ sal_uInt32 argument, bool * ignoreUnpublished, bool * delimiter,
+ OUString * uri)
+{
+ assert(ignoreUnpublished != nullptr);
+ assert(uri != nullptr);
+ OUString arg;
+ rtl_getAppCommandArg(argument, &arg.pData);
+ if (argument == 0 && arg == "--ignore-unpublished") {
+ *ignoreUnpublished = true;
+ return false;
+ }
+ if (arg == "--") {
+ if (delimiter == nullptr) {
+ badUsage();
+ }
+ *delimiter = true;
+ return false;
+ }
+ OUString url;
+ osl::FileBase::RC e1 = osl::FileBase::getFileURLFromSystemPath(arg, url);
+ if (e1 != osl::FileBase::E_None) {
+ std::cerr
+ << "Cannot convert \"" << arg << "\" to file URL, error code "
+ << +e1 << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ OUString cwd;
+ oslProcessError e2 = osl_getProcessWorkingDir(&cwd.pData);
+ if (e2 != osl_Process_E_None) {
+ std::cerr
+ << "Cannot obtain working directory, error code " << +e2
+ << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ e1 = osl::FileBase::getAbsoluteFileURL(cwd, url, *uri);
+ if (e1 != osl::FileBase::E_None) {
+ std::cerr
+ << "Cannot make \"" << url
+ << "\" into an absolute file URL, error code " << +e1 << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ return true;
+}
+
+OUString showDirection(
+ unoidl::InterfaceTypeEntity::Method::Parameter::Direction direction)
+{
+ switch (direction) {
+ case unoidl::InterfaceTypeEntity::Method::Parameter::DIRECTION_IN:
+ return "[in]";
+ case unoidl::InterfaceTypeEntity::Method::Parameter::DIRECTION_OUT:
+ return "[out]";
+ case unoidl::InterfaceTypeEntity::Method::Parameter::DIRECTION_IN_OUT:
+ return "[inout]";
+ default:
+ assert(false && "this cannot happen"); for (;;) { std::abort(); }
+ }
+}
+
+struct EqualsAnnotation {
+ explicit EqualsAnnotation(OUString name): name_(std::move(name)) {}
+
+ bool operator ()(unoidl::AnnotatedReference const & ref)
+ { return ref.name == name_; }
+
+private:
+ OUString name_;
+};
+
+void checkMap(
+ rtl::Reference<unoidl::Provider> const & providerB, std::u16string_view prefix,
+ rtl::Reference<unoidl::MapCursor> const & cursor, bool ignoreUnpublished)
+{
+ assert(providerB.is());
+ assert(cursor.is());
+ for (;;) {
+ OUString id;
+ rtl::Reference<unoidl::Entity> entA(cursor->getNext(&id));
+ if (!entA.is()) {
+ break;
+ }
+ OUString name(prefix + id);
+ if (entA->getSort() == unoidl::Entity::SORT_MODULE) {
+ checkMap(
+ providerB, Concat2View(name + "."),
+ (static_cast<unoidl::ModuleEntity *>(entA.get())
+ ->createCursor()),
+ ignoreUnpublished);
+ } else {
+ bool pubA = dynamic_cast<unoidl::PublishableEntity&>(*entA).isPublished();
+ if (!pubA && ignoreUnpublished) {
+ continue;
+ }
+ rtl::Reference<unoidl::Entity> entB(providerB->findEntity(name));
+ if (!entB.is()) {
+ std::cerr
+ << "A entity " << name << " is not present in B"
+ << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ if (entA->getSort() != entB->getSort()) {
+ std::cerr
+ << "A entity " << name << " is of different sort in B"
+ << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ if (pubA && (!dynamic_cast<unoidl::PublishableEntity&>(*entB).isPublished()))
+ {
+ std::cerr
+ << "A published entity " << name << " is not published in B"
+ << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ switch (entA->getSort()) {
+ case unoidl::Entity::SORT_ENUM_TYPE:
+ {
+ rtl::Reference<unoidl::EnumTypeEntity> ent2A(
+ static_cast<unoidl::EnumTypeEntity *>(entA.get()));
+ rtl::Reference<unoidl::EnumTypeEntity> ent2B(
+ static_cast<unoidl::EnumTypeEntity *>(entB.get()));
+ if (ent2A->getMembers().size()
+ != ent2B->getMembers().size())
+ {
+ std::cerr
+ << "enum type " << name
+ << " number of members changed from "
+ << ent2A->getMembers().size() << " to "
+ << ent2B->getMembers().size() << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ for (auto
+ i(ent2A->getMembers().begin()),
+ j(ent2B->getMembers().begin());
+ i != ent2A->getMembers().end(); ++i, ++j)
+ {
+ if (i->name != j->name || i->value != j->value) {
+ std::cerr
+ << "enum type " << name << " member #"
+ << i - ent2A->getMembers().begin() + 1
+ << " changed from " << i->name << " = "
+ << i->value << " to " << j->name << " = "
+ << j->value << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ }
+ break;
+ }
+ case unoidl::Entity::SORT_PLAIN_STRUCT_TYPE:
+ {
+ rtl::Reference<unoidl::PlainStructTypeEntity> ent2A(
+ static_cast<unoidl::PlainStructTypeEntity *>(
+ entA.get()));
+ rtl::Reference<unoidl::PlainStructTypeEntity> ent2B(
+ static_cast<unoidl::PlainStructTypeEntity *>(
+ entB.get()));
+ if (ent2A->getDirectBase() != ent2B->getDirectBase()) {
+ std::cerr
+ << "plain struct type " << name
+ << " direct base changed from "
+ << (ent2A->getDirectBase().isEmpty()
+ ? OUString("none") : ent2A->getDirectBase())
+ << " to "
+ << (ent2B->getDirectBase().isEmpty()
+ ? OUString("none") : ent2B->getDirectBase())
+ << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ if (ent2A->getDirectMembers().size()
+ != ent2B->getDirectMembers().size())
+ {
+ std::cerr
+ << "plain struct type " << name
+ << " number of direct members changed from "
+ << ent2A->getDirectMembers().size() << " to "
+ << ent2B->getDirectMembers().size() << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ for (auto
+ i(ent2A->getDirectMembers().begin()),
+ j(ent2B->getDirectMembers().begin());
+ i != ent2A->getDirectMembers().end(); ++i, ++j)
+ {
+ if (i->name != j->name || i->type != j->type) {
+ std::cerr
+ << "plain struct type " << name
+ << " direct member #"
+ << i - ent2A->getDirectMembers().begin() + 1
+ << " changed from " << i->type << " " << i->name
+ << " to " << j->type << " " << j->name
+ << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ }
+ break;
+ }
+ case unoidl::Entity::SORT_POLYMORPHIC_STRUCT_TYPE_TEMPLATE:
+ {
+ rtl::Reference<unoidl::PolymorphicStructTypeTemplateEntity>
+ ent2A(
+ static_cast<unoidl::PolymorphicStructTypeTemplateEntity *>(
+ entA.get()));
+ rtl::Reference<unoidl::PolymorphicStructTypeTemplateEntity>
+ ent2B(
+ static_cast<unoidl::PolymorphicStructTypeTemplateEntity *>(
+ entB.get()));
+ if (ent2A->getTypeParameters().size()
+ != ent2B->getTypeParameters().size())
+ {
+ std::cerr
+ << "polymorphic struct type template " << name
+ << " number of type parameters changed from "
+ << ent2A->getTypeParameters().size() << " to "
+ << ent2B->getTypeParameters().size() << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ for (auto
+ i(ent2A->getTypeParameters().begin()),
+ j(ent2B->getTypeParameters().begin());
+ i != ent2A->getTypeParameters().end(); ++i, ++j)
+ {
+ if (*i != *j) {
+ std::cerr
+ << "polymorphic struct type template " << name
+ << " type parameter #"
+ << i - ent2A->getTypeParameters().begin() + 1
+ << " changed from " << *i << " to " << *j
+ << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ }
+ if (ent2A->getMembers().size()
+ != ent2B->getMembers().size())
+ {
+ std::cerr
+ << "polymorphic struct type template " << name
+ << " number of members changed from "
+ << ent2A->getMembers().size() << " to "
+ << ent2B->getMembers().size() << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ for (auto
+ i(ent2A->getMembers().begin()),
+ j(ent2B->getMembers().begin());
+ i != ent2A->getMembers().end(); ++i, ++j)
+ {
+ if (i->name != j->name || i->type != j->type
+ || i->parameterized != j->parameterized)
+ {
+ std::cerr
+ << "polymorphic struct type template " << name
+ << " member #"
+ << i - ent2A->getMembers().begin() + 1
+ << " changed from "
+ << (i->parameterized
+ ? OUString("parameterized ") : OUString())
+ << i->type << " " << i->name
+ << " to "
+ << (j->parameterized
+ ? OUString("parameterized ") : OUString())
+ << j->type << " " << j->name
+ << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ }
+ break;
+ }
+ case unoidl::Entity::SORT_EXCEPTION_TYPE:
+ {
+ rtl::Reference<unoidl::ExceptionTypeEntity> ent2A(
+ static_cast<unoidl::ExceptionTypeEntity *>(entA.get()));
+ rtl::Reference<unoidl::ExceptionTypeEntity> ent2B(
+ static_cast<unoidl::ExceptionTypeEntity *>(entB.get()));
+ if (ent2A->getDirectBase() != ent2B->getDirectBase()) {
+ std::cerr
+ << "exception type " << name
+ << " direct base changed from "
+ << (ent2A->getDirectBase().isEmpty()
+ ? OUString("none") : ent2A->getDirectBase())
+ << " to "
+ << (ent2B->getDirectBase().isEmpty()
+ ? OUString("none") : ent2B->getDirectBase())
+ << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ if (ent2A->getDirectMembers().size()
+ != ent2B->getDirectMembers().size())
+ {
+ std::cerr
+ << "exception type " << name
+ << " number of direct members changed from "
+ << ent2A->getDirectMembers().size() << " to "
+ << ent2B->getDirectMembers().size() << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ for (auto
+ i(ent2A->getDirectMembers().begin()),
+ j(ent2B->getDirectMembers().begin());
+ i != ent2A->getDirectMembers().end(); ++i, ++j)
+ {
+ if (i->name != j->name || i->type != j->type) {
+ std::cerr
+ << "exception type " << name
+ << " direct member #"
+ << i - ent2A->getDirectMembers().begin() + 1
+ << " changed from " << i->type << " " << i->name
+ << " to " << j->type << " " << j->name
+ << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ }
+ break;
+ }
+ case unoidl::Entity::SORT_INTERFACE_TYPE:
+ {
+ rtl::Reference<unoidl::InterfaceTypeEntity> ent2A(
+ static_cast<unoidl::InterfaceTypeEntity *>(entA.get()));
+ rtl::Reference<unoidl::InterfaceTypeEntity> ent2B(
+ static_cast<unoidl::InterfaceTypeEntity *>(entB.get()));
+ if (ent2A->getDirectMandatoryBases().size()
+ != ent2B->getDirectMandatoryBases().size())
+ {
+ std::cerr
+ << "interface type " << name
+ << " number of direct mandatory bases changed from "
+ << ent2A->getDirectMandatoryBases().size() << " to "
+ << ent2B->getDirectMandatoryBases().size()
+ << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ for (auto
+ i(ent2A->getDirectMandatoryBases().begin()),
+ j(ent2B->getDirectMandatoryBases().begin());
+ i != ent2A->getDirectMandatoryBases().end(); ++i, ++j)
+ {
+ if (i->name != j->name) {
+ std::cerr
+ << "interface type " << name
+ << " direct mandatory base #"
+ << (i - ent2A->getDirectMandatoryBases().begin()
+ + 1)
+ << " changed from " << i->name << " to "
+ << j->name << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ }
+ if (ent2A->getDirectOptionalBases().size()
+ != ent2B->getDirectOptionalBases().size())
+ {
+ std::cerr
+ << "interface type " << name
+ << " number of direct optional bases changed from "
+ << ent2A->getDirectOptionalBases().size() << " to "
+ << ent2B->getDirectOptionalBases().size()
+ << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ for (auto
+ i(ent2A->getDirectOptionalBases().begin()),
+ j(ent2B->getDirectOptionalBases().begin());
+ i != ent2A->getDirectOptionalBases().end(); ++i, ++j)
+ {
+ if (i->name != j->name) {
+ std::cerr
+ << "interface type " << name
+ << " direct optional base #"
+ << (i - ent2A->getDirectOptionalBases().begin()
+ + 1)
+ << " changed from " << i->name << " to "
+ << j->name << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ }
+ if (ent2A->getDirectAttributes().size()
+ != ent2B->getDirectAttributes().size())
+ {
+ std::cerr
+ << "interface type " << name
+ << " number of direct attributes changed from "
+ << ent2A->getDirectAttributes().size() << " to "
+ << ent2B->getDirectAttributes().size() << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ for (auto
+ i(ent2A->getDirectAttributes().begin()),
+ j(ent2B->getDirectAttributes().begin());
+ i != ent2A->getDirectAttributes().end(); ++i, ++j)
+ {
+ if (i->name != j->name || i->type != j->type
+ || i->bound != j->bound
+ || i->readOnly != j->readOnly
+ || i->getExceptions != j->getExceptions
+ || i->setExceptions != j->setExceptions)
+ {
+ std::cerr
+ << "interface type " << name
+ << " direct attribute #"
+ << i - ent2A->getDirectAttributes().begin() + 1
+ << " changed from "
+ << (i->bound ? OUString("bound ") : OUString())
+ << (i->readOnly
+ ? OUString("read-only ") : OUString())
+ << i->type << " " << i->name //TODO: exceptions
+ << " to "
+ << (j->bound ? OUString("bound ") : OUString())
+ << (j->readOnly
+ ? OUString("read-only ") : OUString())
+ << j->type << " " << j->name //TODO: exceptions
+ << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ }
+ if (ent2A->getDirectMethods().size()
+ != ent2B->getDirectMethods().size())
+ {
+ std::cerr
+ << "interface type " << name
+ << " number of direct methods changed from "
+ << ent2A->getDirectMethods().size() << " to "
+ << ent2B->getDirectMethods().size() << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ for (auto
+ i(ent2A->getDirectMethods().begin()),
+ j(ent2B->getDirectMethods().begin());
+ i != ent2A->getDirectMethods().end(); ++i, ++j)
+ {
+ if (i->name != j->name || i->returnType != j->returnType
+ || i->exceptions != j->exceptions)
+ {
+ std::cerr
+ << "interface type " << name
+ << " direct method #"
+ << i - ent2A->getDirectMethods().begin() + 1
+ << " changed from "
+ << i->returnType << " " << i->name //TODO: exceptions
+ << " to " << j->returnType << " " << j->name //TODO: exceptions
+ << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ if (i->parameters.size() != j->parameters.size()) {
+ std::cerr
+ << "interface type " << name
+ << " direct method " << i->name
+ << " number of parameters changed from "
+ << i->parameters.size() << " to "
+ << j->parameters.size() << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ for (auto
+ k(i->parameters.begin()),
+ l(j->parameters.begin());
+ k != i->parameters.end(); ++k, ++l)
+ {
+ if (k->type != l->type || k->direction != l->direction)
+ {
+ std::cerr
+ << "interface type " << name
+ << " direct method " << i->name
+ << " parameter #"
+ << k - i->parameters.begin() + 1
+ << " changed from "
+ << showDirection(k->direction) << " "
+ << k->type << " to "
+ << showDirection(l->direction) << " "
+ << l->type << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ if (k->name != l->name) {
+ std::cerr
+ << "interface type " << name
+ << " direct method " << i->name
+ << " parameter #"
+ << k - i->parameters.begin() + 1
+ << " changed name from " << k->name
+ << " to " << l->name << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ }
+ }
+ break;
+ }
+ case unoidl::Entity::SORT_TYPEDEF:
+ {
+ rtl::Reference<unoidl::TypedefEntity> ent2A(
+ static_cast<unoidl::TypedefEntity *>(entA.get()));
+ rtl::Reference<unoidl::TypedefEntity> ent2B(
+ static_cast<unoidl::TypedefEntity *>(entB.get()));
+ if (ent2A->getType() != ent2B->getType()) {
+ std::cerr
+ << "typedef " << name << " type changed from "
+ << ent2A->getType() << " to " << ent2B->getType()
+ << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ break;
+ }
+ case unoidl::Entity::SORT_CONSTANT_GROUP:
+ {
+ rtl::Reference<unoidl::ConstantGroupEntity> ent2A(
+ static_cast<unoidl::ConstantGroupEntity *>(entA.get()));
+ rtl::Reference<unoidl::ConstantGroupEntity> ent2B(
+ static_cast<unoidl::ConstantGroupEntity *>(entB.get()));
+ for (auto & i: ent2A->getMembers()) {
+ bool found = false;
+ for (auto & j: ent2B->getMembers()) {
+ if (i.name == j.name) {
+ if (i.value != j.value) {
+ std::cerr
+ << "constant group " << name
+ << " member " << i.name
+ << " changed value" << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ found = true;
+ break;
+ }
+ }
+ if (!found) {
+ std::cerr
+ << "A constant group " << name << " member "
+ << i.name << " is not present in B"
+ << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ }
+ break;
+ }
+ case unoidl::Entity::SORT_SINGLE_INTERFACE_BASED_SERVICE:
+ {
+ rtl::Reference<unoidl::SingleInterfaceBasedServiceEntity>
+ ent2A(
+ static_cast<unoidl::SingleInterfaceBasedServiceEntity *>(
+ entA.get()));
+ rtl::Reference<unoidl::SingleInterfaceBasedServiceEntity>
+ ent2B(
+ static_cast<unoidl::SingleInterfaceBasedServiceEntity *>(
+ entB.get()));
+ if (ent2A->getBase() != ent2B->getBase()) {
+ std::cerr
+ << "single-interface--based service " << name
+ << " base changed from " << ent2A->getBase()
+ << " to " << ent2B->getBase()
+ << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ if (ent2A->getConstructors().size()
+ != ent2B->getConstructors().size())
+ {
+ std::cerr
+ << "single-interface--based service " << name
+ << " number of constructors changed from "
+ << ent2A->getConstructors().size() << " to "
+ << ent2B->getConstructors().size() << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ for (auto
+ i(ent2A->getConstructors().begin()),
+ j(ent2B->getConstructors().begin());
+ i != ent2A->getConstructors().end(); ++i, ++j)
+ {
+ if (i->name != j->name || i->parameters != j->parameters
+ || i->exceptions != j->exceptions
+ || i->defaultConstructor != j->defaultConstructor)
+ {
+ std::cerr
+ << "single-interface--based service " << name
+ << " constructor #"
+ << i - ent2A->getConstructors().begin() + 1
+ << " changed from "
+ << (i->defaultConstructor
+ ? OUString("default ") : i->name) //TODO: parameters, exceptions
+ << " to "
+ << (j->defaultConstructor
+ ? OUString("default ") : j->name) //TODO: parameters, exceptions
+ << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ }
+ break;
+ }
+ case unoidl::Entity::SORT_ACCUMULATION_BASED_SERVICE:
+ {
+ rtl::Reference<unoidl::AccumulationBasedServiceEntity>
+ ent2A(
+ static_cast<unoidl::AccumulationBasedServiceEntity *>(
+ entA.get()));
+ rtl::Reference<unoidl::AccumulationBasedServiceEntity>
+ ent2B(
+ static_cast<unoidl::AccumulationBasedServiceEntity *>(
+ entB.get()));
+ if (ent2A->getDirectMandatoryBaseServices().size()
+ != ent2B->getDirectMandatoryBaseServices().size())
+ {
+ std::cerr
+ << "accumulation-based service " << name
+ << (" number of direct mandatory base services"
+ " changed from ")
+ << ent2A->getDirectMandatoryBaseServices().size()
+ << " to "
+ << ent2B->getDirectMandatoryBaseServices().size()
+ << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ for (auto
+ i(ent2A->getDirectMandatoryBaseServices().begin()),
+ j(ent2B->getDirectMandatoryBaseServices().begin());
+ i != ent2A->getDirectMandatoryBaseServices().end();
+ ++i, ++j)
+ {
+ if (i->name != j->name) {
+ std::cerr
+ << "accumulation-based service " << name
+ << " direct mandatory base service #"
+ << (i
+ - (ent2A->getDirectMandatoryBaseServices()
+ .begin())
+ + 1)
+ << " changed from " << i->name << " to "
+ << j->name << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ }
+ if (ent2A->getDirectOptionalBaseServices().size()
+ > ent2B->getDirectOptionalBaseServices().size())
+ {
+ std::cerr
+ << "accumulation-based service " << name
+ << (" number of direct optional base services"
+ " shrank from ")
+ << ent2A->getDirectOptionalBaseServices().size()
+ << " to "
+ << ent2B->getDirectOptionalBaseServices().size()
+ << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ for (auto & i: ent2A->getDirectOptionalBaseServices()) {
+ if (std::none_of(
+ ent2B->getDirectOptionalBaseServices().begin(),
+ ent2B->getDirectOptionalBaseServices().end(),
+ EqualsAnnotation(i.name)))
+ {
+ std::cerr
+ << "accumulation-based service " << name
+ << " direct optional base service " << i.name
+ << " was removed" << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ }
+ if (ent2A->getDirectMandatoryBaseInterfaces().size()
+ != ent2B->getDirectMandatoryBaseInterfaces().size())
+ {
+ std::cerr
+ << "accumulation-based service " << name
+ << (" number of direct mandatory base interfaces"
+ " changed from ")
+ << ent2A->getDirectMandatoryBaseInterfaces().size()
+ << " to "
+ << ent2B->getDirectMandatoryBaseInterfaces().size()
+ << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ for (auto
+ i(ent2A->getDirectMandatoryBaseInterfaces()
+ .begin()),
+ j(ent2B->getDirectMandatoryBaseInterfaces()
+ .begin());
+ i != ent2A->getDirectMandatoryBaseInterfaces().end();
+ ++i, ++j)
+ {
+ if (i->name != j->name) {
+ std::cerr
+ << "accumulation-based service " << name
+ << " direct mandatory base interface #"
+ << (i
+ - (ent2A->getDirectMandatoryBaseInterfaces()
+ .begin())
+ + 1)
+ << " changed from " << i->name << " to "
+ << j->name << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ }
+ if (ent2A->getDirectOptionalBaseInterfaces().size()
+ > ent2B->getDirectOptionalBaseInterfaces().size())
+ {
+ std::cerr
+ << "accumulation-based service " << name
+ << (" number of direct optional base interfaces"
+ " shrank from ")
+ << ent2A->getDirectOptionalBaseInterfaces().size()
+ << " to "
+ << ent2B->getDirectOptionalBaseInterfaces().size()
+ << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ for (auto & i: ent2A->getDirectOptionalBaseInterfaces()) {
+ if (std::none_of(
+ (ent2B->getDirectOptionalBaseInterfaces()
+ .begin()),
+ ent2B->getDirectOptionalBaseInterfaces().end(),
+ EqualsAnnotation(i.name)))
+ {
+ std::cerr
+ << "accumulation-based service " << name
+ << " direct optional base interface " << i.name
+ << " was removed" << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ }
+ if (ent2A->getDirectProperties().size()
+ > ent2B->getDirectProperties().size())
+ {
+ std::cerr
+ << "accumulation-based service " << name
+ << " number of direct properties changed from "
+ << ent2A->getDirectProperties().size() << " to "
+ << ent2B->getDirectProperties().size() << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ for (auto
+ i(ent2A->getDirectProperties().begin()),
+ j(ent2B->getDirectProperties().begin());
+ i != ent2A->getDirectProperties().end(); ++i, ++j)
+ {
+ if (i->name != j->name || i->type != j->type
+ || i->attributes != j->attributes)
+ {
+ std::cerr
+ << "accumulation-based service " << name
+ << " direct property #"
+ << i - ent2A->getDirectProperties().begin() + 1
+ << " changed from "
+ << i->type << " " << i->name //TODO: attributes
+ << " to "
+ << j->type << " " << j->name //TODO: attributes
+ << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ }
+ for (auto
+ i(ent2B->getDirectProperties().begin()
+ + ent2A->getDirectProperties().size());
+ i != ent2B->getDirectProperties().end(); ++i)
+ {
+ if ((i->attributes & unoidl::AccumulationBasedServiceEntity::Property::ATTRIBUTE_OPTIONAL) == 0)
+ {
+ std::cerr
+ << "B accumulation-based service " << name
+ << " additional direct property " << i->name
+ << " is not optional" << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ }
+ break;
+ }
+ case unoidl::Entity::SORT_INTERFACE_BASED_SINGLETON:
+ {
+ rtl::Reference<unoidl::InterfaceBasedSingletonEntity> ent2A(
+ static_cast<unoidl::InterfaceBasedSingletonEntity *>(
+ entA.get()));
+ rtl::Reference<unoidl::InterfaceBasedSingletonEntity> ent2B(
+ static_cast<unoidl::InterfaceBasedSingletonEntity *>(
+ entB.get()));
+ if (ent2A->getBase() != ent2B->getBase()) {
+ std::cerr
+ << "interface-based singleton " << name
+ << " base changed from " << ent2A->getBase()
+ << " to " << ent2B->getBase() << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ break;
+ }
+ case unoidl::Entity::SORT_SERVICE_BASED_SINGLETON:
+ {
+ rtl::Reference<unoidl::ServiceBasedSingletonEntity> ent2A(
+ static_cast<unoidl::ServiceBasedSingletonEntity *>(
+ entA.get()));
+ rtl::Reference<unoidl::ServiceBasedSingletonEntity> ent2B(
+ static_cast<unoidl::ServiceBasedSingletonEntity *>(
+ entB.get()));
+ if (ent2A->getBase() != ent2B->getBase()) {
+ std::cerr
+ << "service-based singleton " << name
+ << " base changed from " << ent2A->getBase()
+ << " to " << ent2B->getBase() << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ break;
+ }
+ case unoidl::Entity::SORT_MODULE:
+ assert(false && "this cannot happen");
+ }
+ }
+ }
+}
+
+bool valid(std::u16string_view identifier) {
+ for (size_t i = 0;; ++i) {
+ i = identifier.find('_', i);
+ if (i == std::u16string_view::npos) {
+ return true;
+ }
+ if (!rtl::isAsciiUpperCase(identifier[0]) || identifier[i - 1] == '_') {
+ return false;
+ }
+ }
+}
+
+void checkIds(
+ rtl::Reference<unoidl::Provider> const & providerA, std::u16string_view prefix,
+ rtl::Reference<unoidl::MapCursor> const & cursor)
+{
+ assert(cursor.is());
+ for (;;) {
+ OUString id;
+ rtl::Reference<unoidl::Entity> entB(cursor->getNext(&id));
+ if (!entB.is()) {
+ break;
+ }
+ OUString name(prefix + id);
+ rtl::Reference<unoidl::Entity> entA(providerA->findEntity(name));
+ if (!(entA.is() || valid(id))) {
+ std::cerr
+ << "entity name " << name << " uses an invalid identifier"
+ << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ switch (entB->getSort()) {
+ case unoidl::Entity::SORT_MODULE:
+ checkIds(
+ providerA, Concat2View(name + "."),
+ (static_cast<unoidl::ModuleEntity *>(entB.get())
+ ->createCursor()));
+ break;
+ case unoidl::Entity::SORT_ENUM_TYPE:
+ if (!entA.is()) {
+ rtl::Reference<unoidl::EnumTypeEntity> ent2B(
+ static_cast<unoidl::EnumTypeEntity *>(entB.get()));
+ for (auto & i: ent2B->getMembers()) {
+ if (!valid(i.name)) {
+ std::cerr
+ << "enum type " << name << " member " << i.name
+ << " uses an invalid identifier" << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ }
+ }
+ break;
+ case unoidl::Entity::SORT_PLAIN_STRUCT_TYPE:
+ if (!entA.is()) {
+ rtl::Reference<unoidl::PlainStructTypeEntity> ent2B(
+ static_cast<unoidl::PlainStructTypeEntity *>(
+ entB.get()));
+ for (auto & i: ent2B->getDirectMembers()) {
+ if (!valid(i.name)) {
+ std::cerr
+ << "plain struct type " << name << " direct member "
+ << i.name << " uses an invalid identifier"
+ << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ }
+ }
+ break;
+ case unoidl::Entity::SORT_POLYMORPHIC_STRUCT_TYPE_TEMPLATE:
+ if (!entA.is()) {
+ rtl::Reference<unoidl::PolymorphicStructTypeTemplateEntity>
+ ent2B(
+ static_cast<
+ unoidl::PolymorphicStructTypeTemplateEntity *>(
+ entB.get()));
+ for (auto & i: ent2B->getTypeParameters()) {
+ if (!valid(i)) {
+ std::cerr
+ << "polymorphic struct type template " << name
+ << " type parameter " << i
+ << " uses an invalid identifier" << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ }
+ for (auto & i: ent2B->getMembers()) {
+ if (!valid(i.name)) {
+ std::cerr
+ << "polymorphic struct type template " << name
+ << " member " << i.name
+ << " uses an invalid identifier" << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ }
+ }
+ break;
+ case unoidl::Entity::SORT_EXCEPTION_TYPE:
+ if (!entA.is()) {
+ rtl::Reference<unoidl::ExceptionTypeEntity> ent2B(
+ static_cast<unoidl::ExceptionTypeEntity *>(entB.get()));
+ for (auto & i: ent2B->getDirectMembers()) {
+ if (!valid(i.name)) {
+ std::cerr
+ << "exception type " << name << " direct member "
+ << i.name << " uses an invalid identifier"
+ << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ }
+ }
+ break;
+ case unoidl::Entity::SORT_INTERFACE_TYPE:
+ if (!entA.is()) {
+ rtl::Reference<unoidl::InterfaceTypeEntity> ent2B(
+ static_cast<unoidl::InterfaceTypeEntity *>(entB.get()));
+ for (auto & i: ent2B->getDirectAttributes()) {
+ if (!valid(i.name)) {
+ std::cerr
+ << "interface type " << name << " direct attribute "
+ << i.name << " uses an invalid identifier"
+ << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ }
+ for (auto & i: ent2B->getDirectMethods()) {
+ if (!valid(i.name)) {
+ std::cerr
+ << "interface type " << name << " direct method "
+ << i.name << " uses an invalid identifier"
+ << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ for (auto & j: i.parameters) {
+ if (!valid(j.name)) {
+ std::cerr
+ << "interface type " << name
+ << " direct method " << i.name << " parameter "
+ << j.name << " uses an invalid identifier"
+ << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ }
+ }
+ }
+ break;
+ case unoidl::Entity::SORT_TYPEDEF:
+ case unoidl::Entity::SORT_INTERFACE_BASED_SINGLETON:
+ case unoidl::Entity::SORT_SERVICE_BASED_SINGLETON:
+ break;
+ case unoidl::Entity::SORT_CONSTANT_GROUP:
+ {
+ rtl::Reference<unoidl::ConstantGroupEntity> ent2B(
+ static_cast<unoidl::ConstantGroupEntity *>(entB.get()));
+ for (auto & i: ent2B->getMembers()) {
+ bool found = false;
+ if (entA.is()) {
+ rtl::Reference<unoidl::ConstantGroupEntity> ent2A(
+ static_cast<unoidl::ConstantGroupEntity *>(
+ entA.get()));
+ for (auto & j: ent2A->getMembers()) {
+ if (i.name == j.name) {
+ found = true;
+ break;
+ }
+ }
+ }
+ if (!(found || valid(i.name))) {
+ std::cerr
+ << "Constant group " << name << " member "
+ << i.name << " uses an invalid identifier"
+ << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ }
+ break;
+ }
+ case unoidl::Entity::SORT_SINGLE_INTERFACE_BASED_SERVICE:
+ if (!entA.is()) {
+ rtl::Reference<unoidl::SingleInterfaceBasedServiceEntity>
+ ent2B(
+ static_cast<unoidl::SingleInterfaceBasedServiceEntity *>(
+ entB.get()));
+ for (auto & i: ent2B->getConstructors()) {
+ if (!valid(i.name)) {
+ std::cerr
+ << "single-interface--based service " << name
+ << " constructor " << i.name
+ << " uses an invalid identifier" << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ for (auto & j: i.parameters) {
+ if (!valid(j.name)) {
+ std::cerr
+ << "single-interface--based service " << name
+ << " constructor " << i.name << " parameter "
+ << j.name << " uses an invalid identifier"
+ << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ }
+ }
+ }
+ break;
+ case unoidl::Entity::SORT_ACCUMULATION_BASED_SERVICE:
+ {
+ rtl::Reference<unoidl::AccumulationBasedServiceEntity> ent2B(
+ static_cast<unoidl::AccumulationBasedServiceEntity *>(
+ entB.get()));
+ std::vector<unoidl::AccumulationBasedServiceEntity::Property>::size_type
+ n(entA.is()
+ ? (static_cast<unoidl::AccumulationBasedServiceEntity *>(
+ entA.get())
+ ->getDirectProperties().size())
+ : 0);
+ assert(n <= ent2B->getDirectProperties().size());
+ for (auto i(ent2B->getDirectProperties().begin() +n);
+ i != ent2B->getDirectProperties().end(); ++i)
+ {
+ if (!valid(i->name)) {
+ std::cerr
+ << "accumulation-based service " << name
+ << " direct property " << i->name
+ << " uses an invalid identifier" << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ }
+ break;
+ }
+ }
+ }
+}
+
+}
+
+SAL_IMPLEMENT_MAIN() {
+ try {
+ sal_uInt32 args = rtl_getAppCommandArgCount();
+ rtl::Reference<unoidl::Manager> mgr[2];
+ mgr[0] = new unoidl::Manager;
+ mgr[1] = new unoidl::Manager;
+ rtl::Reference<unoidl::Provider> prov[2];
+ int side = 0;
+ bool ignoreUnpublished = false;
+ for (sal_uInt32 i = 0; i != args; ++i) {
+ bool delimiter = false;
+ OUString uri;
+ if (getArgument(
+ i, &ignoreUnpublished, side == 0 ? &delimiter : nullptr,
+ &uri))
+ {
+ try {
+ prov[side] = mgr[side]->addProvider(uri);
+ } catch (unoidl::NoSuchFileException &) {
+ std::cerr
+ << "Input <" << uri << "> does not exist" << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ } else if (delimiter) {
+ side = 1;
+ }
+ }
+ if (side == 0 || !(prov[0].is() && prov[1].is())) {
+ badUsage();
+ }
+ checkMap(prov[1], u"", prov[0]->createRootCursor(), ignoreUnpublished);
+ checkIds(prov[0], u"", prov[1]->createRootCursor());
+ return EXIT_SUCCESS;
+ } catch (unoidl::FileFormatException & e1) {
+ std::cerr
+ << "Bad input <" << e1.getUri() << ">: " << e1.getDetail()
+ << std::endl;
+ std::exit(EXIT_FAILURE);
+ } catch (std::exception & e1) {
+ std::cerr << "Failure: " << e1.what() << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */