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