unoidl/source/unoidl-read.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 <cstdlib>
  14 #include <iostream>
  15 #include <map>
  16 #include <set>
  17 #include <utility>
  18 #include <vector>
  19
  20 #include <osl/file.hxx>
  21 #include <osl/process.h>
  22 #include <rtl/process.h>
  23 #include <rtl/ref.hxx>
  24 #include <rtl/ustring.hxx>
  25 #include <sal/main.h>
  26 #include <sal/types.h>
  27 #include <unoidl/unoidl.hxx>
  28
  29 namespace {
  30
  31 void badUsage() {
  32     std::cerr
  33         << "Usage:" << std::endl << std::endl
  34         << "  unoidl-read [--published] [<extra registries>] <registry>"
  35         << std::endl << std::endl
  36         << ("where each <registry> is either a new- or legacy-format .rdb file,"
  37             " a single .idl")
  38         << std::endl
  39         << ("file, or a root directory of an .idl file tree.  The complete"
  40             " content of the")
  41         << std::endl
  42         << ("last <registry> is written to stdout; if --published is specified,"
  43             " only the")
  44         << std::endl
  45         << ("published entities (plus any non-published entities referenced"
  46             " from published")
  47         << std::endl
  48         << "via any unpublished optional bases) are written out." << std::endl;
  49     std::exit(EXIT_FAILURE);
  50 }
  51
  52 OUString getArgumentUri(sal_uInt32 argument) {
  53     OUString arg;
  54     rtl_getAppCommandArg(argument, &arg.pData);
  55     OUString url;
  56     osl::FileBase::RC e1 = osl::FileBase::getFileURLFromSystemPath(arg, url);
  57     if (e1 != osl::FileBase::E_None) {
  58         std::cerr
  59             << "Cannot convert \"" << arg << "\" to file URL, error code "
  60             << +e1 << std::endl;
  61         std::exit(EXIT_FAILURE);
  62     }
  63     OUString cwd;
  64     oslProcessError e2 = osl_getProcessWorkingDir(&cwd.pData);
  65     if (e2 != osl_Process_E_None) {
  66         std::cerr
  67             << "Cannot obtain working directory, error code " << +e2
  68             << std::endl;
  69         std::exit(EXIT_FAILURE);
  70     }
  71     OUString abs;
  72     e1 = osl::FileBase::getAbsoluteFileURL(cwd, url, abs);
  73     if (e1 != osl::FileBase::E_None) {
  74         std::cerr
  75             << "Cannot make \"" << url
  76             << "\" into an absolute file URL, error code " << +e1 << std::endl;
  77         std::exit(EXIT_FAILURE);
  78     }
  79     return abs;
  80 }
  81
  82 OUString decomposeType(
  83     OUString const & type, std::size_t * rank,
  84     std::vector<OUString> * typeArguments, bool * entity)
  85 {
  86     assert(rank != nullptr);
  87     assert(typeArguments != nullptr);
  88     assert(entity != nullptr);
  89     OUString nucl(type);
  90     *rank = 0;
  91     typeArguments->clear();
  92     while (nucl.startsWith("[]", &nucl)) {
  93         ++*rank;
  94     }
  95     sal_Int32 i = nucl.indexOf('<');
  96     if (i != -1) {
  97         OUString tmpl(nucl.copy(0, i));
  98         do {
  99             ++i; // skip '<' or ','
 100             sal_Int32 j = i;
 101             for (sal_Int32 level = 0; j != nucl.getLength(); ++j) {
 102                 sal_Unicode c = nucl[j];
 103                 if (c == ',') {
 104                     if (level == 0) {
 105                         break;
 106                     }
 107                 } else if (c == '<') {
 108                     ++level;
 109                 } else if (c == '>') {
 110                     if (level == 0) {
 111                         break;
 112                     }
 113                     --level;
 114                 }
 115             }
 116             if (j != nucl.getLength()) {
 117                 typeArguments->push_back(nucl.copy(i, j - i));
 118             }
 119             i = j;
 120         } while (i != nucl.getLength() && nucl[i] != '>');
 121         assert(i == nucl.getLength() - 1 && nucl[i] == '>');
 122         assert(!typeArguments->empty());
 123         nucl = tmpl;
 124     }
 125     assert(!nucl.isEmpty());
 126     *entity = nucl != "void" && nucl != "boolean" && nucl != "byte"
 127         && nucl != "short" && nucl != "unsigned short" && nucl != "long"
 128         && nucl != "unsigned long" && nucl != "hyper"
 129         && nucl != "unsigned hyper" && nucl != "float" && nucl != "double"
 130         && nucl != "char" && nucl != "string" && nucl != "type"
 131         && nucl != "any";
 132     assert(*entity || typeArguments->empty());
 133     return nucl;
 134 }
 135
 136 struct Entity {
 137     enum class Sorted { NO, ACTIVE, YES };
 138
 139     explicit Entity(
 140         rtl::Reference<unoidl::Entity> const & theEntity, bool theRelevant):
 141         entity(theEntity), relevant(theRelevant), sorted(Sorted::NO),
 142         written(false)
 143     {}
 144
 145     rtl::Reference<unoidl::Entity> const entity;
 146     std::set<OUString> dependencies;
 147     std::set<OUString> interfaceDependencies;
 148     bool relevant;
 149     Sorted sorted;
 150     bool written;
 151 };
 152
 153 void insertEntityDependency(
 154     rtl::Reference<unoidl::Manager> const & manager,
 155     std::map<OUString, Entity>::iterator const & iterator,
 156     OUString const & name, bool weakInterfaceDependency = false)
 157 {
 158     assert(manager.is());
 159     if (name != iterator->first) {
 160         bool ifc = false;
 161         if (weakInterfaceDependency) {
 162             rtl::Reference<unoidl::Entity> ent(manager->findEntity(name));
 163             if (!ent.is()) {
 164                 std::cerr << "Unknown entity " << name << std::endl;
 165                 std::exit(EXIT_FAILURE);
 166             }
 167             ifc = ent->getSort() == unoidl::Entity::SORT_INTERFACE_TYPE;
 168         }
 169         (ifc
 170          ? iterator->second.interfaceDependencies
 171          : iterator->second.dependencies)
 172             .insert(name);
 173     }
 174 }
 175
 176 void insertEntityDependencies(
 177     rtl::Reference<unoidl::Manager> const & manager,
 178     std::map<OUString, Entity>::iterator const & iterator,
 179     std::vector<OUString> const & names)
 180 {
 181     for (auto & i: names) {
 182         insertEntityDependency(manager, iterator, i);
 183     }
 184 }
 185
 186 void insertEntityDependencies(
 187     rtl::Reference<unoidl::Manager> const & manager,
 188     std::map<OUString, Entity>::iterator const & iterator,
 189     std::vector<unoidl::AnnotatedReference> const & references)
 190 {
 191     for (auto & i: references) {
 192         insertEntityDependency(manager, iterator, i.name);
 193     }
 194 }
 195
 196 void insertTypeDependency(
 197     rtl::Reference<unoidl::Manager> const & manager,
 198     std::map<OUString, Entity>::iterator const & iterator,
 199     OUString const & type)
 200 {
 201     std::size_t rank;
 202     std::vector<OUString> args;
 203     bool entity;
 204     OUString nucl(decomposeType(type, &rank, &args, &entity));
 205     if (entity) {
 206         insertEntityDependency(manager, iterator, nucl, true);
 207         for (const auto & i: args) {
 208             insertTypeDependency(manager, iterator, i);
 209         }
 210     }
 211 }
 212
 213 void scanMap(
 214     rtl::Reference<unoidl::Manager> const & manager,
 215     rtl::Reference<unoidl::MapCursor> const & cursor, bool published,
 216     OUString const & prefix, std::map<OUString, Entity> & entities)
 217 {
 218     assert(cursor.is());
 219     for (;;) {
 220         OUString id;
 221         rtl::Reference<unoidl::Entity> ent(cursor->getNext(&id));
 222         if (!ent.is()) {
 223             break;
 224         }
 225         OUString name(prefix + id);
 226         if (ent->getSort() == unoidl::Entity::SORT_MODULE) {
 227             scanMap(
 228                 manager,
 229                 static_cast<unoidl::ModuleEntity *>(ent.get())->createCursor(),
 230                 published, name + ".", entities);
 231         } else {
 232             std::map<OUString, Entity>::iterator i(
 233                 entities.insert(
 234                     std::make_pair(
 235                         name,
 236                         Entity(
 237                             ent,
 238                             (!published
 239                              || (static_cast<unoidl::PublishableEntity *>(
 240                                      ent.get())
 241                                  ->isPublished())))))
 242                 .first);
 243             switch (ent->getSort()) {
 244             case unoidl::Entity::SORT_ENUM_TYPE:
 245             case unoidl::Entity::SORT_CONSTANT_GROUP:
 246                 break;
 247             case unoidl::Entity::SORT_PLAIN_STRUCT_TYPE:
 248                 {
 249                     rtl::Reference<unoidl::PlainStructTypeEntity> ent2(
 250                         static_cast<unoidl::PlainStructTypeEntity *>(
 251                             ent.get()));
 252                     if (!ent2->getDirectBase().isEmpty()) {
 253                         insertEntityDependency(
 254                             manager, i, ent2->getDirectBase());
 255                     }
 256                     for (auto & j: ent2->getDirectMembers()) {
 257                         insertTypeDependency(manager, i, j.type);
 258                     }
 259                     break;
 260                 }
 261             case unoidl::Entity::SORT_POLYMORPHIC_STRUCT_TYPE_TEMPLATE:
 262                 {
 263                     rtl::Reference<unoidl::PolymorphicStructTypeTemplateEntity>
 264                         ent2(
 265                             static_cast<unoidl::PolymorphicStructTypeTemplateEntity *>(
 266                                 ent.get()));
 267                     for (auto & j: ent2->getMembers()) {
 268                         if (!j.parameterized) {
 269                             insertTypeDependency(manager, i, j.type);
 270                         }
 271                     }
 272                     break;
 273                 }
 274             case unoidl::Entity::SORT_EXCEPTION_TYPE:
 275                 {
 276                     rtl::Reference<unoidl::ExceptionTypeEntity> ent2(
 277                         static_cast<unoidl::ExceptionTypeEntity *>(ent.get()));
 278                     if (!ent2->getDirectBase().isEmpty()) {
 279                         insertEntityDependency(
 280                             manager, i, ent2->getDirectBase());
 281                     }
 282                     for (auto & j: ent2->getDirectMembers()) {
 283                         insertTypeDependency(manager, i, j.type);
 284                     }
 285                     break;
 286                 }
 287             case unoidl::Entity::SORT_INTERFACE_TYPE:
 288                 {
 289                     rtl::Reference<unoidl::InterfaceTypeEntity> ent2(
 290                         static_cast<unoidl::InterfaceTypeEntity *>(
 291                             ent.get()));
 292                     insertEntityDependencies(
 293                         manager, i, ent2->getDirectMandatoryBases());
 294                     insertEntityDependencies(
 295                         manager, i, ent2->getDirectOptionalBases());
 296                     for (auto & j: ent2->getDirectAttributes()) {
 297                         insertTypeDependency(manager, i, j.type);
 298                     }
 299                     for (auto & j: ent2->getDirectMethods()) {
 300                         insertTypeDependency(manager, i, j.returnType);
 301                         for (auto & k: j.parameters) {
 302                             insertTypeDependency(manager, i, k.type);
 303                         }
 304                         insertEntityDependencies(manager, i, j.exceptions);
 305                     }
 306                     break;
 307                 }
 308             case unoidl::Entity::SORT_TYPEDEF:
 309                 {
 310                     rtl::Reference<unoidl::TypedefEntity> ent2(
 311                         static_cast<unoidl::TypedefEntity *>(ent.get()));
 312                     insertTypeDependency(manager, i, ent2->getType());
 313                     break;
 314                 }
 315             case unoidl::Entity::SORT_SINGLE_INTERFACE_BASED_SERVICE:
 316                 {
 317                     rtl::Reference<unoidl::SingleInterfaceBasedServiceEntity>
 318                         ent2(
 319                             static_cast<unoidl::SingleInterfaceBasedServiceEntity *>(
 320                                 ent.get()));
 321                     insertEntityDependency(manager, i, ent2->getBase());
 322                     for (auto & j: ent2->getConstructors()) {
 323                         for (auto & k: j.parameters) {
 324                             insertTypeDependency(manager, i, k.type);
 325                         }
 326                         insertEntityDependencies(manager, i, j.exceptions);
 327                     }
 328                     break;
 329                 }
 330             case unoidl::Entity::SORT_ACCUMULATION_BASED_SERVICE:
 331                 {
 332                     rtl::Reference<unoidl::AccumulationBasedServiceEntity> ent2(
 333                         static_cast<unoidl::AccumulationBasedServiceEntity *>(
 334                             ent.get()));
 335                     insertEntityDependencies(
 336                         manager, i, ent2->getDirectMandatoryBaseServices());
 337                     insertEntityDependencies(
 338                         manager, i, ent2->getDirectOptionalBaseServices());
 339                     insertEntityDependencies(
 340                         manager, i, ent2->getDirectMandatoryBaseInterfaces());
 341                     insertEntityDependencies(
 342                         manager, i, ent2->getDirectOptionalBaseInterfaces());
 343                     for (auto & j: ent2->getDirectProperties()) {
 344                         insertTypeDependency(manager, i, j.type);
 345                     }
 346                     break;
 347                 }
 348             case unoidl::Entity::SORT_INTERFACE_BASED_SINGLETON:
 349                 {
 350                     rtl::Reference<unoidl::InterfaceBasedSingletonEntity> ent2(
 351                         static_cast<unoidl::InterfaceBasedSingletonEntity *>(
 352                             ent.get()));
 353                     insertEntityDependency(manager, i, ent2->getBase());
 354                     break;
 355                 }
 356             case unoidl::Entity::SORT_SERVICE_BASED_SINGLETON:
 357                 {
 358                     rtl::Reference<unoidl::ServiceBasedSingletonEntity> ent2(
 359                         static_cast<unoidl::ServiceBasedSingletonEntity *>(
 360                             ent.get()));
 361                     insertEntityDependency(manager, i, ent2->getBase());
 362                     break;
 363                 }
 364             case unoidl::Entity::SORT_MODULE:
 365                 assert(false && "this cannot happen");
 366             }
 367         }
 368     }
 369 }
 370
 371 void propagateRelevant(std::map<OUString, Entity> & entities, Entity & entity) {
 372     if (!entity.relevant) {
 373         entity.relevant = true;
 374         if (entity.sorted != Entity::Sorted::YES) {
 375             for (auto & i: entity.dependencies) {
 376                 std::map<OUString, Entity>::iterator j(entities.find(i));
 377                 if (j != entities.end()) {
 378                     propagateRelevant(entities, j->second);
 379                 }
 380             }
 381         }
 382     }
 383 }
 384
 385 void visit(
 386     std::map<OUString, Entity> & entities,
 387     std::map<OUString, Entity>::iterator const & iterator,
 388     std::vector<OUString> & result)
 389 {
 390     switch (iterator->second.sorted) {
 391     case Entity::Sorted::NO:
 392         iterator->second.sorted = Entity::Sorted::ACTIVE;
 393         for (auto & i: iterator->second.dependencies) {
 394             std::map<OUString, Entity>::iterator j(entities.find(i));
 395             if (j != entities.end()) {
 396                 if (iterator->second.relevant) {
 397                     propagateRelevant(entities, j->second);
 398                 }
 399                 visit(entities, j, result);
 400             }
 401         }
 402         iterator->second.sorted = Entity::Sorted::YES;
 403         result.push_back(iterator->first);
 404         break;
 405     case Entity::Sorted::ACTIVE:
 406         std::cerr
 407             << "Entity " << iterator->first << " recursively depends on itself"
 408             << std::endl;
 409         std::exit(EXIT_FAILURE);
 410         // fall-through avoids warnings
 411     default:
 412         break;
 413     }
 414 }
 415
 416 std::vector<OUString> sort(std::map<OUString, Entity> & entities) {
 417     std::vector<OUString> res;
 418     for (auto i(entities.begin()); i != entities.end(); ++i) {
 419         visit(entities, i, res);
 420     }
 421     return res;
 422 }
 423
 424 void indent(std::vector<OUString> const & modules, unsigned int extra = 0) {
 425     for (std::vector<OUString>::size_type i = 0; i != modules.size(); ++i) {
 426         std::cout << ' ';
 427     }
 428     for (unsigned int i = 0; i != extra; ++i) {
 429         std::cout << ' ';
 430     }
 431 }
 432
 433 void closeModules(
 434     std::vector<OUString> & modules, std::vector<OUString>::size_type n)
 435 {
 436     for (std::vector<OUString>::size_type i = 0; i != n; ++i) {
 437         assert(!modules.empty());
 438         modules.pop_back();
 439         indent(modules);
 440         std::cout << "};\n";
 441     }
 442 }
 443
 444 OUString openModulesFor(std::vector<OUString> & modules, OUString const & name)
 445 {
 446     std::vector<OUString>::iterator i(modules.begin());
 447     for (sal_Int32 j = 0;;) {
 448         OUString id(name.getToken(0, '.', j));
 449         if (j == -1) {
 450             closeModules(
 451                 modules,
 452                 static_cast< std::vector<OUString>::size_type >(
 453                     modules.end() - i));
 454             indent(modules);
 455             return id;
 456         }
 457         if (i != modules.end()) {
 458             if (id == *i) {
 459                 ++i;
 460                 continue;
 461             }
 462             closeModules(
 463                 modules,
 464                 static_cast< std::vector<OUString>::size_type >(
 465                     modules.end() - i));
 466             i = modules.end();
 467         }
 468         indent(modules);
 469         std::cout << "module " << id << " {\n";
 470         modules.push_back(id);
 471         i = modules.end();
 472     }
 473 }
 474
 475 void writeName(OUString const & name) {
 476     std::cout << "::" << name.replaceAll(".", "::");
 477 }
 478
 479 void writeAnnotations(std::vector<OUString> const & annotations) {
 480     if (!annotations.empty()) {
 481         std::cout << "/**";
 482         for (auto & i: annotations) {
 483             //TODO: i.indexOf("*/") == -1
 484             std::cout << " @" << i;
 485         }
 486         std::cout << " */ ";
 487     }
 488 }
 489
 490 void writePublished(rtl::Reference<unoidl::PublishableEntity> const & entity) {
 491     assert(entity.is());
 492     if (entity->isPublished()) {
 493         std::cout << "published ";
 494     }
 495 }
 496
 497 void writeAnnotationsPublished(
 498     rtl::Reference<unoidl::PublishableEntity> const & entity)
 499 {
 500     assert(entity.is());
 501     writeAnnotations(entity->getAnnotations());
 502     writePublished(entity);
 503 }
 504
 505 void writeType(OUString const & type) {
 506     std::size_t rank;
 507     std::vector<OUString> args;
 508     bool entity;
 509     OUString nucl(decomposeType(type, &rank, &args, &entity));
 510     for (std::size_t i = 0; i != rank; ++i) {
 511         std::cout << "sequence< ";
 512     }
 513     if (entity) {
 514         writeName(nucl);
 515     } else {
 516         std::cout << nucl;
 517     }
 518     if (!args.empty()) {
 519         std::cout << "< ";
 520         for (auto i(args.begin()); i != args.end(); ++i) {
 521             if (i != args.begin()) {
 522                 std::cout << ", ";
 523             }
 524             writeType(*i);
 525         }
 526         std::cout << " >";
 527     }
 528     for (std::size_t i = 0; i != rank; ++i) {
 529         std::cout << " >";
 530     }
 531 }
 532
 533 void writeExceptionSpecification(std::vector<OUString> const & exceptions) {
 534     if (!exceptions.empty()) {
 535         std::cout << " raises (";
 536         for (auto i(exceptions.begin()); i != exceptions.end(); ++i) {
 537             if (i != exceptions.begin()) {
 538                 std::cout << ", ";
 539             }
 540             writeName(*i);
 541         }
 542         std::cout << ')';
 543     }
 544 }
 545
 546 void writeEntity(
 547     std::map<OUString, Entity> & entities, std::vector<OUString> & modules,
 548     OUString const & name)
 549 {
 550     std::map<OUString, Entity>::iterator i(entities.find(name));
 551     if (i != entities.end() && i->second.relevant) {
 552         assert(!i->second.written);
 553         i->second.written = true;
 554         for (auto & j: i->second.interfaceDependencies) {
 555             std::map<OUString, Entity>::iterator k(entities.find(j));
 556             if (k != entities.end() && !k->second.written) {
 557                 OUString id(openModulesFor(modules, j));
 558                 if (k->second.entity->getSort()
 559                     != unoidl::Entity::SORT_INTERFACE_TYPE)
 560                 {
 561                     std::cerr
 562                         << "Entity " << j << " should be an interface type"
 563                         << std::endl;
 564                     std::exit(EXIT_FAILURE);
 565                 }
 566                 writePublished(
 567                     static_cast<unoidl::PublishableEntity *>(
 568                         k->second.entity.get()));
 569                 std::cout << "interface " << id << ";\n";
 570             }
 571         }
 572         OUString id(openModulesFor(modules, name));
 573         rtl::Reference<unoidl::PublishableEntity> ent(
 574             static_cast<unoidl::PublishableEntity *>(i->second.entity.get()));
 575         switch (ent->getSort()) {
 576         case unoidl::Entity::SORT_ENUM_TYPE:
 577             {
 578                 rtl::Reference<unoidl::EnumTypeEntity> ent2(
 579                     static_cast<unoidl::EnumTypeEntity *>(ent.get()));
 580                 writeAnnotationsPublished(ent);
 581                 std::cout << "enum " << id << " {\n";
 582                 for (auto j(ent2->getMembers().begin());
 583                      j != ent2->getMembers().end(); ++j)
 584                 {
 585                     indent(modules, 1);
 586                     writeAnnotations(j->annotations);
 587                     std::cout << j->name << " = " << j->value;
 588                     if (j + 1 != ent2->getMembers().end()) {
 589                         std::cout << ',';
 590                     }
 591                     std::cout << '\n';
 592                 }
 593                 indent(modules);
 594                 std::cout << "};\n";
 595                 break;
 596             }
 597         case unoidl::Entity::SORT_PLAIN_STRUCT_TYPE:
 598             {
 599                 rtl::Reference<unoidl::PlainStructTypeEntity> ent2(
 600                     static_cast<unoidl::PlainStructTypeEntity *>(ent.get()));
 601                 writeAnnotationsPublished(ent);
 602                 std::cout << "struct " << id;
 603                 if (!ent2->getDirectBase().isEmpty()) {
 604                     std::cout << ": ";
 605                     writeName(ent2->getDirectBase());
 606                 }
 607                 std::cout << " {\n";
 608                 for (auto & j: ent2->getDirectMembers()) {
 609                     indent(modules, 1);
 610                     writeAnnotations(j.annotations);
 611                     writeType(j.type);
 612                     std::cout << ' ' << j.name << ";\n";
 613                 }
 614                 indent(modules);
 615                 std::cout << "};\n";
 616                 break;
 617             }
 618         case unoidl::Entity::SORT_POLYMORPHIC_STRUCT_TYPE_TEMPLATE:
 619             {
 620                 rtl::Reference<unoidl::PolymorphicStructTypeTemplateEntity>
 621                     ent2(
 622                         static_cast<unoidl::PolymorphicStructTypeTemplateEntity *>(
 623                             ent.get()));
 624                 writeAnnotationsPublished(ent);
 625                 std::cout << "struct " << id << '<';
 626                 for (auto j(ent2->getTypeParameters().begin());
 627                      j != ent2->getTypeParameters().end(); ++j)
 628                 {
 629                     if (j != ent2->getTypeParameters().begin()) {
 630                         std::cout << ", ";
 631                     }
 632                     std::cout << *j;
 633                 }
 634                 std::cout << ">  {\n";
 635                 for (auto & j: ent2->getMembers()) {
 636                     indent(modules, 1);
 637                     writeAnnotations(j.annotations);
 638                     if (j.parameterized) {
 639                         std::cout << j.type;
 640                     } else {
 641                         writeType(j.type);
 642                     }
 643                     std::cout << ' ' << j.name << ";\n";
 644                 }
 645                 indent(modules);
 646                 std::cout << "};\n";
 647                 break;
 648             }
 649         case unoidl::Entity::SORT_EXCEPTION_TYPE:
 650             {
 651                 rtl::Reference<unoidl::ExceptionTypeEntity> ent2(
 652                     static_cast<unoidl::ExceptionTypeEntity *>(ent.get()));
 653                 writeAnnotationsPublished(ent);
 654                 std::cout << "exception " << id;
 655                 if (!ent2->getDirectBase().isEmpty()) {
 656                     std::cout << ": ";
 657                     writeName(ent2->getDirectBase());
 658                 }
 659                 std::cout << " {\n";
 660                 for (auto & j: ent2->getDirectMembers()) {
 661                     indent(modules, 1);
 662                     writeAnnotations(j.annotations);
 663                     writeType(j.type);
 664                     std::cout << ' ' << j.name << ";\n";
 665                 }
 666                 indent(modules);
 667                 std::cout << "};\n";
 668                 break;
 669             }
 670         case unoidl::Entity::SORT_INTERFACE_TYPE:
 671             {
 672                 rtl::Reference<unoidl::InterfaceTypeEntity> ent2(
 673                     static_cast<unoidl::InterfaceTypeEntity *>(
 674                         ent.get()));
 675                 writeAnnotationsPublished(ent);
 676                 std::cout << "interface " << id << " {\n";
 677                 for (auto & j: ent2->getDirectMandatoryBases()) {
 678                     indent(modules, 1);
 679                     writeAnnotations(j.annotations);
 680                     std::cout << "interface ";
 681                     writeName(j.name);
 682                     std::cout << ";\n";
 683                 }
 684                 for (auto & j: ent2->getDirectOptionalBases()) {
 685                     indent(modules, 1);
 686                     writeAnnotations(j.annotations);
 687                     std::cout << "[optional] interface ";
 688                     writeName(j.name);
 689                     std::cout << ";\n";
 690                 }
 691                 for (auto & j: ent2->getDirectAttributes()) {
 692                     indent(modules, 1);
 693                     writeAnnotations(j.annotations);
 694                     std::cout << "[attribute";
 695                     if (j.bound) {
 696                         std::cout << ", bound";
 697                     }
 698                     if (j.readOnly) {
 699                         std::cout << ", readonly";
 700                     }
 701                     std::cout << "] ";
 702                     writeType(j.type);
 703                     std::cout << ' ' << j.name;
 704                     if (!(j.getExceptions.empty() && j.setExceptions.empty())) {
 705                         std::cout << " {\n";
 706                         if (!j.getExceptions.empty()) {
 707                             indent(modules, 2);
 708                             std::cout << "get";
 709                             writeExceptionSpecification(j.getExceptions);
 710                             std::cout << ";\n";
 711                         }
 712                         if (!j.setExceptions.empty()) {
 713                             indent(modules, 2);
 714                             std::cout << "set";
 715                             writeExceptionSpecification(j.setExceptions);
 716                             std::cout << ";\n";
 717                         }
 718                         std::cout << " }";
 719                     }
 720                     std::cout << ";\n";
 721                 }
 722                 for (auto & j: ent2->getDirectMethods()) {
 723                     indent(modules, 1);
 724                     writeAnnotations(j.annotations);
 725                     writeType(j.returnType);
 726                     std::cout << ' ' << j.name << '(';
 727                     for (auto k(j.parameters.begin()); k != j.parameters.end();
 728                          ++k)
 729                     {
 730                         if (k != j.parameters.begin()) {
 731                             std::cout << ", ";
 732                         }
 733                         switch (k->direction) {
 734                         case unoidl::InterfaceTypeEntity::Method::Parameter::DIRECTION_IN:
 735                             std::cout << "[in] ";
 736                             break;
 737                         case unoidl::InterfaceTypeEntity::Method::Parameter::DIRECTION_OUT:
 738                             std::cout << "[out] ";
 739                             break;
 740                         case unoidl::InterfaceTypeEntity::Method::Parameter::DIRECTION_IN_OUT:
 741                             std::cout << "[inout] ";
 742                             break;
 743                         }
 744                         writeType(k->type);
 745                         std::cout << ' ' << k->name;
 746                     }
 747                     std::cout << ')';
 748                     writeExceptionSpecification(j.exceptions);
 749                     std::cout << ";\n";
 750                 }
 751                 indent(modules);
 752                 std::cout << "};\n";
 753                 break;
 754             }
 755         case unoidl::Entity::SORT_TYPEDEF:
 756             {
 757                 rtl::Reference<unoidl::TypedefEntity> ent2(
 758                     static_cast<unoidl::TypedefEntity *>(ent.get()));
 759                 writeAnnotationsPublished(ent);
 760                 std::cout << "typedef ";
 761                 writeType(ent2->getType());
 762                 std::cout << ' ' << id << ";\n";
 763                 break;
 764             }
 765         case unoidl::Entity::SORT_CONSTANT_GROUP:
 766             {
 767                 rtl::Reference<unoidl::ConstantGroupEntity> ent2(
 768                     static_cast<unoidl::ConstantGroupEntity *>(ent.get()));
 769                 writeAnnotationsPublished(ent);
 770                 std::cout << "constants " << id << " {\n";
 771                 for (auto & j: ent2->getMembers()) {
 772                     indent(modules, 1);
 773                     writeAnnotations(j.annotations);
 774                     std::cout << "const ";
 775                     switch (j.value.type) {
 776                     case unoidl::ConstantValue::TYPE_BOOLEAN:
 777                         std::cout << "boolean";
 778                         break;
 779                     case unoidl::ConstantValue::TYPE_BYTE:
 780                         std::cout << "byte";
 781                         break;
 782                     case unoidl::ConstantValue::TYPE_SHORT:
 783                         std::cout << "short";
 784                         break;
 785                     case unoidl::ConstantValue::TYPE_UNSIGNED_SHORT:
 786                         std::cout << "unsigned short";
 787                         break;
 788                     case unoidl::ConstantValue::TYPE_LONG:
 789                         std::cout << "long";
 790                         break;
 791                     case unoidl::ConstantValue::TYPE_UNSIGNED_LONG:
 792                         std::cout << "unsigned long";
 793                         break;
 794                     case unoidl::ConstantValue::TYPE_HYPER:
 795                         std::cout << "hyper";
 796                         break;
 797                     case unoidl::ConstantValue::TYPE_UNSIGNED_HYPER:
 798                         std::cout << "unsigned hyper";
 799                         break;
 800                     case unoidl::ConstantValue::TYPE_FLOAT:
 801                         std::cout << "float";
 802                         break;
 803                     case unoidl::ConstantValue::TYPE_DOUBLE:
 804                         std::cout << "double";
 805                         break;
 806                     }
 807                     std::cout << ' ' << j.name << " = ";
 808                     switch (j.value.type) {
 809                     case unoidl::ConstantValue::TYPE_BOOLEAN:
 810                         std::cout << (j.value.booleanValue ? "TRUE" : "FALSE");
 811                         break;
 812                     case unoidl::ConstantValue::TYPE_BYTE:
 813                         std::cout << int(j.value.byteValue);
 814                         break;
 815                     case unoidl::ConstantValue::TYPE_SHORT:
 816                         std::cout << j.value.shortValue;
 817                         break;
 818                     case unoidl::ConstantValue::TYPE_UNSIGNED_SHORT:
 819                         std::cout << j.value.unsignedShortValue;
 820                         break;
 821                     case unoidl::ConstantValue::TYPE_LONG:
 822                         std::cout << j.value.longValue;
 823                         break;
 824                     case unoidl::ConstantValue::TYPE_UNSIGNED_LONG:
 825                         std::cout << j.value.unsignedLongValue;
 826                         break;
 827                     case unoidl::ConstantValue::TYPE_HYPER:
 828                         std::cout << j.value.hyperValue;
 829                         break;
 830                     case unoidl::ConstantValue::TYPE_UNSIGNED_HYPER:
 831                         std::cout << j.value.unsignedHyperValue;
 832                         break;
 833                     case unoidl::ConstantValue::TYPE_FLOAT:
 834                         std::cout << j.value.floatValue;
 835                         break;
 836                     case unoidl::ConstantValue::TYPE_DOUBLE:
 837                         std::cout << j.value.doubleValue;
 838                         break;
 839                     }
 840                     std::cout << ";\n";
 841                 }
 842                 indent(modules);
 843                 std::cout << "};\n";
 844                 break;
 845             }
 846         case unoidl::Entity::SORT_SINGLE_INTERFACE_BASED_SERVICE:
 847             {
 848                 rtl::Reference<unoidl::SingleInterfaceBasedServiceEntity> ent2(
 849                     static_cast<unoidl::SingleInterfaceBasedServiceEntity *>(
 850                         ent.get()));
 851                 writeAnnotationsPublished(ent);
 852                 std::cout << "service " << id << ": ";
 853                 writeName(ent2->getBase());
 854                 if (ent2->getConstructors().size() != 1
 855                     || !ent2->getConstructors().front().defaultConstructor)
 856                 {
 857                     std::cout << " {\n";
 858                     for (auto & j: ent2->getConstructors()) {
 859                         indent(modules, 1);
 860                         writeAnnotations(j.annotations);
 861                         std::cout << j.name << '(';
 862                         for (auto k(j.parameters.begin());
 863                              k != j.parameters.end(); ++k)
 864                         {
 865                             if (k != j.parameters.begin()) {
 866                                 std::cout << ", ";
 867                             }
 868                             std::cout << "[in] ";
 869                             writeType(k->type);
 870                             if (k->rest) {
 871                                 std::cout << "...";
 872                             }
 873                             std::cout << ' ' << k->name;
 874                         }
 875                         std::cout << ')';
 876                         writeExceptionSpecification(j.exceptions);
 877                         std::cout << ";\n";
 878                     }
 879                     indent(modules);
 880                     std::cout << '}';
 881                 }
 882                 std::cout << ";\n";
 883                 break;
 884             }
 885         case unoidl::Entity::SORT_ACCUMULATION_BASED_SERVICE:
 886             {
 887                 rtl::Reference<unoidl::AccumulationBasedServiceEntity> ent2(
 888                     static_cast<unoidl::AccumulationBasedServiceEntity *>(
 889                         ent.get()));
 890                 writeAnnotationsPublished(ent);
 891                 std::cout << "service " << id << " {\n";
 892                 for (auto & j: ent2->getDirectMandatoryBaseServices()) {
 893                     indent(modules, 1);
 894                     writeAnnotations(j.annotations);
 895                     std::cout << "service ";
 896                     writeName(j.name);
 897                     std::cout << ";\n";
 898                 }
 899                 for (auto & j: ent2->getDirectOptionalBaseServices()) {
 900                     indent(modules, 1);
 901                     writeAnnotations(j.annotations);
 902                     std::cout << "[optional] service ";
 903                     writeName(j.name);
 904                     std::cout << ";\n";
 905                 }
 906                 for (auto & j: ent2->getDirectMandatoryBaseInterfaces()) {
 907                     indent(modules, 1);
 908                     writeAnnotations(j.annotations);
 909                     std::cout << "interface ";
 910                     writeName(j.name);
 911                     std::cout << ";\n";
 912                 }
 913                 for (auto & j: ent2->getDirectOptionalBaseInterfaces()) {
 914                     indent(modules, 1);
 915                     writeAnnotations(j.annotations);
 916                     std::cout << "[optional] interface ";
 917                     writeName(j.name);
 918                     std::cout << ";\n";
 919                 }
 920                 for (auto & j: ent2->getDirectProperties()) {
 921                     indent(modules, 1);
 922                     writeAnnotations(j.annotations);
 923                     std::cout << "[property";
 924                     if ((j.attributes
 925                          & unoidl::AccumulationBasedServiceEntity::Property::ATTRIBUTE_BOUND)
 926                         != 0)
 927                     {
 928                         std::cout << ", bound";
 929                     }
 930                     if ((j.attributes
 931                          & unoidl::AccumulationBasedServiceEntity::Property::ATTRIBUTE_CONSTRAINED)
 932                         != 0)
 933                     {
 934                         std::cout << ", constrained";
 935                     }
 936                     if ((j.attributes
 937                          & unoidl::AccumulationBasedServiceEntity::Property::ATTRIBUTE_MAYBE_AMBIGUOUS)
 938                         != 0)
 939                     {
 940                         std::cout << ", maybeambiguous";
 941                     }
 942                     if ((j.attributes
 943                          & unoidl::AccumulationBasedServiceEntity::Property::ATTRIBUTE_MAYBE_DEFAULT)
 944                         != 0)
 945                     {
 946                         std::cout << ", maybedefault";
 947                     }
 948                     if ((j.attributes
 949                          & unoidl::AccumulationBasedServiceEntity::Property::ATTRIBUTE_MAYBE_VOID)
 950                         != 0)
 951                     {
 952                         std::cout << ", maybevoid";
 953                     }
 954                     if ((j.attributes
 955                          & unoidl::AccumulationBasedServiceEntity::Property::ATTRIBUTE_OPTIONAL)
 956                         != 0)
 957                     {
 958                         std::cout << ", optional";
 959                     }
 960                     if ((j.attributes
 961                          & unoidl::AccumulationBasedServiceEntity::Property::ATTRIBUTE_READ_ONLY)
 962                         != 0)
 963                     {
 964                         std::cout << ", readonly";
 965                     }
 966                     if ((j.attributes
 967                          & unoidl::AccumulationBasedServiceEntity::Property::ATTRIBUTE_REMOVABLE)
 968                         != 0)
 969                     {
 970                         std::cout << ", removable";
 971                     }
 972                     if ((j.attributes
 973                          & unoidl::AccumulationBasedServiceEntity::Property::ATTRIBUTE_TRANSIENT)
 974                         != 0)
 975                     {
 976                         std::cout << ", transient";
 977                     }
 978                     std::cout << "] ";
 979                     writeType(j.type);
 980                     std::cout << ' ' << j.name << ";\n";
 981                 }
 982                 indent(modules);
 983                 std::cout << "};\n";
 984                 break;
 985             }
 986         case unoidl::Entity::SORT_INTERFACE_BASED_SINGLETON:
 987             {
 988                 rtl::Reference<unoidl::InterfaceBasedSingletonEntity> ent2(
 989                     static_cast<unoidl::InterfaceBasedSingletonEntity *>(
 990                         ent.get()));
 991                 writeAnnotationsPublished(ent);
 992                 std::cout << "singleton " << id << ": ";
 993                 writeName(ent2->getBase());
 994                 std::cout << ";\n";
 995                 break;
 996             }
 997         case unoidl::Entity::SORT_SERVICE_BASED_SINGLETON:
 998             {
 999                 rtl::Reference<unoidl::ServiceBasedSingletonEntity> ent2(
1000                     static_cast<unoidl::ServiceBasedSingletonEntity *>(
1001                         ent.get()));
1002                 writeAnnotationsPublished(ent);
1003                 std::cout << "singleton " << id << " { service ";
1004                 writeName(ent2->getBase());
1005                 std::cout << "; };";
1006                 break;
1007             }
1008         case unoidl::Entity::SORT_MODULE:
1009             assert(false && "this cannot happen");
1010         }
1011     }
1012 }
1013
1014 }
1015
1016 SAL_IMPLEMENT_MAIN() {
1017     try {
1018         sal_uInt32 args = rtl_getAppCommandArgCount();
1019         if (args == 0) {
1020             badUsage();
1021         }
1022         OUString arg;
1023         rtl_getAppCommandArg(0, &arg.pData);
1024         bool published = arg == "--published";
1025         if (published && args == 1) {
1026             badUsage();
1027         }
1028         rtl::Reference<unoidl::Manager> mgr(new unoidl::Manager);
1029         rtl::Reference<unoidl::Provider> prov;
1030         for (sal_uInt32 i = (published ? 1 : 0); i != args; ++i) {
1031             OUString uri(getArgumentUri(i));
1032             try {
1033                 prov = mgr->addProvider(uri);
1034             } catch (unoidl::NoSuchFileException &) {
1035                 std::cerr
1036                     << "Input <" << uri << "> does not exist" << std::endl;
1037                 std::exit(EXIT_FAILURE);
1038             }
1039         }
1040         std::map<OUString, Entity> ents;
1041         scanMap(mgr, prov->createRootCursor(), published, "", ents);
1042         std::vector<OUString> sorted(sort(ents));
1043         std::vector<OUString> mods;
1044         for (const auto & i: sorted) {
1045             writeEntity(ents, mods, i);
1046         }
1047         closeModules(mods, mods.size());
1048         return EXIT_SUCCESS;
1049     } catch (unoidl::FileFormatException & e1) {
1050         std::cerr
1051             << "Bad input <" << e1.getUri() << ">: " << e1.getDetail()
1052             << std::endl;
1053         std::exit(EXIT_FAILURE);
1054     } catch (std::exception & e1) {
1055         std::cerr << "Failure: " << e1.what() << std::endl;
1056         std::exit(EXIT_FAILURE);
1057     }
1058 }
1059
1060 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */