xref: /trunk/main/autodoc/source/parser/cpp/pe_funct.cxx (revision 78bc99aafea97f4987aed12e674c2d2f1166dd91)

/**************************************************************
 *
 * 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.
 *
 *************************************************************/

#include <precomp.h>
#include "pe_funct.hxx"


// NOT FULLY DEFINED SERVICES
#include <cosv/tpl/tpltools.hxx>
#include <ary/cpp/c_gate.hxx>
#include <ary/cpp/c_funct.hxx>
#include <ary/cpp/c_type.hxx>
#include <ary/cpp/cp_ce.hxx>
#include <ary/cpp/cp_type.hxx>
#include <ary/cpp/inpcontx.hxx>
#include "pe_type.hxx"
#include "pe_param.hxx"




namespace cpp
{


inline void
PE_Function::PerformFinishingPunctuation()
{
    SetTokenResult(not_done,pop_success);
}


PE_Function::PE_Function( Cpp_PE * i_pParent )
    :   Cpp_PE(i_pParent),
        pStati( new PeStatusArray<PE_Function> ),
        // pSpParameter,
        // pSpuParameter,
        // pSpType,
        // pSpuException,
        // pSpuCastOperatorType,
        nResult(0),
        bResult_WithImplementation(false),
        aName(60),
        eVirtuality(ary::cpp::VIRTUAL_none),
        eConVol(ary::cpp::CONVOL_none),
        // aFlags,
        nReturnType(0),
        // aParameters
        // aExceptions,
        bThrow(false),
        nBracketCounterInImplementation(0)
{
    Setup_StatusFunctions();

    pSpParameter     = new SP_Parameter(*this);
    pSpType          = new SP_Type(*this);

    pSpuParameter           = new SPU_Parameter(*pSpParameter, 0, &PE_Function::SpReturn_Parameter);
    pSpuException           = new SPU_Type(*pSpType, 0, &PE_Function::SpReturn_Exception);
    pSpuCastOperatorType    = new SPU_Type(*pSpType, &PE_Function::SpInit_CastOperatorType, &PE_Function::SpReturn_CastOperatorType);
}

PE_Function::~PE_Function()
{

}

void
PE_Function::Init_Std( const String  &          i_sName,
                       ary::cpp::Type_id        i_nReturnType,
                       bool                     i_bVirtual,
                       ary::cpp::FunctionFlags  i_aFlags )
{
    aName << i_sName;
    eVirtuality = i_bVirtual ? ary::cpp::VIRTUAL_virtual : ary::cpp::VIRTUAL_none;
    aFlags = i_aFlags;
    nReturnType = i_nReturnType;
    pStati->SetCur(afterName);
}

void
PE_Function::Init_Ctor( const String  &         i_sName,
                        ary::cpp::FunctionFlags i_aFlags )
{
    aName << i_sName;
    eVirtuality = ary::cpp::VIRTUAL_none;
    aFlags = i_aFlags;
    nReturnType = 0;
    pStati->SetCur(afterName);
}

void
PE_Function::Init_Dtor( const String  &         i_sName,
                        bool                    i_bVirtual,
                        ary::cpp::FunctionFlags i_aFlags )
{
    aName << "~" << i_sName;
    eVirtuality = i_bVirtual ? ary::cpp::VIRTUAL_virtual : ary::cpp::VIRTUAL_none;
    aFlags = i_aFlags;
    nReturnType = 0;
    pStati->SetCur(afterName);
}

void
PE_Function::Init_CastOperator( bool                    i_bVirtual,
                                ary::cpp::FunctionFlags i_aFlags )
{
    aName << "operator ";
    eVirtuality = i_bVirtual ? ary::cpp::VIRTUAL_virtual : ary::cpp::VIRTUAL_none;
    aFlags = i_aFlags;
    nReturnType = 0;
    pStati->SetCur(afterCastOperator);
}

void
PE_Function::Init_NormalOperator( ary::cpp::Type_id                  i_nReturnType,
                                  bool                      i_bVirtual,
                                  ary::cpp::FunctionFlags   i_aFlags )
{
    aName << "operator";
    eVirtuality = i_bVirtual ? ary::cpp::VIRTUAL_virtual : ary::cpp::VIRTUAL_none;
    aFlags = i_aFlags;
    nReturnType = i_nReturnType;
    pStati->SetCur(afterStdOperator);
}

ary::cpp::Ce_id
PE_Function::Result_Id() const
{
    return nResult;
}

void
PE_Function::Call_Handler( const cpp::Token & i_rTok )
{
    pStati->Cur().Call_Handler(i_rTok.TypeId(), i_rTok.Text());
}

void
PE_Function::Setup_StatusFunctions()
{
    typedef CallFunction<PE_Function>::F_Tok    F_Tok;

    static F_Tok stateF_afterStdOperator[] =
                                            { &PE_Function::On_afterOperator_Std_Operator,
                                              &PE_Function::On_afterOperator_Std_LeftBracket,
                                              &PE_Function::On_afterOperator_Std_LeftBracket,
                                              &PE_Function::On_afterOperator_Std_Operator,
                                              &PE_Function::On_afterOperator_Std_Operator,
                                              &PE_Function::On_afterOperator_Std_Operator,
                                              &PE_Function::On_afterOperator_Std_Operator,
                                              &PE_Function::On_afterOperator_Std_Operator,
                                              &PE_Function::On_afterOperator_Std_Operator };
    static INT16 stateT_afterStdOperator[] =
                                            { Tid_Operator,
                                              Tid_ArrayBracket_Left,
                                              Tid_Bracket_Left,
                                              Tid_Comma,
                                              Tid_Assign,
                                              Tid_Less,
                                              Tid_Greater,
                                              Tid_Asterix,
                                              Tid_AmpersAnd };

    static F_Tok stateF_afterStdOperatorLeftBracket[] =
                                            { &PE_Function::On_afterStdOperatorLeftBracket_RightBracket,
                                              &PE_Function::On_afterStdOperatorLeftBracket_RightBracket };
    static INT16 stateT_afterStdOperatorLeftBracket[] =
                                            { Tid_ArrayBracket_Right,
                                              Tid_Bracket_Right };

    static F_Tok stateF_afterCastOperator[] =
                                            { &PE_Function::On_afterOperator_Cast_Type,
                                              &PE_Function::On_afterOperator_Cast_Type,
                                              &PE_Function::On_afterOperator_Cast_Type,
                                              &PE_Function::On_afterOperator_Cast_Type,
                                              &PE_Function::On_afterOperator_Cast_Type,
                                              &PE_Function::On_afterOperator_Cast_Type,
                                              &PE_Function::On_afterOperator_Cast_Type,
                                              &PE_Function::On_afterOperator_Cast_Type,
                                              &PE_Function::On_afterOperator_Cast_Type,
                                              &PE_Function::On_afterOperator_Cast_Type,
                                              &PE_Function::On_afterOperator_Cast_Type };
    static INT16 stateT_afterCastOperator[] =
                                            { Tid_Identifier,
                                              Tid_class,
                                              Tid_struct,
                                              Tid_union,
                                              Tid_enum,
                                              Tid_const,
                                              Tid_volatile,
                                              Tid_DoubleColon,
                                              Tid_typename,
                                              Tid_BuiltInType,
                                              Tid_TypeSpecializer };

    static F_Tok stateF_afterName[] =       { &PE_Function::On_afterName_Bracket_Left };
    static INT16 stateT_afterName[] =       { Tid_Bracket_Left };

    static F_Tok stateF_expectParameterSeparator[] =
                                            { &PE_Function::On_expectParameterSeparator_BracketRight,
                                              &PE_Function::On_expectParameterSeparator_Comma };
    static INT16 stateT_expectParameterSeparator[] =
                                            { Tid_Bracket_Right,
                                              Tid_Comma };

    static F_Tok stateF_afterParameters[] = { &PE_Function::On_afterParameters_const,
                                              &PE_Function::On_afterParameters_volatile,
                                              &PE_Function::On_afterParameters_throw,
                                              &PE_Function::On_afterParameters_SwBracket_Left,
                                              &PE_Function::On_afterParameters_Semicolon,
                                              &PE_Function::On_afterParameters_Comma,
                                              &PE_Function::On_afterParameters_Colon,
                                              &PE_Function::On_afterParameters_Assign };
    static INT16 stateT_afterParameters[] = { Tid_const,
                                              Tid_volatile,
                                              Tid_throw,
                                              Tid_SwBracket_Left,
                                              Tid_Semicolon,
                                              Tid_Comma,
                                              Tid_Colon,
                                              Tid_Assign };

    static F_Tok stateF_afterThrow[] =      { &PE_Function::On_afterThrow_Bracket_Left };
    static INT16 stateT_afterThrow[] =      { Tid_Bracket_Left };

    static F_Tok stateF_expectExceptionSeparator[] =
                                            { &PE_Function::On_expectExceptionSeparator_BracketRight,
                                              &PE_Function::On_expectExceptionSeparator_Comma };
    static INT16 stateT_expectExceptionSeparator[] =
                                            { Tid_Bracket_Right,
                                              Tid_Comma };

    static F_Tok stateF_afterExceptions[] = { &PE_Function::On_afterExceptions_SwBracket_Left,
                                              &PE_Function::On_afterExceptions_Semicolon,
                                              &PE_Function::On_afterExceptions_Comma,
                                              &PE_Function::On_afterExceptions_Colon,
                                              &PE_Function::On_afterExceptions_Assign };
    static INT16 stateT_afterExceptions[] = { Tid_SwBracket_Left,
                                              Tid_Semicolon,
                                              Tid_Comma,
                                              Tid_Colon,
                                              Tid_Assign };

    static F_Tok stateF_expectZero[] =      { &PE_Function::On_expectZero_Constant };
    static INT16 stateT_expectZero[] =      { Tid_Constant };

    static F_Tok stateF_inImplementation[] =
                                            { &PE_Function::On_inImplementation_SwBracket_Left,
                                              &PE_Function::On_inImplementation_SwBracket_Right };
    static INT16 stateT_inImplementation[] =
                                            { Tid_SwBracket_Left,
                                              Tid_SwBracket_Right };

    SEMPARSE_CREATE_STATUS(PE_Function, afterStdOperator, Hdl_SyntaxError);
    SEMPARSE_CREATE_STATUS(PE_Function, afterStdOperatorLeftBracket, Hdl_SyntaxError);
    SEMPARSE_CREATE_STATUS(PE_Function, afterCastOperator, Hdl_SyntaxError);
    SEMPARSE_CREATE_STATUS(PE_Function, afterName, Hdl_SyntaxError);
    SEMPARSE_CREATE_STATUS(PE_Function, expectParameterSeparator, Hdl_SyntaxError);
    SEMPARSE_CREATE_STATUS(PE_Function, afterParameters, Hdl_SyntaxError);
    SEMPARSE_CREATE_STATUS(PE_Function, afterThrow, Hdl_SyntaxError);
    SEMPARSE_CREATE_STATUS(PE_Function, expectExceptionSeparator, Hdl_SyntaxError);
    SEMPARSE_CREATE_STATUS(PE_Function, afterExceptions, Hdl_SyntaxError);
    SEMPARSE_CREATE_STATUS(PE_Function, expectZero, Hdl_SyntaxError);
    SEMPARSE_CREATE_STATUS(PE_Function, inImplementation, On_inImplementation_Default );
}

void
PE_Function::InitData()
{
    pStati->SetCur( afterName ),
    nResult = 0;
    bResult_WithImplementation = false;
    aName.seekp(0);
    eVirtuality = ary::cpp::VIRTUAL_none;
    eConVol = ary::cpp::CONVOL_none;
    aFlags.Reset();
    nReturnType = 0;
    csv::erase_container(aParameters);
    csv::erase_container(aExceptions);
    bThrow = false;
}

void
PE_Function::TransferData()
{
    String  sName( aName.c_str() );
    ary::cpp::Function *
        pFunction = Env().AryGate().Ces().Store_Operation(
                                                Env().Context(),
                                                sName,
                                                nReturnType,
                                                aParameters,
                                                eVirtuality,
                                                eConVol,
                                                aFlags,
                                                bThrow,
                                                aExceptions );
    if (pFunction != 0)
    {
        // KORR_FUTURE: How to handle differing documentation?

        Dyn< StringVector >
                pTplParams ( Env().Get_CurTemplateParameters() );
        if ( pTplParams )
        {
            for ( StringVector::const_iterator it = pTplParams->begin();
                  it !=  pTplParams->end();
                  ++it )
            {
                pFunction->Add_TemplateParameterType( *it, ary::cpp::Type_id(0) );
            }  // end for
        }

        Env().Event_Store_Function(*pFunction);
    }

    pStati->SetCur(size_of_states);
}

void
PE_Function::Hdl_SyntaxError(const char * i_sText)
{
    StdHandlingOfSyntaxError(i_sText);
}

void
PE_Function::SpInit_CastOperatorType()
{
    pSpuCastOperatorType->Child().Init_AsCastOperatorType();
}

void
PE_Function::SpReturn_Parameter()
{
    pStati->SetCur(expectParameterSeparator);

    ary::cpp::Type_id nParamType = pSpuParameter->Child().Result_FrontType();
    if ( nParamType.IsValid() )      // Check, if there was a parameter, or only the closing ')'.
    {
        aParameters.push_back( pSpuParameter->Child().Result_ParamInfo() );
    }
}

void
PE_Function::SpReturn_Exception()
{
    pStati->SetCur(expectExceptionSeparator);

    ary::cpp::Type_id
        nException = pSpuException->Child().Result_Type().TypeId();
    if ( nException.IsValid() AND pSpuException->Child().Result_KindOf() == PE_Type::is_type )
    {
        aExceptions.push_back( nException );
    }
}

void
PE_Function::SpReturn_CastOperatorType()
{
    pStati->SetCur(afterName);

    Env().AryGate().Types().Get_TypeText(
            aName, pSpuCastOperatorType->Child().Result_Type().TypeId() );
}

void
PE_Function::On_afterOperator_Std_Operator(const char * i_sText)
{
    SetTokenResult(done,stay);
    pStati->SetCur(afterName);

    if ( 'a' <= *i_sText AND *i_sText <= 'z' )
        aName << ' ';
    aName << i_sText;
}

void
PE_Function::On_afterOperator_Std_LeftBracket(const char * i_sText)
{
    SetTokenResult(done,stay);
    pStati->SetCur(afterStdOperatorLeftBracket);

    aName << i_sText;
}

void
PE_Function::On_afterStdOperatorLeftBracket_RightBracket(const char * i_sText)
{
    SetTokenResult(done,stay);
    pStati->SetCur(afterName);

    aName << i_sText;
}

void
PE_Function::On_afterOperator_Cast_Type(const char *)
{
    pSpuCastOperatorType->Push(not_done);
}

void
PE_Function::On_afterName_Bracket_Left(const char *)
{
    pSpuParameter->Push(done);
}

void
PE_Function::On_expectParameterSeparator_BracketRight(const char *)
{
    SetTokenResult(done,stay);
    pStati->SetCur(afterParameters);
}

void
PE_Function::On_expectParameterSeparator_Comma(const char *)
{
    pSpuParameter->Push(done);
}

void
PE_Function::On_afterParameters_const(const char *)
{
    SetTokenResult(done,stay);
    eConVol = static_cast<E_ConVol>(
                    static_cast<int>(eConVol) | static_cast<int>(ary::cpp::CONVOL_const) );
}

void
PE_Function::On_afterParameters_volatile(const char *)
{
    SetTokenResult(done,stay);
    eConVol = static_cast<E_ConVol>(
                    static_cast<int>(eConVol) | static_cast<int>(ary::cpp::CONVOL_volatile) );
}

void
PE_Function::On_afterParameters_throw(const char *)
{
    SetTokenResult(done,stay);
    pStati->SetCur(afterThrow);
    bThrow = true;
}

void
PE_Function::On_afterParameters_SwBracket_Left(const char *)
{
    EnterImplementation(1);
}

void
PE_Function::On_afterParameters_Semicolon(const char *)
{
    PerformFinishingPunctuation();
}

void
PE_Function::On_afterParameters_Comma(const char *)
{
    PerformFinishingPunctuation();
}

void
PE_Function::On_afterParameters_Colon(const char *)
{
    EnterImplementation(0);
}

void
PE_Function::On_afterParameters_Assign(const char *)
{
    SetTokenResult(done,stay);
    pStati->SetCur(expectZero);
}

void
PE_Function::On_afterThrow_Bracket_Left(const char *)
{
    pSpuException->Push(done);
}

void
PE_Function::On_expectExceptionSeparator_BracketRight(const char *)
{
    SetTokenResult(done,stay);
    pStati->SetCur(afterExceptions);
}

void
PE_Function::On_expectExceptionSeparator_Comma(const char *)
{
    pSpuException->Push(done);
}

void
PE_Function::On_afterExceptions_SwBracket_Left(const char *)
{
    EnterImplementation(1);
}

void
PE_Function::On_afterExceptions_Semicolon(const char *)
{
    PerformFinishingPunctuation();
}

void
PE_Function::On_afterExceptions_Comma(const char *)
{
    PerformFinishingPunctuation();
}

void
PE_Function::On_afterExceptions_Colon(const char *)
{
    EnterImplementation(0);
}

void
PE_Function::On_afterExceptions_Assign(const char *)
{
    SetTokenResult(done,stay);
    pStati->SetCur(expectZero);
}

void
PE_Function::On_expectZero_Constant(const char * i_sText)
{
    if ( strcmp(i_sText,"0") != 0 )
        Hdl_SyntaxError(i_sText);

    SetTokenResult(done,stay);
    pStati->SetCur(afterExceptions);

    eVirtuality = ary::cpp::VIRTUAL_abstract;
}

void
PE_Function::On_inImplementation_SwBracket_Left(const char *)
{
    SetTokenResult(done,stay);
    nBracketCounterInImplementation++;
}

void
PE_Function::On_inImplementation_SwBracket_Right(const char *)
{
    nBracketCounterInImplementation--;
    if (nBracketCounterInImplementation == 0)
    {
        SetTokenResult(done,pop_success);
    }
    else
    {
        SetTokenResult(done,stay);
    }
}

void
PE_Function::On_inImplementation_Default(const char *)
{
    SetTokenResult(done,stay);
}

void
PE_Function::EnterImplementation( intt i_nBracketCountStart )
{
    SetTokenResult(done,stay);
    pStati->SetCur(inImplementation);

    bResult_WithImplementation = true;
    nBracketCounterInImplementation = i_nBracketCountStart;
    if ( Env().Context().CurClass() != 0 )
    {
        aFlags.SetInline();
    }
}



}   // namespace cpp