diff options
Diffstat (limited to 'autodoc/source/parser/cpp/pe_funct.cxx')
-rw-r--r-- | autodoc/source/parser/cpp/pe_funct.cxx | 610 |
1 files changed, 610 insertions, 0 deletions
diff --git a/autodoc/source/parser/cpp/pe_funct.cxx b/autodoc/source/parser/cpp/pe_funct.cxx new file mode 100644 index 000000000000..14bff991cb4d --- /dev/null +++ b/autodoc/source/parser/cpp/pe_funct.cxx @@ -0,0 +1,610 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 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 + + + + + |