unoidl/source/sourceprovider-scanner.hxx

   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 #pragma once
  11
  12 #include <sal/config.h>
  13
  14 #include <cassert>
  15 #include <map>
  16 #include <set>
  17 #include <vector>
  18
  19 #include <rtl/ref.hxx>
  20 #include <rtl/ustring.hxx>
  21 #include <sal/types.h>
  22 #include <salhelper/simplereferenceobject.hxx>
  23 #include <unoidl/unoidl.hxx>
  24
  25 #include "sourceprovider-parser-requires.hxx"
  26 #include <sourceprovider-parser.hxx>
  27
  28 namespace unoidl::detail {
  29
  30 struct SourceProviderScannerData;
  31
  32 class SourceProviderEntityPad: public salhelper::SimpleReferenceObject {
  33 public:
  34     bool isPublished() const { return published_; }
  35
  36 protected:
  37     explicit SourceProviderEntityPad(bool published): published_(published) {}
  38
  39     virtual ~SourceProviderEntityPad() override {}
  40
  41 private:
  42     bool const published_;
  43 };
  44
  45 class SourceProviderEnumTypeEntityPad: public SourceProviderEntityPad {
  46 public:
  47     explicit SourceProviderEnumTypeEntityPad(bool published):
  48         SourceProviderEntityPad(published)
  49     {}
  50
  51     std::vector<unoidl::EnumTypeEntity::Member> members;
  52
  53 private:
  54     virtual ~SourceProviderEnumTypeEntityPad() noexcept override {}
  55 };
  56
  57 class SourceProviderPlainStructTypeEntityPad: public SourceProviderEntityPad {
  58 public:
  59     SourceProviderPlainStructTypeEntityPad(
  60         bool published, const OUString & theBaseName,
  61         rtl::Reference<unoidl::PlainStructTypeEntity> const & theBaseEntity):
  62         SourceProviderEntityPad(published), baseName(theBaseName),
  63         baseEntity(theBaseEntity)
  64     { assert(theBaseName.isEmpty() != theBaseEntity.is()); }
  65
  66     OUString const baseName;
  67     rtl::Reference<unoidl::PlainStructTypeEntity> const baseEntity;
  68     std::vector<unoidl::PlainStructTypeEntity::Member> members;
  69
  70 private:
  71     virtual ~SourceProviderPlainStructTypeEntityPad() noexcept override {}
  72 };
  73
  74 class SourceProviderPolymorphicStructTypeTemplateEntityPad:
  75     public SourceProviderEntityPad
  76 {
  77 public:
  78     explicit SourceProviderPolymorphicStructTypeTemplateEntityPad(bool published)
  79         : SourceProviderEntityPad(published)
  80     {}
  81
  82     std::vector<OUString> typeParameters;
  83     std::vector<unoidl::PolymorphicStructTypeTemplateEntity::Member> members;
  84
  85 private:
  86     virtual ~SourceProviderPolymorphicStructTypeTemplateEntityPad() noexcept override {}
  87 };
  88
  89 class SourceProviderExceptionTypeEntityPad: public SourceProviderEntityPad {
  90 public:
  91     SourceProviderExceptionTypeEntityPad(
  92         bool published, const OUString & theBaseName,
  93         rtl::Reference<unoidl::ExceptionTypeEntity> const & theBaseEntity):
  94         SourceProviderEntityPad(published), baseName(theBaseName),
  95         baseEntity(theBaseEntity)
  96     { assert(theBaseName.isEmpty() != theBaseEntity.is()); }
  97
  98     OUString const baseName;
  99     rtl::Reference<unoidl::ExceptionTypeEntity> const baseEntity;
 100     std::vector<unoidl::ExceptionTypeEntity::Member> members;
 101
 102 private:
 103     virtual ~SourceProviderExceptionTypeEntityPad() noexcept override {}
 104 };
 105
 106 class SourceProviderInterfaceTypeEntityPad: public SourceProviderEntityPad {
 107 public:
 108     struct DirectBase {
 109         DirectBase(
 110             OUString const & theName,
 111             rtl::Reference<unoidl::InterfaceTypeEntity> const & theEntity,
 112             std::vector<OUString> const & theAnnotations):
 113             name(theName), entity(theEntity), annotations(theAnnotations)
 114         { assert(theEntity.is()); }
 115
 116         OUString name;
 117         rtl::Reference<unoidl::InterfaceTypeEntity> entity;
 118         std::vector<OUString> annotations;
 119     };
 120
 121     enum BaseKind {
 122         BASE_INDIRECT_OPTIONAL, BASE_DIRECT_OPTIONAL, BASE_INDIRECT_MANDATORY,
 123         BASE_DIRECT_MANDATORY
 124     };
 125
 126     struct Member {
 127         OUString mandatory;
 128         std::set<OUString> optional;
 129
 130         explicit Member(const OUString & theMandatory): mandatory(theMandatory) {}
 131     };
 132
 133     SourceProviderInterfaceTypeEntityPad(bool published, bool theSingleBase):
 134         SourceProviderEntityPad(published), singleBase(theSingleBase)
 135     {}
 136
 137     bool addDirectBase(
 138         YYLTYPE location, yyscan_t yyscanner, SourceProviderScannerData * data,
 139         DirectBase const & base, bool optional);
 140
 141     bool addDirectMember(
 142         YYLTYPE location, yyscan_t yyscanner, SourceProviderScannerData * data,
 143         OUString const & name);
 144
 145     bool singleBase;
 146     std::vector<DirectBase> directMandatoryBases;
 147     std::vector<DirectBase> directOptionalBases;
 148     std::vector<unoidl::InterfaceTypeEntity::Attribute> directAttributes;
 149     std::vector<unoidl::InterfaceTypeEntity::Method> directMethods;
 150     std::map<OUString, BaseKind> allBases;
 151     std::map<OUString, Member> allMembers;
 152
 153 private:
 154     virtual ~SourceProviderInterfaceTypeEntityPad() noexcept override {}
 155
 156     bool checkBaseClashes(
 157         YYLTYPE location, yyscan_t yyscanner, SourceProviderScannerData * data,
 158         OUString const & name,
 159         rtl::Reference<unoidl::InterfaceTypeEntity> const & entity,
 160         bool direct, bool optional, bool outerOptional,
 161         std::set<OUString> * seen) const;
 162
 163     bool checkMemberClashes(
 164         YYLTYPE location, yyscan_t yyscanner, SourceProviderScannerData * data,
 165         std::u16string_view interfaceName, OUString const & memberName,
 166         bool checkOptional) const;
 167
 168     bool addBase(
 169         YYLTYPE location, yyscan_t yyscanner, SourceProviderScannerData * data,
 170         OUString const & directBaseName, OUString const & name,
 171         rtl::Reference<unoidl::InterfaceTypeEntity> const & entity, bool direct,
 172         bool optional);
 173
 174     bool addOptionalBaseMembers(
 175         YYLTYPE location, yyscan_t yyscanner, SourceProviderScannerData * data,
 176         OUString const & name,
 177         rtl::Reference<unoidl::InterfaceTypeEntity> const & entity);
 178 };
 179
 180 class SourceProviderConstantGroupEntityPad: public SourceProviderEntityPad {
 181 public:
 182     explicit SourceProviderConstantGroupEntityPad(bool published):
 183         SourceProviderEntityPad(published)
 184     {}
 185
 186     std::vector<unoidl::ConstantGroupEntity::Member> members;
 187
 188 private:
 189     virtual ~SourceProviderConstantGroupEntityPad() noexcept override {}
 190 };
 191
 192 class SourceProviderSingleInterfaceBasedServiceEntityPad:
 193     public SourceProviderEntityPad
 194 {
 195 public:
 196     struct Constructor {
 197         struct Parameter {
 198             Parameter(
 199                 OUString const & theName,
 200                 SourceProviderType const & theType, bool theRest):
 201                 name(theName), type(theType), rest(theRest)
 202             {}
 203
 204             OUString name;
 205
 206             SourceProviderType type;
 207
 208             bool rest;
 209         };
 210
 211         Constructor(
 212             OUString const & theName,
 213             std::vector< OUString > const & theAnnotations):
 214             name(theName), annotations(theAnnotations)
 215         {}
 216
 217         OUString name;
 218
 219         std::vector< Parameter > parameters;
 220
 221         std::vector< OUString > exceptions;
 222
 223         std::vector< OUString > annotations;
 224     };
 225
 226     explicit SourceProviderSingleInterfaceBasedServiceEntityPad(
 227         bool published, OUString const & theBase):
 228         SourceProviderEntityPad(published), base(theBase)
 229     {}
 230
 231     OUString const base;
 232     std::vector<Constructor> constructors;
 233
 234 private:
 235     virtual ~SourceProviderSingleInterfaceBasedServiceEntityPad() noexcept override {}
 236 };
 237
 238 class SourceProviderAccumulationBasedServiceEntityPad:
 239     public SourceProviderEntityPad
 240 {
 241 public:
 242     explicit SourceProviderAccumulationBasedServiceEntityPad(bool published):
 243         SourceProviderEntityPad(published)
 244     {}
 245
 246     std::vector<unoidl::AnnotatedReference> directMandatoryBaseServices;
 247     std::vector<unoidl::AnnotatedReference> directOptionalBaseServices;
 248     std::vector<unoidl::AnnotatedReference> directMandatoryBaseInterfaces;
 249     std::vector<unoidl::AnnotatedReference> directOptionalBaseInterfaces;
 250     std::vector<unoidl::AccumulationBasedServiceEntity::Property>
 251         directProperties;
 252
 253 private:
 254     virtual ~SourceProviderAccumulationBasedServiceEntityPad() noexcept override {}
 255 };
 256
 257 struct SourceProviderEntity {
 258     enum Kind {
 259         KIND_EXTERNAL, KIND_LOCAL, KIND_INTERFACE_DECL,
 260         KIND_PUBLISHED_INTERFACE_DECL, KIND_MODULE
 261     };
 262
 263     explicit SourceProviderEntity(
 264         Kind theKind, rtl::Reference<unoidl::Entity> const & externalEntity):
 265         kind(theKind), entity(externalEntity)
 266     { assert(theKind <= KIND_LOCAL); assert(externalEntity.is()); }
 267
 268     explicit SourceProviderEntity(
 269         rtl::Reference<SourceProviderEntityPad> const & localPad):
 270         kind(KIND_LOCAL), pad(localPad)
 271     { assert(localPad.is()); }
 272
 273     explicit SourceProviderEntity(Kind theKind): kind(theKind)
 274     { assert(theKind >= KIND_INTERFACE_DECL); }
 275
 276     SourceProviderEntity(): // needed for std::map::operator []
 277         kind() // avoid false warnings about uninitialized members
 278     {}
 279
 280     Kind kind;
 281     rtl::Reference<unoidl::Entity> entity;
 282     rtl::Reference<SourceProviderEntityPad> pad;
 283 };
 284
 285 struct SourceProviderScannerData {
 286     explicit SourceProviderScannerData(
 287         rtl::Reference<unoidl::Manager> const & theManager):
 288         manager(theManager),
 289         sourcePosition(), sourceEnd(),
 290             // avoid false warnings about uninitialized members
 291         errorLine(0), publishedContext(false)
 292     { assert(manager.is()); }
 293
 294     void setSource(void const * address, sal_uInt64 size) {
 295         sourcePosition = static_cast<char const *>(address);
 296         sourceEnd = sourcePosition + size;
 297     }
 298
 299     rtl::Reference<unoidl::Manager> manager;
 300
 301     char const * sourcePosition;
 302     char const * sourceEnd;
 303     YYLTYPE errorLine;
 304     OString parserError;
 305     OUString errorMessage;
 306
 307     std::map<OUString, SourceProviderEntity> entities;
 308     std::vector<OUString> modules;
 309     OUString currentName;
 310     bool publishedContext;
 311 };
 312
 313 bool parse(OUString const & uri, SourceProviderScannerData * data);
 314
 315 }
 316
 317 int yylex_init_extra(
 318     unoidl::detail::SourceProviderScannerData * user_defined,
 319     yyscan_t * yyscanner);
 320
 321 int yylex_destroy(yyscan_t yyscanner);
 322
 323 int yylex(YYSTYPE * yylval_param, YYLTYPE * yylloc_param, yyscan_t yyscanner);
 324
 325 unoidl::detail::SourceProviderScannerData * yyget_extra(yyscan_t yyscanner);
 326
 327 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */