/**************************************************************
*
* 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_PE_FUNCT_HXX
#define ADC_CPP_PE_FUNCT_HXX
// USED SERVICES
// BASE CLASSES
#include "cpp_pe.hxx"
// COMPONENTS
#include <semantic/callf.hxx>
#include <semantic/sub_peu.hxx>
#include <ary/cpp/c_types4cpp.hxx>
#include <ary/cpp/c_vfflag.hxx>
// PARAMETERS
namespace ary
{
namespace cpp
{
class Function;
struct S_VariableInfo;
}
}
namespace cpp
{
class PE_Type;
class PE_Parameter;
class PE_Function : public Cpp_PE
{
public:
enum E_State
{
afterStdOperator, // if initializes as operator
afterStdOperatorLeftBracket,
// if initializes as operator with ( or [
afterCastOperator, // if initializes as operator
afterName, // undecided
expectParameterSeparator, //
afterParameters, // before const, volatile throw or = 0.
afterThrow, // expect (
expectExceptionSeparator, //
afterExceptions, // = 0 oder ; oder ,
expectZero, // after '='
inImplementation, // after {
size_of_states
};
typedef ary::cpp::E_Protection E_Protection;
typedef ary::cpp::E_Virtuality E_Virtuality;
typedef ary::cpp::E_ConVol E_ConVol;
PE_Function(
Cpp_PE * i_pParent );
~PE_Function();
void Init_Std(
const String & i_sName,
ary::cpp::Type_id i_nReturnType,
bool i_bVirtual,
ary::cpp::FunctionFlags
i_aFlags );
void Init_Ctor(
const String & i_sName,
ary::cpp::FunctionFlags
i_aFlags );
void Init_Dtor(
const String & i_sName,
bool i_bVirtual,
ary::cpp::FunctionFlags
i_aFlags );
void Init_CastOperator(
bool i_bVirtual,
ary::cpp::FunctionFlags
i_aFlags );
void Init_NormalOperator(
ary::cpp::Type_id i_nReturnType,
bool i_bVirtual,
ary::cpp::FunctionFlags
i_aFlags );
ary::cpp::Ce_id Result_Id() const;
bool Result_WithImplementation() const;
virtual void Call_Handler(
const cpp::Token & i_rTok );
private:
typedef SubPe< PE_Function, PE_Type > SP_Type;
typedef SubPeUse< PE_Function, PE_Type > SPU_Type;
typedef SubPe< PE_Function, PE_Parameter> SP_Parameter;
typedef SubPeUse<PE_Function, PE_Parameter> SPU_Parameter;
typedef std::vector<ary::cpp::S_Parameter> ParameterList;
typedef std::vector<ary::cpp::Type_id> ExceptionTypeList;
void Setup_StatusFunctions();
virtual void InitData();
virtual void TransferData();
void Hdl_SyntaxError(const char * i_sText);
void SpInit_CastOperatorType();
void SpReturn_Parameter();
void SpReturn_Exception();
void SpReturn_CastOperatorType();
void On_afterOperator_Std_Operator(const char * i_sText); // Operator+() etc.
void On_afterOperator_Std_LeftBracket(const char * i_sText); // operator [] or ()
void On_afterStdOperatorLeftBracket_RightBracket(const char * i_sText);
void On_afterOperator_Cast_Type(const char * i_sText); // Type
void On_afterName_Bracket_Left(const char * i_sText);
void On_expectParameterSeparator_BracketRight(const char * i_sText);
void On_expectParameterSeparator_Comma(const char * i_sText);
void On_afterParameters_const(const char * i_sText);
void On_afterParameters_volatile(const char * i_sText);
void On_afterParameters_throw(const char * i_sText);
void On_afterParameters_SwBracket_Left(const char * i_sText);
void On_afterParameters_Semicolon(const char * i_sText);
void On_afterParameters_Comma(const char * i_sText);
void On_afterParameters_Colon(const char * i_sText);
void On_afterParameters_Assign(const char * i_sText);
void On_afterThrow_Bracket_Left(const char * i_sText);
void On_expectExceptionSeparator_BracketRight(const char * i_sText);
void On_expectExceptionSeparator_Comma(const char * i_sText);
void On_afterExceptions_SwBracket_Left(const char * i_sText);
void On_afterExceptions_Semicolon(const char * i_sText);
void On_afterExceptions_Comma(const char * i_sText);
void On_afterExceptions_Colon(const char * i_sText);
void On_afterExceptions_Assign(const char * i_sText);
void On_expectZero_Constant(const char * i_sText);
void On_inImplementation_SwBracket_Left(const char * i_sText);
void On_inImplementation_SwBracket_Right(const char * i_sText);
void On_inImplementation_Default(const char * i_sText);
void PerformFinishingPunctuation();
void EnterImplementation(
intt i_nBracketCountStart ); /// 1 normally, 0 in initialisation section of c'tors.
// DATA
Dyn< PeStatusArray<PE_Function> >
pStati;
Dyn< SP_Parameter > pSpParameter;
Dyn< SPU_Parameter> pSpuParameter;
Dyn< SP_Type > pSpType;
Dyn< SPU_Type > pSpuException;
Dyn< SPU_Type > pSpuCastOperatorType; // in "operator int()" or "operator ThatClass *()"
ary::cpp::Ce_id nResult;
bool bResult_WithImplementation; // Necessary for the parent ParseEnvironment
// to know, there is no semicolon or comma following.
// Pre results
StreamStr aName;
E_Virtuality eVirtuality;
E_ConVol eConVol;
ary::cpp::FunctionFlags
aFlags;
ary::cpp::Type_id nReturnType;
ParameterList aParameters;
ExceptionTypeList aExceptions;
bool bThrow; // Indicates, if there is a throw - important, if there are 0 exceptions listed.
intt nBracketCounterInImplementation;
};
// IMPLEMENTATION
inline bool
PE_Function::Result_WithImplementation() const
{ return bResult_WithImplementation; }
} // namespace cpp
#endif
/* // Overview of Stati
Undecided
---------
start // vor und während storage class specifiern
->Typ
expectName // Typ ist da
afterName
Variable
--------
start // vor und während storage class specifiern
->Typ
expectName // Typ ist da -> im Falle von '(': notyetimplemented
afterName
expectSize // after [
expectFinish
// vor ; oder ,
expectNextVarName // anders als bei expectName kann hier auch * oder & kommen
Function
--------
start // vor und während storage class specifiern
->Typ
expectName // Typ ist da
expectBracket // Nach Name
expectParameter // nach ( oder ,
-> Parameter
after Parameters // before const, volatile throw or = 0.
after throw // expect (
expectException // after (
after exceptions // = 0 oder ; oder ,
expectNextVarName // anders als bei expectName kann hier auch * oder & kommen
*/