xref: /trunk/main/autodoc/source/parser/cpp/pev.hxx (revision 1c78a5d6c0093dece4c096ba53051800fbad6e33)

/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



#ifndef ADC_CPP_PEV_HXX
#define ADC_CPP_PEV_HXX



// USED SERVICES
    // BASE CLASSES
#include <tokens/tokproct.hxx>
    // COMPONENTS
    // PARAMETERS
#include <ary/cpp/c_types4cpp.hxx>

namespace ary
{
    namespace cpp
    {
        class Gate;
        class InputContext;

        class Namespace;
        class Class;
        class Enum;
        class Typedef;
        class Function;
        class Variable;
        class EnumValue;

        class DefineEntity;
    }

    class Documentation;
}


namespace cpp
{


class PeEnvironment : protected TokenProcessing_Types
{
  public:
    // INQUIRY
    virtual             ~PeEnvironment() {}

    // OPERATIONS
        // Token results
    void                SetTokenResult(
                            E_TokenDone         i_eDone,
                            E_EnvStackAction    i_eWhat2DoWithEnvStack,
                            ParseEnvironment *  i_pParseEnv2Push = 0 );

        // Owner stack
    void                OpenNamespace(
                            ary::cpp::Namespace &
                                                io_rOpenedNamespace );
    void                OpenExternC(
                            bool                i_bOnlyForOneDeclaration = false );
    void                OpenClass(
                            ary::cpp::Class &   io_rOpenedClass );
    void                OpenEnum(
                            ary::cpp::Enum &    io_rOpenedEnum );
    void                CloseBlock();           /// Handles a '}' on file scope.
    void                CloseClass();
    void                CloseEnum();
    void                SetCurProtection(       /// Handles 'public:', 'protected:' and 'private:' on class scope.
                            ary::cpp::E_Protection
                                                i_eProtection );
    void                OpenTemplate(
                            const StringVector &
                                                i_rParameters );
    /// Removes parameters from this object.
    DYN StringVector *  Get_CurTemplateParameters();
    /// Checks, if a template is still open, and if yes, closes it.
    void                Close_OpenTemplate();

        // Special events
    void                Event_Class_FinishedBase(
                            const String  &     i_sParameterName );

    void                Event_Store_Typedef(
                            ary::cpp::Typedef & io_rTypedef );
    void                Event_Store_EnumValue(
                            ary::cpp::EnumValue &
                                                io_rEnumValue );
    void                Event_Store_CppDefinition(
                            ary::cpp::DefineEntity  &
                                                io_rDefinition );

    void                Event_EnterFunction_ParameterList();
    void                Event_Function_FinishedParameter(
                            const String  &     i_sParameterName );
    void                Event_LeaveFunction_ParameterList();
    void                Event_EnterFunction_Implementation();
    void                Event_LeaveFunction_Implementation();

    void                Event_Store_Function(
                            ary::cpp::Function &
                                                io_rFunction );
    void                Event_Store_Variable(
                            ary::cpp::Variable &
                                                io_rVariable );
        // Error recovery
    void                StartWaitingFor_Recovery();

    // INQUIRY
    ary::cpp::Gate &  AryGate() const;
    const ary::cpp::InputContext &
                        Context() const;
    String              CurFileName() const;
    uintt               LineCount() const;
    bool                IsWaitingFor_Recovery() const;
    bool                IsExternC() const;

  private:
    virtual void        do_SetTokenResult(
                            E_TokenDone         i_eDone,
                            E_EnvStackAction    i_eWhat2DoWithEnvStack,
                            ParseEnvironment *  i_pParseEnv2Push ) = 0;
    virtual void        do_OpenNamespace(
                            ary::cpp::Namespace &
                                                io_rOpenedNamespace ) = 0;
    virtual void        do_OpenExternC(
                            bool                i_bOnlyForOneDeclaration ) = 0;
    virtual void        do_OpenClass(
                            ary::cpp::Class &   io_rOpenedClass ) = 0;
    virtual void        do_OpenEnum(
                            ary::cpp::Enum &    io_rOpenedEnum ) = 0;
    virtual void        do_CloseBlock() = 0;
    virtual void        do_CloseClass() = 0;
    virtual void        do_CloseEnum() = 0;
    virtual void        do_SetCurProtection(
                            ary::cpp::E_Protection
                                                i_eProtection ) = 0;
    virtual void        do_OpenTemplate(
                            const StringVector &
                                                i_rParameters ) = 0;
    virtual DYN StringVector *
                        do_Get_CurTemplateParameters() = 0;
    virtual void        do_Close_OpenTemplate() = 0;
    virtual void        do_Event_Class_FinishedBase(
                            const String  &     i_sBaseName ) = 0;

