LCOV - code coverage report
Current view: top level - unoidl/source - sourceprovider-scanner.hxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 69 69 100.0 %
Date: 2014-11-03 Functions: 51 52 98.1 %
Legend: Lines: hit not hit

          Line data    Source code
       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        9333 :     bool isPublished() const { return published_; }
      36             : 
      37             : protected:
      38        9562 :     explicit SourceProviderEntityPad(bool published): published_(published) {}
      39             : 
      40        9562 :     virtual ~SourceProviderEntityPad() {}
      41             : 
      42             : private:
      43             :     bool const published_;
      44             : };
      45             : 
      46             : class SourceProviderEnumTypeEntityPad: public SourceProviderEntityPad {
      47             : public:
      48         437 :     explicit SourceProviderEnumTypeEntityPad(bool published):
      49         437 :         SourceProviderEntityPad(published)
      50         437 :     {}
      51             : 
      52             :     std::vector<unoidl::EnumTypeEntity::Member> members;
      53             : 
      54             : private:
      55         874 :     virtual ~SourceProviderEnumTypeEntityPad() throw () {}
      56             : };
      57             : 
      58             : class SourceProviderPlainStructTypeEntityPad: public SourceProviderEntityPad {
      59             : public:
      60         759 :     SourceProviderPlainStructTypeEntityPad(
      61             :         bool published, const OUString & theBaseName,
      62             :         rtl::Reference<unoidl::PlainStructTypeEntity> const & theBaseEntity):
      63             :         SourceProviderEntityPad(published), baseName(theBaseName),
      64         759 :         baseEntity(theBaseEntity)
      65         759 :     { 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        1518 :     virtual ~SourceProviderPlainStructTypeEntityPad() throw () {}
      73             : };
      74             : 
      75             : class SourceProviderPolymorphicStructTypeTemplateEntityPad:
      76             :     public SourceProviderEntityPad
      77             : {
      78             : public:
      79         150 :     SourceProviderPolymorphicStructTypeTemplateEntityPad(bool published):
      80         150 :         SourceProviderEntityPad(published)
      81         150 :     {}
      82             : 
      83             :     std::vector<OUString> typeParameters;
      84             :     std::vector<unoidl::PolymorphicStructTypeTemplateEntity::Member> members;
      85             : 
      86             : private:
      87         300 :     virtual ~SourceProviderPolymorphicStructTypeTemplateEntityPad() throw () {}
      88             : };
      89             : 
      90             : class SourceProviderExceptionTypeEntityPad: public SourceProviderEntityPad {
      91             : public:
      92         499 :     SourceProviderExceptionTypeEntityPad(
      93             :         bool published, const OUString & theBaseName,
      94             :         rtl::Reference<unoidl::ExceptionTypeEntity> const & theBaseEntity):
      95             :         SourceProviderEntityPad(published), baseName(theBaseName),
      96         499 :         baseEntity(theBaseEntity)
      97         499 :     { 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         998 :     virtual ~SourceProviderExceptionTypeEntityPad() throw () {}
     105             : };
     106             : 
     107             : class SourceProviderInterfaceTypeEntityPad: public SourceProviderEntityPad {
     108             : public:
     109       12327 :     struct DirectBase {
     110        3809 :         DirectBase(
     111             :             OUString const & theName,
     112             :             rtl::Reference<unoidl::InterfaceTypeEntity> const & theEntity,
     113             :             std::vector<OUString> const & theAnnotations):
     114        3809 :             name(theName), entity(theEntity), annotations(theAnnotations)
     115        3809 :         { 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      151666 :     struct Member {
     128             :         OUString mandatory;
     129             :         std::set<OUString> optional;
     130             : 
     131       30418 :         explicit Member(const OUString & theMandatory): mandatory(theMandatory) {}
     132             :     };
     133             : 
     134        3691 :     SourceProviderInterfaceTypeEntityPad(bool published, bool theSingleBase):
     135        3691 :         SourceProviderEntityPad(published), singleBase(theSingleBase)
     136        3691 :     {}
     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        7382 :     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        1519 :     explicit SourceProviderConstantGroupEntityPad(bool published):
     184        1519 :         SourceProviderEntityPad(published)
     185        1519 :     {}
     186             : 
     187             :     std::vector<unoidl::ConstantGroupEntity::Member> members;
     188             : 
     189             : private:
     190        3038 :     virtual ~SourceProviderConstantGroupEntityPad() throw () {}
     191             : };
     192             : 
     193             : class SourceProviderSingleInterfaceBasedServiceEntityPad:
     194             :     public SourceProviderEntityPad
     195             : {
     196             : public:
     197        1266 :     struct Constructor {
     198        2781 :         struct Parameter {
     199         585 :             Parameter(
     200             :                 rtl::OUString const & theName,
     201             :                 SourceProviderType const & theType, bool theRest):
     202         585 :                 name(theName), type(theType), rest(theRest)
     203         585 :             {}
     204             : 
     205             :             rtl::OUString name;
     206             : 
     207             :             SourceProviderType type;
     208             : 
     209             :             bool rest;
     210             :         };
     211             : 
     212         372 :         Constructor(
     213             :             rtl::OUString const & theName,
     214             :             std::vector< rtl::OUString > const & theAnnotations):
     215         372 :             name(theName), annotations(theAnnotations)
     216         372 :         {}
     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         685 :     explicit SourceProviderSingleInterfaceBasedServiceEntityPad(
     228             :         bool published, OUString const & theBase):
     229         685 :         SourceProviderEntityPad(published), base(theBase)
     230         685 :     {}
     231             : 
     232             :     OUString const base;
     233             :     std::vector<Constructor> constructors;
     234             : 
     235             : private:
     236        1370 :     virtual ~SourceProviderSingleInterfaceBasedServiceEntityPad() throw () {}
     237             : };
     238             : 
     239             : class SourceProviderAccumulationBasedServiceEntityPad:
     240             :     public SourceProviderEntityPad
     241             : {
     242             : public:
     243        1822 :     explicit SourceProviderAccumulationBasedServiceEntityPad(bool published):
     244        1822 :         SourceProviderEntityPad(published)
     245        1822 :     {}
     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        3644 :     virtual ~SourceProviderAccumulationBasedServiceEntityPad() throw () {}
     256             : };
     257             : 
     258      215222 : struct SourceProviderEntity {
     259             :     enum Kind {
     260             :         KIND_EXTERNAL, KIND_LOCAL, KIND_INTERFACE_DECL,
     261             :         KIND_PUBLISHED_INTERFACE_DECL, KIND_MODULE
     262             :     };
     263             : 
     264       11283 :     explicit SourceProviderEntity(
     265             :         Kind theKind, rtl::Reference<unoidl::Entity> const & externalEntity):
     266       11283 :         kind(theKind), entity(externalEntity)
     267       11283 :     { assert(theKind <= KIND_LOCAL); assert(externalEntity.is()); }
     268             : 
     269        9562 :     explicit SourceProviderEntity(
     270             :         rtl::Reference<SourceProviderEntityPad> const & localPad):
     271        9562 :         kind(KIND_LOCAL), pad(localPad)
     272        9562 :     { assert(localPad.is()); }
     273             : 
     274       24003 :     explicit SourceProviderEntity(Kind theKind): kind(theKind)
     275       24003 :     { assert(theKind >= KIND_INTERFACE_DECL); }
     276             : 
     277        3451 :     SourceProviderEntity(): // needed for std::map::operator []
     278        3451 :         kind() // avoid false warnings about uninitialized members
     279        3451 :     {}
     280             : 
     281             :     Kind kind;
     282             :     rtl::Reference<unoidl::Entity> entity;
     283             :     rtl::Reference<SourceProviderEntityPad> pad;
     284             : };
     285             : 
     286       12934 : struct SourceProviderScannerData {
     287       12934 :     SourceProviderScannerData(
     288             :         rtl::Reference<unoidl::Manager> const & theManager):
     289             :         manager(theManager),
     290             :         sourcePosition(), sourceEnd(),
     291             :             // avoid false warnings about uninitialized members
     292       12934 :         errorLine(0), publishedContext(false)
     293       12934 :     { assert(manager.is()); }
     294             : 
     295        6238 :     void setSource(void const * address, sal_uInt64 size) {
     296        6238 :         sourcePosition = static_cast<char const *>(address);
     297        6238 :         sourceEnd = sourcePosition + size;
     298        6238 :     }
     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: */

Generated by: LCOV version 1.10