xref: /trunk/main/autodoc/source/parser/cpp/pe_vafu.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_vafu.hxx"


// NOT FULLY DEFINED SERVICES
#include <cosv/tpl/tpltools.hxx>
#include <ary/cpp/c_gate.hxx>
#include <ary/cpp/c_class.hxx>
#include <ary/cpp/c_vari.hxx>
#include <ary/cpp/c_vfflag.hxx>
#include <ary/cpp/cp_ce.hxx>
#include <ary/cpp/inpcontx.hxx>
#include "pe_type.hxx"
#include "pe_vari.hxx"
#include "pe_funct.hxx"
#include "pe_ignor.hxx"
#include <x_parse.hxx>




namespace cpp {



//***********************       PE_VarFunc      ***********************//


PE_VarFunc::PE_VarFunc( Cpp_PE * i_pParent )
    :   Cpp_PE(i_pParent),
        pStati( new PeStatusArray<PE_VarFunc> ),
        // pSpType,
        // pSpuType,
        // pSpVariable,
        // pSpuVariable,
        // pSpFunction,
        // pSpuFunctionStd,
        // pSpuFunctionCtor,
        // pSpuFunctionDtor,
        // pSpuFunctionCastOperator,
        // pSpuFunctionNormalOperator
        // pSpIgnore,
        // pSpuIgnore,
        nCounter_TemplateBrackets(0),
        bInDestructor(false),
        // aResultIds,
        nResultFrontType(0),
        eResultType(result_unknown),
        bVirtual(false),
        bStatic(false),
        bExtern(false),
        bExternC(false),
        bMutable(false),
        bInline(false),
        bRegister(false),
        bExplicit(false)
{
    Setup_StatusFunctions();

    pSpType             = new SP_Type(*this);
    pSpuType            = new SPU_Type(*pSpType, 0, &PE_VarFunc::SpReturn_Type);
    pSpVariable         = new SP_Variable(*this);
    pSpuVariable        = new SPU_Variable(*pSpVariable, 0, &PE_VarFunc::SpReturn_Variable);
    pSpFunction         = new SP_Function(*this);
    pSpuFunctionStd     = new SPU_Function(*pSpFunction, &PE_VarFunc::SpInit_FunctionStd, &PE_VarFunc::SpReturn_FunctionStd);
    pSpuFunctionCtor    = new SPU_Function(*pSpFunction, &PE_VarFunc::SpInit_FunctionCtor, &PE_VarFunc::SpReturn_FunctionStd);
    pSpuFunctionDtor    = new SPU_Function(*pSpFunction, &PE_VarFunc::SpInit_FunctionDtor, &PE_VarFunc::SpReturn_FunctionStd);
    pSpuFunctionCastOperator
                        = new SPU_Function(*pSpFunction, &PE_VarFunc::SpInit_FunctionCastOperator, &PE_VarFunc::SpReturn_FunctionStd);
    pSpuFunctionNormalOperator
                        = new SPU_Function(*pSpFunction, &PE_VarFunc::SpInit_FunctionNormalOperator, &PE_VarFunc::SpReturn_FunctionStd);
    pSpIgnore           = new SP_Ignore(*this);
    pSpuIgnore          = new SPU_Ignore(*pSpIgnore, 0, &PE_VarFunc::SpReturn_Ignore);
}

PE_VarFunc::~PE_VarFunc()
{
}

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

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

