[Libreoffice-commits] core.git: codemaker/source cppuhelper/source include/unoidl unodevtools/source unoidl/README unoidl/source
Stephan Bergmann
sbergman at redhat.com
Thu May 16 07:13:16 PDT 2013
codemaker/source/cppumaker/cpputype.cxx | 47 +-
codemaker/source/cppumaker/dependencies.cxx | 4
codemaker/source/javamaker/javatype.cxx | 6
cppuhelper/source/typemanager.cxx | 15
include/unoidl/unoidl.hxx | 218 ++++++++----
unodevtools/source/skeletonmaker/cpptypemaker.cxx | 18 -
unodevtools/source/skeletonmaker/javatypemaker.cxx | 16
unodevtools/source/skeletonmaker/skeletoncommon.cxx | 35 +-
unoidl/README | 120 ++++---
unoidl/source/legacyprovider.cxx | 117 ++++--
unoidl/source/reg2unoidl.cxx | 339 +++++++++++++++-----
unoidl/source/unoidlprovider.cxx | 338 +++++++++++++------
12 files changed, 869 insertions(+), 404 deletions(-)
New commits:
commit a1dff2901e9b6f70ea87df5e76825367b38ceaf4
Author: Stephan Bergmann <sbergman at redhat.com>
Date: Thu May 16 14:50:21 2013 +0200
Support for annotations in the new UNOIDL format
...used for now to transport @deprecated information.
Also, improve Idx-String (formerly Idx-Name, but also used for UTF-8 annotations
now) format, using the 0x80000000 for the indirection rather than the base case.
(And the README erroneously used "Offset of" Idx-String all over the place.)
Change-Id: I7003b1558ab536a11a9af308f9b16a7ef8840792
diff --git a/codemaker/source/cppumaker/cpputype.cxx b/codemaker/source/cppumaker/cpputype.cxx
index 5d01a9f..9848f57 100755
--- a/codemaker/source/cppumaker/cpputype.cxx
+++ b/codemaker/source/cppumaker/cpputype.cxx
@@ -930,9 +930,15 @@ OUString CppuType::indent() const {
return buf.makeStringAndClear();
}
-bool isDocumentedDeprecated(OUString const & documentation) {
- return documentation.indexOf("@deprecated") != -1;
- //TODO: this check is somewhat crude
+bool isDeprecated(std::vector< OUString > const & annotations) {
+ for (std::vector< OUString >::const_iterator i(annotations.begin());
+ i != annotations.end(); ++i)
+ {
+ if (*i == "deprecated") {
+ return true;
+ }
+ }
+ return false;
}
void dumpDeprecation(FileStream & out, bool deprecated) {
@@ -963,16 +969,17 @@ void BaseOffset::calculateBases(
rtl::Reference< unoidl::InterfaceTypeEntity > const & entity)
{
assert(entity.is());
- for (std::vector< OUString >::const_iterator i(
+ for (std::vector< unoidl::AnnotatedReference >::const_iterator i(
entity->getDirectMandatoryBases().begin());
i != entity->getDirectMandatoryBases().end(); ++i)
{
- if (set_.insert(*i).second) {
+ if (set_.insert(i->name).second) {
rtl::Reference< unoidl::Entity > ent;
- codemaker::UnoType::Sort sort = manager_->getSort(*i, &ent);
+ codemaker::UnoType::Sort sort = manager_->getSort(i->name, &ent);
if (sort != codemaker::UnoType::SORT_INTERFACE_TYPE) {
throw CannotDumpException(
- "interface type base " + *i + " is not an interface type");
+ "interface type base " + i->name
+ + " is not an interface type");
}
rtl::Reference< unoidl::InterfaceTypeEntity > ent2(
dynamic_cast< unoidl::InterfaceTypeEntity * >(ent.get()));
@@ -1037,17 +1044,17 @@ InterfaceType::InterfaceType(
{
assert(entity.is());
m_inheritedMemberCount = 0;
- m_isDeprecated = isDocumentedDeprecated("TODO");
+ m_isDeprecated = isDeprecated(entity->getAnnotations());
}
void InterfaceType::dumpDeclaration(FileStream & out) {
out << "\nclass SAL_NO_VTABLE " << id_;
- for (std::vector< OUString >::const_iterator i(
+ for (std::vector< unoidl::AnnotatedReference >::const_iterator i(
entity_->getDirectMandatoryBases().begin());
i != entity_->getDirectMandatoryBases().end(); ++i)
{
out << (i == entity_->getDirectMandatoryBases().begin() ? " :" : ",")
- << " public " << codemaker::cpp::scopedCppName(u2b(*i));
+ << " public " << codemaker::cpp::scopedCppName(u2b(i->name));
}
out << "\n{\npublic:\n";
inc();
@@ -1094,7 +1101,7 @@ void InterfaceType::dumpAttributes(FileStream & out) {
i(entity_->getDirectAttributes().begin());
i != entity_->getDirectAttributes().end(); ++i)
{
- bool depr = m_isDeprecated || isDocumentedDeprecated("TODO");
+ bool depr = m_isDeprecated || isDeprecated(i->annotations);
out << indent();
dumpDeprecation(out, depr);
out << "virtual ";
@@ -1124,7 +1131,7 @@ void InterfaceType::dumpMethods(FileStream & out) {
i != entity_->getDirectMethods().end(); ++i)
{
out << indent();
- dumpDeprecation(out, m_isDeprecated || isDocumentedDeprecated("TODO"));
+ dumpDeprecation(out, m_isDeprecated || isDeprecated(i->annotations));
out << "virtual ";
dumpType(out, i->returnType);
out << " SAL_CALL " << i->name << "(";
@@ -1169,10 +1176,10 @@ void InterfaceType::dumpNormalGetCppuType(FileStream & out) {
<< "static typelib_TypeDescriptionReference * the_type = 0;\n"
<< indent() << "if ( !the_type )\n" << indent() << "{\n";
inc();
- std::vector< OUString >::size_type bases(
+ std::vector< unoidl::AnnotatedReference >::size_type bases(
entity_->getDirectMandatoryBases().size());
if (bases == 1
- && (entity_->getDirectMandatoryBases()[0]
+ && (entity_->getDirectMandatoryBases()[0].name
== "com.sun.star.uno.XInterface"))
{
bases = 0;
@@ -1180,13 +1187,13 @@ void InterfaceType::dumpNormalGetCppuType(FileStream & out) {
if (bases != 0) {
out << indent() << "typelib_TypeDescriptionReference * aSuperTypes["
<< entity_->getDirectMandatoryBases().size() << "];\n";
- std::vector< OUString >::size_type n = 0;
- for (std::vector< OUString >::const_iterator i(
+ std::vector< unoidl::AnnotatedReference >::size_type n = 0;
+ for (std::vector< unoidl::AnnotatedReference >::const_iterator i(
entity_->getDirectMandatoryBases().begin());
i != entity_->getDirectMandatoryBases().end(); ++i)
{
out << indent() << "aSuperTypes[" << n++ << "] = ::cppu::UnoType< ";
- dumpType(out, *i, true, false, false, true);
+ dumpType(out, i->name, true, false, false, true);
out << " >::get().getTypeLibType();\n";
}
}
@@ -1215,13 +1222,13 @@ void InterfaceType::dumpComprehensiveGetCppuType(FileStream & out) {
<< indent() << "typelib_InterfaceTypeDescription * pTD = 0;\n\n";
out << indent() << "typelib_TypeDescriptionReference * aSuperTypes["
<< entity_->getDirectMandatoryBases().size() << "];\n";
- std::vector< OUString >::size_type n = 0;
- for (std::vector< OUString >::const_iterator i(
+ std::vector< unoidl::AnnotatedReference >::size_type n = 0;
+ for (std::vector< unoidl::AnnotatedReference >::const_iterator i(
entity_->getDirectMandatoryBases().begin());
i != entity_->getDirectMandatoryBases().end(); ++i)
{
out << indent() << "aSuperTypes[" << n++ << "] = ::cppu::UnoType< ";
- dumpType(out, *i, false, false, false, true);
+ dumpType(out, i->name, false, false, false, true);
out << " >::get().getTypeLibType();\n";
}
std::size_t count = entity_->getDirectAttributes().size()
diff --git a/codemaker/source/cppumaker/dependencies.cxx b/codemaker/source/cppumaker/dependencies.cxx
index 82ae4a1..b56bacf 100644
--- a/codemaker/source/cppumaker/dependencies.cxx
+++ b/codemaker/source/cppumaker/dependencies.cxx
@@ -103,11 +103,11 @@ Dependencies::Dependencies(
{
rtl::Reference< unoidl::InterfaceTypeEntity > ent2(
static_cast< unoidl::InterfaceTypeEntity * >(ent.get()));
- for (std::vector< OUString >::const_iterator i(
+ for (std::vector< unoidl::AnnotatedReference >::const_iterator i(
ent2->getDirectMandatoryBases().begin());
i != ent2->getDirectMandatoryBases().end(); ++i)
{
- insert(*i, true);
+ insert(i->name, true);
}
if (!(ent2->getDirectAttributes().empty()
&& ent2->getDirectMethods().empty()))
diff --git a/codemaker/source/javamaker/javatype.cxx b/codemaker/source/javamaker/javatype.cxx
index 6f31866..d12f04e 100644
--- a/codemaker/source/javamaker/javatype.cxx
+++ b/codemaker/source/javamaker/javatype.cxx
@@ -1810,12 +1810,12 @@ void handleInterfaceType(
| ClassFile::ACC_ABSTRACT),
className, "java/lang/Object", ""));
SAL_WNODEPRECATED_DECLARATIONS_POP
- for (std::vector< OUString >::const_iterator i(
+ for (std::vector< unoidl::AnnotatedReference >::const_iterator i(
entity->getDirectMandatoryBases().begin());
i != entity->getDirectMandatoryBases().end(); ++i)
{
- dependencies->insert(*i);
- cf->addInterface(codemaker::convertString(*i).replace('.', '/'));
+ dependencies->insert(i->name);
+ cf->addInterface(codemaker::convertString(i->name).replace('.', '/'));
}
// As a special case, let com.sun.star.lang.XEventListener extend
// java.util.EventListener ("A tagging interface that all event listener
diff --git a/cppuhelper/source/typemanager.cxx b/cppuhelper/source/typemanager.cxx
index 6f7cd89..672e377 100644
--- a/cppuhelper/source/typemanager.cxx
+++ b/cppuhelper/source/typemanager.cxx
@@ -926,7 +926,7 @@ private:
getBaseType() throw (css::uno::RuntimeException) {
return entity_->getDirectMandatoryBases().empty()
? css::uno::Reference< css::reflection::XTypeDescription >()
- : manager_->resolve(entity_->getDirectMandatoryBases()[0]);
+ : manager_->resolve(entity_->getDirectMandatoryBases()[0].name);
}
virtual css::uno::Uik SAL_CALL getUik() throw (css::uno::RuntimeException)
@@ -988,7 +988,7 @@ InterfaceTypeDescription::getBaseTypes() throw (css::uno::RuntimeException) {
css::uno::Sequence<
css::uno::Reference< css::reflection::XTypeDescription > > s(n);
for (sal_Int32 i = 0; i != n; ++i) {
- s[i] = manager_->resolve(entity_->getDirectMandatoryBases()[i]);
+ s[i] = manager_->resolve(entity_->getDirectMandatoryBases()[i].name);
}
return s;
}
@@ -1003,7 +1003,7 @@ InterfaceTypeDescription::getOptionalBaseTypes()
css::uno::Sequence<
css::uno::Reference< css::reflection::XTypeDescription > > s(n);
for (sal_Int32 i = 0; i != n; ++i) {
- s[i] = manager_->resolve(entity_->getDirectOptionalBases()[i]);
+ s[i] = manager_->resolve(entity_->getDirectOptionalBases()[i].name);
}
return s;
}
@@ -1487,7 +1487,8 @@ AccumulationBasedServiceDescription::getMandatoryServices()
css::uno::Reference< css::reflection::XServiceTypeDescription > > s(n);
for (sal_Int32 i = 0; i != n; ++i) {
s[i].set(
- manager_->resolve(entity_->getDirectMandatoryBaseServices()[i]),
+ manager_->resolve(
+ entity_->getDirectMandatoryBaseServices()[i].name),
css::uno::UNO_QUERY_THROW);
}
return s;
@@ -1505,7 +1506,7 @@ AccumulationBasedServiceDescription::getOptionalServices()
css::uno::Reference< css::reflection::XServiceTypeDescription > > s(n);
for (sal_Int32 i = 0; i != n; ++i) {
s[i].set(
- manager_->resolve(entity_->getDirectOptionalBaseServices()[i]),
+ manager_->resolve(entity_->getDirectOptionalBaseServices()[i].name),
css::uno::UNO_QUERY_THROW);
}
return s;
@@ -1526,7 +1527,7 @@ AccumulationBasedServiceDescription::getMandatoryInterfaces()
s[i].set(
resolveTypedefs(
manager_->find(
- entity_->getDirectMandatoryBaseInterfaces()[i])),
+ entity_->getDirectMandatoryBaseInterfaces()[i].name)),
css::uno::UNO_QUERY_THROW);
}
return s;
@@ -1547,7 +1548,7 @@ AccumulationBasedServiceDescription::getOptionalInterfaces()
s[i].set(
resolveTypedefs(
manager_->find(
- entity_->getDirectOptionalBaseInterfaces()[i])),
+ entity_->getDirectOptionalBaseInterfaces()[i].name)),
css::uno::UNO_QUERY_THROW);
}
return s;
diff --git a/include/unoidl/unoidl.hxx b/include/unoidl/unoidl.hxx
index 9d77447..7a7c558 100644
--- a/include/unoidl/unoidl.hxx
+++ b/include/unoidl/unoidl.hxx
@@ -65,6 +65,18 @@ private:
rtl::OUString detail_;
};
+struct AnnotatedReference {
+ AnnotatedReference(
+ rtl::OUString const & theName,
+ std::vector< rtl::OUString > const & theAnnotations):
+ name(theName), annotations(theAnnotations)
+ {}
+
+ rtl::OUString name;
+
+ std::vector< rtl::OUString > annotations;
+};
+
class LO_DLLPUBLIC_UNOIDL Entity: public salhelper::SimpleReferenceObject {
public:
enum Sort {
@@ -115,32 +127,45 @@ class LO_DLLPUBLIC_UNOIDL PublishableEntity: public Entity {
public:
bool isPublished() const { return published_; }
+ std::vector< rtl::OUString > const & getAnnotations() const
+ { return annotations_; }
+
protected:
- SAL_DLLPRIVATE PublishableEntity(Sort sort, bool published):
- Entity(sort), published_(published)
+ SAL_DLLPRIVATE PublishableEntity(
+ Sort sort, bool published,
+ std::vector< rtl::OUString > const & annotations):
+ Entity(sort), published_(published), annotations_(annotations)
{}
virtual SAL_DLLPRIVATE ~PublishableEntity() throw ();
private:
bool published_;
+
+ std::vector< rtl::OUString > annotations_;
};
class LO_DLLPUBLIC_UNOIDL EnumTypeEntity: public PublishableEntity {
public:
struct Member {
- Member(rtl::OUString const & theName, sal_Int32 theValue):
- name(theName), value(theValue)
+ Member(
+ rtl::OUString const & theName, sal_Int32 theValue,
+ std::vector< rtl::OUString > const & theAnnotations):
+ name(theName), value(theValue), annotations(theAnnotations)
{}
rtl::OUString name;
sal_Int32 value;
+
+ std::vector< rtl::OUString > annotations;
};
SAL_DLLPRIVATE EnumTypeEntity(
- bool published, std::vector< Member > const & members):
- PublishableEntity(SORT_ENUM_TYPE, published), members_(members)
+ bool published, std::vector< Member > const & members,
+ std::vector< rtl::OUString > const & annotations):
+ PublishableEntity(SORT_ENUM_TYPE, published, annotations),
+ members_(members)
{ assert(!members.empty()); }
std::vector< Member > const & getMembers() const { return members_; }
@@ -154,19 +179,23 @@ private:
class LO_DLLPUBLIC_UNOIDL PlainStructTypeEntity: public PublishableEntity {
public:
struct Member {
- Member(rtl::OUString const & theName, rtl::OUString const & theType):
- name(theName), type(theType)
+ Member(rtl::OUString const & theName, rtl::OUString const & theType,
+ std::vector< rtl::OUString > const & theAnnotations):
+ name(theName), type(theType), annotations(theAnnotations)
{}
rtl::OUString name;
rtl::OUString type;
+
+ std::vector< rtl::OUString > annotations;
};
SAL_DLLPRIVATE PlainStructTypeEntity(
bool published, rtl::OUString const & directBase,
- std::vector< Member > const & directMembers):
- PublishableEntity(SORT_PLAIN_STRUCT_TYPE, published),
+ std::vector< Member > const & directMembers,
+ std::vector< rtl::OUString > const & annotations):
+ PublishableEntity(SORT_PLAIN_STRUCT_TYPE, published, annotations),
directBase_(directBase), directMembers_(directMembers)
{}
@@ -189,8 +218,10 @@ public:
struct Member {
Member(
rtl::OUString const & theName, rtl::OUString const & theType,
- bool theParameterized):
- name(theName), type(theType), parameterized(theParameterized)
+ bool theParameterized,
+ std::vector< rtl::OUString > const & theAnnotations):
+ name(theName), type(theType), parameterized(theParameterized),
+ annotations(theAnnotations)
{}
rtl::OUString name;
@@ -198,12 +229,16 @@ public:
rtl::OUString type;
bool parameterized;
+
+ std::vector< rtl::OUString > annotations;
};
SAL_DLLPRIVATE PolymorphicStructTypeTemplateEntity(
bool published, std::vector< rtl::OUString > const & typeParameters,
- std::vector< Member > const & members):
- PublishableEntity(SORT_POLYMORPHIC_STRUCT_TYPE_TEMPLATE, published),
+ std::vector< Member > const & members,
+ std::vector< rtl::OUString > const & annotations):
+ PublishableEntity(
+ SORT_POLYMORPHIC_STRUCT_TYPE_TEMPLATE, published, annotations),
typeParameters_(typeParameters), members_(members)
{}
@@ -222,19 +257,24 @@ private:
class LO_DLLPUBLIC_UNOIDL ExceptionTypeEntity: public PublishableEntity {
public:
struct Member {
- Member(rtl::OUString const & theName, rtl::OUString const & theType):
- name(theName), type(theType)
+ Member(
+ rtl::OUString const & theName, rtl::OUString const & theType,
+ std::vector< rtl::OUString > const & theAnnotations):
+ name(theName), type(theType), annotations(theAnnotations)
{}
rtl::OUString name;
rtl::OUString type;
+
+ std::vector< rtl::OUString > annotations;
};
SAL_DLLPRIVATE ExceptionTypeEntity(
bool published, rtl::OUString const & directBase,
- std::vector< Member > const & directMembers):
- PublishableEntity(SORT_EXCEPTION_TYPE, published),
+ std::vector< Member > const & directMembers,
+ std::vector< rtl::OUString > const & annotations):
+ PublishableEntity(SORT_EXCEPTION_TYPE, published, annotations),
directBase_(directBase), directMembers_(directMembers)
{}
@@ -257,10 +297,11 @@ public:
rtl::OUString const & theName, rtl::OUString const & theType,
bool theBound, bool theReadOnly,
std::vector< rtl::OUString > const & theGetExceptions,
- std::vector< rtl::OUString > const & theSetExceptions):
+ std::vector< rtl::OUString > const & theSetExceptions,
+ std::vector< rtl::OUString > const & theAnnotations):
name(theName), type(theType), bound(theBound),
readOnly(theReadOnly), getExceptions(theGetExceptions),
- setExceptions(theSetExceptions)
+ setExceptions(theSetExceptions), annotations(theAnnotations)
{ assert(!theReadOnly || theSetExceptions.empty()); }
rtl::OUString name;
@@ -274,6 +315,8 @@ public:
std::vector< rtl::OUString > getExceptions;
std::vector< rtl::OUString > setExceptions;
+
+ std::vector< rtl::OUString > annotations;
};
struct Method {
@@ -296,9 +339,10 @@ public:
Method(
rtl::OUString const & theName, rtl::OUString const & theReturnType,
std::vector< Parameter > const & theParameters,
- std::vector< rtl::OUString > const & theExceptions):
+ std::vector< rtl::OUString > const & theExceptions,
+ std::vector< rtl::OUString > const & theAnnotations):
name(theName), returnType(theReturnType), parameters(theParameters),
- exceptions(theExceptions)
+ exceptions(theExceptions), annotations(theAnnotations)
{}
rtl::OUString name;
@@ -308,24 +352,27 @@ public:
std::vector< Parameter > parameters;
std::vector< rtl::OUString > exceptions;
+
+ std::vector< rtl::OUString > annotations;
};
SAL_DLLPRIVATE InterfaceTypeEntity(
bool published,
- std::vector< rtl::OUString > const & directMandatoryBases,
- std::vector< rtl::OUString > const & directOptionalBases,
+ std::vector< AnnotatedReference > const & directMandatoryBases,
+ std::vector< AnnotatedReference > const & directOptionalBases,
std::vector< Attribute > const & directAttributes,
- std::vector< Method > const & directMethods):
- PublishableEntity(SORT_INTERFACE_TYPE, published),
+ std::vector< Method > const & directMethods,
+ std::vector< rtl::OUString > const & annotations):
+ PublishableEntity(SORT_INTERFACE_TYPE, published, annotations),
directMandatoryBases_(directMandatoryBases),
directOptionalBases_(directOptionalBases),
directAttributes_(directAttributes), directMethods_(directMethods)
{}
- std::vector< rtl::OUString > const & getDirectMandatoryBases() const
+ std::vector< AnnotatedReference > const & getDirectMandatoryBases() const
{ return directMandatoryBases_; }
- std::vector< rtl::OUString > const & getDirectOptionalBases() const
+ std::vector< AnnotatedReference > const & getDirectOptionalBases() const
{ return directOptionalBases_; }
std::vector< Attribute > const & getDirectAttributes() const
@@ -337,16 +384,18 @@ public:
private:
virtual SAL_DLLPRIVATE ~InterfaceTypeEntity() throw ();
- std::vector< rtl::OUString > directMandatoryBases_;
- std::vector< rtl::OUString > directOptionalBases_;
+ std::vector< AnnotatedReference > directMandatoryBases_;
+ std::vector< AnnotatedReference > directOptionalBases_;
std::vector< Attribute > directAttributes_;
std::vector< Method > directMethods_;
};
class LO_DLLPUBLIC_UNOIDL TypedefEntity: public PublishableEntity {
public:
- SAL_DLLPRIVATE TypedefEntity(bool published, rtl::OUString const & type):
- PublishableEntity(SORT_TYPEDEF, published), type_(type)
+ SAL_DLLPRIVATE TypedefEntity(
+ bool published, rtl::OUString const & type,
+ std::vector< rtl::OUString > const & annotations):
+ PublishableEntity(SORT_TYPEDEF, published, annotations), type_(type)
{}
rtl::OUString getType() const { return type_; }
@@ -363,36 +412,31 @@ struct LO_DLLPUBLIC_UNOIDL ConstantValue {
TYPE_UNSIGNED_LONG, TYPE_HYPER, TYPE_UNSIGNED_HYPER, TYPE_FLOAT,
TYPE_DOUBLE };
- explicit ConstantValue(bool value): type(TYPE_BOOLEAN), booleanValue(value)
- {}
+ ConstantValue(bool value): type(TYPE_BOOLEAN), booleanValue(value) {}
- explicit ConstantValue(sal_Int8 value): type(TYPE_BYTE), byteValue(value) {}
+ ConstantValue(sal_Int8 value): type(TYPE_BYTE), byteValue(value) {}
- explicit ConstantValue(sal_Int16 value): type(TYPE_SHORT), shortValue(value)
- {}
+ ConstantValue(sal_Int16 value): type(TYPE_SHORT), shortValue(value) {}
- explicit ConstantValue(sal_uInt16 value):
+ ConstantValue(sal_uInt16 value):
type(TYPE_UNSIGNED_SHORT), unsignedShortValue(value)
{}
- explicit ConstantValue(sal_Int32 value): type(TYPE_LONG), longValue(value)
- {}
+ ConstantValue(sal_Int32 value): type(TYPE_LONG), longValue(value) {}
- explicit ConstantValue(sal_uInt32 value):
+ ConstantValue(sal_uInt32 value):
type(TYPE_UNSIGNED_LONG), unsignedLongValue(value)
{}
- explicit ConstantValue(sal_Int64 value): type(TYPE_HYPER), hyperValue(value)
- {}
+ ConstantValue(sal_Int64 value): type(TYPE_HYPER), hyperValue(value) {}
- explicit ConstantValue(sal_uInt64 value):
+ ConstantValue(sal_uInt64 value):
type(TYPE_UNSIGNED_HYPER), unsignedHyperValue(value)
{}
- explicit ConstantValue(float value): type(TYPE_FLOAT), floatValue(value) {}
+ ConstantValue(float value): type(TYPE_FLOAT), floatValue(value) {}
- explicit ConstantValue(double value): type(TYPE_DOUBLE), doubleValue(value)
- {}
+ ConstantValue(double value): type(TYPE_DOUBLE), doubleValue(value) {}
Type type;
@@ -413,18 +457,24 @@ struct LO_DLLPUBLIC_UNOIDL ConstantValue {
class LO_DLLPUBLIC_UNOIDL ConstantGroupEntity: public PublishableEntity {
public:
struct Member {
- Member(rtl::OUString const & theName, ConstantValue const & theValue):
- name(theName), value(theValue)
+ Member(
+ rtl::OUString const & theName, ConstantValue const & theValue,
+ std::vector< rtl::OUString > const & theAnnotations):
+ name(theName), value(theValue), annotations(theAnnotations)
{}
rtl::OUString name;
ConstantValue value;
+
+ std::vector< rtl::OUString > annotations;
};
SAL_DLLPRIVATE ConstantGroupEntity(
- bool published, std::vector< Member > const & members):
- PublishableEntity(SORT_CONSTANT_GROUP, published), members_(members)
+ bool published, std::vector< Member > const & members,
+ std::vector< rtl::OUString > const & annotations):
+ PublishableEntity(SORT_CONSTANT_GROUP, published, annotations),
+ members_(members)
{}
std::vector< Member > const & getMembers() const { return members_; }
@@ -459,9 +509,10 @@ public:
Constructor(
rtl::OUString const & theName,
std::vector< Parameter > const & theParameters,
- std::vector< rtl::OUString > const & theExceptions):
+ std::vector< rtl::OUString > const & theExceptions,
+ std::vector< rtl::OUString > const & theAnnotations):
name(theName), parameters(theParameters), exceptions(theExceptions),
- defaultConstructor(false)
+ annotations(theAnnotations), defaultConstructor(false)
{}
rtl::OUString name;
@@ -470,13 +521,17 @@ public:
std::vector< rtl::OUString > exceptions;
+ std::vector< rtl::OUString > annotations;
+
bool defaultConstructor;
};
SAL_DLLPRIVATE SingleInterfaceBasedServiceEntity(
bool published, rtl::OUString const & base,
- std::vector< Constructor > const & constructors):
- PublishableEntity(SORT_SINGLE_INTERFACE_BASED_SERVICE, published),
+ std::vector< Constructor > const & constructors,
+ std::vector< rtl::OUString > const & annotations):
+ PublishableEntity(
+ SORT_SINGLE_INTERFACE_BASED_SERVICE, published, annotations),
base_(base), constructors_(constructors)
{}
@@ -511,8 +566,10 @@ public:
Property(
rtl::OUString const & theName, rtl::OUString const & theType,
- Attributes theAttributes):
- name(theName), type(theType), attributes(theAttributes)
+ Attributes theAttributes,
+ std::vector< rtl::OUString > const & theAnnotations):
+ name(theName), type(theType), attributes(theAttributes),
+ annotations(theAnnotations)
{}
rtl::OUString name;
@@ -520,16 +577,20 @@ public:
rtl::OUString type;
Attributes attributes;
+
+ std::vector< rtl::OUString > annotations;
};
SAL_DLLPRIVATE AccumulationBasedServiceEntity(
bool published,
- std::vector< rtl::OUString > const & directMandatoryBaseServices,
- std::vector< rtl::OUString > const & directOptionalBaseServices,
- std::vector< rtl::OUString > const & directMandatoryBaseInterfaces,
- std::vector< rtl::OUString > const & directOptionalBaseInterfaces,
- std::vector< Property > const & directProperties):
- PublishableEntity(SORT_ACCUMULATION_BASED_SERVICE, published),
+ std::vector< AnnotatedReference > const & directMandatoryBaseServices,
+ std::vector< AnnotatedReference > const & directOptionalBaseServices,
+ std::vector< AnnotatedReference > const & directMandatoryBaseInterfaces,
+ std::vector< AnnotatedReference > const & directOptionalBaseInterfaces,
+ std::vector< Property > const & directProperties,
+ std::vector< rtl::OUString > const & annotations):
+ PublishableEntity(
+ SORT_ACCUMULATION_BASED_SERVICE, published, annotations),
directMandatoryBaseServices_(directMandatoryBaseServices),
directOptionalBaseServices_(directOptionalBaseServices),
directMandatoryBaseInterfaces_(directMandatoryBaseInterfaces),
@@ -537,17 +598,20 @@ public:
directProperties_(directProperties)
{}
- std::vector< rtl::OUString > const & getDirectMandatoryBaseServices() const
+ std::vector< AnnotatedReference > const & getDirectMandatoryBaseServices()
+ const
{ return directMandatoryBaseServices_; }
- std::vector< rtl::OUString > const & getDirectOptionalBaseServices() const
+ std::vector< AnnotatedReference > const & getDirectOptionalBaseServices()
+ const
{ return directOptionalBaseServices_; }
- std::vector< rtl::OUString > const & getDirectMandatoryBaseInterfaces()
+ std::vector< AnnotatedReference > const & getDirectMandatoryBaseInterfaces()
const
{ return directMandatoryBaseInterfaces_; }
- std::vector< rtl::OUString > const & getDirectOptionalBaseInterfaces() const
+ std::vector< AnnotatedReference > const & getDirectOptionalBaseInterfaces()
+ const
{ return directOptionalBaseInterfaces_; }
std::vector< Property > const & getDirectProperties() const
@@ -556,10 +620,10 @@ public:
private:
virtual SAL_DLLPRIVATE ~AccumulationBasedServiceEntity() throw ();
- std::vector< rtl::OUString > directMandatoryBaseServices_;
- std::vector< rtl::OUString > directOptionalBaseServices_;
- std::vector< rtl::OUString > directMandatoryBaseInterfaces_;
- std::vector< rtl::OUString > directOptionalBaseInterfaces_;
+ std::vector< AnnotatedReference > directMandatoryBaseServices_;
+ std::vector< AnnotatedReference > directOptionalBaseServices_;
+ std::vector< AnnotatedReference > directMandatoryBaseInterfaces_;
+ std::vector< AnnotatedReference > directOptionalBaseInterfaces_;
std::vector< Property > directProperties_;
};
@@ -568,8 +632,10 @@ class LO_DLLPUBLIC_UNOIDL InterfaceBasedSingletonEntity:
{
public:
SAL_DLLPRIVATE InterfaceBasedSingletonEntity(
- bool published, rtl::OUString const & base):
- PublishableEntity(SORT_INTERFACE_BASED_SINGLETON, published),
+ bool published, rtl::OUString const & base,
+ std::vector< rtl::OUString > const & annotations):
+ PublishableEntity(
+ SORT_INTERFACE_BASED_SINGLETON, published, annotations),
base_(base)
{}
@@ -585,8 +651,10 @@ class LO_DLLPUBLIC_UNOIDL ServiceBasedSingletonEntity: public PublishableEntity
{
public:
SAL_DLLPRIVATE ServiceBasedSingletonEntity(
- bool published, rtl::OUString const & base):
- PublishableEntity(SORT_SERVICE_BASED_SINGLETON, published), base_(base)
+ bool published, rtl::OUString const & base,
+ std::vector< rtl::OUString > const & annotations):
+ PublishableEntity(SORT_SERVICE_BASED_SINGLETON, published, annotations),
+ base_(base)
{}
rtl::OUString getBase() const { return base_; }
diff --git a/unodevtools/source/skeletonmaker/cpptypemaker.cxx b/unodevtools/source/skeletonmaker/cpptypemaker.cxx
index abd3012..51a17c4 100644
--- a/unodevtools/source/skeletonmaker/cpptypemaker.cxx
+++ b/unodevtools/source/skeletonmaker/cpptypemaker.cxx
@@ -537,12 +537,12 @@ void printMethods(std::ostream & o,
dynamic_cast< unoidl::InterfaceTypeEntity * >(ent.get()));
assert(ent2.is());
if (options.all || defaultvalue) {
- for (std::vector< OUString >::const_iterator i(
+ for (std::vector< unoidl::AnnotatedReference >::const_iterator i(
ent2->getDirectMandatoryBases().begin());
i != ent2->getDirectMandatoryBases().end(); ++i)
{
printMethods(
- o, options, manager, *i, generated, delegate, classname,
+ o, options, manager, i->name, generated, delegate, classname,
indentation, defaultvalue, propertyhelper);
}
if (!(ent2->getDirectAttributes().empty()
@@ -737,20 +737,20 @@ void printServiceMembers(
OString const & delegate)
{
assert(entity.is());
- for (std::vector< OUString >::const_iterator i(
+ for (std::vector< unoidl::AnnotatedReference >::const_iterator i(
entity->getDirectMandatoryBaseServices().begin());
i != entity->getDirectMandatoryBaseServices().end(); ++i)
{
- o << "\n// exported service " << *i << "\n";
- generateDocumentation(o, options, manager, u2b(*i), delegate);
- o << "\n// end of exported service " << *i << "\n";
+ o << "\n// exported service " << i->name << "\n";
+ generateDocumentation(o, options, manager, u2b(i->name), delegate);
+ o << "\n// end of exported service " << i->name << "\n";
}
- for (std::vector< OUString >::const_iterator i(
+ for (std::vector< unoidl::AnnotatedReference >::const_iterator i(
entity->getDirectMandatoryBaseInterfaces().begin());
i != entity->getDirectMandatoryBaseInterfaces().end(); ++i)
{
- o << "\n// supported interface " << *i << "\n";
- generateDocumentation(o, options, manager, u2b(*i), delegate);
+ o << "\n// supported interface " << i->name << "\n";
+ generateDocumentation(o, options, manager, u2b(i->name), delegate);
}
if (delegate.isEmpty()) {
o << "\n// properties of service \""<< name << "\"\n";
diff --git a/unodevtools/source/skeletonmaker/javatypemaker.cxx b/unodevtools/source/skeletonmaker/javatypemaker.cxx
index cb84458..d6b29b0 100644
--- a/unodevtools/source/skeletonmaker/javatypemaker.cxx
+++ b/unodevtools/source/skeletonmaker/javatypemaker.cxx
@@ -461,12 +461,12 @@ void printMethods(std::ostream & o,
dynamic_cast< unoidl::InterfaceTypeEntity * >(ent.get()));
assert(ent2.is());
if ( options.all || defaultvalue ) {
- for (std::vector< OUString >::const_iterator i(
+ for (std::vector< unoidl::AnnotatedReference >::const_iterator i(
ent2->getDirectMandatoryBases().begin());
i != ent2->getDirectMandatoryBases().end(); ++i)
{
printMethods(
- o, options, manager, *i, generated, delegate, indentation,
+ o, options, manager, i->name, generated, delegate, indentation,
defaultvalue, usepropertymixin);
}
if (!(ent2->getDirectAttributes().empty()
@@ -638,19 +638,19 @@ void printServiceMembers(
OString const & delegate)
{
assert(entity.is());
- for (std::vector< OUString >::const_iterator i(
+ for (std::vector< unoidl::AnnotatedReference >::const_iterator i(
entity->getDirectMandatoryBaseServices().begin());
i != entity->getDirectMandatoryBaseServices().end(); ++i)
{
- o << "\n// exported service " << *i << "\n";
- generateDocumentation(o, options, manager, u2b(*i), delegate);
+ o << "\n// exported service " << i->name << "\n";
+ generateDocumentation(o, options, manager, u2b(i->name), delegate);
}
- for (std::vector< OUString >::const_iterator i(
+ for (std::vector< unoidl::AnnotatedReference >::const_iterator i(
entity->getDirectMandatoryBaseInterfaces().begin());
i != entity->getDirectMandatoryBaseInterfaces().end(); ++i)
{
- o << "\n// supported interface " << *i << "\n";
- generateDocumentation(o, options, manager, u2b(*i), delegate);
+ o << "\n// supported interface " << i->name << "\n";
+ generateDocumentation(o, options, manager, u2b(i->name), delegate);
}
o << "\n// properties of service \""<< name << "\"\n";
for (std::vector< unoidl::AccumulationBasedServiceEntity::Property >::
diff --git a/unodevtools/source/skeletonmaker/skeletoncommon.cxx b/unodevtools/source/skeletonmaker/skeletoncommon.cxx
index a8957aa..e66b39a 100644
--- a/unodevtools/source/skeletonmaker/skeletoncommon.cxx
+++ b/unodevtools/source/skeletonmaker/skeletoncommon.cxx
@@ -122,11 +122,11 @@ void checkAttributes(rtl::Reference< TypeManager > const & manager,
rtl::Reference< unoidl::InterfaceTypeEntity > ent2(
dynamic_cast< unoidl::InterfaceTypeEntity * >(ent.get()));
assert(ent2.is());
- for (std::vector< OUString >::const_iterator i(
+ for (std::vector< unoidl::AnnotatedReference >::const_iterator i(
ent2->getDirectMandatoryBases().begin());
i != ent2->getDirectMandatoryBases().end(); ++i)
{
- checkAttributes(manager, *i, attributes, propinterfaces);
+ checkAttributes(manager, i->name, attributes, propinterfaces);
}
for (std::vector< unoidl::InterfaceTypeEntity::Attribute >::
const_iterator i(ent2->getDirectAttributes().begin());
@@ -146,7 +146,8 @@ void checkAttributes(rtl::Reference< TypeManager > const & manager,
| (i->readOnly
? (unoidl::AccumulationBasedServiceEntity::
Property::ATTRIBUTE_READ_ONLY)
- : 0))))));
+ : 0)))),
+ std::vector< OUString >()));
}
}
break;
@@ -157,17 +158,17 @@ void checkAttributes(rtl::Reference< TypeManager > const & manager,
dynamic_cast< unoidl::AccumulationBasedServiceEntity * >(
ent.get()));
assert(ent2.is());
- for (std::vector< OUString >::const_iterator i(
+ for (std::vector< unoidl::AnnotatedReference >::const_iterator i(
ent2->getDirectMandatoryBaseServices().begin());
i != ent2->getDirectMandatoryBaseServices().end(); ++i)
{
- checkAttributes(manager, *i, attributes, propinterfaces);
+ checkAttributes(manager, i->name, attributes, propinterfaces);
}
- for (std::vector< OUString >::const_iterator i(
+ for (std::vector< unoidl::AnnotatedReference >::const_iterator i(
ent2->getDirectMandatoryBaseInterfaces().begin());
i != ent2->getDirectMandatoryBaseInterfaces().end(); ++i)
{
- checkAttributes(manager, *i, attributes, propinterfaces);
+ checkAttributes(manager, i->name, attributes, propinterfaces);
}
for (std::vector<
unoidl::AccumulationBasedServiceEntity::Property >::
@@ -237,19 +238,19 @@ void checkType(rtl::Reference< TypeManager > const & manager,
dynamic_cast< unoidl::AccumulationBasedServiceEntity * >(
ent.get()));
assert(ent2.is());
- for (std::vector< OUString >::const_iterator i(
+ for (std::vector< unoidl::AnnotatedReference >::const_iterator i(
ent2->getDirectMandatoryBaseServices().begin());
i != ent2->getDirectMandatoryBaseServices().end(); ++i)
{
checkType(
- manager, *i, interfaceTypes, serviceTypes, properties);
+ manager, i->name, interfaceTypes, serviceTypes, properties);
}
- for (std::vector< OUString >::const_iterator i(
+ for (std::vector< unoidl::AnnotatedReference >::const_iterator i(
ent2->getDirectMandatoryBaseInterfaces().begin());
i != ent2->getDirectMandatoryBaseInterfaces().end(); ++i)
{
checkType(
- manager, *i, interfaceTypes, serviceTypes, properties);
+ manager, i->name, interfaceTypes, serviceTypes, properties);
}
for (std::vector<
unoidl::AccumulationBasedServiceEntity::Property >::
@@ -307,11 +308,11 @@ bool checkServiceProperties(rtl::Reference< TypeManager > const & manager,
if (!ent2->getDirectProperties().empty()) {
return true;
}
- for (std::vector< OUString >::const_iterator i(
+ for (std::vector< unoidl::AnnotatedReference >::const_iterator i(
ent2->getDirectMandatoryBaseServices().begin());
i != ent2->getDirectMandatoryBaseServices().end(); ++i)
{
- if (checkServiceProperties(manager, *i)) {
+ if (checkServiceProperties(manager, i->name)) {
return true;
}
}
@@ -391,11 +392,11 @@ bool checkXComponentSupport(
rtl::Reference< unoidl::InterfaceTypeEntity > ent2(
dynamic_cast< unoidl::InterfaceTypeEntity * >(ent.get()));
assert(ent2.is());
- for (std::vector< OUString >::const_iterator i(
+ for (std::vector< unoidl::AnnotatedReference >::const_iterator i(
ent2->getDirectMandatoryBases().begin());
i != ent2->getDirectMandatoryBases().end(); ++i)
{
- if (checkXComponentSupport(manager, *i)) {
+ if (checkXComponentSupport(manager, i->name)) {
return true;
}
}
@@ -587,12 +588,12 @@ void generateFunctionParameterMap(std::ostream& o,
// check if the specified add-in functions supports valid types
checkAddInTypes(manager, name, ent2);
- for (std::vector< OUString >::const_iterator i(
+ for (std::vector< unoidl::AnnotatedReference >::const_iterator i(
ent2->getDirectMandatoryBases().begin());
i != ent2->getDirectMandatoryBases().end(); ++i)
{
generateFunctionParameterMap(
- o, options, manager, *i, generated, bFirst);
+ o, options, manager, i->name, generated, bFirst);
}
if ( generated.contains(u2b(name)) )
diff --git a/unoidl/README b/unoidl/README
index 5daff7a..84246e9 100644
--- a/unoidl/README
+++ b/unoidl/README
@@ -27,6 +27,18 @@ quantities are stored LSB first, without alignment requirements. Offsets are
considered a limitation in practice (and avoids unnecessary bloat compared to
64 bit offsets).
+Annotations can be added for (non-module) entities and certain parts of such
+entities (e.g., both for an interface type definition and for a direct method of
+an interface type definition; the idea is that it can be added for direct parts
+that forma a "many-to-one" relationship; there is a tradeoff between generality
+of concept and size of representation, esp. for the C++ representation types in
+namespace unoidl) and consist of arbitrary sequences of name/value strings.
+Each name/value string is encoded as a single UTF-8 string containing a name (an
+arbitrary sequence of Unicode code points not containing U+003D EQUALS SIGN),
+optionally followed by U+003D EQUALS SIGN and a value (an abritrary sequence of
+Unicode code points). The only annotation name currently in use is "deprecated"
+(without a value).
+
The following definitions are used throughout:
* UInt16: 2-byte value, LSB first
@@ -34,10 +46,12 @@ The following definitions are used throughout:
* UInt64: 8-byte value, LSB first
* Offset: UInt32 value, counting bytes from start of file
* NUL-Name: zero or more non-NUL US-ASCII bytes followed by a NUL byte
-* Len-Name: UInt32 number of characters, with 0x80000000 bit 1, followed by that
- many (- 0x80000000) US-ASCII bytes
-* Idx-Name: either an Offset (with 0x80000000 bit 0) of a Len-Name, or a
- Len-Name
+* Len-String: UInt32 number of characters, with 0x80000000 bit 0, followed by
+ that many US-ASCII (for UNOIDL related names) resp. UTF-8 (for annotations)
+ bytes
+* Idx-String: either an Offset (with 0x80000000 bit 1) of a Len-String, or a
+ Len-String
+* Annotations: UInt32 number N of annotations followed by N * Idx-String
* Entry: Offset of NUL-Name followed by Offset of payload
* Map: zero or more Entries
@@ -68,7 +82,7 @@ Layout of per-entry payload in the root or a module Map:
** otherwise:
*** 0x80 bit: 1 if published
-*** 0x40 bit: 1 if deprecated
+*** 0x40 bit: 1 if annotated
*** 0x20 bit: flag (may only be 1 for certain kinds, see below)
*** remaining bits:
@@ -76,67 +90,77 @@ Layout of per-entry payload in the root or a module Map:
***** followed by:
****** UInt32 number N1 of members
****** N1 * tuple of:
-******* Offset of Idx-Name
+******* Idx-String
******* UInt32
+******* if annotated: Annotations
**** 2: plain struct type (with base if flag is 1)
***** followed by:
-****** if "with base": Offset of Idx-Name
+****** if "with base": Idx-String
****** UInt32 number N1 of direct members
****** N1 * tuple of:
-******* Offset of Idx-Name name
-******* Offset of Idx-Name type
+******* Idx-String name
+******* Idx-String type
+******* if annotated: Annotations
**** 3: polymorphic struct type template
***** followed by:
****** UInt32 number N1 of type parameters
-****** N1 * Offset of Idx-Name
+****** N1 * Idx-String
****** UInt32 number N2 of members
****** N2 * tuple of:
******* kind byte: 0x01 bit is 1 if parameterized type
-******* Offset of Idx-Name name
-******* Offset of Idx-Name type
+******* Idx-String name
+******* Idx-String type
+******* if annotated: Annotations
**** 4: exception type (with base if flag is 1)
***** followed by:
-****** if "with base": Offset of Idx-Name
+****** if "with base": Idx-String
****** UInt32 number N1 of direct members
****** N1 * tuple of:
-******* Offset of Idx-Name name
-******* Offset of Idx-Name type
+******* Idx-String name
+******* Idx-String type
+******* if annotated: Annotations
**** 5: interface type
***** followed by:
****** UInt32 number N1 of direct mandatory bases
-****** N1 * Offset of Idx-Name
+****** N1 * tuple of:
+******* Idx-String
+******* if annotated: Annotations
****** UInt32 number N2 of direct optional bases
-****** N2 * Offset of Idx-Name
+****** N2 * tuple of:
+******* Idx-String
+******* if annotated: Annotations
****** UInt32 number N3 of direct attributes
****** N3 * tuple of:
******* kind byte:
******** 0x02 bit: 1 if read-only
******** 0x01 bit: 1 if bound
-******* Offset of Idx-Name name
-******* Offset of Idx-Name type
+******* Idx-String name
+******* Idx-String type
******* UInt32 number N4 of get exceptions
-******* N4 * Offset of Idx-Name
+******* N4 * Idx-String
******* UInt32 number N5 of set exceptions
-******* N5 * Offset of Idx-Name
+******* N5 * Idx-String
+******* if annotated: Annotations
****** UInt32 number N6 of direct methods
****** N6 * tuple of:
-******* Offset of Idx-Name name
-******* Offset of Idx-Name return type
+******* Idx-String name
+******* Idx-String return type
******* UInt32 number N7 of parameters
******* N7 * tuple of:
******** direction byte: 0 for in, 1 for out, 2 for in-out
-******** Offset of Idx-Name name
-******** Offset of Idx-Name type
+******** Idx-String name
+******** Idx-String type
******* UInt32 number N8 of exceptions
-******* N8 * Offset of Idx-Name
+******* N8 * Idx-String
+******* if annotated: Annotations
**** 6: typedef
***** followed by:
-****** Offset of Idx-Name
+****** Idx-String
**** 7: constant group
***** followed by:
@@ -145,29 +169,38 @@ Layout of per-entry payload in the root or a module Map:
**** 8: single-interface--based service (with default constructor if flag is 1)
***** followed by:
-****** Offset of Idx-Name
+****** Idx-String
****** if not "with default constructor":
******* UInt32 number N1 of constructors
******* N1 * tuple of:
-******** Offset of Idx-Name
+******** Idx-String
******** UInt32 number N2 of parameters
******** N2 * tuple of
********* kind byte: 0x04 bit is 1 if rest parameter
-********* Offset of Idx-Name name
-********* Offset of Idx-Name type
+********* Idx-String name
+********* Idx-String type
******** UInt32 number N3 of exceptions
-******** N3 * Offset of Idx-Name
+******** N3 * Idx-String
+******** if annotated: Annotations
**** 9: accumulation-based service
***** followed by:
****** UInt32 number N1 of direct mandatory base services
-****** N1 * Offset of Idx-Name
+****** N1 * tuple of:
+******* Idx-String
+******* if annotated: Annotations
****** UInt32 number N2 of direct optional base services
-****** N2 * Offset of Idx-Name
+****** N2 * tuple of:
+******* Idx-String
+******* if annotated: Annotations
****** UInt32 number N3 of direct mandatory base interfaces
-****** N3 * Offset of Idx-Name
+****** N3 * tuple of:
+******* Idx-String
+******* if annotated: Annotations
****** UInt32 number N4 of direct optional base interfaces
-****** N4 * Offset of Idx-Name
+****** N4 * tuple of:
+******* Idx-String
+******* if annotated: Annotations
****** UInt32 number N5 of direct properties
****** N5 * tuple of:
******* UInt16 kind:
@@ -180,21 +213,24 @@ Layout of per-entry payload in the root or a module Map:
******** 0x0004 bit: 1 if constrained
******** 0x0002 bit: 1 if bound
******** 0x0001 bit: 1 if maybevoid
-******* Offset of Idx-Name name
-******* Offset of Idx-Name type
+******* Idx-String name
+******* Idx-String type
+******* if annotated: Annotations
**** 10: interface-based singleton
***** followed by:
-****** Offset of Idx-Name
+****** Idx-String
**** 11: service-based singleton
***** followed by:
-****** Offset of Idx-Name
+****** Idx-String
+
+*** if annotated, followed by: Annotations
Layout of per-entry payload in a constant group Map:
* kind byte:
-** 0x80 bit: 1 if deprecated
+** 0x80 bit: 1 if annotated
** remaining bits:
*** 0: BOOLEAN
@@ -228,3 +264,5 @@ Layout of per-entry payload in a constant group Map:
*** 9: DOUBLE
**** followed by 8-byte value, representing values in ISO 60599 binary64 format,
LSB first
+
+* if annotated, followed by: Annotations
diff --git a/unoidl/source/legacyprovider.cxx b/unoidl/source/legacyprovider.cxx
index 485b43d..17b95dc 100644
--- a/unoidl/source/legacyprovider.cxx
+++ b/unoidl/source/legacyprovider.cxx
@@ -26,6 +26,15 @@ namespace unoidl {
namespace {
+std::vector< OUString > translateAnnotations(OUString const & documentation) {
+ std::vector< OUString > ans;
+ if (documentation.indexOf("@deprecated") != -1) {
+ //TODO: this check is somewhat crude
+ ans.push_back("deprecated");
+ }
+ return ans;
+}
+
ConstantValue translateConstantValue(
RegistryKey & key, RTConstValue const & value)
{
@@ -219,17 +228,22 @@ rtl::Reference< Entity > readEntity(
switch (reader.getTypeClass()) {
case RT_TYPE_INTERFACE:
{
- std::vector< OUString > mandBases;
+ std::vector< AnnotatedReference > mandBases;
sal_uInt16 n = reader.getSuperTypeCount();
for (sal_uInt16 j = 0; j != n; ++j) {
mandBases.push_back(
- reader.getSuperTypeName(j).replace('/', '.'));
+ AnnotatedReference(
+ reader.getSuperTypeName(j).replace('/', '.'),
+ std::vector< OUString >()));
}
- std::vector< OUString > optBases;
+ std::vector< AnnotatedReference > optBases;
n = reader.getReferenceCount();
for (sal_uInt16 j = 0; j != n; ++j) {
optBases.push_back(
- reader.getReferenceTypeName(j).replace('/', '.'));
+ AnnotatedReference(
+ reader.getReferenceTypeName(j).replace('/', '.'),
+ translateAnnotations(
+ reader.getReferenceDocumentation(j))));
}
sal_uInt16 methodCount = reader.getMethodCount();
std::vector< InterfaceTypeEntity::Attribute > attrs;
@@ -278,7 +292,8 @@ rtl::Reference< Entity > readEntity(
InterfaceTypeEntity::Attribute(
attrName, reader.getFieldTypeName(j).replace('/', '.'),
(flags & RT_ACCESS_BOUND) != 0,
- (flags & RT_ACCESS_READONLY) != 0, getExcs, setExcs));
+ (flags & RT_ACCESS_READONLY) != 0, getExcs, setExcs,
+ translateAnnotations(reader.getFieldDocumentation(j))));
}
std::vector< InterfaceTypeEntity::Method > meths;
for (sal_uInt16 j = 0; j != methodCount; ++j) {
@@ -330,11 +345,14 @@ rtl::Reference< Entity > readEntity(
InterfaceTypeEntity::Method(
reader.getMethodName(j),
reader.getMethodReturnTypeName(j).replace('/', '.'),
- params, excs));
+ params, excs,
+ translateAnnotations(
+ reader.getMethodDocumentation(j))));
}
}
return new InterfaceTypeEntity(
- reader.isPublished(), mandBases, optBases, attrs, meths);
+ reader.isPublished(), mandBases, optBases, attrs, meths,
+ translateAnnotations(reader.getDocumentation()));
}
case RT_TYPE_MODULE:
return new Module(manager, ucr, sub);
@@ -363,10 +381,13 @@ rtl::Reference< Entity > readEntity(
mems.push_back(
PlainStructTypeEntity::Member(
reader.getFieldName(j),
- reader.getFieldTypeName(j).replace('/', '.')));
+ reader.getFieldTypeName(j).replace('/', '.'),
+ translateAnnotations(
+ reader.getFieldDocumentation(j))));
}
return new PlainStructTypeEntity(
- reader.isPublished(), base, mems);
+ reader.isPublished(), base, mems,
+ translateAnnotations(reader.getDocumentation()));
} else {
if (reader.getSuperTypeCount() != 0) {
FileFormatException(
@@ -390,10 +411,13 @@ rtl::Reference< Entity > readEntity(
reader.getFieldTypeName(j).replace('/', '.'),
((reader.getFieldFlags(j)
& RT_ACCESS_PARAMETERIZED_TYPE)
- != 0)));
+ != 0),
+ translateAnnotations(
+ reader.getFieldDocumentation(j))));
}
return new PolymorphicStructTypeTemplateEntity(
- reader.isPublished(), params, mems);
+ reader.isPublished(), params, mems,
+ translateAnnotations(reader.getDocumentation()));
}
}
case RT_TYPE_ENUM:
@@ -412,9 +436,13 @@ rtl::Reference< Entity > readEntity(
}
mems.push_back(
EnumTypeEntity::Member(
- reader.getFieldName(j), v.m_value.aLong));
+ reader.getFieldName(j), v.m_value.aLong,
+ translateAnnotations(reader.getFieldDocumentation(j))));
+
}
- return new EnumTypeEntity(reader.isPublished(), mems);
+ return new EnumTypeEntity(
+ reader.isPublished(), mems,
+ translateAnnotations(reader.getDocumentation()));
}
case RT_TYPE_EXCEPTION:
{
@@ -439,9 +467,12 @@ rtl::Reference< Entity > readEntity(
mems.push_back(
ExceptionTypeEntity::Member(
reader.getFieldName(j),
- reader.getFieldTypeName(j).replace('/', '.')));
+ reader.getFieldTypeName(j).replace('/', '.'),
+ translateAnnotations(reader.getFieldDocumentation(j))));
}
- return new ExceptionTypeEntity(reader.isPublished(), base, mems);
+ return new ExceptionTypeEntity(
+ reader.isPublished(), base, mems,
+ translateAnnotations(reader.getDocumentation()));
}
case RT_TYPE_TYPEDEF:
if (reader.getSuperTypeCount() != 1) {
@@ -452,36 +483,39 @@ rtl::Reference< Entity > readEntity(
+ " of super-types of typedef with key " + sub.getName()));
}
return new TypedefEntity(
- reader.isPublished(), reader.getSuperTypeName(0).replace('/', '.'));
+ reader.isPublished(), reader.getSuperTypeName(0).replace('/', '.'),
+ translateAnnotations(reader.getDocumentation()));
case RT_TYPE_SERVICE:
switch (reader.getSuperTypeCount()) {
case 0:
{
- std::vector< OUString > mandServs;
- std::vector< OUString > optServs;
- std::vector< OUString > mandIfcs;
- std::vector< OUString > optIfcs;
+ std::vector< AnnotatedReference > mandServs;
+ std::vector< AnnotatedReference > optServs;
+ std::vector< AnnotatedReference > mandIfcs;
+ std::vector< AnnotatedReference > optIfcs;
sal_uInt16 n = reader.getReferenceCount();
for (sal_uInt16 j = 0; j != n; ++j) {
- OUString refName(
- reader.getReferenceTypeName(j).replace('/', '.'));
+ AnnotatedReference base(
+ reader.getReferenceTypeName(j).replace('/', '.'),
+ translateAnnotations(
+ reader.getReferenceDocumentation(j)));
switch (reader.getReferenceSort(j)) {
case RT_REF_EXPORTS:
if ((reader.getReferenceFlags(j) & RT_ACCESS_OPTIONAL)
== 0)
{
- mandServs.push_back(refName);
+ mandServs.push_back(base);
} else {
- optServs.push_back(refName);
+ optServs.push_back(base);
}
break;
case RT_REF_SUPPORTS:
if ((reader.getReferenceFlags(j) & RT_ACCESS_OPTIONAL)
== 0)
{
- mandIfcs.push_back(refName);
+ mandIfcs.push_back(base);
} else {
- optIfcs.push_back(refName);
+ optIfcs.push_back(base);
}
break;
default:
@@ -540,11 +574,14 @@ rtl::Reference< Entity > readEntity(
reader.getFieldTypeName(j).replace('/', '.'),
static_cast<
AccumulationBasedServiceEntity::Property::
- Attributes >(attrs)));
+ Attributes >(attrs),
+ translateAnnotations(
+ reader.getFieldDocumentation(j))));
}
return new AccumulationBasedServiceEntity(
reader.isPublished(), mandServs, optServs, mandIfcs,
- optIfcs, props);
+ optIfcs, props,
+ translateAnnotations(reader.getDocumentation()));
}
case 1:
{
@@ -615,17 +652,20 @@ rtl::Reference< Entity > readEntity(
m = reader.getMethodExceptionCount(j);
for (sal_uInt16 k = 0; k != m; ++k) {
excs.push_back(
- reader.getMethodExceptionTypeName(j, k).
- replace('/', '.'));
+ reader.getMethodExceptionTypeName(j, k).replace(
+ '/', '.'));
}
ctors.push_back(
SingleInterfaceBasedServiceEntity::Constructor(
- reader.getMethodName(j), params, excs));
+ reader.getMethodName(j), params, excs,
+ translateAnnotations(
+ reader.getMethodDocumentation(j))));
}
}
return new SingleInterfaceBasedServiceEntity(
reader.isPublished(),
- reader.getSuperTypeName(0).replace('/', '.'), ctors);
+ reader.getSuperTypeName(0).replace('/', '.'), ctors,
+ translateAnnotations(reader.getDocumentation()));
}
default:
throw FileFormatException(
@@ -702,10 +742,12 @@ rtl::Reference< Entity > readEntity(
return newStyle
? rtl::Reference< Entity >(
new InterfaceBasedSingletonEntity(
- reader.isPublished(), baseName))
+ reader.isPublished(), baseName,
+ translateAnnotations(reader.getDocumentation())))
: rtl::Reference< Entity >(
new ServiceBasedSingletonEntity(
- reader.isPublished(), baseName));
+ reader.isPublished(), baseName,
+ translateAnnotations(reader.getDocumentation())));
}
case RT_TYPE_CONSTANTS:
{
@@ -715,9 +757,12 @@ rtl::Reference< Entity > readEntity(
mems.push_back(
ConstantGroupEntity::Member(
reader.getFieldName(j),
- translateConstantValue(sub, reader.getFieldValue(j))));
+ translateConstantValue(sub, reader.getFieldValue(j)),
+ translateAnnotations(reader.getFieldDocumentation(j))));
}
- return new ConstantGroupEntity(reader.isPublished(), mems);
+ return new ConstantGroupEntity(
+ reader.isPublished(), mems,
+ translateAnnotations(reader.getDocumentation()));
}
default:
throw FileFormatException(
diff --git a/unoidl/source/reg2unoidl.cxx b/unoidl/source/reg2unoidl.cxx
index 2bd9e56..bf2b6d2 100644
--- a/unoidl/source/reg2unoidl.cxx
+++ b/unoidl/source/reg2unoidl.cxx
@@ -201,7 +201,21 @@ OString toAscii(OUString const & name) {
return ascii;
}
-sal_uInt64 writeNameNul(osl::File & file, OUString const & name) {
+OString toUtf8(OUString const & string) {
+ OString ascii;
+ if (!string.convertToString(
+ &ascii, RTL_TEXTENCODING_UTF8,
+ (RTL_UNICODETOTEXT_FLAGS_UNDEFINED_ERROR
+ | RTL_UNICODETOTEXT_FLAGS_INVALID_ERROR)))
+ {
+ std::cerr
+ << "Cannot convert \"" << string << "\" to UTF-8" << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ return ascii;
+}
+
+sal_uInt64 writeNulName(osl::File & file, OUString const & name) {
OString ascii(toAscii(name));
if (ascii.indexOf('\0') != -1) {
std::cerr
@@ -213,33 +227,57 @@ sal_uInt64 writeNameNul(osl::File & file, OUString const & name) {
return off;
}
-void writeNameLen(osl::File & file, OUString const & name) {
- static std::map< OUString, sal_uInt64 > reuse;
- std::map< OUString, sal_uInt64 >::iterator i(reuse.find(name));
+void writeIdxString(osl::File & file, OString const & string) {
+ static std::map< OString, sal_uInt64 > reuse;
+ std::map< OString, sal_uInt64 >::iterator i(reuse.find(string));
if (i == reuse.end()) {
- reuse.insert(std::make_pair(name, getOffset(file)));
- OString ascii(toAscii(name));
+ reuse.insert(std::make_pair(string, getOffset(file)));
assert(
- (static_cast< sal_uInt64 >(ascii.getLength()) & 0x80000000) == 0);
- write32(
- file, static_cast< sal_uInt64 >(ascii.getLength()) | 0x80000000);
- write(file, ascii.getStr(), ascii.getLength());
+ (static_cast< sal_uInt64 >(string.getLength()) & 0x80000000) == 0);
+ write32(file, static_cast< sal_uInt64 >(string.getLength()));
+ write(file, string.getStr(), string.getLength());
} else {
- write32(file, i->second);
+ if ((i->second & 0x80000000) != 0) {
+ std::cerr
+ << "Cannot write index 0x" << std::hex << i->second << std::dec
+ << " of \"" << string << "\"; input is too large" << std::endl;
+ std::exit(EXIT_FAILURE);
+ }
+ write32(file, i->second | 0x80000000);
+ }
+}
+
+void writeIdxName(osl::File & file, OUString const & name) {
+ writeIdxString(file, toAscii(name));
+}
+
+void writeAnnotations(
+ osl::File & file, bool annotate,
+ std::vector< OUString > const & annotations)
+{
+ assert(annotate || annotations.empty());
+ if (annotate) {
+ write32(file, annotations.size());
+ // overflow from std::vector::size_type -> sal_uInt64 is unrealistic
+ for (std::vector< OUString >::const_iterator i(annotations.begin());
+ i != annotations.end(); ++i)
+ {
+ writeIdxString(file, toUtf8(*i));
+ }
}
}
void writeKind(
osl::File & file,
rtl::Reference< unoidl::PublishableEntity > const & entity,
- bool flag = false)
+ bool annotated, bool flag = false)
{
assert(entity.is());
sal_uInt64 v = entity->getSort();
if (entity->isPublished()) {
v |= 0x80;
}
- if (false /*TODO: deprecated */) {
+ if (annotated) {
v |= 0x40;
}
if (flag) {
@@ -250,7 +288,7 @@ void writeKind(
struct Item {
explicit Item(rtl::Reference< unoidl::Entity > const & theEntity):
- entity(theEntity),nameOffset(0),dataOffset(0)
+ entity(theEntity), nameOffset(0), dataOffset(0)
{}
rtl::Reference< unoidl::Entity > entity;
@@ -259,11 +297,15 @@ struct Item {
};
struct ConstItem {
- explicit ConstItem(unoidl::ConstantValue const & theConstant):
- constant(theConstant),nameOffset(0),dataOffset(0)
+ ConstItem(
+ unoidl::ConstantValue const & theConstant,
+ std::vector< OUString > const & theAnnotations):
+ constant(theConstant), annotations(theAnnotations), nameOffset(0),
+ dataOffset(0)
{}
unoidl::ConstantValue constant;
+ std::vector< OUString > annotations;
sal_uInt64 nameOffset;
sal_uInt64 dataOffset;
};
@@ -302,16 +344,25 @@ sal_uInt64 writeMap(
rtl::Reference< unoidl::EnumTypeEntity > ent2(
static_cast< unoidl::EnumTypeEntity * >(
i->second.entity.get()));
+ bool ann = !ent2->getAnnotations().empty();
+ for (std::vector< unoidl::EnumTypeEntity::Member >::
+ const_iterator j(ent2->getMembers().begin());
+ !ann && j != ent2->getMembers().end(); ++j)
+ {
+ ann = !j->annotations.empty();
+ }
i->second.dataOffset = getOffset(file);
- writeKind(file, ent2.get());
+ writeKind(file, ent2.get(), ann);
write32(file, ent2->getMembers().size());
for (std::vector< unoidl::EnumTypeEntity::Member >::
const_iterator j(ent2->getMembers().begin());
j != ent2->getMembers().end(); ++j)
{
- writeNameLen(file, j->name);
+ writeIdxName(file, j->name);
write32(file, static_cast< sal_uInt32 >(j->value));
+ writeAnnotations(file, ann, j->annotations);
}
+ writeAnnotations(file, ann, ent2->getAnnotations());
break;
}
case unoidl::Entity::SORT_PLAIN_STRUCT_TYPE:
@@ -319,19 +370,29 @@ sal_uInt64 writeMap(
rtl::Reference< unoidl::PlainStructTypeEntity > ent2(
static_cast< unoidl::PlainStructTypeEntity * >(
i->second.entity.get()));
+ bool ann = !ent2->getAnnotations().empty();
+ for (std::vector< unoidl::PlainStructTypeEntity::Member >::
+ const_iterator j(ent2->getDirectMembers().begin());
+ !ann && j != ent2->getDirectMembers().end(); ++j)
+ {
+ ann = !j->annotations.empty();
+ }
i->second.dataOffset = getOffset(file);
- writeKind(file, ent2.get(), !ent2->getDirectBase().isEmpty());
+ writeKind(
+ file, ent2.get(), ann, !ent2->getDirectBase().isEmpty());
if (!ent2->getDirectBase().isEmpty()) {
- writeNameLen(file, ent2->getDirectBase());
+ writeIdxName(file, ent2->getDirectBase());
}
write32(file, ent2->getDirectMembers().size());
for (std::vector< unoidl::PlainStructTypeEntity::Member >::
const_iterator j(ent2->getDirectMembers().begin());
j != ent2->getDirectMembers().end(); ++j)
{
- writeNameLen(file, j->name);
- writeNameLen(file, j->type);
+ writeIdxName(file, j->name);
+ writeIdxName(file, j->type);
+ writeAnnotations(file, ann, j->annotations);
}
+ writeAnnotations(file, ann, ent2->getAnnotations());
break;
}
case unoidl::Entity::SORT_POLYMORPHIC_STRUCT_TYPE_TEMPLATE:
@@ -341,14 +402,23 @@ sal_uInt64 writeMap(
static_cast<
unoidl::PolymorphicStructTypeTemplateEntity * >(
i->second.entity.get()));
+ bool ann = !ent2->getAnnotations().empty();
+ for (std::vector<
+ unoidl::PolymorphicStructTypeTemplateEntity::Member >::
+ const_iterator j(
+ ent2->getMembers().begin());
+ !ann && j != ent2->getMembers().end(); ++j)
+ {
+ ann = !j->annotations.empty();
+ }
i->second.dataOffset = getOffset(file);
- writeKind(file, ent2.get());
+ writeKind(file, ent2.get(), ann);
write32(file, ent2->getTypeParameters().size());
for (std::vector< OUString >::const_iterator j(
ent2->getTypeParameters().begin());
j != ent2->getTypeParameters().end(); ++j)
{
- writeNameLen(file, *j);
+ writeIdxName(file, *j);
}
write32(file, ent2->getMembers().size());
for (std::vector<
@@ -362,9 +432,11 @@ sal_uInt64 writeMap(
f |= 0x01;
}
write8(file, f);
- writeNameLen(file, j->name);
- writeNameLen(file, j->type);
+ writeIdxName(file, j->name);
+ writeIdxName(file, j->type);
+ writeAnnotations(file, ann, j->annotations);
}
+ writeAnnotations(file, ann, ent2->getAnnotations());
break;
}
case unoidl::Entity::SORT_EXCEPTION_TYPE:
@@ -372,19 +444,29 @@ sal_uInt64 writeMap(
rtl::Reference< unoidl::ExceptionTypeEntity > ent2(
static_cast< unoidl::ExceptionTypeEntity * >(
i->second.entity.get()));
+ bool ann = !ent2->getAnnotations().empty();
+ for (std::vector< unoidl::ExceptionTypeEntity::Member >::
+ const_iterator j(ent2->getDirectMembers().begin());
+ !ann && j != ent2->getDirectMembers().end(); ++j)
+ {
+ ann = !j->annotations.empty();
+ }
i->second.dataOffset = getOffset(file);
- writeKind(file, ent2.get(), !ent2->getDirectBase().isEmpty());
+ writeKind(
+ file, ent2.get(), ann, !ent2->getDirectBase().isEmpty());
if (!ent2->getDirectBase().isEmpty()) {
- writeNameLen(file, ent2->getDirectBase());
+ writeIdxName(file, ent2->getDirectBase());
}
write32(file, ent2->getDirectMembers().size());
for (std::vector< unoidl::ExceptionTypeEntity::Member >::
const_iterator j(ent2->getDirectMembers().begin());
j != ent2->getDirectMembers().end(); ++j)
{
- writeNameLen(file, j->name);
- writeNameLen(file, j->type);
+ writeIdxName(file, j->name);
+ writeIdxName(file, j->type);
+ writeAnnotations(file, ann, j->annotations);
}
+ writeAnnotations(file, ann, ent2->getAnnotations());
break;
}
case unoidl::Entity::SORT_INTERFACE_TYPE:
@@ -392,21 +474,48 @@ sal_uInt64 writeMap(
rtl::Reference< unoidl::InterfaceTypeEntity > ent2(
static_cast< unoidl::InterfaceTypeEntity * >(
i->second.entity.get()));
+ bool ann = !ent2->getAnnotations().empty();
+ for (std::vector< unoidl::AnnotatedReference >::const_iterator
+ j(ent2->getDirectMandatoryBases().begin());
+ !ann && j != ent2->getDirectMandatoryBases().end(); ++j)
+ {
+ ann = !j->annotations.empty();
+ }
+ for (std::vector< unoidl::AnnotatedReference >::const_iterator
+ j(ent2->getDirectOptionalBases().begin());
+ !ann && j != ent2->getDirectOptionalBases().end(); ++j)
+ {
+ ann = !j->annotations.empty();
+ }
+ for (std::vector< unoidl::InterfaceTypeEntity::Attribute >::
+ const_iterator j(ent2->getDirectAttributes().begin());
+ !ann && j != ent2->getDirectAttributes().end(); ++j)
+ {
+ ann = !j->annotations.empty();
+ }
+ for (std::vector< unoidl::InterfaceTypeEntity::Method >::
+ const_iterator j(ent2->getDirectMethods().begin());
+ !ann && j != ent2->getDirectMethods().end(); ++j)
+ {
+ ann = !j->annotations.empty();
+ }
i->second.dataOffset = getOffset(file);
- writeKind(file, ent2.get());
+ writeKind(file, ent2.get(), ann);
write32(file, ent2->getDirectMandatoryBases().size());
- for (std::vector< OUString >::const_iterator j(
- ent2->getDirectMandatoryBases().begin());
+ for (std::vector< unoidl::AnnotatedReference >::const_iterator
+ j(ent2->getDirectMandatoryBases().begin());
j != ent2->getDirectMandatoryBases().end(); ++j)
{
- writeNameLen(file, *j);
+ writeIdxName(file, j->name);
+ writeAnnotations(file, ann, j->annotations);
}
write32(file, ent2->getDirectOptionalBases().size());
- for (std::vector< OUString >::const_iterator j(
- ent2->getDirectOptionalBases().begin());
+ for (std::vector< unoidl::AnnotatedReference >::const_iterator
+ j(ent2->getDirectOptionalBases().begin());
j != ent2->getDirectOptionalBases().end(); ++j)
{
- writeNameLen(file, *j);
+ writeIdxName(file, j->name);
+ writeAnnotations(file, ann, j->annotations);
}
write32(file, ent2->getDirectAttributes().size());
for (std::vector< unoidl::InterfaceTypeEntity::Attribute >::
@@ -421,14 +530,14 @@ sal_uInt64 writeMap(
f |= 0x02;
}
write8(file, f);
- writeNameLen(file, j->name);
- writeNameLen(file, j->type);
+ writeIdxName(file, j->name);
+ writeIdxName(file, j->type);
write32(file, j->getExceptions.size());
for (std::vector< OUString >::const_iterator k(
j->getExceptions.begin());
k != j->getExceptions.end(); ++k)
{
- writeNameLen(file, *k);
+ writeIdxName(file, *k);
}
if (!j->readOnly) {
write32(file, j->setExceptions.size());
@@ -436,17 +545,18 @@ sal_uInt64 writeMap(
j->setExceptions.begin());
k != j->setExceptions.end(); ++k)
{
- writeNameLen(file, *k);
+ writeIdxName(file, *k);
}
}
+ writeAnnotations(file, ann, j->annotations);
}
write32(file, ent2->getDirectMethods().size());
for (std::vector< unoidl::InterfaceTypeEntity::Method >::
const_iterator j(ent2->getDirectMethods().begin());
j != ent2->getDirectMethods().end(); ++j)
{
- writeNameLen(file, j->name);
- writeNameLen(file, j->returnType);
+ writeIdxName(file, j->name);
+ writeIdxName(file, j->returnType);
write32(file, j->parameters.size());
for (std::vector<
unoidl::InterfaceTypeEntity::Method::Parameter >::
@@ -454,17 +564,19 @@ sal_uInt64 writeMap(
k != j->parameters.end(); ++k)
{
write8(file, k->direction);
- writeNameLen(file, k->name);
- writeNameLen(file, k->type);
+ writeIdxName(file, k->name);
+ writeIdxName(file, k->type);
}
write32(file, j->exceptions.size());
for (std::vector< OUString >::const_iterator k(
j->exceptions.begin());
k != j->exceptions.end(); ++k)
{
- writeNameLen(file, *k);
+ writeIdxName(file, *k);
}
+ writeAnnotations(file, ann, j->annotations);
}
+ writeAnnotations(file, ann, ent2->getAnnotations());
break;
}
case unoidl::Entity::SORT_TYPEDEF:
@@ -472,9 +584,11 @@ sal_uInt64 writeMap(
rtl::Reference< unoidl::TypedefEntity > ent2(
static_cast< unoidl::TypedefEntity * >(
i->second.entity.get()));
+ bool ann = !ent2->getAnnotations().empty();
i->second.dataOffset = getOffset(file);
- writeKind(file, ent2.get());
- writeNameLen(file, ent2->getType());
+ writeKind(file, ent2.get(), ann);
+ writeIdxName(file, ent2->getType());
+ writeAnnotations(file, ann, ent2->getAnnotations());
break;
}
case unoidl::Entity::SORT_CONSTANT_GROUP:
@@ -488,7 +602,8 @@ sal_uInt64 writeMap(
j != ent2->getMembers().end(); ++j)
{
if (!cmap.insert(
- std::make_pair(j->name, ConstItem(j->value))).
+ std::make_pair(
+ j->name, ConstItem(j->value, j->annotations))).
second)
{
std::cout
@@ -502,7 +617,7 @@ sal_uInt64 writeMap(
{
j->second.dataOffset = getOffset(file);
sal_uInt64 v = j->second.constant.type;
- if (false /*TODO: deprecated */) {
+ if (!j->second.annotations.empty()) {
v |= 0x80;
}
write8(file, v);
@@ -554,15 +669,19 @@ sal_uInt64 writeMap(
default:
for (;;) { std::abort(); } // this cannot happen
}
+ writeAnnotations(
+ file, !j->second.annotations.empty(),
+ j->second.annotations);
}
for (std::map< OUString, ConstItem >::iterator j(
cmap.begin());
j != cmap.end(); ++j)
{
- j->second.nameOffset = writeNameNul(file, j->first);
+ j->second.nameOffset = writeNulName(file, j->first);
}
+ bool ann = !ent2->getAnnotations().empty();
i->second.dataOffset = getOffset(file);
- writeKind(file, ent2.get());
+ writeKind(file, ent2.get(), ann);
write32(file, cmap.size());
// overflow from std::map::size_type -> sal_uInt64 is
// unrealistic
@@ -573,6 +692,7 @@ sal_uInt64 writeMap(
write32(file, j->second.nameOffset);
write32(file, j->second.dataOffset);
}
+ writeAnnotations(file, ann, ent2->getAnnotations());
break;
}
case unoidl::Entity::SORT_SINGLE_INTERFACE_BASED_SERVICE:
@@ -582,11 +702,22 @@ sal_uInt64 writeMap(
static_cast<
unoidl::SingleInterfaceBasedServiceEntity * >(
i->second.entity.get()));
- i->second.dataOffset = getOffset(file);
bool dfltCtor = ent2->getConstructors().size() == 1
&& ent2->getConstructors()[0].defaultConstructor;
- writeKind(file, ent2.get(), dfltCtor);
- writeNameLen(file, ent2->getBase());
+ bool ann = !ent2->getAnnotations().empty();
+ if (!dfltCtor) {
+ for (std::vector<
+ unoidl::SingleInterfaceBasedServiceEntity::
+ Constructor >::const_iterator j(
+ ent2->getConstructors().begin());
+ !ann && j != ent2->getConstructors().end(); ++j)
+ {
+ ann = !j->annotations.empty();
+ }
+ }
+ i->second.dataOffset = getOffset(file);
+ writeKind(file, ent2.get(), ann, dfltCtor);
+ writeIdxName(file, ent2->getBase());
if (!dfltCtor) {
write32(file, ent2->getConstructors().size());
for (std::vector<
@@ -601,7 +732,7 @@ sal_uInt64 writeMap(
<< j->name << '"' << std::endl;
std::exit(EXIT_FAILURE);
}
- writeNameLen(file, j->name);
+ writeIdxName(file, j->name);
write32(file, j->parameters.size());
for (std::vector<
unoidl::SingleInterfaceBasedServiceEntity::
@@ -614,18 +745,20 @@ sal_uInt64 writeMap(
f |= 0x04;
}
write8(file, f);
- writeNameLen(file, k->name);
- writeNameLen(file, k->type);
+ writeIdxName(file, k->name);
+ writeIdxName(file, k->type);
}
write32(file, j->exceptions.size());
for (std::vector< OUString >::const_iterator k(
j->exceptions.begin());
k != j->exceptions.end(); ++k)
{
- writeNameLen(file, *k);
+ writeIdxName(file, *k);
}
+ writeAnnotations(file, ann, j->annotations);
}
}
+ writeAnnotations(file, ann, ent2->getAnnotations());
break;
}
case unoidl::Entity::SORT_ACCUMULATION_BASED_SERVICE:
@@ -633,35 +766,77 @@ sal_uInt64 writeMap(
rtl::Reference< unoidl::AccumulationBasedServiceEntity > ent2(
static_cast< unoidl::AccumulationBasedServiceEntity * >(
i->second.entity.get()));
+ bool ann = !ent2->getAnnotations().empty();
+ for (std::vector< unoidl::AnnotatedReference >::const_iterator
+ j(ent2->getDirectMandatoryBaseServices().begin());
+ !ann && j != ent2->getDirectMandatoryBaseServices().end();
+ ++j)
+ {
+ ann = !j->annotations.empty();
+ }
+ for (std::vector< unoidl::AnnotatedReference >::const_iterator
+ j(ent2->getDirectOptionalBaseServices().begin());
+ !ann && j != ent2->getDirectOptionalBaseServices().end();
+ ++j)
+ {
+ ann = !j->annotations.empty();
+ }
+ for (std::vector< unoidl::AnnotatedReference >::const_iterator
+ j(ent2->getDirectMandatoryBaseInterfaces().begin());
+ (!ann
+ && j != ent2->getDirectMandatoryBaseInterfaces().end());
+ ++j)
+ {
+ ann = !j->annotations.empty();
+ }
+ for (std::vector< unoidl::AnnotatedReference >::const_iterator
+ j(ent2->getDirectOptionalBaseInterfaces().begin());
+ !ann && j != ent2->getDirectOptionalBaseInterfaces().end();
+ ++j)
+ {
+ ann = !j->annotations.empty();
+ }
+ for (std::vector<
+ unoidl::AccumulationBasedServiceEntity::Property >::
+ const_iterator j(
+ ent2->getDirectProperties().begin());
+ !ann && j != ent2->getDirectProperties().end(); ++j)
+ {
+ ann = !j->annotations.empty();
+ }
i->second.dataOffset = getOffset(file);
- writeKind(file, ent2.get());
+ writeKind(file, ent2.get(), ann);
write32(file, ent2->getDirectMandatoryBaseServices().size());
- for (std::vector< OUString >::const_iterator j(
- ent2->getDirectMandatoryBaseServices().begin());
+ for (std::vector< unoidl::AnnotatedReference >::const_iterator
+ j(ent2->getDirectMandatoryBaseServices().begin());
j != ent2->getDirectMandatoryBaseServices().end(); ++j)
{
- writeNameLen(file, *j);
+ writeIdxName(file, j->name);
+ writeAnnotations(file, ann, j->annotations);
}
write32(file, ent2->getDirectOptionalBaseServices().size());
- for (std::vector< OUString >::const_iterator j(
- ent2->getDirectOptionalBaseServices().begin());
+ for (std::vector< unoidl::AnnotatedReference >::const_iterator
+ j(ent2->getDirectOptionalBaseServices().begin());
j != ent2->getDirectOptionalBaseServices().end(); ++j)
{
- writeNameLen(file, *j);
+ writeIdxName(file, j->name);
+ writeAnnotations(file, ann, j->annotations);
}
write32(file, ent2->getDirectMandatoryBaseInterfaces().size());
- for (std::vector< OUString >::const_iterator j(
- ent2->getDirectMandatoryBaseInterfaces().begin());
+ for (std::vector< unoidl::AnnotatedReference >::const_iterator
+ j(ent2->getDirectMandatoryBaseInterfaces().begin());
j != ent2->getDirectMandatoryBaseInterfaces().end(); ++j)
{
- writeNameLen(file, *j);
+ writeIdxName(file, j->name);
+ writeAnnotations(file, ann, j->annotations);
}
write32(file, ent2->getDirectOptionalBaseInterfaces().size());
- for (std::vector< OUString >::const_iterator j(
- ent2->getDirectOptionalBaseInterfaces().begin());
+ for (std::vector< unoidl::AnnotatedReference >::const_iterator
+ j(ent2->getDirectOptionalBaseInterfaces().begin());
j != ent2->getDirectOptionalBaseInterfaces().end(); ++j)
{
- writeNameLen(file, *j);
+ writeIdxName(file, j->name);
+ writeAnnotations(file, ann, j->annotations);
}
write32(file, ent2->getDirectProperties().size());
for (std::vector<
@@ -671,9 +846,11 @@ sal_uInt64 writeMap(
j != ent2->getDirectProperties().end(); ++j)
{
write16(file, static_cast< sal_uInt16 >(j->attributes));
- writeNameLen(file, j->name);
- writeNameLen(file, j->type);
+ writeIdxName(file, j->name);
+ writeIdxName(file, j->type);
+ writeAnnotations(file, ann, j->annotations);
}
+ writeAnnotations(file, ann, ent2->getAnnotations());
break;
}
case unoidl::Entity::SORT_INTERFACE_BASED_SINGLETON:
@@ -681,9 +858,11 @@ sal_uInt64 writeMap(
rtl::Reference< unoidl::InterfaceBasedSingletonEntity > ent2(
static_cast< unoidl::InterfaceBasedSingletonEntity * >(
i->second.entity.get()));
+ bool ann = !ent2->getAnnotations().empty();
i->second.dataOffset = getOffset(file);
- writeKind(file, ent2.get());
- writeNameLen(file, ent2->getBase());
+ writeKind(file, ent2.get(), ann);
+ writeIdxName(file, ent2->getBase());
+ writeAnnotations(file, ann, ent2->getAnnotations());
break;
}
case unoidl::Entity::SORT_SERVICE_BASED_SINGLETON:
@@ -691,9 +870,11 @@ sal_uInt64 writeMap(
rtl::Reference< unoidl::ServiceBasedSingletonEntity > ent2(
static_cast< unoidl::ServiceBasedSingletonEntity * >(
i->second.entity.get()));
+ bool ann = !ent2->getAnnotations().empty();
i->second.dataOffset = getOffset(file);
- writeKind(file, ent2.get());
- writeNameLen(file, ent2->getBase());
+ writeKind(file, ent2.get(), ann);
+ writeIdxName(file, ent2->getBase());
+ writeAnnotations(file, ann, ent2->getAnnotations());
break;
}
}
@@ -701,7 +882,7 @@ sal_uInt64 writeMap(
for (std::map< OUString, Item >::iterator i(map.begin()); i != map.end();
++i)
{
- i->second.nameOffset = writeNameNul(file, i->first);
+ i->second.nameOffset = writeNulName(file, i->first);
}
sal_uInt64 off = getOffset(file);
if (rootSize == 0) {
diff --git a/unoidl/source/unoidlprovider.cxx b/unoidl/source/unoidlprovider.cxx
index 33848a1..47b6f9e 100644
--- a/unoidl/source/unoidlprovider.cxx
+++ b/unoidl/source/unoidlprovider.cxx
@@ -17,6 +17,8 @@
#include "osl/endian.h"
#include "osl/file.h"
#include "rtl/ref.hxx"
+#include "rtl/textenc.h"
+#include "rtl/textcvt.h"
#include "rtl/ustring.hxx"
#include "sal/log.hxx"
#include "sal/types.h"
@@ -132,9 +134,13 @@ public:
double readIso60599Binary64(sal_uInt32 offset) const;
- OUString readNameNul(sal_uInt32 offset) const;
+ OUString readNulName(sal_uInt32 offset) const;
- OUString readNameLen(sal_uInt32 offset, sal_uInt32 * newOffset = 0) const;
+ OUString readIdxName(sal_uInt32 * offset) const
+ { return readIdxString(offset, RTL_TEXTENCODING_ASCII_US); }
+
+ OUString readIdxString(sal_uInt32 * offset) const
+ { return readIdxString(offset, RTL_TEXTENCODING_UTF8); }
OUString uri;
oslFileHandle handle;
@@ -155,6 +161,9 @@ private:
float getIso60599Binary32(sal_uInt32 offset) const;
double getIso60599Binary64(sal_uInt32 offset) const;
+
+ OUString readIdxString(sal_uInt32 * offset, rtl_TextEncoding encoding)
+ const;
};
MappedFile::MappedFile(OUString const & fileUrl): uri(fileUrl) {
@@ -235,7 +244,7 @@ double MappedFile::readIso60599Binary64(sal_uInt32 offset) const {
return getIso60599Binary64(offset);
}
-OUString MappedFile::readNameNul(sal_uInt32 offset) const {
+OUString MappedFile::readNulName(sal_uInt32 offset) const {
if (offset > size) {
throw FileFormatException(
uri, "UNOIDL format: offset for string too large");
@@ -266,44 +275,6 @@ OUString MappedFile::readNameNul(sal_uInt32 offset) const {
return name;
}
-OUString MappedFile::readNameLen(sal_uInt32 offset, sal_uInt32 * newOffset)
- const
-{
- sal_uInt32 len = read32(offset);
- if ((len & 0x80000000) == 0) {
- if (newOffset != 0) {
- *newOffset = offset + 4;
- }
- offset = len;
- len = read32(offset);
- if ((len & 0x80000000) == 0) {
- throw FileFormatException(
- uri, "UNOIDL format: name length high bit unset");
- }
- len &= ~0x80000000;
- } else {
- len &= ~0x80000000;
- if (newOffset != 0) {
- *newOffset = offset + 4 + len;
- }
- }
- if (len > SAL_MAX_INT32 || len > size - offset - 4) {
- throw FileFormatException(
- uri, "UNOIDL format: size of name is too large");
- }
- OUString name;
- if (!rtl_convertStringToUString(
- &name.pData, static_cast< char const * >(address) + offset + 4, len,
- RTL_TEXTENCODING_ASCII_US,
- (RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_ERROR
- | RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_ERROR
- | RTL_TEXTTOUNICODE_FLAGS_INVALID_ERROR)))
- {
- throw FileFormatException(uri, "UNOIDL format: name is not ASCII");
- }
- return name;
-}
-
MappedFile::~MappedFile() {
oslFileError e = osl_unmapMappedFile(handle, address, size);
SAL_WARN_IF(e != osl_File_E_None, "unoidl", "cannot unmap: " << +e);
@@ -352,6 +323,42 @@ double MappedFile::getIso60599Binary64(sal_uInt32 offset) const {
static_cast< char const * >(address) + offset)->getIso60599Binary64();
}
+OUString MappedFile::readIdxString(
+ sal_uInt32 * offset, rtl_TextEncoding encoding) const
+{
+ assert(offset != 0);
+ sal_uInt32 len = read32(*offset);
+ sal_uInt32 off;
+ if ((len & 0x80000000) == 0) {
+ off = *offset;
+ *offset += 4 + len;
+ } else {
+ *offset += 4;
+ off = len & ~0x80000000;
+ len = read32(off);
+ if ((len & 0x80000000) != 0) {
+ throw FileFormatException(
+ uri, "UNOIDL format: string length high bit set");
+ }
+ }
+ if (len > SAL_MAX_INT32 || len > size - off - 4) {
+ throw FileFormatException(
+ uri, "UNOIDL format: size of string is too large");
+ }
+ OUString name;
+ if (!rtl_convertStringToUString(
+ &name.pData, static_cast< char const * >(address) + off + 4, len,
+ encoding,
+ (RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_ERROR
+ | RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_ERROR
+ | RTL_TEXTTOUNICODE_FLAGS_INVALID_ERROR)))
+ {
+ throw FileFormatException(
+ uri, "UNOIDL format: string bytes do not match encoding");
+ }
+ return name;
+}
+
// sizeof (MapEntry) == 8
struct MapEntry {
Memory32 name;
@@ -430,16 +437,40 @@ sal_uInt32 findInMap(
return off;
}
+std::vector< OUString > readAnnotations(
+ bool annotated, rtl::Reference< detail::MappedFile > const & file,
+ sal_uInt32 offset, sal_uInt32 * newOffset = 0)
+{
+ std::vector< OUString > ans;
+ if (annotated) {
+ sal_uInt32 n = file->read32(offset);
+ offset += 4;
+ for (sal_uInt32 i = 0; i != n; ++i) {
+ ans.push_back(file->readIdxString(&offset));
+ }
+ }
+ if (newOffset != 0) {
+ *newOffset = offset;
+ }
+ return ans;
+}
+
ConstantValue readConstant(
- rtl::Reference< detail::MappedFile > const & file, sal_uInt32 offset)
+ rtl::Reference< detail::MappedFile > const & file, sal_uInt32 offset,
+ sal_uInt32 * newOffset = 0, bool * annotated = 0)
{
assert(file.is());
int v = file->read8(offset);
int type = v & 0x7F;
- bool deprecated = (v & 0x80) != 0; (void)deprecated;//TODO
+ if (annotated != 0) {
+ *annotated = (v & 0x80) != 0;
+ }
switch (type) {
case 0: // BOOLEAN
v = file->read8(offset + 1);
+ if (newOffset != 0) {
+ *newOffset = offset + 2;
+ }
switch (v) {
case 0:
return ConstantValue(false);
@@ -452,33 +483,60 @@ ConstantValue readConstant(
+ OUString::number(v)));
}
case 1: // BYTE
+ if (newOffset != 0) {
+ *newOffset = offset + 2;
+ }
return ConstantValue(static_cast< sal_Int8 >(file->read8(offset + 1)));
//TODO: implementation-defined behavior of conversion from sal_uInt8
// to sal_Int8 relies on two's complement representation
case 2: // SHORT
+ if (newOffset != 0) {
+ *newOffset = offset + 3;
+ }
return ConstantValue(
static_cast< sal_Int16 >(file->read16(offset + 1)));
//TODO: implementation-defined behavior of conversion from
// sal_uInt16 to sal_Int16 relies on two's complement representation
case 3: // UNSIGNED SHORT
+ if (newOffset != 0) {
+ *newOffset = offset + 3;
+ }
return ConstantValue(file->read16(offset + 1));
case 4: // LONG
+ if (newOffset != 0) {
+ *newOffset = offset + 5;
+ }
return ConstantValue(
static_cast< sal_Int32 >(file->read32(offset + 1)));
... etc. - the rest is truncated
More information about the Libreoffice-commits
mailing list