autodoc/source/parser_i/idl/pe_excp.cxx

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