    virtual void        do_Event_Store_Typedef(
                            ary::cpp::Typedef & io_rTypedef ) = 0;
    virtual void        do_Event_Store_EnumValue(
                            ary::cpp::EnumValue &
                                                io_rEnumValue ) = 0;
    virtual void        do_Event_Store_CppDefinition(
                            ary::cpp::DefineEntity &
                                                io_rDefinition ) = 0;
    virtual void        do_Event_EnterFunction_ParameterList() = 0;
    virtual void        do_Event_Function_FinishedParameter(
                            const String  &     i_sParameterName ) = 0;
    virtual void        do_Event_LeaveFunction_ParameterList() = 0;
    virtual void        do_Event_EnterFunction_Implementation() = 0;
    virtual void        do_Event_LeaveFunction_Implementation() = 0;
    virtual void        do_Event_Store_Function(
                            ary::cpp::Function &
                                                io_rFunction ) = 0;
    virtual void        do_Event_Store_Variable(
                            ary::cpp::Variable &
                                                io_rVariable ) = 0;
    virtual void        do_StartWaitingFor_Recovery() = 0;
    virtual ary::cpp::Gate &
                        inq_AryGate() const = 0;
    virtual const ary::cpp::InputContext &
                        inq_Context() const = 0;
    virtual String      inq_CurFileName() const = 0;
    virtual uintt       inq_LineCount() const = 0;
    virtual bool        inq_IsWaitingFor_Recovery() const = 0;
    virtual bool        inq_IsExternC() const = 0;
};



// IMPLEMENTATION

inline void
PeEnvironment::SetTokenResult( E_TokenDone          i_eDone,
                               E_EnvStackAction     i_eWhat2DoWithEnvStack,
                               ParseEnvironment *   i_pParseEnv2Push )
    { do_SetTokenResult(i_eDone, i_eWhat2DoWithEnvStack,  i_pParseEnv2Push); }
inline void
PeEnvironment::OpenNamespace( ary::cpp::Namespace & io_rOpenedNamespace )
    { do_OpenNamespace(io_rOpenedNamespace); }
inline void
PeEnvironment::OpenExternC( bool i_bOnlyForOneDeclaration )
    { do_OpenExternC(i_bOnlyForOneDeclaration); }
inline void
PeEnvironment::OpenClass( ary::cpp::Class & io_rOpenedClass )
    { do_OpenClass(io_rOpenedClass); }
inline void
PeEnvironment::OpenEnum( ary::cpp::Enum & io_rOpenedEnum )
    { do_OpenEnum(io_rOpenedEnum); }
inline void
PeEnvironment::CloseBlock()
    { do_CloseBlock(); }
inline void
PeEnvironment::CloseClass()
    { do_CloseClass(); }
inline void
PeEnvironment::CloseEnum()
    { do_CloseEnum(); }
inline void
PeEnvironment::SetCurProtection( ary::cpp::E_Protection i_eProtection )
    { do_SetCurProtection(i_eProtection); }
inline void
PeEnvironment::OpenTemplate( const StringVector & i_rParameters )
    { do_OpenTemplate(i_rParameters); }
inline DYN StringVector *
PeEnvironment::Get_CurTemplateParameters()
    { return do_Get_CurTemplateParameters(); }
inline void
PeEnvironment::Close_OpenTemplate()
    { do_Close_OpenTemplate(); }
inline void
PeEnvironment::Event_Class_FinishedBase( const String  &  i_sBaseName )
    { do_Event_Class_FinishedBase(i_sBaseName); }
inline void
PeEnvironment::Event_Store_Typedef( ary::cpp::Typedef & io_rTypedef )
    { do_Event_Store_Typedef(io_rTypedef); }
inline void
PeEnvironment::Event_Store_EnumValue( ary::cpp::EnumValue & io_rEnumValue )
    { do_Event_Store_EnumValue(io_rEnumValue); }
inline void
PeEnvironment::Event_Store_CppDefinition( ary::cpp::DefineEntity & io_rDefinition )
    { do_Event_Store_CppDefinition(io_rDefinition); }
inline void
PeEnvironment::Event_EnterFunction_ParameterList()
    { do_Event_EnterFunction_ParameterList(); }
inline void
PeEnvironment::Event_Function_FinishedParameter( const String  & i_sParameterName )
    { do_Event_Function_FinishedParameter(i_sParameterName); }
inline void
PeEnvironment::Event_LeaveFunction_ParameterList()
    { do_Event_LeaveFunction_ParameterList(); }
inline void
PeEnvironment::Event_EnterFunction_Implementation()
    { do_Event_EnterFunction_Implementation(); }
inline void
PeEnvironment::Event_LeaveFunction_Implementation()
    { do_Event_LeaveFunction_Implementation(); }
inline void
PeEnvironment::Event_Store_Function( ary::cpp::Function & io_rFunction )
    { do_Event_Store_Function(io_rFunction); }
inline void
PeEnvironment::Event_Store_Variable( ary::cpp::Variable & io_rVariable )
    { do_Event_Store_Variable(io_rVariable); }
inline void
PeEnvironment::StartWaitingFor_Recovery()
    { do_StartWaitingFor_Recovery(); }
inline ary::cpp::Gate &
PeEnvironment::AryGate() const
    { return inq_AryGate(); }
inline const ary::cpp::InputContext &
PeEnvironment::Context() const
    { return inq_Context(); }
inline String
PeEnvironment::CurFileName() const
    { return inq_CurFileName(); }
inline uintt
PeEnvironment::LineCount() const
    { return inq_LineCount(); }
inline bool
PeEnvironment::IsWaitingFor_Recovery() const
    { return inq_IsWaitingFor_Recovery(); }
inline bool
PeEnvironment::IsExternC() const
    { return inq_IsExternC(); }



}   // namespace cpp


#endif