/************************************************************** * * 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 #include #include #include // 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 SPU_Parameter; typedef std::vector ParameterList; typedef std::vector 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 > 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 */