    static F_Tok stateF_start[] =           { &PE_VarFunc::On_start_Identifier,
                                              &PE_VarFunc::On_start_operator,
                                              &PE_VarFunc::On_start_TypeKey,
                                              &PE_VarFunc::On_start_TypeKey,
                                              &PE_VarFunc::On_start_TypeKey,
                                              &PE_VarFunc::On_start_TypeKey,
                                              &PE_VarFunc::On_start_virtual,
                                              &PE_VarFunc::On_start_Tilde,
                                              &PE_VarFunc::On_start_const,
                                              &PE_VarFunc::On_start_volatile,
                                              &PE_VarFunc::On_start_extern,
                                              &PE_VarFunc::On_start_static,
                                              &PE_VarFunc::On_start_mutable,
                                              &PE_VarFunc::On_start_register,
                                              &PE_VarFunc::On_start_inline,
                                              &PE_VarFunc::On_start_explicit,
                                              &PE_VarFunc::On_start_Bracket_Right,
                                              &PE_VarFunc::On_start_Identifier,
                                              &PE_VarFunc::On_start_typename,
                                              &PE_VarFunc::On_start_Identifier,
                                              &PE_VarFunc::On_start_Identifier };
    static INT16 stateT_start[] =           { Tid_Identifier,
                                              Tid_operator,
                                              Tid_class,
                                              Tid_struct,
                                              Tid_union,
                                              Tid_enum,
                                              Tid_virtual,
                                              Tid_Tilde,
                                              Tid_const,
                                              Tid_volatile,
                                              Tid_extern,
                                              Tid_static,
                                              Tid_mutable,
                                              Tid_register,
                                              Tid_inline,
                                              Tid_explicit,
                                              Tid_Bracket_Right,
                                              Tid_DoubleColon,
                                              Tid_typename,
                                              Tid_BuiltInType,
                                              Tid_TypeSpecializer };

    static F_Tok stateF_expectCtor[] =      { &PE_VarFunc::On_expectCtor_Bracket_Left };
    static INT16 stateT_expectCtor[] =      { Tid_Bracket_Left };

    static F_Tok stateF_afterClassDecl[] =  { &PE_VarFunc::On_afterClassDecl_Semicolon };
    static INT16 stateT_afterClassDecl[] =  { Tid_Semicolon };

    static F_Tok stateF_expectName[] =      { &PE_VarFunc::On_expectName_Identifier,
                                              &PE_VarFunc::On_expectName_operator,
                                              &PE_VarFunc::On_expectName_Bracket_Left };
    static INT16 stateT_expectName[] =      { Tid_Identifier,
                                              Tid_operator,
                                              Tid_Bracket_Left };

    static F_Tok stateF_afterName[] =       { &PE_VarFunc::On_afterName_ArrayBracket_Left,
                                              &PE_VarFunc::On_afterName_Bracket_Left,
                                              &PE_VarFunc::On_afterName_DoubleColon,
                                              &PE_VarFunc::On_afterName_Semicolon,
                                              &PE_VarFunc::On_afterName_Comma,
                                              &PE_VarFunc::On_afterName_Assign,
                                              &PE_VarFunc::On_afterName_Less };
    static INT16 stateT_afterName[] =       { Tid_ArrayBracket_Left,
                                              Tid_Bracket_Left,
                                              Tid_DoubleColon,
                                              Tid_Semicolon,
                                              Tid_Comma,
                                              Tid_Assign,
                                              Tid_Less };

    static F_Tok stateF_afterName_inErraneousTemplate[] =
                                            { &PE_VarFunc::On_afterName_inErraneousTemplate_Less,
                                              &PE_VarFunc::On_afterName_inErraneousTemplate_Greater };
    static INT16 stateT_afterName_inErraneousTemplate[] =
                                            { Tid_Less,
                                              Tid_Greater };

    static F_Tok stateF_finished[] =        { &PE_VarFunc::On_finished_Semicolon,
                                              &PE_VarFunc::On_finished_Comma };
    static INT16 stateT_finished[] =        { Tid_Semicolon,
                                              Tid_Comma };

    static F_Tok stateF_finishedIncludingFunctionImplementation[] =
                                            { &PE_VarFunc::On_finishedIncludingFunctionImplementation_Default
                                            };
    static INT16 stateT_finishedIncludingFunctionImplementation[] =
                                            { Tid_BuiltInType     // Just to have one entry, but it is default handled, too.
                                            };

