sourceprovider-scanner.hxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
 
#pragma once
 
#include <sal/config.h>
 
#include <cassert>
#include <map>
#include <set>
#include <utility>
#include <vector>
 
#include <rtl/ref.hxx>
#include <rtl/ustring.hxx>
#include <sal/types.h>
#include <salhelper/simplereferenceobject.hxx>
#include <unoidl/unoidl.hxx>
 
#include "sourceprovider-parser-requires.hxx"
#include <sourceprovider-parser.hxx>
 
namespace unoidl::detail {
 
struct SourceProviderScannerData;
 
class SourceProviderEntityPad: public salhelper::SimpleReferenceObject {
public:
    bool isPublished() const { return published_; }
 
protected:
    explicit SourceProviderEntityPad(bool published): published_(published) {}
 
    virtual ~SourceProviderEntityPad() override {}
 
private:
    bool const published_;
};
 
class SourceProviderEnumTypeEntityPad: public SourceProviderEntityPad {
public:
    explicit SourceProviderEnumTypeEntityPad(bool published):
        SourceProviderEntityPad(published)
    {}
 
    std::vector<unoidl::EnumTypeEntity::Member> members;
 
private:
    virtual ~SourceProviderEnumTypeEntityPad() noexcept override {}
};
 
class SourceProviderPlainStructTypeEntityPad: public SourceProviderEntityPad {
public:
    SourceProviderPlainStructTypeEntityPad(
        bool published, const OUString & theBaseName,
        rtl::Reference<unoidl::PlainStructTypeEntity> const & theBaseEntity):
        SourceProviderEntityPad(published), baseName(theBaseName),
        baseEntity(theBaseEntity)
    { assert(theBaseName.isEmpty() != theBaseEntity.is()); }
 
    OUString const baseName;
    rtl::Reference<unoidl::PlainStructTypeEntity> const baseEntity;
    std::vector<unoidl::PlainStructTypeEntity::Member> members;
 
private:
    virtual ~SourceProviderPlainStructTypeEntityPad() noexcept override {}
};
 
class SourceProviderPolymorphicStructTypeTemplateEntityPad:
    public SourceProviderEntityPad
{
public:
    explicit SourceProviderPolymorphicStructTypeTemplateEntityPad(bool published)
        : SourceProviderEntityPad(published)
    {}
 
    std::vector<OUString> typeParameters;
    std::vector<unoidl::PolymorphicStructTypeTemplateEntity::Member> members;
 
private:
    virtual ~SourceProviderPolymorphicStructTypeTemplateEntityPad() noexcept override {}
};
 
class SourceProviderExceptionTypeEntityPad: public SourceProviderEntityPad {
public:
    SourceProviderExceptionTypeEntityPad(
        bool published, const OUString & theBaseName,
        rtl::Reference<unoidl::ExceptionTypeEntity> const & theBaseEntity):
        SourceProviderEntityPad(published), baseName(theBaseName),
        baseEntity(theBaseEntity)
    { assert(theBaseName.isEmpty() != theBaseEntity.is()); }
 
    OUString const baseName;
    rtl::Reference<unoidl::ExceptionTypeEntity> const baseEntity;
    std::vector<unoidl::ExceptionTypeEntity::Member> members;
 
private:
    virtual ~SourceProviderExceptionTypeEntityPad() noexcept override {}
};
 
class SourceProviderInterfaceTypeEntityPad: public SourceProviderEntityPad {
public:
    struct DirectBase {
        DirectBase(
            OUString theName,
            rtl::Reference<unoidl::InterfaceTypeEntity> const & theEntity,
            std::vector<OUString>&& theAnnotations):
            name(std::move(theName)), entity(theEntity), annotations(std::move(theAnnotations))
        { assert(theEntity.is()); }
 
        OUString name;
        rtl::Reference<unoidl::InterfaceTypeEntity> entity;
        std::vector<OUString> annotations;
    };
 
    enum BaseKind {
        BASE_INDIRECT_OPTIONAL, BASE_DIRECT_OPTIONAL, BASE_INDIRECT_MANDATORY,
        BASE_DIRECT_MANDATORY
    };
 
    struct Member {
        OUString mandatory;
        std::set<OUString> optional;
 
        explicit Member(OUString theMandatory): mandatory(std::move(theMandatory)) {}
    };
 
    SourceProviderInterfaceTypeEntityPad(bool published, bool theSingleBase):
        SourceProviderEntityPad(published), singleBase(theSingleBase)
    {}
 
    bool addDirectBase(
        YYLTYPE location, yyscan_t yyscanner, SourceProviderScannerData * data,
        DirectBase const & base, bool optional);
 
    bool addDirectMember(
        YYLTYPE location, yyscan_t yyscanner, SourceProviderScannerData * data,
        OUString const & name);
 
    bool singleBase;
    std::vector<DirectBase> directMandatoryBases;
    std::vector<DirectBase> directOptionalBases;
    std::vector<unoidl::InterfaceTypeEntity::Attribute> directAttributes;
    std::vector<unoidl::InterfaceTypeEntity::Method> directMethods;
    std::map<OUString, BaseKind> allBases;
    std::map<OUString, Member> allMembers;
 
private:
    virtual ~SourceProviderInterfaceTypeEntityPad() noexcept override {}
 
    bool checkBaseClashes(
        YYLTYPE location, yyscan_t yyscanner, SourceProviderScannerData * data,
        OUString const & name,
        rtl::Reference<unoidl::InterfaceTypeEntity> const & entity,
        bool direct, bool optional, bool outerOptional,
        std::set<OUString> * seen) const;
 
