xref: /aoo41x/main/autodoc/source/parser/cpp/pe_vafu.cxx (revision 78bc99aa)

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