    SEMPARSE_CREATE_STATUS(PE_VarFunc, start, Hdl_UnknownToken);
    SEMPARSE_CREATE_STATUS(PE_VarFunc, expectCtor, Hdl_UnknownToken);
    SEMPARSE_CREATE_STATUS(PE_VarFunc, afterClassDecl, Hdl_UnknownToken);
    SEMPARSE_CREATE_STATUS(PE_VarFunc, expectName, Hdl_UnknownToken);
    SEMPARSE_CREATE_STATUS(PE_VarFunc, afterName, Hdl_UnknownToken);
    SEMPARSE_CREATE_STATUS(PE_VarFunc, afterName_inErraneousTemplate, On_afterName_inErraneousTemplate_Default);
    SEMPARSE_CREATE_STATUS(PE_VarFunc, finished, On_finished_Default);
    SEMPARSE_CREATE_STATUS(PE_VarFunc, finishedIncludingFunctionImplementation, On_finishedIncludingFunctionImplementation_Default);
}

void
PE_VarFunc::InitData()
{
    pStati->SetCur(start);
    csv::erase_container(aResultIds);

    nCounter_TemplateBrackets = 0;
    bInDestructor = false;

    nResultFrontType = 0;
    eResultType = result_unknown;
    sName.clear();
    bVirtual = ary::cpp::VIRTUAL_none;
    bStatic = false;
    bExtern = false;
    bExternC = false;
    bMutable = false;
    bInline = false;
    bRegister = false;
    bExplicit = false;
}

void
PE_VarFunc::TransferData()
{
    pStati->SetCur(size_of_states);
}

void
PE_VarFunc::Hdl_UnknownToken( const char *)
{
    pSpuIgnore->Push(not_done);
}

void
PE_VarFunc::SpInit_FunctionStd()
{
    if ( nResultFrontType.IsValid() AND sName.length() > 0 )
    {
        pSpuFunctionStd->Child().Init_Std(
                                       sName,
                                       nResultFrontType,
                                       bVirtual,
                                       CreateFunctionFlags() );
    }
    else
    {
        throw X_Parser( X_Parser::x_UnexpectedToken,
                        "",
                        Env().CurFileName(),
                        Env().LineCount() );
    }
}

void
PE_VarFunc::SpInit_FunctionCtor()
{
    ary::cpp::Class * pOwnerClass = Env().Context().CurClass();
    csv_assert( pOwnerClass != 0 );
    pSpuFunctionStd->Child().Init_Ctor( pOwnerClass->LocalName(),
                                        CreateFunctionFlags() );
}

void
PE_VarFunc::SpInit_FunctionDtor()
{
    pSpuFunctionStd->Child().Init_Dtor( sName,
                                        bVirtual,
                                        CreateFunctionFlags() );
}

void
PE_VarFunc::SpInit_FunctionCastOperator()
{
    pSpuFunctionStd->Child().Init_CastOperator( bVirtual,
                                                CreateFunctionFlags() );
}

void
PE_VarFunc::SpInit_FunctionNormalOperator()
{
    pSpuFunctionStd->Child().Init_NormalOperator( nResultFrontType,
                                                  bVirtual,
                                                  CreateFunctionFlags() );
}

void
PE_VarFunc::SpReturn_Type()
{
    switch ( pSpuType->Child().Result_KindOf() )
    {
        case PE_Type::is_type:
                            pStati->SetCur(expectName);
                            nResultFrontType
                                    = pSpuType->Child().Result_Type().Id();
                            break;
        case PE_Type::is_constructor:
                            pStati->SetCur(expectCtor);
                            eResultType = result_function;
                            break;
        case PE_Type::is_explicit_class_declaration:
        case PE_Type::is_explicit_enum_declaration:
                            pStati->SetCur(afterClassDecl);
                            eResultType = result_ignore;
                            break;
        case PE_Type::is_class_predeclaration:
                            pStati->SetCur(afterClassDecl);
                            eResultType = result_ignore;
                            break;
        default:
                            ;
    }
}

