e9a59da46a
Fixes #fdo30794 Based on bin/add-modelines script (originally posted in mail 1286706307.1871.1399280959@webmail.messagingengine.com) Signed-off-by: Sebastian Spaeth <Sebastian@SSpaeth.de>
448 lines
12 KiB
C++
448 lines
12 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/*************************************************************************
|
|
*
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* Copyright 2000, 2010 Oracle and/or its affiliates.
|
|
*
|
|
* OpenOffice.org - a multi-platform office productivity suite
|
|
*
|
|
* This file is part of OpenOffice.org.
|
|
*
|
|
* OpenOffice.org is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Lesser General Public License version 3
|
|
* only, as published by the Free Software Foundation.
|
|
*
|
|
* OpenOffice.org is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Lesser General Public License version 3 for more details
|
|
* (a copy is included in the LICENSE file that accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* version 3 along with OpenOffice.org. If not, see
|
|
* <http://www.openoffice.org/license.html>
|
|
* for a copy of the LGPLv3 License.
|
|
*
|
|
************************************************************************/
|
|
|
|
#include <precomp.h>
|
|
#include <s2_luidl/pe_func2.hxx>
|
|
|
|
|
|
// NOT FULLY DEFINED SERVICES
|
|
#include <ary/idl/i_function.hxx>
|
|
#include <ary/idl/i_type.hxx>
|
|
#include <ary/idl/i_gate.hxx>
|
|
#include <ary/idl/ip_ce.hxx>
|
|
#include <ary/idl/ip_type.hxx>
|
|
#include <ary/doc/d_oldidldocu.hxx>
|
|
#include <s2_luidl/pe_type2.hxx>
|
|
#include <s2_luidl/pe_vari2.hxx>
|
|
#include <s2_luidl/tk_keyw.hxx>
|
|
#include <s2_luidl/tk_ident.hxx>
|
|
#include <s2_luidl/tk_punct.hxx>
|
|
#include <x_parse2.hxx>
|
|
|
|
|
|
namespace csi
|
|
{
|
|
namespace uidl
|
|
{
|
|
|
|
|
|
PE_Function::PE_Function( const RParent & i_rCurInterface )
|
|
: eState(e_none),
|
|
sData_Name(),
|
|
nData_ReturnType(0),
|
|
bData_Oneway(false),
|
|
pCurFunction(0),
|
|
pCurParent(&i_rCurInterface),
|
|
pPE_Type(0),
|
|
nCurParsedType(0),
|
|
sName(),
|
|
pPE_Variable(0),
|
|
eCurParsedParam_Direction(ary::idl::param_in),
|
|
nCurParsedParam_Type(0),
|
|
sCurParsedParam_Name(),
|
|
bIsForConstructors(false)
|
|
{
|
|
pPE_Type = new PE_Type(nCurParsedType);
|
|
pPE_Variable = new PE_Variable(nCurParsedParam_Type, sCurParsedParam_Name);
|
|
}
|
|
|
|
PE_Function::PE_Function( const RParent & i_rCurService,
|
|
E_Constructor )
|
|
: eState(expect_name),
|
|
sData_Name(),
|
|
nData_ReturnType(0),
|
|
bData_Oneway(false),
|
|
pCurFunction(0),
|
|
pCurParent(&i_rCurService),
|
|
pPE_Type(0),
|
|
nCurParsedType(0),
|
|
sName(),
|
|
pPE_Variable(0),
|
|
eCurParsedParam_Direction(ary::idl::param_in),
|
|
nCurParsedParam_Type(0),
|
|
sCurParsedParam_Name(),
|
|
bIsForConstructors(true)
|
|
{
|
|
pPE_Type = new PE_Type(nCurParsedType);
|
|
pPE_Variable = new PE_Variable(nCurParsedParam_Type, sCurParsedParam_Name);
|
|
}
|
|
|
|
void
|
|
PE_Function::EstablishContacts( UnoIDL_PE * io_pParentPE,
|
|
ary::Repository & io_rRepository,
|
|
TokenProcessing_Result & o_rResult )
|
|
{
|
|
UnoIDL_PE::EstablishContacts(io_pParentPE,io_rRepository,o_rResult);
|
|
pPE_Type->EstablishContacts(this,io_rRepository,o_rResult);
|
|
pPE_Variable->EstablishContacts(this,io_rRepository,o_rResult);
|
|
}
|
|
|
|
PE_Function::~PE_Function()
|
|
{
|
|
}
|
|
|
|
void
|
|
PE_Function::ProcessToken( const Token & i_rToken )
|
|
{
|
|
i_rToken.Trigger(*this);
|
|
}
|
|
|
|
void
|
|
PE_Function::Process_Stereotype( const TokStereotype & i_rToken )
|
|
{
|
|
if (eState == e_start)
|
|
{
|
|
switch (i_rToken.Id())
|
|
{
|
|
case TokStereotype::ste_oneway:
|
|
bData_Oneway = true;
|
|
SetResult(done, stay);
|
|
break;
|
|
default:
|
|
OnDefault();
|
|
} // end switch
|
|
}
|
|
else
|
|
OnDefault();
|
|
}
|
|
|
|
void
|
|
PE_Function::Process_Identifier( const TokIdentifier & i_rToken )
|
|
{
|
|
switch (eState)
|
|
{
|
|
case e_start:
|
|
GoIntoReturnType();
|
|
break;
|
|
case expect_name:
|
|
sData_Name = i_rToken.Text();
|
|
SetResult(done,stay);
|
|
eState = expect_params_list;
|
|
|
|
if (NOT bIsForConstructors)
|
|
{
|
|
pCurFunction = &Gate().Ces().Store_Function(
|
|
*pCurParent,
|
|
sData_Name,
|
|
nData_ReturnType,
|
|
bData_Oneway );
|
|
}
|
|
else
|
|
{
|
|
pCurFunction = &Gate().Ces().Store_ServiceConstructor(
|
|
*pCurParent,
|
|
sData_Name );
|
|
}
|
|
PassDocuAt(*pCurFunction);
|
|
break;
|
|
case expect_parameter_variable:
|
|
GoIntoParameterVariable();
|
|
break;
|
|
case expect_exception:
|
|
GoIntoException();
|
|
break;
|
|
default:
|
|
OnDefault();
|
|
}
|
|
}
|
|
|
|
void
|
|
PE_Function::Process_Punctuation( const TokPunctuation & i_rToken )
|
|
{
|
|
switch (eState)
|
|
{
|
|
case e_start:
|
|
SetResult(done,stay);
|
|
break;
|
|
case expect_params_list:
|
|
if (i_rToken.Id() != TokPunctuation::BracketOpen)
|
|
{
|
|
OnDefault();
|
|
return;
|
|
}
|
|
SetResult(done,stay);
|
|
eState = expect_parameter;
|
|
break;
|
|
case expect_parameter:
|
|
if (i_rToken.Id() == TokPunctuation::BracketClose)
|
|
{
|
|
SetResult(done,stay);
|
|
eState = params_finished;
|
|
}
|
|
else
|
|
{
|
|
OnDefault();
|
|
return;
|
|
}
|
|
break;
|
|
case expect_parameter_separator:
|
|
if (i_rToken.Id() == TokPunctuation::Comma)
|
|
{
|
|
SetResult(done,stay);
|
|
eState = expect_parameter;
|
|
}
|
|
else if (i_rToken.Id() == TokPunctuation::BracketClose)
|
|
{
|
|
SetResult(done,stay);
|
|
eState = params_finished;
|
|
}
|
|
else
|
|
{
|
|
OnDefault();
|
|
return;
|
|
}
|
|
break;
|
|
case params_finished:
|
|
case exceptions_finished:
|
|
if (i_rToken.Id() != TokPunctuation::Semicolon)
|
|
{
|
|
OnDefault();
|
|
return;
|
|
}
|
|
SetResult(done,pop_success);
|
|
eState = e_none;
|
|
break;
|
|
case expect_exceptions_list:
|
|
if (i_rToken.Id() != TokPunctuation::BracketOpen)
|
|
{
|
|
OnDefault();
|
|
return;
|
|
}
|
|
SetResult(done,stay);
|
|
eState = expect_exception;
|
|
break;
|
|
case expect_exception_separator:
|
|
if (i_rToken.Id() == TokPunctuation::Comma)
|
|
{
|
|
SetResult(done,stay);
|
|
eState = expect_exception;
|
|
}
|
|
else if (i_rToken.Id() == TokPunctuation::BracketClose)
|
|
{
|
|
SetResult(done,stay);
|
|
eState = exceptions_finished;
|
|
}
|
|
else
|
|
{
|
|
OnDefault();
|
|
return;
|
|
}
|
|
break;
|
|
default:
|
|
OnDefault();
|
|
}
|
|
}
|
|
|
|
void
|
|
PE_Function::Process_BuiltInType( const TokBuiltInType & i_rToken )
|
|
{
|
|
switch (eState)
|
|
{
|
|
case e_start:
|
|
GoIntoReturnType();
|
|
break;
|
|
case expect_parameter_variable:
|
|
GoIntoParameterVariable();
|
|
break;
|
|
case expect_parameter_separator:
|
|
if (i_rToken.Id() != TokBuiltInType::bty_ellipse)
|
|
{
|
|
OnDefault();
|
|
}
|
|
else
|
|
{
|
|
pCurFunction->Set_Ellipse();
|
|
SetResult(done,stay);
|
|
// eState stays the same, because we wait for the closing ")" now.
|
|
}
|
|
break;
|
|
case expect_exception:
|
|
GoIntoException();
|
|
break;
|
|
default:
|
|
OnDefault();
|
|
} // end switch
|
|
}
|
|
|
|
void
|
|
PE_Function::Process_ParameterHandling( const TokParameterHandling & i_rToken )
|
|
{
|
|
if (eState != expect_parameter)
|
|
{
|
|
OnDefault();
|
|
return;
|
|
}
|
|
|
|
switch (i_rToken.Id())
|
|
{
|
|
case TokParameterHandling::ph_in:
|
|
eCurParsedParam_Direction = ary::idl::param_in;
|
|
break;
|
|
case TokParameterHandling::ph_out:
|
|
eCurParsedParam_Direction = ary::idl::param_out;
|
|
break;
|
|
case TokParameterHandling::ph_inout:
|
|
eCurParsedParam_Direction = ary::idl::param_inout;
|
|
break;
|
|
default:
|
|
csv_assert(false);
|
|
}
|
|
SetResult(done,stay);
|
|
eState = expect_parameter_variable;
|
|
}
|
|
|
|
void
|
|
PE_Function::Process_Raises()
|
|
{
|
|
if (eState != params_finished)
|
|
{
|
|
OnDefault();
|
|
return;
|
|
}
|
|
SetResult(done,stay);
|
|
eState = expect_exceptions_list;
|
|
}
|
|
|
|
void
|
|
PE_Function::Process_Default()
|
|
{
|
|
switch (eState)
|
|
{
|
|
case e_start:
|
|
GoIntoReturnType();
|
|
break;
|
|
case expect_parameter_variable:
|
|
GoIntoParameterVariable();
|
|
break;
|
|
case expect_exception:
|
|
GoIntoException();
|
|
break;
|
|
default:
|
|
OnDefault();
|
|
} // end switch
|
|
}
|
|
|
|
void
|
|
PE_Function::GoIntoReturnType()
|
|
{
|
|
SetResult(not_done, push_sure, pPE_Type.Ptr());
|
|
eState = in_return_type;
|
|
}
|
|
|
|
void
|
|
PE_Function::GoIntoParameterVariable()
|
|
{
|
|
SetResult(not_done, push_sure, pPE_Variable.Ptr());
|
|
eState = in_parameter_variable;
|
|
}
|
|
|
|
void
|
|
PE_Function::GoIntoException()
|
|
{
|
|
SetResult(not_done, push_sure, pPE_Type.Ptr());
|
|
eState = in_exception;
|
|
}
|
|
|
|
void
|
|
PE_Function::OnDefault()
|
|
{
|
|
throw X_AutodocParser(X_AutodocParser::x_Any);
|
|
}
|
|
|
|
void
|
|
PE_Function::InitData()
|
|
{
|
|
eState = e_start;
|
|
|
|
sData_Name.clear();
|
|
nData_ReturnType = 0;
|
|
bData_Oneway = false;
|
|
pCurFunction = 0;
|
|
|
|
nCurParsedType = 0;
|
|
eCurParsedParam_Direction = ary::idl::param_in;
|
|
nCurParsedParam_Type = 0;
|
|
sCurParsedParam_Name.clear();
|
|
|
|
if (bIsForConstructors)
|
|
{
|
|
eState = expect_name;
|
|
}
|
|
}
|
|
|
|
void
|
|
PE_Function::ReceiveData()
|
|
{
|
|
switch (eState)
|
|
{
|
|
case in_return_type:
|
|
nData_ReturnType = nCurParsedType;
|
|
nCurParsedType = 0;
|
|
eState = expect_name;
|
|
break;
|
|
case in_parameter_variable:
|
|
csv_assert(pCurFunction != 0);
|
|
pCurFunction->Add_Parameter(
|
|
sCurParsedParam_Name,
|
|
nCurParsedParam_Type,
|
|
eCurParsedParam_Direction );
|
|
sCurParsedParam_Name = "";
|
|
nCurParsedParam_Type = 0;
|
|
eCurParsedParam_Direction = ary::idl::param_in;
|
|
eState = expect_parameter_separator;
|
|
break;
|
|
case in_exception:
|
|
csv_assert(pCurFunction != 0);
|
|
pCurFunction->Add_Exception(nCurParsedType);
|
|
eState = expect_exception_separator;
|
|
break;
|
|
default:
|
|
csv_assert(false);
|
|
} // end switch
|
|
}
|
|
|
|
void
|
|
PE_Function::TransferData()
|
|
{
|
|
pCurFunction = 0;
|
|
eState = e_none;
|
|
}
|
|
|
|
UnoIDL_PE &
|
|
PE_Function::MyPE()
|
|
{
|
|
return *this;
|
|
}
|
|
|
|
|
|
|
|
} // namespace uidl
|
|
} // namespace csi
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|