xref: /trunk/main/autodoc/source/parser_i/idl/pe_file2.cxx (revision 78bc99aafea97f4987aed12e674c2d2f1166dd91)

/**************************************************************
 *
 * 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_file2.hxx>


// NOT FULLY DECLARED SERVICES
#include <ary/idl/i_gate.hxx>
#include <ary/idl/i_module.hxx>
#include <ary/idl/ip_ce.hxx>
#include <ary/doc/d_oldidldocu.hxx>
#include <s2_luidl/distrib.hxx>
#include <s2_luidl/pe_servi.hxx>
#include <s2_luidl/pe_iface.hxx>
#include <s2_luidl/pe_singl.hxx>
#include <s2_luidl/pe_struc.hxx>
#include <s2_luidl/pe_excp.hxx>
#include <s2_luidl/pe_const.hxx>
#include <s2_luidl/pe_enum2.hxx>
#include <s2_luidl/pe_tydf2.hxx>
#include <s2_luidl/tk_keyw.hxx>
#include <s2_luidl/tk_ident.hxx>
#include <s2_luidl/tk_punct.hxx>




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