void
PE_VarFunc::SpReturn_Variable()
{
    typedef ary::cpp::VariableFlags  VarFlags;

    if ( NOT bExtern )
    {
        VarFlags aFlags( UINT16(
                           ( bStatic AND Env().Context().CurClass() == 0 ? VarFlags::f_static_local : 0 )
                         | ( bStatic AND Env().Context().CurClass() != 0 ? VarFlags::f_static_member : 0 )
                         | ( bMutable  ? VarFlags::f_mutable : 0 ) )
                       );

//      ary::S_InitData aData( 0, Env().CurCeSpace().Id(), i_sName, 0 );
        ary::cpp::Variable & rCurParsedVariable
                = Env().AryGate().Ces().Store_Variable( Env().Context(),
                                                    sName,
                                                    nResultFrontType,
                                                    aFlags,
                                                    pSpuVariable->Child().Result_SizeExpression(),
                                                    pSpuVariable->Child().Result_InitExpression() );
        Env().Event_Store_Variable(rCurParsedVariable);
        aResultIds.push_back( rCurParsedVariable.CeId() );
        eResultType = result_variable;
    }
    else if (bExtern)
    {
        eResultType = result_ignore;
    }

    pStati->SetCur(finished);
}

void
PE_VarFunc::SpReturn_FunctionStd()
{
    if ( (NOT bExtern) OR bExternC )
    {
        aResultIds.push_back(pSpuFunctionStd->Child().Result_Id());
        eResultType = result_function;
    }
    else
    {
        eResultType = result_ignore;
    }

    if ( NOT pSpuFunctionStd->Child().Result_WithImplementation() )
        pStati->SetCur(finished);
    else
        pStati->SetCur(finishedIncludingFunctionImplementation);
}

void
PE_VarFunc::SpReturn_Ignore()
{
    pStati->SetCur(finished);
}

void
PE_VarFunc::On_start_Identifier(const char *)
{
    pSpuType->Push(not_done);
}

void
PE_VarFunc::On_start_operator(const char *)
{
    pSpuFunctionCastOperator->Push(done);
}

void
PE_VarFunc::On_start_TypeKey(const char *)
{
    pSpuType->Push(not_done);
}

void
PE_VarFunc::On_start_virtual(const char *)
{
    SetTokenResult(done, stay);
    bVirtual = true;
}

void
PE_VarFunc::On_start_Tilde(const char *)
{
    SetTokenResult(done, stay);
    pStati->SetCur(expectName);

    bInDestructor = true;
}

void
PE_VarFunc::On_start_const(const char *)
{
    pSpuType->Push(not_done);
}

void
PE_VarFunc::On_start_volatile(const char *)
{
    pSpuType->Push(not_done);
}

void
PE_VarFunc::On_start_extern(const char *)
{
    SetTokenResult(done, stay);
    bExtern = true;
}

void
PE_VarFunc::On_start_static(const char *)
{
    SetTokenResult(done, stay);
    bStatic = true;
}

void
PE_VarFunc::On_start_mutable(const char *)
{
    SetTokenResult(done, stay);
    bMutable = true;
}

void
PE_VarFunc::On_start_register(const char *)
{
    SetTokenResult(done, stay);
    bRegister = true;
}

void
PE_VarFunc::On_start_inline(const char *)
{
    SetTokenResult(done, stay);

    bInline = true;
}

void
PE_VarFunc::On_start_explicit(const char *)
{
    SetTokenResult(done, stay);
    bExplicit = true;
}

void
PE_VarFunc::On_start_Bracket_Right(const char *)
{
    SetTokenResult(not_done, pop_success);
}

void
PE_VarFunc::On_start_typename(const char *)
{
    pSpuType->Push(not_done);
}

void
PE_VarFunc::On_expectCtor_Bracket_Left(const char *)
{
    pSpuFunctionCtor->Push(not_done);
}

