1*78bc99aaSAndrew Rist /**************************************************************
2cdf0e10cSrcweir *
3*78bc99aaSAndrew Rist * Licensed to the Apache Software Foundation (ASF) under one
4*78bc99aaSAndrew Rist * or more contributor license agreements. See the NOTICE file
5*78bc99aaSAndrew Rist * distributed with this work for additional information
6*78bc99aaSAndrew Rist * regarding copyright ownership. The ASF licenses this file
7*78bc99aaSAndrew Rist * to you under the Apache License, Version 2.0 (the
8*78bc99aaSAndrew Rist * "License"); you may not use this file except in compliance
9*78bc99aaSAndrew Rist * with the License. You may obtain a copy of the License at
10*78bc99aaSAndrew Rist *
11*78bc99aaSAndrew Rist * http://www.apache.org/licenses/LICENSE-2.0
12*78bc99aaSAndrew Rist *
13*78bc99aaSAndrew Rist * Unless required by applicable law or agreed to in writing,
14*78bc99aaSAndrew Rist * software distributed under the License is distributed on an
15*78bc99aaSAndrew Rist * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16*78bc99aaSAndrew Rist * KIND, either express or implied. See the License for the
17*78bc99aaSAndrew Rist * specific language governing permissions and limitations
18*78bc99aaSAndrew Rist * under the License.
19*78bc99aaSAndrew Rist *
20*78bc99aaSAndrew Rist *************************************************************/
21cdf0e10cSrcweir
22cdf0e10cSrcweir #include <precomp.h>
23cdf0e10cSrcweir #include "pe_vafu.hxx"
24cdf0e10cSrcweir
25cdf0e10cSrcweir
26cdf0e10cSrcweir // NOT FULLY DEFINED SERVICES
27cdf0e10cSrcweir #include <cosv/tpl/tpltools.hxx>
28cdf0e10cSrcweir #include <ary/cpp/c_gate.hxx>
29cdf0e10cSrcweir #include <ary/cpp/c_class.hxx>
30cdf0e10cSrcweir #include <ary/cpp/c_vari.hxx>
31cdf0e10cSrcweir #include <ary/cpp/c_vfflag.hxx>
32cdf0e10cSrcweir #include <ary/cpp/cp_ce.hxx>
33cdf0e10cSrcweir #include <ary/cpp/inpcontx.hxx>
34cdf0e10cSrcweir #include "pe_type.hxx"
35cdf0e10cSrcweir #include "pe_vari.hxx"
36cdf0e10cSrcweir #include "pe_funct.hxx"
37cdf0e10cSrcweir #include "pe_ignor.hxx"
38cdf0e10cSrcweir #include <x_parse.hxx>
39cdf0e10cSrcweir
40cdf0e10cSrcweir
41cdf0e10cSrcweir
42cdf0e10cSrcweir
43cdf0e10cSrcweir namespace cpp {
44cdf0e10cSrcweir
45cdf0e10cSrcweir
46cdf0e10cSrcweir
47cdf0e10cSrcweir //*********************** PE_VarFunc ***********************//
48cdf0e10cSrcweir
49cdf0e10cSrcweir
PE_VarFunc(Cpp_PE * i_pParent)50cdf0e10cSrcweir PE_VarFunc::PE_VarFunc( Cpp_PE * i_pParent )
51cdf0e10cSrcweir : Cpp_PE(i_pParent),
52cdf0e10cSrcweir pStati( new PeStatusArray<PE_VarFunc> ),
53cdf0e10cSrcweir // pSpType,
54cdf0e10cSrcweir // pSpuType,
55cdf0e10cSrcweir // pSpVariable,
56cdf0e10cSrcweir // pSpuVariable,
57cdf0e10cSrcweir // pSpFunction,
58cdf0e10cSrcweir // pSpuFunctionStd,
59cdf0e10cSrcweir // pSpuFunctionCtor,
60cdf0e10cSrcweir // pSpuFunctionDtor,
61cdf0e10cSrcweir // pSpuFunctionCastOperator,
62cdf0e10cSrcweir // pSpuFunctionNormalOperator
63cdf0e10cSrcweir // pSpIgnore,
64cdf0e10cSrcweir // pSpuIgnore,
65cdf0e10cSrcweir nCounter_TemplateBrackets(0),
66cdf0e10cSrcweir bInDestructor(false),
67cdf0e10cSrcweir // aResultIds,
68cdf0e10cSrcweir nResultFrontType(0),
69cdf0e10cSrcweir eResultType(result_unknown),
70cdf0e10cSrcweir bVirtual(false),
71cdf0e10cSrcweir bStatic(false),
72cdf0e10cSrcweir bExtern(false),
73cdf0e10cSrcweir bExternC(false),
74cdf0e10cSrcweir bMutable(false),
75cdf0e10cSrcweir bInline(false),
76cdf0e10cSrcweir bRegister(false),
77cdf0e10cSrcweir bExplicit(false)
78cdf0e10cSrcweir {
79cdf0e10cSrcweir Setup_StatusFunctions();
80cdf0e10cSrcweir
81cdf0e10cSrcweir pSpType = new SP_Type(*this);
82cdf0e10cSrcweir pSpuType = new SPU_Type(*pSpType, 0, &PE_VarFunc::SpReturn_Type);
83cdf0e10cSrcweir pSpVariable = new SP_Variable(*this);
84cdf0e10cSrcweir pSpuVariable = new SPU_Variable(*pSpVariable, 0, &PE_VarFunc::SpReturn_Variable);
85cdf0e10cSrcweir pSpFunction = new SP_Function(*this);
86cdf0e10cSrcweir pSpuFunctionStd = new SPU_Function(*pSpFunction, &PE_VarFunc::SpInit_FunctionStd, &PE_VarFunc::SpReturn_FunctionStd);
87cdf0e10cSrcweir pSpuFunctionCtor = new SPU_Function(*pSpFunction, &PE_VarFunc::SpInit_FunctionCtor, &PE_VarFunc::SpReturn_FunctionStd);
88cdf0e10cSrcweir pSpuFunctionDtor = new SPU_Function(*pSpFunction, &PE_VarFunc::SpInit_FunctionDtor, &PE_VarFunc::SpReturn_FunctionStd);
89cdf0e10cSrcweir pSpuFunctionCastOperator
90cdf0e10cSrcweir = new SPU_Function(*pSpFunction, &PE_VarFunc::SpInit_FunctionCastOperator, &PE_VarFunc::SpReturn_FunctionStd);
91cdf0e10cSrcweir pSpuFunctionNormalOperator
92cdf0e10cSrcweir = new SPU_Function(*pSpFunction, &PE_VarFunc::SpInit_FunctionNormalOperator, &PE_VarFunc::SpReturn_FunctionStd);
93cdf0e10cSrcweir pSpIgnore = new SP_Ignore(*this);
94cdf0e10cSrcweir pSpuIgnore = new SPU_Ignore(*pSpIgnore, 0, &PE_VarFunc::SpReturn_Ignore);
95cdf0e10cSrcweir }
96cdf0e10cSrcweir
~PE_VarFunc()97cdf0e10cSrcweir PE_VarFunc::~PE_VarFunc()
98cdf0e10cSrcweir {
99cdf0e10cSrcweir }
100cdf0e10cSrcweir
101cdf0e10cSrcweir void
Call_Handler(const cpp::Token & i_rTok)102cdf0e10cSrcweir PE_VarFunc::Call_Handler( const cpp::Token & i_rTok )
103cdf0e10cSrcweir {
104cdf0e10cSrcweir pStati->Cur().Call_Handler(i_rTok.TypeId(), i_rTok.Text());
105cdf0e10cSrcweir }
106cdf0e10cSrcweir
107cdf0e10cSrcweir void
Setup_StatusFunctions()108cdf0e10cSrcweir PE_VarFunc::Setup_StatusFunctions()
109cdf0e10cSrcweir {
110cdf0e10cSrcweir typedef CallFunction<PE_VarFunc>::F_Tok F_Tok;
111cdf0e10cSrcweir
112cdf0e10cSrcweir static F_Tok stateF_start[] = { &PE_VarFunc::On_start_Identifier,
113cdf0e10cSrcweir &PE_VarFunc::On_start_operator,
114cdf0e10cSrcweir &PE_VarFunc::On_start_TypeKey,
115cdf0e10cSrcweir &PE_VarFunc::On_start_TypeKey,
116cdf0e10cSrcweir &PE_VarFunc::On_start_TypeKey,
117cdf0e10cSrcweir &PE_VarFunc::On_start_TypeKey,
118cdf0e10cSrcweir &PE_VarFunc::On_start_virtual,
119cdf0e10cSrcweir &PE_VarFunc::On_start_Tilde,
120cdf0e10cSrcweir &PE_VarFunc::On_start_const,
121cdf0e10cSrcweir &PE_VarFunc::On_start_volatile,
122cdf0e10cSrcweir &PE_VarFunc::On_start_extern,
123cdf0e10cSrcweir &PE_VarFunc::On_start_static,
124cdf0e10cSrcweir &PE_VarFunc::On_start_mutable,
125cdf0e10cSrcweir &PE_VarFunc::On_start_register,
126cdf0e10cSrcweir &PE_VarFunc::On_start_inline,
127cdf0e10cSrcweir &PE_VarFunc::On_start_explicit,
128cdf0e10cSrcweir &PE_VarFunc::On_start_Bracket_Right,
129cdf0e10cSrcweir &PE_VarFunc::On_start_Identifier,
130cdf0e10cSrcweir &PE_VarFunc::On_start_typename,
131cdf0e10cSrcweir &PE_VarFunc::On_start_Identifier,
132cdf0e10cSrcweir &PE_VarFunc::On_start_Identifier };
133cdf0e10cSrcweir static INT16 stateT_start[] = { Tid_Identifier,
134cdf0e10cSrcweir Tid_operator,
135cdf0e10cSrcweir Tid_class,
136cdf0e10cSrcweir Tid_struct,
137cdf0e10cSrcweir Tid_union,
138cdf0e10cSrcweir Tid_enum,
139cdf0e10cSrcweir Tid_virtual,
140cdf0e10cSrcweir Tid_Tilde,
141cdf0e10cSrcweir Tid_const,
142cdf0e10cSrcweir Tid_volatile,
143cdf0e10cSrcweir Tid_extern,
144cdf0e10cSrcweir Tid_static,
145cdf0e10cSrcweir Tid_mutable,
146cdf0e10cSrcweir Tid_register,
147cdf0e10cSrcweir Tid_inline,
148cdf0e10cSrcweir Tid_explicit,
149cdf0e10cSrcweir Tid_Bracket_Right,
150cdf0e10cSrcweir Tid_DoubleColon,
151cdf0e10cSrcweir Tid_typename,
152cdf0e10cSrcweir Tid_BuiltInType,
153cdf0e10cSrcweir Tid_TypeSpecializer };
154cdf0e10cSrcweir
155cdf0e10cSrcweir static F_Tok stateF_expectCtor[] = { &PE_VarFunc::On_expectCtor_Bracket_Left };
156cdf0e10cSrcweir static INT16 stateT_expectCtor[] = { Tid_Bracket_Left };
157cdf0e10cSrcweir
158cdf0e10cSrcweir static F_Tok stateF_afterClassDecl[] = { &PE_VarFunc::On_afterClassDecl_Semicolon };
159cdf0e10cSrcweir static INT16 stateT_afterClassDecl[] = { Tid_Semicolon };
160cdf0e10cSrcweir
161cdf0e10cSrcweir static F_Tok stateF_expectName[] = { &PE_VarFunc::On_expectName_Identifier,
162cdf0e10cSrcweir &PE_VarFunc::On_expectName_operator,
163cdf0e10cSrcweir &PE_VarFunc::On_expectName_Bracket_Left };
164cdf0e10cSrcweir static INT16 stateT_expectName[] = { Tid_Identifier,
165cdf0e10cSrcweir Tid_operator,
166cdf0e10cSrcweir Tid_Bracket_Left };
167cdf0e10cSrcweir
168cdf0e10cSrcweir static F_Tok stateF_afterName[] = { &PE_VarFunc::On_afterName_ArrayBracket_Left,
169cdf0e10cSrcweir &PE_VarFunc::On_afterName_Bracket_Left,
170cdf0e10cSrcweir &PE_VarFunc::On_afterName_DoubleColon,
171cdf0e10cSrcweir &PE_VarFunc::On_afterName_Semicolon,
172cdf0e10cSrcweir &PE_VarFunc::On_afterName_Comma,
173cdf0e10cSrcweir &PE_VarFunc::On_afterName_Assign,
174cdf0e10cSrcweir &PE_VarFunc::On_afterName_Less };
175cdf0e10cSrcweir static INT16 stateT_afterName[] = { Tid_ArrayBracket_Left,
176cdf0e10cSrcweir Tid_Bracket_Left,
177cdf0e10cSrcweir Tid_DoubleColon,
178cdf0e10cSrcweir Tid_Semicolon,
179cdf0e10cSrcweir Tid_Comma,
180cdf0e10cSrcweir Tid_Assign,
181cdf0e10cSrcweir Tid_Less };
182cdf0e10cSrcweir
183cdf0e10cSrcweir static F_Tok stateF_afterName_inErraneousTemplate[] =
184cdf0e10cSrcweir { &PE_VarFunc::On_afterName_inErraneousTemplate_Less,
185cdf0e10cSrcweir &PE_VarFunc::On_afterName_inErraneousTemplate_Greater };
186cdf0e10cSrcweir static INT16 stateT_afterName_inErraneousTemplate[] =
187cdf0e10cSrcweir { Tid_Less,
188cdf0e10cSrcweir Tid_Greater };
189cdf0e10cSrcweir
190cdf0e10cSrcweir static F_Tok stateF_finished[] = { &PE_VarFunc::On_finished_Semicolon,
191cdf0e10cSrcweir &PE_VarFunc::On_finished_Comma };
192cdf0e10cSrcweir static INT16 stateT_finished[] = { Tid_Semicolon,
193cdf0e10cSrcweir Tid_Comma };
194cdf0e10cSrcweir
195cdf0e10cSrcweir static F_Tok stateF_finishedIncludingFunctionImplementation[] =
196cdf0e10cSrcweir { &PE_VarFunc::On_finishedIncludingFunctionImplementation_Default
197cdf0e10cSrcweir };
198cdf0e10cSrcweir static INT16 stateT_finishedIncludingFunctionImplementation[] =
199cdf0e10cSrcweir { Tid_BuiltInType // Just to have one entry, but it is default handled, too.
200cdf0e10cSrcweir };
201cdf0e10cSrcweir
202cdf0e10cSrcweir SEMPARSE_CREATE_STATUS(PE_VarFunc, start, Hdl_UnknownToken);
203cdf0e10cSrcweir SEMPARSE_CREATE_STATUS(PE_VarFunc, expectCtor, Hdl_UnknownToken);
204cdf0e10cSrcweir SEMPARSE_CREATE_STATUS(PE_VarFunc, afterClassDecl, Hdl_UnknownToken);
205cdf0e10cSrcweir SEMPARSE_CREATE_STATUS(PE_VarFunc, expectName, Hdl_UnknownToken);
206cdf0e10cSrcweir SEMPARSE_CREATE_STATUS(PE_VarFunc, afterName, Hdl_UnknownToken);
207cdf0e10cSrcweir SEMPARSE_CREATE_STATUS(PE_VarFunc, afterName_inErraneousTemplate, On_afterName_inErraneousTemplate_Default);
208cdf0e10cSrcweir SEMPARSE_CREATE_STATUS(PE_VarFunc, finished, On_finished_Default);
209cdf0e10cSrcweir SEMPARSE_CREATE_STATUS(PE_VarFunc, finishedIncludingFunctionImplementation, On_finishedIncludingFunctionImplementation_Default);
210cdf0e10cSrcweir }
211cdf0e10cSrcweir
212cdf0e10cSrcweir void
InitData()213cdf0e10cSrcweir PE_VarFunc::InitData()
214cdf0e10cSrcweir {
215cdf0e10cSrcweir pStati->SetCur(start);
216cdf0e10cSrcweir csv::erase_container(aResultIds);
217cdf0e10cSrcweir
218cdf0e10cSrcweir nCounter_TemplateBrackets = 0;
219cdf0e10cSrcweir bInDestructor = false;
220cdf0e10cSrcweir
221cdf0e10cSrcweir nResultFrontType = 0;
222cdf0e10cSrcweir eResultType = result_unknown;
223cdf0e10cSrcweir sName.clear();
224cdf0e10cSrcweir bVirtual = ary::cpp::VIRTUAL_none;
225cdf0e10cSrcweir bStatic = false;
226cdf0e10cSrcweir bExtern = false;
227cdf0e10cSrcweir bExternC = false;
228cdf0e10cSrcweir bMutable = false;
229cdf0e10cSrcweir bInline = false;
230cdf0e10cSrcweir bRegister = false;
231cdf0e10cSrcweir bExplicit = false;
232cdf0e10cSrcweir }
233cdf0e10cSrcweir
234cdf0e10cSrcweir void
TransferData()235cdf0e10cSrcweir PE_VarFunc::TransferData()
236cdf0e10cSrcweir {
237cdf0e10cSrcweir pStati->SetCur(size_of_states);
238cdf0e10cSrcweir }
239cdf0e10cSrcweir
240cdf0e10cSrcweir void
Hdl_UnknownToken(const char *)241cdf0e10cSrcweir PE_VarFunc::Hdl_UnknownToken( const char *)
242cdf0e10cSrcweir {
243cdf0e10cSrcweir pSpuIgnore->Push(not_done);
244cdf0e10cSrcweir }
245cdf0e10cSrcweir
246cdf0e10cSrcweir void
SpInit_FunctionStd()247cdf0e10cSrcweir PE_VarFunc::SpInit_FunctionStd()
248cdf0e10cSrcweir {
249cdf0e10cSrcweir if ( nResultFrontType.IsValid() AND sName.length() > 0 )
250cdf0e10cSrcweir {
251cdf0e10cSrcweir pSpuFunctionStd->Child().Init_Std(
252cdf0e10cSrcweir sName,
253cdf0e10cSrcweir nResultFrontType,
254cdf0e10cSrcweir bVirtual,
255cdf0e10cSrcweir CreateFunctionFlags() );
256cdf0e10cSrcweir }
257cdf0e10cSrcweir else
258cdf0e10cSrcweir {
259cdf0e10cSrcweir throw X_Parser( X_Parser::x_UnexpectedToken,
260cdf0e10cSrcweir "",
261cdf0e10cSrcweir Env().CurFileName(),
262cdf0e10cSrcweir Env().LineCount() );
263cdf0e10cSrcweir }
264cdf0e10cSrcweir }
265cdf0e10cSrcweir
266cdf0e10cSrcweir void
SpInit_FunctionCtor()267cdf0e10cSrcweir PE_VarFunc::SpInit_FunctionCtor()
268cdf0e10cSrcweir {
269cdf0e10cSrcweir ary::cpp::Class * pOwnerClass = Env().Context().CurClass();
270cdf0e10cSrcweir csv_assert( pOwnerClass != 0 );
271cdf0e10cSrcweir pSpuFunctionStd->Child().Init_Ctor( pOwnerClass->LocalName(),
272cdf0e10cSrcweir CreateFunctionFlags() );
273cdf0e10cSrcweir }
274cdf0e10cSrcweir
275cdf0e10cSrcweir void
SpInit_FunctionDtor()276cdf0e10cSrcweir PE_VarFunc::SpInit_FunctionDtor()
277cdf0e10cSrcweir {
278cdf0e10cSrcweir pSpuFunctionStd->Child().Init_Dtor( sName,
279cdf0e10cSrcweir bVirtual,
280cdf0e10cSrcweir CreateFunctionFlags() );
281cdf0e10cSrcweir }
282cdf0e10cSrcweir
283cdf0e10cSrcweir void
SpInit_FunctionCastOperator()284cdf0e10cSrcweir PE_VarFunc::SpInit_FunctionCastOperator()
285cdf0e10cSrcweir {
286cdf0e10cSrcweir pSpuFunctionStd->Child().Init_CastOperator( bVirtual,
287cdf0e10cSrcweir CreateFunctionFlags() );
288cdf0e10cSrcweir }
289cdf0e10cSrcweir
290cdf0e10cSrcweir void
SpInit_FunctionNormalOperator()291cdf0e10cSrcweir PE_VarFunc::SpInit_FunctionNormalOperator()
292cdf0e10cSrcweir {
293cdf0e10cSrcweir pSpuFunctionStd->Child().Init_NormalOperator( nResultFrontType,
294cdf0e10cSrcweir bVirtual,
295cdf0e10cSrcweir CreateFunctionFlags() );
296cdf0e10cSrcweir }
297cdf0e10cSrcweir
298cdf0e10cSrcweir void
SpReturn_Type()299cdf0e10cSrcweir PE_VarFunc::SpReturn_Type()
300cdf0e10cSrcweir {
301cdf0e10cSrcweir switch ( pSpuType->Child().Result_KindOf() )
302cdf0e10cSrcweir {
303cdf0e10cSrcweir case PE_Type::is_type:
304cdf0e10cSrcweir pStati->SetCur(expectName);
305cdf0e10cSrcweir nResultFrontType
306cdf0e10cSrcweir = pSpuType->Child().Result_Type().Id();
307cdf0e10cSrcweir break;
308cdf0e10cSrcweir case PE_Type::is_constructor:
309cdf0e10cSrcweir pStati->SetCur(expectCtor);
310cdf0e10cSrcweir eResultType = result_function;
311cdf0e10cSrcweir break;
312cdf0e10cSrcweir case PE_Type::is_explicit_class_declaration:
313cdf0e10cSrcweir case PE_Type::is_explicit_enum_declaration:
314cdf0e10cSrcweir pStati->SetCur(afterClassDecl);
315cdf0e10cSrcweir eResultType = result_ignore;
316cdf0e10cSrcweir break;
317cdf0e10cSrcweir case PE_Type::is_class_predeclaration:
318cdf0e10cSrcweir pStati->SetCur(afterClassDecl);
319cdf0e10cSrcweir eResultType = result_ignore;
320cdf0e10cSrcweir break;
321cdf0e10cSrcweir default:
322cdf0e10cSrcweir ;
323cdf0e10cSrcweir }
324cdf0e10cSrcweir }
325cdf0e10cSrcweir
326cdf0e10cSrcweir void
SpReturn_Variable()327cdf0e10cSrcweir PE_VarFunc::SpReturn_Variable()
328cdf0e10cSrcweir {
329cdf0e10cSrcweir typedef ary::cpp::VariableFlags VarFlags;
330cdf0e10cSrcweir
331cdf0e10cSrcweir if ( NOT bExtern )
332cdf0e10cSrcweir {
333cdf0e10cSrcweir VarFlags aFlags( UINT16(
334cdf0e10cSrcweir ( bStatic AND Env().Context().CurClass() == 0 ? VarFlags::f_static_local : 0 )
335cdf0e10cSrcweir | ( bStatic AND Env().Context().CurClass() != 0 ? VarFlags::f_static_member : 0 )
336cdf0e10cSrcweir | ( bMutable ? VarFlags::f_mutable : 0 ) )
337cdf0e10cSrcweir );
338cdf0e10cSrcweir
339cdf0e10cSrcweir // ary::S_InitData aData( 0, Env().CurCeSpace().Id(), i_sName, 0 );
340cdf0e10cSrcweir ary::cpp::Variable & rCurParsedVariable
341cdf0e10cSrcweir = Env().AryGate().Ces().Store_Variable( Env().Context(),
342cdf0e10cSrcweir sName,
343cdf0e10cSrcweir nResultFrontType,
344cdf0e10cSrcweir aFlags,
345cdf0e10cSrcweir pSpuVariable->Child().Result_SizeExpression(),
346cdf0e10cSrcweir pSpuVariable->Child().Result_InitExpression() );
347cdf0e10cSrcweir Env().Event_Store_Variable(rCurParsedVariable);
348cdf0e10cSrcweir aResultIds.push_back( rCurParsedVariable.CeId() );
349cdf0e10cSrcweir eResultType = result_variable;
350cdf0e10cSrcweir }
351cdf0e10cSrcweir else if (bExtern)
352cdf0e10cSrcweir {
353cdf0e10cSrcweir eResultType = result_ignore;
354cdf0e10cSrcweir }
355cdf0e10cSrcweir
356cdf0e10cSrcweir pStati->SetCur(finished);
357cdf0e10cSrcweir }
358cdf0e10cSrcweir
359cdf0e10cSrcweir void
SpReturn_FunctionStd()360cdf0e10cSrcweir PE_VarFunc::SpReturn_FunctionStd()
361cdf0e10cSrcweir {
362cdf0e10cSrcweir if ( (NOT bExtern) OR bExternC )
363cdf0e10cSrcweir {
364cdf0e10cSrcweir aResultIds.push_back(pSpuFunctionStd->Child().Result_Id());
365cdf0e10cSrcweir eResultType = result_function;
366cdf0e10cSrcweir }
367cdf0e10cSrcweir else
368cdf0e10cSrcweir {
369cdf0e10cSrcweir eResultType = result_ignore;
370cdf0e10cSrcweir }
371cdf0e10cSrcweir
372cdf0e10cSrcweir if ( NOT pSpuFunctionStd->Child().Result_WithImplementation() )
373cdf0e10cSrcweir pStati->SetCur(finished);
374cdf0e10cSrcweir else
375cdf0e10cSrcweir pStati->SetCur(finishedIncludingFunctionImplementation);
376cdf0e10cSrcweir }
377cdf0e10cSrcweir
378cdf0e10cSrcweir void
SpReturn_Ignore()379cdf0e10cSrcweir PE_VarFunc::SpReturn_Ignore()
380cdf0e10cSrcweir {
381cdf0e10cSrcweir pStati->SetCur(finished);
382cdf0e10cSrcweir }
383cdf0e10cSrcweir
384cdf0e10cSrcweir void
On_start_Identifier(const char *)385cdf0e10cSrcweir PE_VarFunc::On_start_Identifier(const char *)
386cdf0e10cSrcweir {
387cdf0e10cSrcweir pSpuType->Push(not_done);
388cdf0e10cSrcweir }
389cdf0e10cSrcweir
390cdf0e10cSrcweir void
On_start_operator(const char *)391cdf0e10cSrcweir PE_VarFunc::On_start_operator(const char *)
392cdf0e10cSrcweir {
393cdf0e10cSrcweir pSpuFunctionCastOperator->Push(done);
394cdf0e10cSrcweir }
395cdf0e10cSrcweir
396cdf0e10cSrcweir void
On_start_TypeKey(const char *)397cdf0e10cSrcweir PE_VarFunc::On_start_TypeKey(const char *)
398cdf0e10cSrcweir {
399cdf0e10cSrcweir pSpuType->Push(not_done);
400cdf0e10cSrcweir }
401cdf0e10cSrcweir
402cdf0e10cSrcweir void
On_start_virtual(const char *)403cdf0e10cSrcweir PE_VarFunc::On_start_virtual(const char *)
404cdf0e10cSrcweir {
405cdf0e10cSrcweir SetTokenResult(done, stay);
406cdf0e10cSrcweir bVirtual = true;
407cdf0e10cSrcweir }
408cdf0e10cSrcweir
409cdf0e10cSrcweir void
On_start_Tilde(const char *)410cdf0e10cSrcweir PE_VarFunc::On_start_Tilde(const char *)
411cdf0e10cSrcweir {
412cdf0e10cSrcweir SetTokenResult(done, stay);
413cdf0e10cSrcweir pStati->SetCur(expectName);
414cdf0e10cSrcweir
415cdf0e10cSrcweir bInDestructor = true;
416cdf0e10cSrcweir }
417cdf0e10cSrcweir
418cdf0e10cSrcweir void
On_start_const(const char *)419cdf0e10cSrcweir PE_VarFunc::On_start_const(const char *)
420cdf0e10cSrcweir {
421cdf0e10cSrcweir pSpuType->Push(not_done);
422cdf0e10cSrcweir }
423cdf0e10cSrcweir
424cdf0e10cSrcweir void
On_start_volatile(const char *)425cdf0e10cSrcweir PE_VarFunc::On_start_volatile(const char *)
426cdf0e10cSrcweir {
427cdf0e10cSrcweir pSpuType->Push(not_done);
428cdf0e10cSrcweir }
429cdf0e10cSrcweir
430cdf0e10cSrcweir void
On_start_extern(const char *)431cdf0e10cSrcweir PE_VarFunc::On_start_extern(const char *)
432cdf0e10cSrcweir {
433cdf0e10cSrcweir SetTokenResult(done, stay);
434cdf0e10cSrcweir bExtern = true;
435cdf0e10cSrcweir }
436cdf0e10cSrcweir
437cdf0e10cSrcweir void
On_start_static(const char *)438cdf0e10cSrcweir PE_VarFunc::On_start_static(const char *)
439cdf0e10cSrcweir {
440cdf0e10cSrcweir SetTokenResult(done, stay);
441cdf0e10cSrcweir bStatic = true;
442cdf0e10cSrcweir }
443cdf0e10cSrcweir
444cdf0e10cSrcweir void
On_start_mutable(const char *)445cdf0e10cSrcweir PE_VarFunc::On_start_mutable(const char *)
446cdf0e10cSrcweir {
447cdf0e10cSrcweir SetTokenResult(done, stay);
448cdf0e10cSrcweir bMutable = true;
449cdf0e10cSrcweir }
450cdf0e10cSrcweir
451cdf0e10cSrcweir void
On_start_register(const char *)452cdf0e10cSrcweir PE_VarFunc::On_start_register(const char *)
453cdf0e10cSrcweir {
454cdf0e10cSrcweir SetTokenResult(done, stay);
455cdf0e10cSrcweir bRegister = true;
456cdf0e10cSrcweir }
457cdf0e10cSrcweir
458cdf0e10cSrcweir void
On_start_inline(const char *)459cdf0e10cSrcweir PE_VarFunc::On_start_inline(const char *)
460cdf0e10cSrcweir {
461cdf0e10cSrcweir SetTokenResult(done, stay);
462cdf0e10cSrcweir
463cdf0e10cSrcweir bInline = true;
464cdf0e10cSrcweir }
465cdf0e10cSrcweir
466cdf0e10cSrcweir void
On_start_explicit(const char *)467cdf0e10cSrcweir PE_VarFunc::On_start_explicit(const char *)
468cdf0e10cSrcweir {
469cdf0e10cSrcweir SetTokenResult(done, stay);
470cdf0e10cSrcweir bExplicit = true;
471cdf0e10cSrcweir }
472cdf0e10cSrcweir
473cdf0e10cSrcweir void
On_start_Bracket_Right(const char *)474cdf0e10cSrcweir PE_VarFunc::On_start_Bracket_Right(const char *)
475cdf0e10cSrcweir {
476cdf0e10cSrcweir SetTokenResult(not_done, pop_success);
477cdf0e10cSrcweir }
478cdf0e10cSrcweir
479cdf0e10cSrcweir void
On_start_typename(const char *)480cdf0e10cSrcweir PE_VarFunc::On_start_typename(const char *)
481cdf0e10cSrcweir {
482cdf0e10cSrcweir pSpuType->Push(not_done);
483cdf0e10cSrcweir }
484cdf0e10cSrcweir
485cdf0e10cSrcweir void
On_expectCtor_Bracket_Left(const char *)486cdf0e10cSrcweir PE_VarFunc::On_expectCtor_Bracket_Left(const char *)
487cdf0e10cSrcweir {
488cdf0e10cSrcweir pSpuFunctionCtor->Push(not_done);
489cdf0e10cSrcweir }
490cdf0e10cSrcweir
491cdf0e10cSrcweir void
On_afterClassDecl_Semicolon(const char *)492cdf0e10cSrcweir PE_VarFunc::On_afterClassDecl_Semicolon(const char *)
493cdf0e10cSrcweir {
494cdf0e10cSrcweir SetTokenResult(done, pop_success);
495cdf0e10cSrcweir }
496cdf0e10cSrcweir
497cdf0e10cSrcweir void
On_expectName_Identifier(const char * i_sText)498cdf0e10cSrcweir PE_VarFunc::On_expectName_Identifier(const char * i_sText)
499cdf0e10cSrcweir {
500cdf0e10cSrcweir SetTokenResult(done, stay);
501cdf0e10cSrcweir pStati->SetCur(afterName);
502cdf0e10cSrcweir sName = i_sText;
503cdf0e10cSrcweir }
504cdf0e10cSrcweir
505cdf0e10cSrcweir void
On_expectName_operator(const char *)506cdf0e10cSrcweir PE_VarFunc::On_expectName_operator(const char *)
507cdf0e10cSrcweir {
508cdf0e10cSrcweir pSpuFunctionNormalOperator->Push(done);
509cdf0e10cSrcweir }
510cdf0e10cSrcweir
511cdf0e10cSrcweir void
On_expectName_Bracket_Left(const char *)512cdf0e10cSrcweir PE_VarFunc::On_expectName_Bracket_Left(const char *)
513cdf0e10cSrcweir {
514cdf0e10cSrcweir // Function pointer declaration
515cdf0e10cSrcweir pSpuIgnore->Push(not_done);
516cdf0e10cSrcweir // TODO
517cdf0e10cSrcweir }
518cdf0e10cSrcweir
519cdf0e10cSrcweir
520cdf0e10cSrcweir void
On_afterName_ArrayBracket_Left(const char *)521cdf0e10cSrcweir PE_VarFunc::On_afterName_ArrayBracket_Left(const char *)
522cdf0e10cSrcweir {
523cdf0e10cSrcweir pSpuVariable->Push(not_done);
524cdf0e10cSrcweir }
525cdf0e10cSrcweir
526cdf0e10cSrcweir void
On_afterName_Bracket_Left(const char *)527cdf0e10cSrcweir PE_VarFunc::On_afterName_Bracket_Left(const char *)
528cdf0e10cSrcweir {
529cdf0e10cSrcweir if ( NOT bInDestructor)
530cdf0e10cSrcweir pSpuFunctionStd->Push(not_done);
531cdf0e10cSrcweir else
532cdf0e10cSrcweir pSpuFunctionDtor->Push(not_done);
533cdf0e10cSrcweir }
534cdf0e10cSrcweir
535cdf0e10cSrcweir void
On_afterName_DoubleColon(const char *)536cdf0e10cSrcweir PE_VarFunc::On_afterName_DoubleColon(const char *)
537cdf0e10cSrcweir {
538cdf0e10cSrcweir pSpuIgnore->Push(done); // This seems to be only an implementation.
539cdf0e10cSrcweir
540cdf0e10cSrcweir // This may have been a template.
541cdf0e10cSrcweir // In that case, the declaration needs to be closed.
542cdf0e10cSrcweir Env().Close_OpenTemplate();
543cdf0e10cSrcweir }
544cdf0e10cSrcweir
545cdf0e10cSrcweir void
On_afterName_Semicolon(const char *)546cdf0e10cSrcweir PE_VarFunc::On_afterName_Semicolon(const char *)
547cdf0e10cSrcweir {
548cdf0e10cSrcweir pSpuVariable->Push(not_done);
549cdf0e10cSrcweir }
550cdf0e10cSrcweir
551cdf0e10cSrcweir void
On_afterName_Comma(const char *)552cdf0e10cSrcweir PE_VarFunc::On_afterName_Comma(const char *)
553cdf0e10cSrcweir {
554cdf0e10cSrcweir pSpuVariable->Push(not_done);
555cdf0e10cSrcweir }
556cdf0e10cSrcweir
557cdf0e10cSrcweir void
On_afterName_Assign(const char *)558cdf0e10cSrcweir PE_VarFunc::On_afterName_Assign(const char * )
559cdf0e10cSrcweir {
560cdf0e10cSrcweir pSpuVariable->Push(not_done);
561cdf0e10cSrcweir }
562cdf0e10cSrcweir
563cdf0e10cSrcweir void
On_afterName_Less(const char *)564cdf0e10cSrcweir PE_VarFunc::On_afterName_Less(const char * )
565cdf0e10cSrcweir {
566cdf0e10cSrcweir SetTokenResult(done, stay);
567cdf0e10cSrcweir pStati->SetCur(afterName_inErraneousTemplate);
568cdf0e10cSrcweir
569cdf0e10cSrcweir nCounter_TemplateBrackets = 1;
570cdf0e10cSrcweir }
571cdf0e10cSrcweir
572cdf0e10cSrcweir void
On_afterName_inErraneousTemplate_Less(const char *)573cdf0e10cSrcweir PE_VarFunc::On_afterName_inErraneousTemplate_Less(const char * )
574cdf0e10cSrcweir {
575cdf0e10cSrcweir SetTokenResult(done, stay);
576cdf0e10cSrcweir
577cdf0e10cSrcweir nCounter_TemplateBrackets++;
578cdf0e10cSrcweir }
579cdf0e10cSrcweir
580cdf0e10cSrcweir void
On_afterName_inErraneousTemplate_Greater(const char *)581cdf0e10cSrcweir PE_VarFunc::On_afterName_inErraneousTemplate_Greater(const char * )
582cdf0e10cSrcweir {
583cdf0e10cSrcweir SetTokenResult(done, stay);
584cdf0e10cSrcweir
585cdf0e10cSrcweir nCounter_TemplateBrackets--;
586cdf0e10cSrcweir if ( nCounter_TemplateBrackets == 0 )
587cdf0e10cSrcweir pStati->SetCur(afterName);
588cdf0e10cSrcweir }
589cdf0e10cSrcweir
590cdf0e10cSrcweir void
On_afterName_inErraneousTemplate_Default(const char *)591cdf0e10cSrcweir PE_VarFunc::On_afterName_inErraneousTemplate_Default(const char * )
592cdf0e10cSrcweir {
593cdf0e10cSrcweir SetTokenResult(done, stay);
594cdf0e10cSrcweir }
595cdf0e10cSrcweir
596cdf0e10cSrcweir void
On_finished_Semicolon(const char *)597cdf0e10cSrcweir PE_VarFunc::On_finished_Semicolon(const char * ) // Should be Semicolon !!!
598cdf0e10cSrcweir {
599cdf0e10cSrcweir SetTokenResult(done, pop_success);
600cdf0e10cSrcweir }
601cdf0e10cSrcweir
602cdf0e10cSrcweir void
On_finished_Comma(const char *)603cdf0e10cSrcweir PE_VarFunc::On_finished_Comma(const char * )
604cdf0e10cSrcweir {
605cdf0e10cSrcweir SetTokenResult(done, stay);
606cdf0e10cSrcweir pStati->SetCur(expectName);
607cdf0e10cSrcweir }
608cdf0e10cSrcweir
609cdf0e10cSrcweir void
On_finished_Default(const char *)610cdf0e10cSrcweir PE_VarFunc::On_finished_Default(const char * )
611cdf0e10cSrcweir {
612cdf0e10cSrcweir SetTokenResult(not_done, pop_success);
613cdf0e10cSrcweir }
614cdf0e10cSrcweir
615cdf0e10cSrcweir void
On_finishedIncludingFunctionImplementation_Default(const char *)616cdf0e10cSrcweir PE_VarFunc::On_finishedIncludingFunctionImplementation_Default(const char * )
617cdf0e10cSrcweir {
618cdf0e10cSrcweir SetTokenResult(not_done, pop_success);
619cdf0e10cSrcweir }
620cdf0e10cSrcweir
621cdf0e10cSrcweir ary::cpp::FunctionFlags
CreateFunctionFlags()622cdf0e10cSrcweir PE_VarFunc::CreateFunctionFlags()
623cdf0e10cSrcweir {
624cdf0e10cSrcweir typedef ary::cpp::FunctionFlags FuncFlags;
625cdf0e10cSrcweir
626cdf0e10cSrcweir return FuncFlags( UINT16(
627cdf0e10cSrcweir ( bStatic AND Env().Context().CurClass() == 0 ? FuncFlags::f_static_local : 0 )
628cdf0e10cSrcweir | ( bStatic AND Env().Context().CurClass() != 0 ? FuncFlags::f_static_member : 0 )
629cdf0e10cSrcweir | ( bExtern ? FuncFlags::f_extern : 0 )
630cdf0e10cSrcweir | ( Env().IsExternC() ? FuncFlags::f_externC : 0 )
631cdf0e10cSrcweir | ( bMutable ? FuncFlags::f_mutable : 0 )
632cdf0e10cSrcweir | ( bInline ? FuncFlags::f_inline : 0 )
633cdf0e10cSrcweir | ( bRegister ? FuncFlags::f_register : 0 )
634cdf0e10cSrcweir | ( bExplicit ? FuncFlags::f_explicit : 0 ) )
635cdf0e10cSrcweir );
636cdf0e10cSrcweir
637cdf0e10cSrcweir }
638cdf0e10cSrcweir
639cdf0e10cSrcweir
640cdf0e10cSrcweir } // namespace cpp
641cdf0e10cSrcweir
642cdf0e10cSrcweir
643cdf0e10cSrcweir
644