xref: /aoo41x/main/autodoc/source/parser_i/idl/pe_servi.cxx (revision a0d53b35)

/**************************************************************
 *
 * 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 <precomp.h>
#include <s2_luidl/pe_servi.hxx>


// NOT FULLY DEFINED SERVICES
#include <ary/idl/i_gate.hxx>
#include <ary/idl/i_service.hxx>
#include <ary/idl/i_siservice.hxx>
#include <ary/idl/ip_ce.hxx>
#include <ary/doc/d_oldidldocu.hxx>
#include <s2_luidl/pe_func2.hxx>
#include <s2_luidl/pe_property.hxx>
#include <s2_luidl/pe_type2.hxx>
#include <s2_luidl/tk_keyw.hxx>
#include <s2_luidl/tk_ident.hxx>
#include <s2_luidl/tk_punct.hxx>



namespace csi
{
namespace uidl
{



PE_Service::PE_Service()
	:	eState(e_none),
		sData_Name(),
		bIsPreDeclaration(false),
		pCurService(0),
		pCurSiService(0),
		nCurService(0),
		pPE_Property(0),
		nCurParsed_Property(0),
		pPE_Type(0),
		nCurParsed_Type(0),
		pPE_Constructor(0),
		bOptionalMember(false)
{
	pPE_Property 	= new PE_Property(nCurService);
	pPE_Type 		= new PE_Type(nCurParsed_Type);
	pPE_Constructor = new PE_Function(nCurService, PE_Function::constructor);
}

void
PE_Service::EstablishContacts( UnoIDL_PE *				io_pParentPE,
							   ary::Repository &		io_rRepository,
							   TokenProcessing_Result & o_rResult )
{
	UnoIDL_PE::EstablishContacts(io_pParentPE,io_rRepository,o_rResult);
	pPE_Property->EstablishContacts(this,io_rRepository,o_rResult);
	pPE_Type->EstablishContacts(this,io_rRepository,o_rResult);
	pPE_Constructor->EstablishContacts(this,io_rRepository,o_rResult);
}

PE_Service::~PE_Service()
{
}

void
PE_Service::ProcessToken( const Token & i_rToken )
{
	i_rToken.Trigger(*this);
}


void
PE_Service::Process_MetaType( const TokMetaType &	i_rToken )
{
	switch ( i_rToken.Id() )
	{
		case TokMetaType::mt_service:
					if (eState == need_name)
						SetResult(done, stay );
					else if (eState == e_std)
					{
						SetResult(done, push_sure, pPE_Type.Ptr());
						eState = in_service_type;
					}
					else
						On_Default();
					break;
		case TokMetaType::mt_interface:
					if (eState == e_std)
					{
						SetResult(done, push_sure, pPE_Type.Ptr());
						eState = in_ifc_type;
					}
					else
						On_Default();
					break;
		case TokMetaType::mt_property:
					if (eState == e_std)
					{
						StartProperty();
					}
					else
						On_Default();
					break;
        default:
            // KORR_FUTURE:
            // Should throw syntax error warning.
                    ;
	}	// end switch
}

void
PE_Service::Process_Identifier( const TokIdentifier & i_rToken )
{
	if (eState == need_name)
	{
		sData_Name = i_rToken.Text();
		SetResult(done, stay);
		eState = need_curlbr_open;
	}
	else if (eState == e_std_sib)
	{
		SetResult(not_done, push_sure, pPE_Constructor.Ptr());
	}
	else
		On_Default();
}

void
PE_Service::Process_Punctuation( const TokPunctuation & i_rToken )
{
	switch (i_rToken.Id())
	{
		case TokPunctuation::Colon:
					if (eState == need_curlbr_open)
					{
						SetResult(done, push_sure, pPE_Type.Ptr());
						eState = need_base_interface;
					}
					else
						On_Default();
					break;

		case TokPunctuation::CurledBracketOpen:
					if (eState == need_curlbr_open)
					{
                        pCurService = &Gate().Ces().Store_Service(
                                                        CurNamespace().CeId(),
                                                        sData_Name );
                        nCurService = pCurService->CeId();
						PassDocuAt(*pCurService);
						SetResult(done, stay);
						eState = e_std;
					}
					else if (eState == need_curlbr_open_sib)
					{
						SetResult(done, stay);
						eState = e_std_sib;
					}
					else
						On_Default();
					break;
		case TokPunctuation::CurledBracketClose:
					if (eState == e_std OR eState == e_std_sib)
					{
						SetResult(done, stay);
						eState = need_finish;
					}
					else
						On_Default();
					break;
		case TokPunctuation::Comma:
					if (eState == expect_ifc_separator)
					{
						SetResult(done, push_sure, pPE_Type.Ptr());
						eState = in_ifc_type;
					}
					else if (eState == expect_service_separator)
					{
						SetResult(done, push_sure, pPE_Type.Ptr());
						eState = in_service_type;
					}
					else if (eState == e_std)
					{
						SetResult(done, stay);
					}
					else
						On_Default();
					break;
		case TokPunctuation::Semicolon:
					switch (eState)
					{
					   case need_curlbr_open:
									sData_Name.clear();
									bIsPreDeclaration = true;
									SetResult(done, pop_success);
									eState = e_none;
									break;
    				   case need_curlbr_open_sib:
						            SetResult(done, pop_success);
						            eState = e_none;
					                break;
					   case expect_ifc_separator:
					   case expect_service_separator:
									SetResult(done, stay);
									eState = e_std;
									break;
					   case need_finish:
									SetResult(done, pop_success);
									eState = e_none;
									break;
					   case at_ignore:
									SetResult(done, stay);
									eState = e_std;
									break;
					   default:
									On_Default();
					}	// end switch
					break;
		default:
					On_Default();
	}	// end switch
}

void
PE_Service::Process_Stereotype( const TokStereotype & i_rToken )
{
    if (i_rToken.Id() == TokStereotype::ste_optional)
	{
		bOptionalMember = true;
		SetResult(done, stay);
	}
	else if ( eState == e_std )
	{
		StartProperty();
	}
	else
		On_Default();
}

void
PE_Service::Process_Needs()
{
	SetResult(done,stay);
	eState = at_ignore;
}

void
PE_Service::Process_Observes()
{
	SetResult(done,stay);
	eState = at_ignore;
}

void
PE_Service::Process_Default()
{
	On_Default();
}


void
PE_Service::On_Default()
{
	if (eState == at_ignore)
		SetResult(done, stay);
	else
		SetResult(not_done, pop_failure);
}

void
PE_Service::InitData()
{
	eState = need_name;
	sData_Name.clear();
	bIsPreDeclaration = false;
	pCurService = 0;
	pCurSiService = 0;
	nCurService = 0;
	nCurParsed_Property = 0;
	nCurParsed_Type = 0;
	bOptionalMember = false;
}

void
PE_Service::TransferData()
{
	if (NOT bIsPreDeclaration)
	{
		csv_assert(! sData_Name.empty());
		csv_assert( (pCurService != 0) != (pCurSiService != 0) );
	}

	eState = e_none;
}

void
PE_Service::ReceiveData()
{
	switch (eState)
	{
		case in_property:
				eState = e_std;
				break;
		case in_ifc_type:
				if (bOptionalMember)
				{
					pPE_Type->SetOptional();
				}
				pCurService->AddRef_SupportedInterface(
						            nCurParsed_Type,
                                    pPE_Type->ReleaseDocu());
				nCurParsed_Type = 0;
				eState = expect_ifc_separator;
				break;
		case in_service_type:
				if (bOptionalMember)
                {
					pPE_Type->SetOptional();
				}
				pCurService->AddRef_IncludedService(
						            nCurParsed_Type,
                                    pPE_Type->ReleaseDocu());
				nCurParsed_Type = 0;
				eState = expect_service_separator;
				break;
        case need_base_interface:
                pCurSiService = &Gate().Ces().Store_SglIfcService(
                                                CurNamespace().CeId(),
                                                sData_Name,
                                                nCurParsed_Type );
                nCurService = pCurSiService->CeId();
				PassDocuAt(*pCurSiService);

                nCurParsed_Type = 0;
                eState = need_curlbr_open_sib;
				break;
		case e_std_sib:
		        break;
		default:
			csv_assert(false);
	}

    bOptionalMember = false;
}


UnoIDL_PE &
PE_Service::MyPE()
{
	return *this;
}

void
PE_Service::StartProperty()
{
	SetResult(not_done, push_sure, pPE_Property.Ptr());
	eState = in_property;

	if (bOptionalMember)
    {
		pPE_Property->PresetOptional();
        bOptionalMember = false;
	}
}


}   // namespace uidl
}   // namespace csi