    bool checkMemberClashes(
        YYLTYPE location, yyscan_t yyscanner, SourceProviderScannerData * data,
        std::u16string_view interfaceName, OUString const & memberName,
        bool checkOptional) const;
 
    bool addBase(
        YYLTYPE location, yyscan_t yyscanner, SourceProviderScannerData * data,
        OUString const & directBaseName, OUString const & name,
        rtl::Reference<unoidl::InterfaceTypeEntity> const & entity, bool direct,
        bool optional);
 
    bool addOptionalBaseMembers(
        YYLTYPE location, yyscan_t yyscanner, SourceProviderScannerData * data,
        OUString const & name,
        rtl::Reference<unoidl::InterfaceTypeEntity> const & entity);
};
 
class SourceProviderConstantGroupEntityPad: public SourceProviderEntityPad {
public:
    explicit SourceProviderConstantGroupEntityPad(bool published):
        SourceProviderEntityPad(published)
    {}
 
    std::vector<unoidl::ConstantGroupEntity::Member> members;
 
private:
    virtual ~SourceProviderConstantGroupEntityPad() noexcept override {}
};
 
class SourceProviderSingleInterfaceBasedServiceEntityPad:
    public SourceProviderEntityPad
{
public:
    struct Constructor {
        struct Parameter {
            Parameter(
                OUString theName,
                SourceProviderType theType, bool theRest):
                name(std::move(theName)), type(std::move(theType)), rest(theRest)
            {}
 
            OUString name;
 
            SourceProviderType type;
 
            bool rest;
        };
 
        Constructor(
            OUString theName,
            std::vector< OUString >&& theAnnotations):
            name(std::move(theName)), annotations(std::move(theAnnotations))
        {}
 
        OUString name;
 
        std::vector< Parameter > parameters;
 
        std::vector< OUString > exceptions;
 
        std::vector< OUString > annotations;
    };
 
    explicit SourceProviderSingleInterfaceBasedServiceEntityPad(
        bool published, OUString theBase):
        SourceProviderEntityPad(published), base(std::move(theBase))
    {}
 
    OUString const base;
    std::vector<Constructor> constructors;
 
private:
    virtual ~SourceProviderSingleInterfaceBasedServiceEntityPad() noexcept override {}
};
 
class SourceProviderAccumulationBasedServiceEntityPad:
    public SourceProviderEntityPad
{
public:
    explicit SourceProviderAccumulationBasedServiceEntityPad(bool published):
        SourceProviderEntityPad(published)
    {}
 
    std::vector<unoidl::AnnotatedReference> directMandatoryBaseServices;
    std::vector<unoidl::AnnotatedReference> directOptionalBaseServices;
    std::vector<unoidl::AnnotatedReference> directMandatoryBaseInterfaces;
    std::vector<unoidl::AnnotatedReference> directOptionalBaseInterfaces;
    std::vector<unoidl::AccumulationBasedServiceEntity::Property>
        directProperties;
 
private:
    virtual ~SourceProviderAccumulationBasedServiceEntityPad() noexcept override {}
};
 
struct SourceProviderEntity {
    enum Kind {
        KIND_EXTERNAL, KIND_LOCAL, KIND_INTERFACE_DECL,
        KIND_PUBLISHED_INTERFACE_DECL, KIND_MODULE
    };
 
    explicit SourceProviderEntity(
        Kind theKind, rtl::Reference<unoidl::Entity> const & externalEntity):
        kind(theKind), entity(externalEntity)
    { assert(theKind <= KIND_LOCAL); assert(externalEntity.is()); }
 
    explicit SourceProviderEntity(
        rtl::Reference<SourceProviderEntityPad> const & localPad):
        kind(KIND_LOCAL), pad(localPad)
    { assert(localPad.is()); }
 
    explicit SourceProviderEntity(Kind theKind): kind(theKind)
    { assert(theKind >= KIND_INTERFACE_DECL); }
 
    SourceProviderEntity(): // needed for std::map::operator []
        kind() // avoid false warnings about uninitialized members
    {}
 
    Kind kind;
    rtl::Reference<unoidl::Entity> entity;
    rtl::Reference<SourceProviderEntityPad> pad;
};
 
struct SourceProviderScannerData {
    explicit SourceProviderScannerData(
        rtl::Reference<unoidl::Manager> theManager):
        manager(std::move(theManager)),
        sourcePosition(), sourceEnd(),
            // avoid false warnings about uninitialized members
        errorLine(0), publishedContext(false)
    { assert(manager.is()); }
 
    void setSource(void const * address, sal_uInt64 size) {
        sourcePosition = static_cast<char const *>(address);
        sourceEnd = sourcePosition + size;
    }
 
    rtl::Reference<unoidl::Manager> manager;
 
    char const * sourcePosition;
    char const * sourceEnd;
    YYLTYPE errorLine;
    OString parserError;
    OUString errorMessage;
 
    std::map<OUString, SourceProviderEntity> entities;
    std::vector<OUString> modules;
    OUString currentName;
    bool publishedContext;
};
 
bool parse(OUString const & uri, SourceProviderScannerData * data);
 
}
 
int yylex_init_extra(
    unoidl::detail::SourceProviderScannerData * user_defined,
    yyscan_t * yyscanner);
 
int yylex_destroy(yyscan_t yyscanner);
 
int yylex(YYSTYPE * yylval_param, YYLTYPE * yylloc_param, yyscan_t yyscanner);
 
unoidl::detail::SourceProviderScannerData * yyget_extra(yyscan_t yyscanner);
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */