autodoc/source/parser_i/idl/pe_excp.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: pe_excp.cxx,v $
  10  * $Revision: 1.8 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #include <precomp.h>
  32 #include <s2_luidl/pe_excp.hxx>
  33
  34
  35 // NOT FULLY DECLARED SERVICES
  36 #include <ary/idl/i_exception.hxx>
  37 #include <ary/idl/i_gate.hxx>
  38 #include <ary/idl/i_structelem.hxx>
  39 #include <ary/idl/ip_ce.hxx>
  40 #include <ary/doc/d_oldidldocu.hxx>
  41 #include <s2_luidl/tk_ident.hxx>
  42 #include <s2_luidl/tk_punct.hxx>
  43 #include <s2_luidl/tk_keyw.hxx>
  44 #include <s2_luidl/pe_type2.hxx>
  45 #include <s2_luidl/pe_selem.hxx>
  46
  47
  48
  49 namespace csi
  50 {
  51 namespace uidl
  52 {
  53
  54
  55 PE_Exception::PE_Exception()
  56     // :        aWork,
  57     //      pStati
  58 {
  59     pStati = new S_Stati(*this);
  60 }
  61
  62 void
  63 PE_Exception::EstablishContacts( UnoIDL_PE *                            io_pParentPE,
  64                               ary::Repository &                 io_rRepository,
  65                               TokenProcessing_Result &  o_rResult )
  66 {
  67     UnoIDL_PE::EstablishContacts(io_pParentPE,io_rRepository,o_rResult);
  68     Work().pPE_Element->EstablishContacts(this,io_rRepository,o_rResult);
  69     Work().pPE_Type->EstablishContacts(this,io_rRepository,o_rResult);
  70 }
  71
  72 PE_Exception::~PE_Exception()
  73 {
  74 }
  75
  76 void
  77 PE_Exception::ProcessToken( const Token & i_rToken )
  78 {
  79     i_rToken.Trigger(*Stati().pCurStatus);
  80 }
  81
  82
  83 void
  84 PE_Exception::InitData()
  85 {
  86     Work().InitData();
  87     Stati().pCurStatus = &Stati().aWaitForName;
  88 }
  89
  90 void
  91 PE_Exception::TransferData()
  92 {
  93     if (NOT Work().bIsPreDeclaration)
  94     {
  95         csv_assert(Work().sData_Name.size() > 0);
  96         csv_assert(Work().nCurStruct.IsValid());
  97     }
  98     Stati().pCurStatus = &Stati().aNone;
  99 }
 100
 101 void
 102 PE_Exception::ReceiveData()
 103 {
 104     Stati().pCurStatus->On_SubPE_Left();
 105 }
 106
 107 PE_Exception::S_Work::S_Work()
 108     :   sData_Name(),
 109         bIsPreDeclaration(false),
 110         nCurStruct(0),
 111         pPE_Element(0),
 112         nCurParsed_ElementRef(0),
 113         pPE_Type(0),
 114         nCurParsed_Base(0)
 115
 116 {
 117     pPE_Element = new PE_StructElement(nCurParsed_ElementRef,nCurStruct);
 118     pPE_Type = new PE_Type(nCurParsed_Base);
 119 }
 120
 121 void
 122 PE_Exception::S_Work::InitData()
 123 {
 124     sData_Name.clear();
 125     bIsPreDeclaration = false;
 126     nCurStruct = 0;
 127
 128     nCurParsed_ElementRef = 0;
 129     nCurParsed_Base = 0;
 130 }
 131
 132 void
 133 PE_Exception::S_Work::Prepare_PE_QualifiedName()
 134 {
 135     nCurParsed_ElementRef = 0;
 136 }
 137
 138 void
 139 PE_Exception::S_Work::Prepare_PE_Element()
 140 {
 141     nCurParsed_Base = 0;
 142 }
 143
 144 void
 145 PE_Exception::S_Work::Data_Set_Name( const char * i_sName )
 146 {
 147     sData_Name = i_sName;
 148 }
 149
 150 PE_Exception::S_Stati::S_Stati(PE_Exception & io_rStruct)
 151     :   aNone(io_rStruct),
 152         aWaitForName(io_rStruct),
 153         aGotName(io_rStruct),
 154         aWaitForBase(io_rStruct),
 155         aGotBase(io_rStruct),
 156         aWaitForElement(io_rStruct),
 157         aWaitForFinish(io_rStruct),
 158         pCurStatus(0)
 159 {
 160     pCurStatus = &aNone;
 161 }
 162
 163
 164 //***********************               Stati           ***************************//
 165
 166
 167 UnoIDL_PE &
 168 PE_Exception::PE_StructState::MyPE()
 169 {
 170     return rStruct;
 171 }
 172
 173
 174 void
 175 PE_Exception::State_WaitForName::Process_Identifier( const TokIdentifier & i_rToken )
 176 {
 177     Work().Data_Set_Name(i_rToken.Text());
 178     MoveState( Stati().aGotName );
 179     SetResult(done,stay);
 180 }
 181
 182 void
 183 PE_Exception::State_GotName::Process_Punctuation( const TokPunctuation & i_rToken )
 184 {
 185     if ( i_rToken.Id() != TokPunctuation::Semicolon )
 186     {
 187         switch (i_rToken.Id())
 188         {
 189             case TokPunctuation::Colon:
 190                 MoveState( Stati().aWaitForBase );
 191                 SetResult(done,push_sure,Work().pPE_Type.Ptr());
 192                 Work().Prepare_PE_QualifiedName();
 193                 break;
 194             case TokPunctuation::CurledBracketOpen:
 195                 PE().store_Exception();
 196                 MoveState( Stati().aWaitForElement );
 197                 SetResult(done,stay);
 198                 break;
 199             default:
 200                 SetResult(not_done,pop_failure);
 201         }       // end switch
 202     }
 203     else
 204     {
 205         Work().sData_Name.clear();
 206         SetResult(done,pop_success);
 207     }
 208 }
 209
 210 void
 211 PE_Exception::State_WaitForBase::On_SubPE_Left()
 212 {
 213     MoveState(Stati().aGotBase);
 214 }
 215
 216 void
 217 PE_Exception::State_GotBase::Process_Punctuation( const TokPunctuation & i_rToken )
 218 {
 219     if ( i_rToken.Id() == TokPunctuation::CurledBracketOpen )
 220     {
 221         PE().store_Exception();
 222         MoveState( Stati().aWaitForElement );
 223         SetResult(done,stay);
 224     }
 225     else
 226     {
 227         SetResult(not_done,pop_failure);
 228     }
 229 }
 230
 231 void
 232 PE_Exception::State_WaitForElement::Process_Identifier( const TokIdentifier & )
 233 {
 234     SetResult( not_done, push_sure, Work().pPE_Element.Ptr() );
 235     Work().Prepare_PE_Element();
 236 }
 237
 238 void
 239 PE_Exception::State_WaitForElement::Process_NameSeparator()
 240 {
 241     SetResult( not_done, push_sure, Work().pPE_Element.Ptr());
 242     Work().Prepare_PE_Element();
 243 }
 244
 245 void
 246 PE_Exception::State_WaitForElement::Process_BuiltInType( const TokBuiltInType & )
 247 {
 248     SetResult( not_done, push_sure, Work().pPE_Element.Ptr());
 249     Work().Prepare_PE_Element();
 250 }
 251
 252 void
 253 PE_Exception::State_WaitForElement::Process_TypeModifier(const TokTypeModifier & )
 254 {
 255     SetResult( not_done, push_sure, Work().pPE_Element.Ptr());
 256     Work().Prepare_PE_Element();
 257 }
 258
 259 void
 260 PE_Exception::State_WaitForElement::Process_Punctuation( const TokPunctuation & i_rToken )
 261 {
 262     if ( i_rToken.Id() == TokPunctuation::CurledBracketClose )
 263     {
 264         MoveState( Stati().aWaitForFinish );
 265         SetResult( done, stay );
 266     }
 267     else
 268     {
 269         SetResult( not_done, pop_failure );
 270     }
 271 }
 272
 273 void
 274 PE_Exception::State_WaitForFinish::Process_Punctuation( const TokPunctuation & i_rToken )
 275 {
 276     if (i_rToken.Id() == TokPunctuation::Semicolon)
 277     {
 278         MoveState( Stati().aNone );
 279         SetResult( done, pop_success );
 280     }
 281     else
 282     {
 283         SetResult( not_done, pop_failure );
 284     }
 285 }
 286
 287 void
 288 PE_Exception::store_Exception()
 289 {
 290     ary::idl::Exception &
 291         rCe = Gate().Ces().Store_Exception(
 292                             CurNamespace().CeId(),
 293                             Work().sData_Name,
 294                             Work().nCurParsed_Base );
 295     PassDocuAt(rCe);
 296     Work().nCurStruct = rCe.Id();
 297 }
 298
 299
 300 }   // namespace uidl
 301 }   // namespace csi