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