void
PE_VarFunc::On_afterClassDecl_Semicolon(const char *)
{
    SetTokenResult(done, pop_success);
}

void
PE_VarFunc::On_expectName_Identifier(const char * i_sText)
{
    SetTokenResult(done, stay);
    pStati->SetCur(afterName);
    sName = i_sText;
}

void
PE_VarFunc::On_expectName_operator(const char *)
{
    pSpuFunctionNormalOperator->Push(done);
}

void
PE_VarFunc::On_expectName_Bracket_Left(const char *)
{
    // Function pointer declaration
    pSpuIgnore->Push(not_done);
    // TODO
}


void
PE_VarFunc::On_afterName_ArrayBracket_Left(const char *)
{
    pSpuVariable->Push(not_done);
}

void
PE_VarFunc::On_afterName_Bracket_Left(const char *)
{
    if ( NOT bInDestructor)
        pSpuFunctionStd->Push(not_done);
    else
        pSpuFunctionDtor->Push(not_done);
}

void
PE_VarFunc::On_afterName_DoubleColon(const char *)
{
    pSpuIgnore->Push(done);   // This seems to be only an implementation.

    // This may have been a template.
    // In that case, the declaration needs to be closed.
    Env().Close_OpenTemplate();
}

void
PE_VarFunc::On_afterName_Semicolon(const char *)
{
    pSpuVariable->Push(not_done);
}

void
PE_VarFunc::On_afterName_Comma(const char *)
{
    pSpuVariable->Push(not_done);
}

void
PE_VarFunc::On_afterName_Assign(const char * )
{
    pSpuVariable->Push(not_done);
}

void
PE_VarFunc::On_afterName_Less(const char * )
{
    SetTokenResult(done, stay);
    pStati->SetCur(afterName_inErraneousTemplate);

    nCounter_TemplateBrackets = 1;
}

void
PE_VarFunc::On_afterName_inErraneousTemplate_Less(const char * )
{
    SetTokenResult(done, stay);

    nCounter_TemplateBrackets++;
}

void
PE_VarFunc::On_afterName_inErraneousTemplate_Greater(const char * )
{
    SetTokenResult(done, stay);

    nCounter_TemplateBrackets--;
    if ( nCounter_TemplateBrackets == 0 )
        pStati->SetCur(afterName);
}

void
PE_VarFunc::On_afterName_inErraneousTemplate_Default(const char * )
{
    SetTokenResult(done, stay);
}

void
PE_VarFunc::On_finished_Semicolon(const char * )  // Should be Semicolon !!!
{
    SetTokenResult(done, pop_success);
}

void
PE_VarFunc::On_finished_Comma(const char * )
{
    SetTokenResult(done, stay);
    pStati->SetCur(expectName);
}

void
PE_VarFunc::On_finished_Default(const char * )
{
    SetTokenResult(not_done, pop_success);
}

void
PE_VarFunc::On_finishedIncludingFunctionImplementation_Default(const char * )
{
    SetTokenResult(not_done, pop_success);
}

ary::cpp::FunctionFlags
PE_VarFunc::CreateFunctionFlags()
{
    typedef ary::cpp::FunctionFlags  FuncFlags;

    return FuncFlags(     UINT16(
                            ( bStatic AND Env().Context().CurClass() == 0 ? FuncFlags::f_static_local : 0 )
                          | ( bStatic AND Env().Context().CurClass() != 0 ? FuncFlags::f_static_member : 0 )
                          | ( bExtern ? FuncFlags::f_extern : 0 )
                          | ( Env().IsExternC() ? FuncFlags::f_externC : 0 )
                          | ( bMutable  ? FuncFlags::f_mutable : 0 )
                          | ( bInline  ? FuncFlags::f_inline : 0 )
                          | ( bRegister  ? FuncFlags::f_register : 0 )
                          | ( bExplicit  ? FuncFlags::f_explicit : 0 ) )
                        );

}


}   // namespace cpp