unoidl/source/legacyprovider.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  */
   9
  10 #include <sal/config.h>
  11
  12 #include <cassert>
  13 #include <vector>
  14
  15 #include <registry/reader.hxx>
  16 #include <registry/registry.hxx>
  17 #include <registry/regtype.h>
  18 #include <rtl/ref.hxx>
  19 #include <rtl/ustring.hxx>
  20 #include <sal/types.h>
  21 #include <unoidl/unoidl.hxx>
  22
  23 #include "legacyprovider.hxx"
  24
  25 namespace unoidl { namespace detail {
  26
  27 namespace {
  28
  29 std::vector< OUString > translateAnnotations(OUString const & documentation) {
  30     std::vector< OUString > ans;
  31     if (documentation.indexOf("@deprecated") != -1) {
  32         //TODO: this check is somewhat crude
  33         ans.push_back("deprecated");
  34     }
  35     return ans;
  36 }
  37
  38 ConstantValue translateConstantValue(
  39     RegistryKey & key, RTConstValue const & value)
  40 {
  41     switch (value.m_type) {
  42     case RT_TYPE_BOOL:
  43         return ConstantValue(value.m_value.aBool);
  44     case RT_TYPE_BYTE:
  45         return ConstantValue(value.m_value.aByte);
  46     case RT_TYPE_INT16:
  47         return ConstantValue(value.m_value.aShort);
  48     case RT_TYPE_UINT16:
  49         return ConstantValue(value.m_value.aUShort);
  50     case RT_TYPE_INT32:
  51         return ConstantValue(value.m_value.aLong);
  52     case RT_TYPE_UINT32:
  53         return ConstantValue(value.m_value.aULong);
  54     case RT_TYPE_INT64:
  55         return ConstantValue(value.m_value.aHyper);
  56     case RT_TYPE_UINT64:
  57         return ConstantValue(value.m_value.aUHyper);
  58     case RT_TYPE_FLOAT:
  59         return ConstantValue(value.m_value.aFloat);
  60     case RT_TYPE_DOUBLE:
  61         return ConstantValue(value.m_value.aDouble);
  62     default:
  63         throw FileFormatException(
  64             key.getRegistryName(),
  65             ("legacy format: unexpected type " + OUString::number(value.m_type)
  66              + " of value of a field  of constant group with key "
  67              + key.getName()));
  68     }
  69 }
  70
  71 rtl::Reference< Entity > readEntity(
  72     rtl::Reference< Manager > const & manager, RegistryKey & ucr,
  73     RegistryKey & key, OUString const & path, bool probe);
  74
  75 class Cursor: public MapCursor {
  76 public:
  77     Cursor(
  78         rtl::Reference< Manager > const & manager, RegistryKey const & ucr,
  79         RegistryKey const & key);
  80
  81 private:
  82     virtual ~Cursor() throw () override {}
  83
  84     virtual rtl::Reference< Entity > getNext(OUString * name) override;
  85
  86     rtl::Reference< Manager > manager_;
  87     RegistryKey ucr_;
  88     RegistryKey key_;
  89     OUString prefix_;
  90     RegistryKeyNames names_;
  91     sal_uInt32 index_;
  92 };
  93
  94 Cursor::Cursor(
  95     rtl::Reference< Manager > const & manager, RegistryKey const & ucr,
  96     RegistryKey const & key):
  97     manager_(manager), ucr_(ucr), key_(key), index_(0)
  98 {
  99     if (ucr_.isValid()) {
 100         prefix_ = key_.getName();
 101         if (!prefix_.endsWith("/")) {
 102             prefix_ += "/";
 103         }
 104         RegError e = key_.getKeyNames("", names_);
 105         if (e != RegError::NO_ERROR) {
 106             throw FileFormatException(
 107                 key_.getRegistryName(),
 108                 ("legacy format: cannot get sub-key names of " + key_.getName()
 109                  + ": " + OUString::number(static_cast<int>(e))));
 110         }
 111     }
 112 }
 113
 114 rtl::Reference< Entity > Cursor::getNext(OUString * name) {
 115     assert(name != nullptr);
 116     rtl::Reference< Entity > ent;
 117     if (index_ != names_.getLength()) {
 118         OUString path(names_.getElement(index_));
 119         assert(path.match(prefix_));
 120         *name = path.copy(prefix_.getLength());
 121         ent = readEntity(manager_, ucr_, key_, *name, false);
 122         assert(ent.is());
 123         ++index_;
 124     }
 125     return ent;
 126 }
 127
 128 class Module: public ModuleEntity {
 129 public:
 130     Module(
 131         rtl::Reference< Manager > const & manager, RegistryKey const & ucr,
 132         RegistryKey const & key):
 133         manager_(manager), ucr_(ucr), key_(key)
 134     {}
 135
 136 private:
 137     virtual ~Module() throw () override {}
 138
 139     virtual std::vector< OUString > getMemberNames() const override;
 140
 141     virtual rtl::Reference< MapCursor > createCursor() const override
 142     { return new Cursor(manager_, ucr_, key_); }
 143
 144     rtl::Reference< Manager > manager_;
 145     RegistryKey const ucr_;
 146     mutable RegistryKey key_;
 147 };
 148
 149 std::vector< OUString > Module::getMemberNames() const {
 150     RegistryKeyNames names;
 151     RegError e = key_.getKeyNames("", names);
 152     if (e != RegError::NO_ERROR) {
 153         throw FileFormatException(
 154             key_.getRegistryName(),
 155             ("legacy format: cannot get sub-key names of " + key_.getName()
 156              + ": " + OUString::number(static_cast<int>(e))));
 157     }
 158     std::vector< OUString > ns;
 159     for (sal_uInt32 i = 0; i != names.getLength(); ++i) {
 160         ns.push_back(names.getElement(i));
 161     }
 162     return ns;
 163 }
 164
 165 typereg::Reader getReader(RegistryKey & key, std::vector< char > * buffer) {
 166     assert(buffer != nullptr);
 167     RegValueType type;
 168     sal_uInt32 size;
 169     RegError e = key.getValueInfo("", &type, &size);
 170     if (e != RegError::NO_ERROR) {
 171         throw FileFormatException(
 172             key.getRegistryName(),
 173             ("legacy format: cannot get value info about key " + key.getName()
 174              + ": " + OUString::number(static_cast<int>(e))));
 175     }
 176     if (type != RegValueType::BINARY) {
 177         throw FileFormatException(
 178             key.getRegistryName(),
 179             ("legacy format: unexpected value type " + OUString::number(static_cast<int>(type))
 180              + " of key " + key.getName()));
 181     }
 182     if (size == 0
 183         /*TODO: || size > std::numeric_limits< std::vector< char >::size_type >::max() */)
 184     {
 185         throw FileFormatException(
 186             key.getRegistryName(),
 187             ("legacy format: bad binary value size " + OUString::number(size)
 188              + " of key " + key.getName()));
 189     }
 190     buffer->resize(static_cast< std::vector< char >::size_type >(size));
 191     e = key.getValue("", buffer->data());
 192     if (e != RegError::NO_ERROR) {
 193         throw FileFormatException(
 194             key.getRegistryName(),
 195             ("legacy format: cannot get binary value of key " + key.getName()
 196              + ": " + OUString::number(static_cast<int>(e))));
 197     }
 198     typereg::Reader reader(buffer->data(), size);
 199     if (!reader.isValid()) {
 200         throw FileFormatException(
 201             key.getRegistryName(),
 202             "legacy format: malformed binary value of key " + key.getName());
 203     }
 204     return reader;
 205 }
 206
 207 rtl::Reference< Entity > readEntity(
 208     rtl::Reference< Manager > const & manager, RegistryKey & ucr,
 209     RegistryKey & key, OUString const & path, bool probe)
 210 {
 211     assert(manager.is());
 212     RegistryKey sub;
 213     RegError e = key.openKey(path, sub);
 214     switch (e) {
 215     case RegError::NO_ERROR:
 216         break;
 217     case RegError::KEY_NOT_EXISTS:
 218         if (probe) {
 219             return rtl::Reference< Entity >();
 220         }
 221         [[fallthrough]];
 222     default:
 223         throw FileFormatException(
 224             key.getRegistryName(),
 225             ("legacy format: cannot open sub-key " + path + " of "
 226              + key.getName() + ": " + OUString::number(static_cast<int>(e))));
 227     }
 228     std::vector< char > buf;
 229     typereg::Reader reader(getReader(sub, &buf));
 230     switch (reader.getTypeClass()) {
 231     case RT_TYPE_INTERFACE:
 232         {
 233             std::vector< AnnotatedReference > mandBases;
 234             sal_uInt16 n = reader.getSuperTypeCount();
 235             for (sal_uInt16 j = 0; j != n; ++j) {
 236                 mandBases.emplace_back(
 237                     reader.getSuperTypeName(j).replace('/', '.'),
 238                     std::vector< OUString >());
 239             }
 240             std::vector< AnnotatedReference > optBases;
 241             n = reader.getReferenceCount();
 242             for (sal_uInt16 j = 0; j != n; ++j) {
 243                 optBases.emplace_back(
 244                     reader.getReferenceTypeName(j).replace('/', '.'),
 245                     translateAnnotations(reader.getReferenceDocumentation(j)));
 246             }
 247             sal_uInt16 methodCount = reader.getMethodCount();
 248             std::vector< InterfaceTypeEntity::Attribute > attrs;
 249             n = reader.getFieldCount(); // attributes
 250             for (sal_uInt16 j = 0; j != n; ++j) {
 251                 OUString attrName(reader.getFieldName(j));
 252                 std::vector< OUString > getExcs;
 253                 std::vector< OUString > setExcs;
 254                 for (sal_uInt16 k = 0; k != methodCount; ++k) {
 255                     if (reader.getMethodName(k) == attrName) {
 256                         switch (reader.getMethodFlags(k)) {
 257                         case RTMethodMode::ATTRIBUTE_GET:
 258                             {
 259                                 sal_uInt16 m
 260                                     = reader.getMethodExceptionCount(k);
 261                                 // cid#1213376 unhelpfully warns about an
 262                                 // untrusted loop bound here:
 263                                 // coverity[tainted_data] - trusted data source
 264                                 for (sal_uInt16 l = 0; l != m; ++l) {
 265                                     getExcs.push_back(
 266                                         reader.getMethodExceptionTypeName(k, l).
 267                                         replace('/', '.'));
 268                                 }
 269                                 break;
 270                             }
 271                         case RTMethodMode::ATTRIBUTE_SET:
 272                             {
 273                                 sal_uInt16 m
 274                                     = reader.getMethodExceptionCount(k);
 275                                 // cid#1213376 unhelpfully warns about an
 276                                 // untrusted loop bound here:
 277                                 // coverity[tainted_data] - trusted data source
 278                                 for (sal_uInt16 l = 0; l != m; ++l) {
 279                                     setExcs.push_back(
 280                                         reader.getMethodExceptionTypeName(k, l).
 281                                         replace('/', '.'));
 282                                 }
 283                                 break;
 284                             }
 285                         default:
 286                             throw FileFormatException(
 287                                 key.getRegistryName(),
 288                                 ("legacy format: method and attribute with same"
 289                                  " name " + attrName
 290                                  + " in interface type with key "
 291                                  + sub.getName()));
 292                         }
 293                     }
 294                 }
 295                 RTFieldAccess flags = reader.getFieldFlags(j);
 296                 attrs.emplace_back(
 297                     attrName, reader.getFieldTypeName(j).replace('/', '.'),
 298                     bool(flags & RTFieldAccess::BOUND),
 299                     bool(flags & RTFieldAccess::READONLY), getExcs, setExcs,
 300                     translateAnnotations(reader.getFieldDocumentation(j)));
 301             }
 302             std::vector< InterfaceTypeEntity::Method > meths;
 303             for (sal_uInt16 j = 0; j != methodCount; ++j) {
 304                 RTMethodMode flags = reader.getMethodFlags(j);
 305                 if (flags != RTMethodMode::ATTRIBUTE_GET
 306                     && flags != RTMethodMode::ATTRIBUTE_SET)
 307                 {
 308                     std::vector< InterfaceTypeEntity::Method::Parameter >
 309                         params;
 310                     sal_uInt16 m = reader.getMethodParameterCount(j);
 311                     // cid#1213376 unhelpfully warns about an untrusted loop
 312                     // bound here:
 313                     // coverity[tainted_data] - trusted data source
 314                     for (sal_uInt16 k = 0; k != m; ++k) {
 315                         RTParamMode mode = reader.getMethodParameterFlags(j, k);
 316                         InterfaceTypeEntity::Method::Parameter::Direction dir;
 317                         switch (mode) {
 318                         case RT_PARAM_IN:
 319                             dir = InterfaceTypeEntity::Method::Parameter::DIRECTION_IN;
 320                             break;
 321                         case RT_PARAM_OUT:
 322                             dir = InterfaceTypeEntity::Method::Parameter::DIRECTION_OUT;
 323                             break;
 324                         case RT_PARAM_INOUT:
 325                             dir = InterfaceTypeEntity::Method::Parameter::DIRECTION_IN_OUT;
 326                             break;
 327                         default:
 328                             throw FileFormatException(
 329                                 key.getRegistryName(),
 330                                 ("legacy format: unexpected mode "
 331                                  + OUString::number(mode) + " of parameter "
 332                                  + reader.getMethodParameterName(j, k)
 333                                  + " of method " + reader.getMethodName(j)
 334                                  + " in interface type with key "
 335                                  + sub.getName()));
 336                         }
 337                         params.emplace_back(
 338                             reader.getMethodParameterName(j, k),
 339                             (reader.getMethodParameterTypeName(j, k).
 340                              replace('/', '.')),
 341                             dir);
 342                     }
 343                     std::vector< OUString > excs;
 344                     m = reader.getMethodExceptionCount(j);
 345                     // cid#1213376 unhelpfully warns about an untrusted loop
 346                     // bound here:
 347                     // coverity[tainted_data] - trusted data source
 348                     for (sal_uInt16 k = 0; k != m; ++k) {
 349                         excs.push_back(
 350                             reader.getMethodExceptionTypeName(j, k).replace(
 351                                 '/', '.'));
 352                     }
 353                     meths.emplace_back(
 354                         reader.getMethodName(j),
 355                         reader.getMethodReturnTypeName(j).replace('/', '.'),
 356                         params, excs,
 357                         translateAnnotations(
 358                             reader.getMethodDocumentation(j)));
 359                 }
 360             }
 361             return new InterfaceTypeEntity(
 362                 reader.isPublished(), mandBases, optBases, attrs, meths,
 363                 translateAnnotations(reader.getDocumentation()));
 364         }
 365     case RT_TYPE_MODULE:
 366         return new Module(manager, ucr, sub);
 367     case RT_TYPE_STRUCT:
 368         {
 369             sal_uInt16 n = reader.getReferenceCount();
 370             if (n == 0) {
 371                 OUString base;
 372                 switch (reader.getSuperTypeCount()) {
 373                 case 0:
 374                     break;
 375                 case 1:
 376                     base = reader.getSuperTypeName(0).replace('/', '.');
 377                     break;
 378                 default:
 379                     throw FileFormatException(
 380                         key.getRegistryName(),
 381                         ("legacy format: unexpected number "
 382                          + OUString::number(reader.getSuperTypeCount())
 383                          + " of super-types of plain struct type with key "
 384                          + sub.getName()));
 385                 }
 386                 std::vector< PlainStructTypeEntity::Member > mems;
 387                 n = reader.getFieldCount();
 388                 for (sal_uInt16 j = 0; j != n; ++j) {
 389                     mems.emplace_back(
 390                         reader.getFieldName(j),
 391                         reader.getFieldTypeName(j).replace('/', '.'),
 392                         translateAnnotations(reader.getFieldDocumentation(j)));
 393                 }
 394                 return new PlainStructTypeEntity(
 395                     reader.isPublished(), base, mems,
 396                     translateAnnotations(reader.getDocumentation()));
 397             } else {
 398                 if (reader.getSuperTypeCount() != 0) {
 399                     throw FileFormatException(
 400                         key.getRegistryName(),
 401                         ("legacy format: unexpected number "
 402                          + OUString::number(reader.getSuperTypeCount())
 403                          + " of super-types of polymorphic struct type template"
 404                          " with key " + sub.getName()));
 405                 }
 406                 std::vector< OUString > params;
 407                 for (sal_uInt16 j = 0; j != n; ++j) {
 408                     params.push_back(
 409                         reader.getReferenceTypeName(j).replace('/', '.'));
 410                 }
 411                 std::vector< PolymorphicStructTypeTemplateEntity::Member > mems;
 412                 n = reader.getFieldCount();
 413                 for (sal_uInt16 j = 0; j != n; ++j) {
 414                     mems.emplace_back(
 415                         reader.getFieldName(j),
 416                         reader.getFieldTypeName(j).replace('/', '.'),
 417                         bool(
 418                             reader.getFieldFlags(j)
 419                             & RTFieldAccess::PARAMETERIZED_TYPE),
 420                         translateAnnotations(reader.getFieldDocumentation(j)));
 421                 }
 422                 return new PolymorphicStructTypeTemplateEntity(
 423                     reader.isPublished(), params, mems,
 424                     translateAnnotations(reader.getDocumentation()));
 425             }
 426         }
 427     case RT_TYPE_ENUM:
 428         {
 429             std::vector< EnumTypeEntity::Member > mems;
 430             sal_uInt16 n = reader.getFieldCount();
 431             for (sal_uInt16 j = 0; j != n; ++j) {
 432                 RTConstValue v(reader.getFieldValue(j));
 433                 if (v.m_type != RT_TYPE_INT32) {
 434                     throw FileFormatException(
 435                         key.getRegistryName(),
 436                         ("legacy format: unexpected type "
 437                          + OUString::number(v.m_type) + " of value of field "
 438                          + reader.getFieldName(j) + " of enum type with key "
 439                          + sub.getName()));
 440                 }
 441                 mems.emplace_back(
 442                     reader.getFieldName(j), v.m_value.aLong,
 443                     translateAnnotations(reader.getFieldDocumentation(j)));
 444
 445             }
 446             return new EnumTypeEntity(
 447                 reader.isPublished(), mems,
 448                 translateAnnotations(reader.getDocumentation()));
 449         }
 450     case RT_TYPE_EXCEPTION:
 451         {
 452             OUString base;
 453             switch (reader.getSuperTypeCount()) {
 454             case 0:
 455                 break;
 456             case 1:
 457                 base = reader.getSuperTypeName(0).replace('/', '.');
 458                 break;
 459             default:
 460                 throw FileFormatException(
 461                     key.getRegistryName(),
 462                     ("legacy format: unexpected number "
 463                      + OUString::number(reader.getSuperTypeCount())
 464                      + " of super-types of exception type with key "
 465                      + sub.getName()));
 466             }
 467             std::vector< ExceptionTypeEntity::Member > mems;
 468             sal_uInt16 n = reader.getFieldCount();
 469             for (sal_uInt16 j = 0; j != n; ++j) {
 470                 mems.emplace_back(
 471                     reader.getFieldName(j),
 472                     reader.getFieldTypeName(j).replace('/', '.'),
 473                     translateAnnotations(reader.getFieldDocumentation(j)));
 474             }
 475             return new ExceptionTypeEntity(
 476                 reader.isPublished(), base, mems,
 477                 translateAnnotations(reader.getDocumentation()));
 478         }
 479     case RT_TYPE_TYPEDEF:
 480         if (reader.getSuperTypeCount() != 1) {
 481             throw FileFormatException(
 482                 key.getRegistryName(),
 483                 ("legacy format: unexpected number "
 484                  + OUString::number(reader.getSuperTypeCount())
 485                  + " of super-types of typedef with key " + sub.getName()));
 486         }
 487         return new TypedefEntity(
 488             reader.isPublished(), reader.getSuperTypeName(0).replace('/', '.'),
 489             translateAnnotations(reader.getDocumentation()));
 490     case RT_TYPE_SERVICE:
 491         switch (reader.getSuperTypeCount()) {
 492         case 0:
 493             {
 494                 std::vector< AnnotatedReference > mandServs;
 495                 std::vector< AnnotatedReference > optServs;
 496                 std::vector< AnnotatedReference > mandIfcs;
 497                 std::vector< AnnotatedReference > optIfcs;
 498                 sal_uInt16 n = reader.getReferenceCount();
 499                 for (sal_uInt16 j = 0; j != n; ++j) {
 500                     AnnotatedReference base{
 501                         reader.getReferenceTypeName(j).replace('/', '.'),
 502                         translateAnnotations(
 503                             reader.getReferenceDocumentation(j))};
 504                     switch (reader.getReferenceSort(j)) {
 505                     case RTReferenceType::EXPORTS:
 506                         if (!(reader.getReferenceFlags(j) & RTFieldAccess::OPTIONAL))
 507                         {
 508                             mandServs.push_back(base);
 509                         } else {
 510                             optServs.push_back(base);
 511                         }
 512                         break;
 513                     case RTReferenceType::SUPPORTS:
 514                         if (!(reader.getReferenceFlags(j) & RTFieldAccess::OPTIONAL))
 515                         {
 516                             mandIfcs.push_back(base);
 517                         } else {
 518                             optIfcs.push_back(base);
 519                         }
 520                         break;
 521                     default:
 522                         throw FileFormatException(
 523                             key.getRegistryName(),
 524                             ("legacy format: unexpected mode "
 525                              + OUString::number(static_cast<int>(reader.getReferenceSort(j)))
 526                              + " of reference " + reader.getReferenceTypeName(j)
 527                              + " in service with key " + sub.getName()));
 528                     }
 529                 }
 530                 std::vector< AccumulationBasedServiceEntity::Property > props;
 531                 n = reader.getFieldCount();
 532                 for (sal_uInt16 j = 0; j != n; ++j) {
 533                     RTFieldAccess acc = reader.getFieldFlags(j);
 534                     int attrs = 0;
 535                     if (acc & RTFieldAccess::READONLY) {
 536                         attrs |= AccumulationBasedServiceEntity::Property::
 537                             ATTRIBUTE_READ_ONLY;
 538                     }
 539                     if (acc & RTFieldAccess::OPTIONAL) {
 540                         attrs |= AccumulationBasedServiceEntity::Property::
 541                             ATTRIBUTE_OPTIONAL;
 542                     }
 543                     if (acc & RTFieldAccess::MAYBEVOID) {
 544                         attrs |= AccumulationBasedServiceEntity::Property::
 545                             ATTRIBUTE_MAYBE_VOID;
 546                     }
 547                     if (acc & RTFieldAccess::BOUND) {
 548                         attrs |= AccumulationBasedServiceEntity::Property::
 549                             ATTRIBUTE_BOUND;
 550                     }
 551                     if (acc & RTFieldAccess::CONSTRAINED) {
 552                         attrs |= AccumulationBasedServiceEntity::Property::
 553                             ATTRIBUTE_CONSTRAINED;
 554                     }
 555                     if (acc & RTFieldAccess::TRANSIENT) {
 556                         attrs |= AccumulationBasedServiceEntity::Property::
 557                             ATTRIBUTE_TRANSIENT;
 558                     }
 559                     if (acc & RTFieldAccess::MAYBEAMBIGUOUS) {
 560                         attrs |= AccumulationBasedServiceEntity::Property::
 561                             ATTRIBUTE_MAYBE_AMBIGUOUS;
 562                     }
 563                     if (acc & RTFieldAccess::MAYBEDEFAULT) {
 564                         attrs |= AccumulationBasedServiceEntity::Property::
 565                             ATTRIBUTE_MAYBE_DEFAULT;
 566                     }
 567                     if (acc & RTFieldAccess::REMOVABLE) {
 568                         attrs |= AccumulationBasedServiceEntity::Property::
 569                             ATTRIBUTE_REMOVABLE;
 570                     }
 571                     props.emplace_back(
 572                         reader.getFieldName(j),
 573                         reader.getFieldTypeName(j).replace('/', '.'),
 574                         static_cast<
 575                             AccumulationBasedServiceEntity::Property::
 576                                 Attributes >(attrs),
 577                         translateAnnotations(reader.getFieldDocumentation(j)));
 578                 }
 579                 return new AccumulationBasedServiceEntity(
 580                     reader.isPublished(), mandServs, optServs, mandIfcs,
 581                     optIfcs, props,
 582                     translateAnnotations(reader.getDocumentation()));
 583             }
 584         case 1:
 585             {
 586                 std::vector< SingleInterfaceBasedServiceEntity::Constructor >
 587                     ctors;
 588                 sal_uInt16 n = reader.getMethodCount();
 589                 if (n == 1 && reader.getMethodFlags(0) == RTMethodMode::TWOWAY
 590                     && reader.getMethodName(0).isEmpty()
 591                     && reader.getMethodReturnTypeName(0) == "void"
 592                     && reader.getMethodParameterCount(0) == 0
 593                     && reader.getMethodExceptionCount(0) == 0)
 594                 {
 595                     ctors.push_back(
 596                         SingleInterfaceBasedServiceEntity::Constructor());
 597                 } else {
 598                     for (sal_uInt16 j = 0; j != n; ++j) {
 599                         if (reader.getMethodFlags(j) != RTMethodMode::TWOWAY) {
 600                             throw FileFormatException(
 601                                 key.getRegistryName(),
 602                                 ("legacy format: unexpected mode "
 603                                  + OUString::number(static_cast<int>(reader.getMethodFlags(j)))
 604                                  + " of constructor " + reader.getMethodName(j)
 605                                  + " in service with key " + sub.getName()));
 606                         }
 607                         std::vector<
 608                             SingleInterfaceBasedServiceEntity::Constructor::
 609                             Parameter > params;
 610                         sal_uInt16 m = reader.getMethodParameterCount(j);
 611                         // cid#1213376 unhelpfully warns about an untrusted
 612                         // loop bound here:
 613                         // coverity[tainted_data] - trusted data source
 614                         for (sal_uInt16 k = 0; k != m; ++k) {
 615                             RTParamMode mode
 616                                 = reader.getMethodParameterFlags(j, k);
 617                             if ((mode & ~RT_PARAM_REST) != RT_PARAM_IN) {
 618                                 throw FileFormatException(
 619                                     key.getRegistryName(),
 620                                     ("legacy format: unexpected mode "
 621                                      + OUString::number(mode)
 622                                      + " of parameter "
 623                                      + reader.getMethodParameterName(j, k)
 624                                      + " of constructor "
 625                                      + reader.getMethodName(j)
 626                                      + " in service with key "
 627                                      + sub.getName()));
 628                             }
 629                             if ((mode & RT_PARAM_REST) != 0
 630                                 && !(m == 1
 631                                      && ((reader.getMethodParameterTypeName(
 632                                               j, 0))
 633                                          == "any")))
 634                             {
 635                                 throw FileFormatException(
 636                                     key.getRegistryName(),
 637                                     ("legacy format: bad rest parameter "
 638                                      + reader.getMethodParameterName(j, k)
 639                                      + " of constructor "
 640                                      + reader.getMethodName(j)
 641                                      + " in service with key "
 642                                      + sub.getName()));
 643                             }
 644                             params.emplace_back(
 645                                 reader.getMethodParameterName(j, k),
 646                                 (reader.getMethodParameterTypeName(j, k).
 647                                  replace('/', '.')),
 648                                 (mode & RT_PARAM_REST) != 0);
 649                         }
 650                         std::vector< OUString > excs;
 651                         m = reader.getMethodExceptionCount(j);
 652                         // cid#1213376 unhelpfully warns about an untrusted
 653                         // loop bound here:
 654                         // coverity[tainted_data] - trusted data source
 655                         for (sal_uInt16 k = 0; k != m; ++k) {
 656                             excs.push_back(
 657                                 reader.getMethodExceptionTypeName(j, k).replace(
 658                                     '/', '.'));
 659                         }
 660                         ctors.push_back(
 661                             SingleInterfaceBasedServiceEntity::Constructor(
 662                                 reader.getMethodName(j), params, excs,
 663                                 translateAnnotations(
 664                                     reader.getMethodDocumentation(j))));
 665                     }
 666                 }
 667                 return new SingleInterfaceBasedServiceEntity(
 668                     reader.isPublished(),
 669                     reader.getSuperTypeName(0).replace('/', '.'), ctors,
 670                     translateAnnotations(reader.getDocumentation()));
 671             }
 672         default:
 673             throw FileFormatException(
 674                 key.getRegistryName(),
 675                 ("legacy format: unexpected number "
 676                  + OUString::number(reader.getSuperTypeCount())
 677                  + " of super-types of service with key " + sub.getName()));
 678         }
 679     case RT_TYPE_SINGLETON:
 680         {
 681             if (reader.getSuperTypeCount() != 1) {
 682                 throw FileFormatException(
 683                     key.getRegistryName(),
 684                     ("legacy format: unexpected number "
 685                      + OUString::number(reader.getSuperTypeCount())
 686                      + " of super-types of singleton with key "
 687                      + sub.getName()));
 688             }
 689             OUString basePath(reader.getSuperTypeName(0));
 690             OUString baseName(basePath.replace('/', '.'));
 691             bool newStyle;
 692             rtl::Reference< Entity > base(manager->findEntity(baseName));
 693             if (base.is()) {
 694                 switch (base->getSort()) {
 695                 case Entity::SORT_INTERFACE_TYPE:
 696                     newStyle = true;
 697                     break;
 698                 case Entity::SORT_ACCUMULATION_BASED_SERVICE:
 699                     newStyle = false;
 700                     break;
 701                 default:
 702                     throw FileFormatException(
 703                         key.getRegistryName(),
 704                         ("legacy format: unexpected sort "
 705                          + OUString::number(base->getSort()) + " of base "
 706                          + baseName + " of singleton with key "
 707                          + sub.getName()));
 708                 }
 709             } else {
 710                 RegistryKey key2;
 711                 e = ucr.openKey(basePath, key2);
 712                 switch (e) {
 713                 case RegError::NO_ERROR:
 714                     break;
 715                 case RegError::KEY_NOT_EXISTS:
 716                     throw FileFormatException(
 717                         key.getRegistryName(),
 718                         ("legacy format: unknown super-type " + basePath
 719                          + " of super-type with key " + sub.getName()));
 720                 default:
 721                     throw FileFormatException(
 722                         key.getRegistryName(),
 723                         ("legacy format: cannot open ucr sub-key " + basePath
 724                          + ": " + OUString::number(static_cast<int>(e))));
 725                 }
 726                 std::vector< char > buf2;
 727                 typereg::Reader reader2(getReader(key2, &buf2));
 728                 switch (reader2.getTypeClass()) {
 729                 case RT_TYPE_INTERFACE:
 730                     newStyle = true;
 731                     break;
 732                 case RT_TYPE_SERVICE:
 733                     newStyle = false;
 734                     break;
 735                 default:
 736                     throw FileFormatException(
 737                         key.getRegistryName(),
 738                         ("legacy format: unexpected type class "
 739                          + OUString::number(reader2.getTypeClass())
 740                          + " of super-type with key " + key2.getName()
 741                          + " of singleton with key " + sub.getName()));
 742                 }
 743             }
 744             return newStyle
 745                 ? rtl::Reference< Entity >(
 746                     new InterfaceBasedSingletonEntity(
 747                         reader.isPublished(), baseName,
 748                         translateAnnotations(reader.getDocumentation())))
 749                 : rtl::Reference< Entity >(
 750                     new ServiceBasedSingletonEntity(
 751                         reader.isPublished(), baseName,
 752                         translateAnnotations(reader.getDocumentation())));
 753         }
 754     case RT_TYPE_CONSTANTS:
 755         {
 756             std::vector< ConstantGroupEntity::Member > mems;
 757             sal_uInt16 n = reader.getFieldCount();
 758             for (sal_uInt16 j = 0; j != n; ++j) {
 759                 mems.emplace_back(
 760                     reader.getFieldName(j),
 761                     translateConstantValue(sub, reader.getFieldValue(j)),
 762                     translateAnnotations(reader.getFieldDocumentation(j)));
 763             }
 764             return new ConstantGroupEntity(
 765                 reader.isPublished(), mems,
 766                 translateAnnotations(reader.getDocumentation()));
 767         }
 768     default:
 769         throw FileFormatException(
 770             key.getRegistryName(),
 771             ("legacy format: unexpected type class "
 772              + OUString::number(reader.getTypeClass()) + " of key "
 773              + sub.getName()));
 774     }
 775 }
 776
 777 }
 778
 779 LegacyProvider::LegacyProvider(Manager & manager, OUString const & uri):
 780     manager_(manager)
 781 {
 782     Registry reg;
 783     RegError e = reg.open(uri, RegAccessMode::READONLY);
 784     switch (e) {
 785     case RegError::NO_ERROR:
 786         break;
 787     case RegError::REGISTRY_NOT_EXISTS:
 788         throw NoSuchFileException(uri);
 789     default:
 790         throw FileFormatException(
 791             uri, "cannot open legacy file: " + OUString::number(static_cast<int>(e)));
 792     }
 793     RegistryKey root;
 794     e = reg.openRootKey(root);
 795     if (e != RegError::NO_ERROR) {
 796         throw FileFormatException(
 797             uri, "legacy format: cannot open root key: " + OUString::number(static_cast<int>(e)));
 798     }
 799     e = root.openKey("UCR", ucr_);
 800     switch (e) {
 801     case RegError::NO_ERROR:
 802     case RegError::KEY_NOT_EXISTS: // such effectively empty files exist in the wild
 803         break;
 804     default:
 805         throw FileFormatException(
 806             uri, "legacy format: cannot open UCR key: " + OUString::number(static_cast<int>(e)));
 807     }
 808 }
 809
 810 rtl::Reference< MapCursor > LegacyProvider::createRootCursor() const {
 811     return new Cursor(&manager_, ucr_, ucr_);
 812 }
 813
 814 rtl::Reference< Entity > LegacyProvider::findEntity(OUString const & name)
 815     const
 816 {
 817     return ucr_.isValid()
 818         ? readEntity(&manager_, ucr_, ucr_, name.replace('.', '/'), true)
 819         : rtl::Reference< Entity >();
 820 }
 821
 822 LegacyProvider::~LegacyProvider() throw () {}
 823
 824 } }
 825
 826 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */