/************************************************************** * * 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. * *************************************************************/ #include #include // NOT FULLY DECLARED SERVICES #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace csi { namespace uidl { PE_File::PE_File( TokenDistributor & i_rTokenAdmin, const ParserInfo & i_parseInfo ) : pTokenAdmin(&i_rTokenAdmin), pPE_Service(new PE_Service), pPE_Singleton(new PE_Singleton), pPE_Interface(new PE_Interface), pPE_Struct(new PE_Struct), pPE_Exception(new PE_Exception), pPE_Constant(new PE_Constant), pPE_Enum(new PE_Enum), pPE_Typedef(new PE_Typedef), pCurNamespace(0), pParseInfo(&i_parseInfo), eState(e_none), nBracketCount_inDefMode(0) { } void PE_File::EstablishContacts( UnoIDL_PE * io_pParentPE, ary::Repository & io_rRepository, TokenProcessing_Result & o_rResult ) { UnoIDL_PE::EstablishContacts(io_pParentPE,io_rRepository,o_rResult); pPE_Service->EstablishContacts(this,io_rRepository,o_rResult); pPE_Singleton->EstablishContacts(this,io_rRepository,o_rResult); pPE_Interface->EstablishContacts(this,io_rRepository,o_rResult); pPE_Struct->EstablishContacts(this,io_rRepository,o_rResult); pPE_Exception->EstablishContacts(this,io_rRepository,o_rResult); pPE_Constant->EstablishContacts(this,io_rRepository,o_rResult); pPE_Enum->EstablishContacts(this,io_rRepository,o_rResult); pPE_Typedef->EstablishContacts(this,io_rRepository,o_rResult); pCurNamespace = &Gate().Ces().GlobalNamespace(); } PE_File::~PE_File() { } void PE_File::ProcessToken( const Token & i_rToken ) { i_rToken.Trigger(*this); } void PE_File::Process_Identifier( const TokIdentifier & i_rToken ) { switch (eState) { case wait_for_module: { csv_assert(pCurNamespace != 0); ary::idl::Module & rCe = Gate().Ces().CheckIn_Module(pCurNamespace->CeId(), i_rToken.Text()); pCurNamespace = &rCe; // Get docu out of normal: SetDocu(pTokenAdmin->ReleaseLastParsedDocu()); PassDocuAt(rCe); csv_assert(pCurNamespace != 0); SetResult(done, stay); eState = wait_for_module_bracket; } break; case on_default: SetResult(done, stay); break; default: csv_assert(false); } } void PE_File::Process_Punctuation( const TokPunctuation & i_rToken ) { switch (eState) { case e_std: if (i_rToken.Id() == TokPunctuation::CurledBracketClose) { csv_assert(pCurNamespace != 0); pCurNamespace = &Gate().Ces().Find_Module(pCurNamespace->Owner()); SetResult(done, stay); eState = wait_for_module_semicolon; } else { csv_assert(false); } break; case wait_for_module_bracket: if (i_rToken.Id() == TokPunctuation::CurledBracketOpen) { SetResult(done, stay); eState = e_std; } else { csv_assert(false); } break; case wait_for_module_semicolon: if (i_rToken.Id() == TokPunctuation::Semicolon) { SetResult(done, stay); eState = e_std; } else { csv_assert(false); } break; case on_default: if (i_rToken.Id() == TokPunctuation::CurledBracketClose) { nBracketCount_inDefMode--; } else if (i_rToken.Id() == TokPunctuation::CurledBracketOpen) { nBracketCount_inDefMode++; } else if (i_rToken.Id() == TokPunctuation::Semicolon) { if (nBracketCount_inDefMode <= 0) { eState = e_std; } } SetResult(done, stay); break; default: csv_assert(false); } } void PE_File::Process_MetaType( const TokMetaType & i_rToken ) { switch (i_rToken.Id()) { case TokMetaType::mt_service: eState = in_sub_pe; SetResult( not_done, push_sure, pPE_Service.Ptr()); break; case TokMetaType::mt_singleton: eState = in_sub_pe; SetResult( not_done, push_sure, pPE_Singleton.Ptr()); break; case TokMetaType::mt_uik: Cerr() << "Syntax error: [uik ....] is obsolete now." << Endl(); SetResult( not_done, pop_failure); break; case TokMetaType::mt_interface: eState = in_sub_pe; SetResult( not_done, push_sure, pPE_Interface.Ptr()); break; case TokMetaType::mt_module: eState = wait_for_module; SetResult( done, stay ); break; case TokMetaType::mt_struct: eState = in_sub_pe; SetResult( done, push_sure, pPE_Struct.Ptr()); break; case TokMetaType::mt_exception: eState = in_sub_pe; SetResult( done, push_sure, pPE_Exception.Ptr()); break; case TokMetaType::mt_constants: eState = in_sub_pe; SetResult( done, push_sure, pPE_Constant.Ptr()); break; case TokMetaType::mt_enum: eState = in_sub_pe; SetResult( done, push_sure, pPE_Enum.Ptr()); break; case TokMetaType::mt_typedef: eState = in_sub_pe; SetResult( done, push_sure, pPE_Typedef.Ptr()); break; default: Process_Default(); } // end switch } void PE_File::Process_Stereotype( const TokStereotype & i_rToken ) { if (i_rToken.Id() == TokStereotype::ste_published) { pTokenAdmin->Set_PublishedOn(); SetResult(done, stay); } else { Process_Default(); } } void PE_File::Process_Default() { if (eState != on_default) { eState = on_default; nBracketCount_inDefMode = 0; } SetResult(done, stay); } const ary::idl::Module & PE_File::CurNamespace() const { csv_assert(pCurNamespace); return *pCurNamespace; } const ParserInfo & PE_File::ParseInfo() const { csv_assert(pParseInfo); return *pParseInfo; } void PE_File::InitData() { eState = e_std; } void PE_File::TransferData() { eState = e_none; } void PE_File::ReceiveData() { eState = e_std; } UnoIDL_PE & PE_File::MyPE() { return *this; } } // namespace uidl } // namespace csi