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_funct.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_funct.hxx> 30 #include <ary/cpp/c_type.hxx> 31 #include <ary/cpp/cp_ce.hxx> 32 #include <ary/cpp/cp_type.hxx> 33 #include <ary/cpp/inpcontx.hxx> 34 #include "pe_type.hxx" 35 #include "pe_param.hxx" 36 37 38 39 40 namespace cpp 41 { 42 43 44 inline void 45 PE_Function::PerformFinishingPunctuation() 46 { 47 SetTokenResult(not_done,pop_success); 48 } 49 50 51 PE_Function::PE_Function( Cpp_PE * i_pParent ) 52 : Cpp_PE(i_pParent), 53 pStati( new PeStatusArray<PE_Function> ), 54 // pSpParameter, 55 // pSpuParameter, 56 // pSpType, 57 // pSpuException, 58 // pSpuCastOperatorType, 59 nResult(0), 60 bResult_WithImplementation(false), 61 aName(60), 62 eVirtuality(ary::cpp::VIRTUAL_none), 63 eConVol(ary::cpp::CONVOL_none), 64 // aFlags, 65 nReturnType(0), 66 // aParameters 67 // aExceptions, 68 bThrow(false), 69 nBracketCounterInImplementation(0) 70 { 71 Setup_StatusFunctions(); 72 73 pSpParameter = new SP_Parameter(*this); 74 pSpType = new SP_Type(*this); 75 76 pSpuParameter = new SPU_Parameter(*pSpParameter, 0, &PE_Function::SpReturn_Parameter); 77 pSpuException = new SPU_Type(*pSpType, 0, &PE_Function::SpReturn_Exception); 78 pSpuCastOperatorType = new SPU_Type(*pSpType, &PE_Function::SpInit_CastOperatorType, &PE_Function::SpReturn_CastOperatorType); 79 } 80 81 PE_Function::~PE_Function() 82 { 83 84 } 85 86 void 87 PE_Function::Init_Std( const String & i_sName, 88 ary::cpp::Type_id i_nReturnType, 89 bool i_bVirtual, 90 ary::cpp::FunctionFlags i_aFlags ) 91 { 92 aName << i_sName; 93 eVirtuality = i_bVirtual ? ary::cpp::VIRTUAL_virtual : ary::cpp::VIRTUAL_none; 94 aFlags = i_aFlags; 95 nReturnType = i_nReturnType; 96 pStati->SetCur(afterName); 97 } 98 99 void 100 PE_Function::Init_Ctor( const String & i_sName, 101 ary::cpp::FunctionFlags i_aFlags ) 102 { 103 aName << i_sName; 104 eVirtuality = ary::cpp::VIRTUAL_none; 105 aFlags = i_aFlags; 106 nReturnType = 0; 107 pStati->SetCur(afterName); 108 } 109 110 void 111 PE_Function::Init_Dtor( const String & i_sName, 112 bool i_bVirtual, 113 ary::cpp::FunctionFlags i_aFlags ) 114 { 115 aName << "~" << i_sName; 116 eVirtuality = i_bVirtual ? ary::cpp::VIRTUAL_virtual : ary::cpp::VIRTUAL_none; 117 aFlags = i_aFlags; 118 nReturnType = 0; 119 pStati->SetCur(afterName); 120 } 121 122 void 123 PE_Function::Init_CastOperator( bool i_bVirtual, 124 ary::cpp::FunctionFlags i_aFlags ) 125 { 126 aName << "operator "; 127 eVirtuality = i_bVirtual ? ary::cpp::VIRTUAL_virtual : ary::cpp::VIRTUAL_none; 128 aFlags = i_aFlags; 129 nReturnType = 0; 130 pStati->SetCur(afterCastOperator); 131 } 132 133 void 134 PE_Function::Init_NormalOperator( ary::cpp::Type_id i_nReturnType, 135 bool i_bVirtual, 136 ary::cpp::FunctionFlags i_aFlags ) 137 { 138 aName << "operator"; 139 eVirtuality = i_bVirtual ? ary::cpp::VIRTUAL_virtual : ary::cpp::VIRTUAL_none; 140 aFlags = i_aFlags; 141 nReturnType = i_nReturnType; 142 pStati->SetCur(afterStdOperator); 143 } 144 145 ary::cpp::Ce_id 146 PE_Function::Result_Id() const 147 { 148 return nResult; 149 } 150 151 void 152 PE_Function::Call_Handler( const cpp::Token & i_rTok ) 153 { 154 pStati->Cur().Call_Handler(i_rTok.TypeId(), i_rTok.Text()); 155 } 156 157 void 158 PE_Function::Setup_StatusFunctions() 159 { 160 typedef CallFunction<PE_Function>::F_Tok F_Tok; 161 162 static F_Tok stateF_afterStdOperator[] = 163 { &PE_Function::On_afterOperator_Std_Operator, 164 &PE_Function::On_afterOperator_Std_LeftBracket, 165 &PE_Function::On_afterOperator_Std_LeftBracket, 166 &PE_Function::On_afterOperator_Std_Operator, 167 &PE_Function::On_afterOperator_Std_Operator, 168 &PE_Function::On_afterOperator_Std_Operator, 169 &PE_Function::On_afterOperator_Std_Operator, 170 &PE_Function::On_afterOperator_Std_Operator, 171 &PE_Function::On_afterOperator_Std_Operator }; 172 static INT16 stateT_afterStdOperator[] = 173 { Tid_Operator, 174 Tid_ArrayBracket_Left, 175 Tid_Bracket_Left, 176 Tid_Comma, 177 Tid_Assign, 178 Tid_Less, 179 Tid_Greater, 180 Tid_Asterix, 181 Tid_AmpersAnd }; 182 183 static F_Tok stateF_afterStdOperatorLeftBracket[] = 184 { &PE_Function::On_afterStdOperatorLeftBracket_RightBracket, 185 &PE_Function::On_afterStdOperatorLeftBracket_RightBracket }; 186 static INT16 stateT_afterStdOperatorLeftBracket[] = 187 { Tid_ArrayBracket_Right, 188 Tid_Bracket_Right }; 189 190 static F_Tok stateF_afterCastOperator[] = 191 { &PE_Function::On_afterOperator_Cast_Type, 192 &PE_Function::On_afterOperator_Cast_Type, 193 &PE_Function::On_afterOperator_Cast_Type, 194 &PE_Function::On_afterOperator_Cast_Type, 195 &PE_Function::On_afterOperator_Cast_Type, 196 &PE_Function::On_afterOperator_Cast_Type, 197 &PE_Function::On_afterOperator_Cast_Type, 198 &PE_Function::On_afterOperator_Cast_Type, 199 &PE_Function::On_afterOperator_Cast_Type, 200 &PE_Function::On_afterOperator_Cast_Type, 201 &PE_Function::On_afterOperator_Cast_Type }; 202 static INT16 stateT_afterCastOperator[] = 203 { Tid_Identifier, 204 Tid_class, 205 Tid_struct, 206 Tid_union, 207 Tid_enum, 208 Tid_const, 209 Tid_volatile, 210 Tid_DoubleColon, 211 Tid_typename, 212 Tid_BuiltInType, 213 Tid_TypeSpecializer }; 214 215 static F_Tok stateF_afterName[] = { &PE_Function::On_afterName_Bracket_Left }; 216 static INT16 stateT_afterName[] = { Tid_Bracket_Left }; 217 218 static F_Tok stateF_expectParameterSeparator[] = 219 { &PE_Function::On_expectParameterSeparator_BracketRight, 220 &PE_Function::On_expectParameterSeparator_Comma }; 221 static INT16 stateT_expectParameterSeparator[] = 222 { Tid_Bracket_Right, 223 Tid_Comma }; 224 225 static F_Tok stateF_afterParameters[] = { &PE_Function::On_afterParameters_const, 226 &PE_Function::On_afterParameters_volatile, 227 &PE_Function::On_afterParameters_throw, 228 &PE_Function::On_afterParameters_SwBracket_Left, 229 &PE_Function::On_afterParameters_Semicolon, 230 &PE_Function::On_afterParameters_Comma, 231 &PE_Function::On_afterParameters_Colon, 232 &PE_Function::On_afterParameters_Assign }; 233 static INT16 stateT_afterParameters[] = { Tid_const, 234 Tid_volatile, 235 Tid_throw, 236 Tid_SwBracket_Left, 237 Tid_Semicolon, 238 Tid_Comma, 239 Tid_Colon, 240 Tid_Assign }; 241 242 static F_Tok stateF_afterThrow[] = { &PE_Function::On_afterThrow_Bracket_Left }; 243 static INT16 stateT_afterThrow[] = { Tid_Bracket_Left }; 244 245 static F_Tok stateF_expectExceptionSeparator[] = 246 { &PE_Function::On_expectExceptionSeparator_BracketRight, 247 &PE_Function::On_expectExceptionSeparator_Comma }; 248 static INT16 stateT_expectExceptionSeparator[] = 249 { Tid_Bracket_Right, 250 Tid_Comma }; 251 252 static F_Tok stateF_afterExceptions[] = { &PE_Function::On_afterExceptions_SwBracket_Left, 253 &PE_Function::On_afterExceptions_Semicolon, 254 &PE_Function::On_afterExceptions_Comma, 255 &PE_Function::On_afterExceptions_Colon, 256 &PE_Function::On_afterExceptions_Assign }; 257 static INT16 stateT_afterExceptions[] = { Tid_SwBracket_Left, 258 Tid_Semicolon, 259 Tid_Comma, 260 Tid_Colon, 261 Tid_Assign }; 262 263 static F_Tok stateF_expectZero[] = { &PE_Function::On_expectZero_Constant }; 264 static INT16 stateT_expectZero[] = { Tid_Constant }; 265 266 static F_Tok stateF_inImplementation[] = 267 { &PE_Function::On_inImplementation_SwBracket_Left, 268 &PE_Function::On_inImplementation_SwBracket_Right }; 269 static INT16 stateT_inImplementation[] = 270 { Tid_SwBracket_Left, 271 Tid_SwBracket_Right }; 272 273 SEMPARSE_CREATE_STATUS(PE_Function, afterStdOperator, Hdl_SyntaxError); 274 SEMPARSE_CREATE_STATUS(PE_Function, afterStdOperatorLeftBracket, Hdl_SyntaxError); 275 SEMPARSE_CREATE_STATUS(PE_Function, afterCastOperator, Hdl_SyntaxError); 276 SEMPARSE_CREATE_STATUS(PE_Function, afterName, Hdl_SyntaxError); 277 SEMPARSE_CREATE_STATUS(PE_Function, expectParameterSeparator, Hdl_SyntaxError); 278 SEMPARSE_CREATE_STATUS(PE_Function, afterParameters, Hdl_SyntaxError); 279 SEMPARSE_CREATE_STATUS(PE_Function, afterThrow, Hdl_SyntaxError); 280 SEMPARSE_CREATE_STATUS(PE_Function, expectExceptionSeparator, Hdl_SyntaxError); 281 SEMPARSE_CREATE_STATUS(PE_Function, afterExceptions, Hdl_SyntaxError); 282 SEMPARSE_CREATE_STATUS(PE_Function, expectZero, Hdl_SyntaxError); 283 SEMPARSE_CREATE_STATUS(PE_Function, inImplementation, On_inImplementation_Default ); 284 } 285 286 void 287 PE_Function::InitData() 288 { 289 pStati->SetCur( afterName ), 290 nResult = 0; 291 bResult_WithImplementation = false; 292 aName.seekp(0); 293 eVirtuality = ary::cpp::VIRTUAL_none; 294 eConVol = ary::cpp::CONVOL_none; 295 aFlags.Reset(); 296 nReturnType = 0; 297 csv::erase_container(aParameters); 298 csv::erase_container(aExceptions); 299 bThrow = false; 300 } 301 302 void 303 PE_Function::TransferData() 304 { 305 String sName( aName.c_str() ); 306 ary::cpp::Function * 307 pFunction = Env().AryGate().Ces().Store_Operation( 308 Env().Context(), 309 sName, 310 nReturnType, 311 aParameters, 312 eVirtuality, 313 eConVol, 314 aFlags, 315 bThrow, 316 aExceptions ); 317 if (pFunction != 0) 318 { 319 // KORR_FUTURE: How to handle differing documentation? 320 321 Dyn< StringVector > 322 pTplParams ( Env().Get_CurTemplateParameters() ); 323 if ( pTplParams ) 324 { 325 for ( StringVector::const_iterator it = pTplParams->begin(); 326 it != pTplParams->end(); 327 ++it ) 328 { 329 pFunction->Add_TemplateParameterType( *it, ary::cpp::Type_id(0) ); 330 } // end for 331 } 332 333 Env().Event_Store_Function(*pFunction); 334 } 335 336 pStati->SetCur(size_of_states); 337 } 338 339 void 340 PE_Function::Hdl_SyntaxError(const char * i_sText) 341 { 342 StdHandlingOfSyntaxError(i_sText); 343 } 344 345 void 346 PE_Function::SpInit_CastOperatorType() 347 { 348 pSpuCastOperatorType->Child().Init_AsCastOperatorType(); 349 } 350 351 void 352 PE_Function::SpReturn_Parameter() 353 { 354 pStati->SetCur(expectParameterSeparator); 355 356 ary::cpp::Type_id nParamType = pSpuParameter->Child().Result_FrontType(); 357 if ( nParamType.IsValid() ) // Check, if there was a parameter, or only the closing ')'. 358 { 359 aParameters.push_back( pSpuParameter->Child().Result_ParamInfo() ); 360 } 361 } 362 363 void 364 PE_Function::SpReturn_Exception() 365 { 366 pStati->SetCur(expectExceptionSeparator); 367 368 ary::cpp::Type_id 369 nException = pSpuException->Child().Result_Type().TypeId(); 370 if ( nException.IsValid() AND pSpuException->Child().Result_KindOf() == PE_Type::is_type ) 371 { 372 aExceptions.push_back( nException ); 373 } 374 } 375 376 void 377 PE_Function::SpReturn_CastOperatorType() 378 { 379 pStati->SetCur(afterName); 380 381 Env().AryGate().Types().Get_TypeText( 382 aName, pSpuCastOperatorType->Child().Result_Type().TypeId() ); 383 } 384 385 void 386 PE_Function::On_afterOperator_Std_Operator(const char * i_sText) 387 { 388 SetTokenResult(done,stay); 389 pStati->SetCur(afterName); 390 391 if ( 'a' <= *i_sText AND *i_sText <= 'z' ) 392 aName << ' '; 393 aName << i_sText; 394 } 395 396 void 397 PE_Function::On_afterOperator_Std_LeftBracket(const char * i_sText) 398 { 399 SetTokenResult(done,stay); 400 pStati->SetCur(afterStdOperatorLeftBracket); 401 402 aName << i_sText; 403 } 404 405 void 406 PE_Function::On_afterStdOperatorLeftBracket_RightBracket(const char * i_sText) 407 { 408 SetTokenResult(done,stay); 409 pStati->SetCur(afterName); 410 411 aName << i_sText; 412 } 413 414 void 415 PE_Function::On_afterOperator_Cast_Type(const char *) 416 { 417 pSpuCastOperatorType->Push(not_done); 418 } 419 420 void 421 PE_Function::On_afterName_Bracket_Left(const char *) 422 { 423 pSpuParameter->Push(done); 424 } 425 426 void 427 PE_Function::On_expectParameterSeparator_BracketRight(const char *) 428 { 429 SetTokenResult(done,stay); 430 pStati->SetCur(afterParameters); 431 } 432 433 void 434 PE_Function::On_expectParameterSeparator_Comma(const char *) 435 { 436 pSpuParameter->Push(done); 437 } 438 439 void 440 PE_Function::On_afterParameters_const(const char *) 441 { 442 SetTokenResult(done,stay); 443 eConVol = static_cast<E_ConVol>( 444 static_cast<int>(eConVol) | static_cast<int>(ary::cpp::CONVOL_const) ); 445 } 446 447 void 448 PE_Function::On_afterParameters_volatile(const char *) 449 { 450 SetTokenResult(done,stay); 451 eConVol = static_cast<E_ConVol>( 452 static_cast<int>(eConVol) | static_cast<int>(ary::cpp::CONVOL_volatile) ); 453 } 454 455 void 456 PE_Function::On_afterParameters_throw(const char *) 457 { 458 SetTokenResult(done,stay); 459 pStati->SetCur(afterThrow); 460 bThrow = true; 461 } 462 463 void 464 PE_Function::On_afterParameters_SwBracket_Left(const char *) 465 { 466 EnterImplementation(1); 467 } 468 469 void 470 PE_Function::On_afterParameters_Semicolon(const char *) 471 { 472 PerformFinishingPunctuation(); 473 } 474 475 void 476 PE_Function::On_afterParameters_Comma(const char *) 477 { 478 PerformFinishingPunctuation(); 479 } 480 481 void 482 PE_Function::On_afterParameters_Colon(const char *) 483 { 484 EnterImplementation(0); 485 } 486 487 void 488 PE_Function::On_afterParameters_Assign(const char *) 489 { 490 SetTokenResult(done,stay); 491 pStati->SetCur(expectZero); 492 } 493 494 void 495 PE_Function::On_afterThrow_Bracket_Left(const char *) 496 { 497 pSpuException->Push(done); 498 } 499 500 void 501 PE_Function::On_expectExceptionSeparator_BracketRight(const char *) 502 { 503 SetTokenResult(done,stay); 504 pStati->SetCur(afterExceptions); 505 } 506 507 void 508 PE_Function::On_expectExceptionSeparator_Comma(const char *) 509 { 510 pSpuException->Push(done); 511 } 512 513 void 514 PE_Function::On_afterExceptions_SwBracket_Left(const char *) 515 { 516 EnterImplementation(1); 517 } 518 519 void 520 PE_Function::On_afterExceptions_Semicolon(const char *) 521 { 522 PerformFinishingPunctuation(); 523 } 524 525 void 526 PE_Function::On_afterExceptions_Comma(const char *) 527 { 528 PerformFinishingPunctuation(); 529 } 530 531 void 532 PE_Function::On_afterExceptions_Colon(const char *) 533 { 534 EnterImplementation(0); 535 } 536 537 void 538 PE_Function::On_afterExceptions_Assign(const char *) 539 { 540 SetTokenResult(done,stay); 541 pStati->SetCur(expectZero); 542 } 543 544 void 545 PE_Function::On_expectZero_Constant(const char * i_sText) 546 { 547 if ( strcmp(i_sText,"0") != 0 ) 548 Hdl_SyntaxError(i_sText); 549 550 SetTokenResult(done,stay); 551 pStati->SetCur(afterExceptions); 552 553 eVirtuality = ary::cpp::VIRTUAL_abstract; 554 } 555 556 void 557 PE_Function::On_inImplementation_SwBracket_Left(const char *) 558 { 559 SetTokenResult(done,stay); 560 nBracketCounterInImplementation++; 561 } 562 563 void 564 PE_Function::On_inImplementation_SwBracket_Right(const char *) 565 { 566 nBracketCounterInImplementation--; 567 if (nBracketCounterInImplementation == 0) 568 { 569 SetTokenResult(done,pop_success); 570 } 571 else 572 { 573 SetTokenResult(done,stay); 574 } 575 } 576 577 void 578 PE_Function::On_inImplementation_Default(const char *) 579 { 580 SetTokenResult(done,stay); 581 } 582 583 void 584 PE_Function::EnterImplementation( intt i_nBracketCountStart ) 585 { 586 SetTokenResult(done,stay); 587 pStati->SetCur(inImplementation); 588 589 bResult_WithImplementation = true; 590 nBracketCounterInImplementation = i_nBracketCountStart; 591 if ( Env().Context().CurClass() != 0 ) 592 { 593 aFlags.SetInline(); 594 } 595 } 596 597 598 599 } // namespace cpp 600 601 602 603 604 605