LCOV - code coverage report
Current view: top level - libreoffice/autodoc/source/parser_i/idl - pe_property.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 75 87 86.2 %
Date: 2012-12-27 Functions: 15 17 88.2 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #include <precomp.h>
      21             : #include <s2_luidl/pe_property.hxx>
      22             : 
      23             : 
      24             : // NOT FULLY DEFINED SERVICES
      25             : #include <ary/idl/i_gate.hxx>
      26             : #include <ary/idl/i_property.hxx>
      27             : #include <ary/idl/i_service.hxx>
      28             : #include <ary/idl/ip_ce.hxx>
      29             : #include <ary/doc/d_oldidldocu.hxx>
      30             : #include <s2_luidl/pe_vari2.hxx>
      31             : #include <s2_luidl/tk_keyw.hxx>
      32             : #include <s2_luidl/tk_ident.hxx>
      33             : #include <s2_luidl/tk_punct.hxx>
      34             : 
      35             : 
      36             : 
      37             : namespace csi
      38             : {
      39             : namespace uidl
      40             : {
      41             : 
      42             : 
      43             : 
      44           3 : PE_Property::PE_Property( const Ce_id & i_rCurOwner )
      45             :     :   eState(e_none),
      46             :         pCurOwner(&i_rCurOwner),
      47             :         pPE_Variable(0),
      48             :         nCurParsedType(0),
      49             :         sCurParsedName(),
      50             :         bIsOptional(false),
      51           3 :         aStereotypes()
      52             : {
      53           3 :     pPE_Variable    = new PE_Variable(nCurParsedType, sCurParsedName);
      54           3 : }
      55             : 
      56             : void
      57           3 : PE_Property::EstablishContacts( UnoIDL_PE *                io_pParentPE,
      58             :                                 ary::Repository &       io_rRepository,
      59             :                                 TokenProcessing_Result &    o_rResult )
      60             : {
      61           3 :     UnoIDL_PE::EstablishContacts(io_pParentPE,io_rRepository,o_rResult);
      62           3 :     pPE_Variable->EstablishContacts(this,io_rRepository,o_rResult);
      63           3 : }
      64             : 
      65           6 : PE_Property::~PE_Property()
      66             : {
      67           6 : }
      68             : 
      69             : void
      70       10362 : PE_Property::ProcessToken( const Token & i_rToken )
      71             : {
      72       10362 :     i_rToken.Trigger(*this);
      73       10362 : }
      74             : 
      75             : void
      76         429 : PE_Property::Process_Stereotype( const TokStereotype & i_rToken )
      77             : {
      78         429 :     switch (i_rToken.Id())
      79             :     {
      80             :         case TokStereotype::ste_optional:
      81          64 :             bIsOptional = true;
      82          64 :             break;
      83             :         case TokStereotype::ste_readonly:
      84         226 :             aStereotypes.Set_Flag(Stereotypes::readonly);
      85         226 :             break;
      86             :         case TokStereotype::ste_bound:
      87           4 :             aStereotypes.Set_Flag(Stereotypes::bound);
      88           4 :             break;
      89             :         case TokStereotype::ste_constrained:
      90           0 :             aStereotypes.Set_Flag(Stereotypes::constrained);
      91           0 :             break;
      92             :         case TokStereotype::ste_maybeambiguous:
      93           0 :             aStereotypes.Set_Flag(Stereotypes::maybeambiguous);
      94           0 :             break;
      95             :         case TokStereotype::ste_maybedefault:
      96           3 :             aStereotypes.Set_Flag(Stereotypes::maybedefault);
      97           3 :             break;
      98             :         case TokStereotype::ste_maybevoid:
      99         126 :             aStereotypes.Set_Flag(Stereotypes::maybevoid);
     100         126 :             break;
     101             :         case TokStereotype::ste_removable:
     102           0 :             aStereotypes.Set_Flag(Stereotypes::removable);
     103           0 :             break;
     104             :         case TokStereotype::ste_transient:
     105           6 :             aStereotypes.Set_Flag(Stereotypes::transient);
     106           6 :             break;
     107             : 
     108             :         default:
     109           0 :             SetResult(not_done, pop_failure);
     110           0 :             eState = e_none;
     111         429 :             return;
     112             :     }
     113             : 
     114         429 :     SetResult(done, stay);
     115             : }
     116             : 
     117             : void
     118        3166 : PE_Property::Process_MetaType( const TokMetaType & i_rToken )
     119             : {
     120        3166 :     if (eState == e_start)
     121             :     {
     122        3166 :         if ( i_rToken.Id() == TokMetaType::mt_property )
     123             :         {
     124        3166 :             SetResult(done, stay);
     125        3166 :             eState = expect_variable;
     126        6332 :             return;
     127             :         }
     128             :     }   // endif (eState == e_start)
     129             : 
     130           0 :     SetResult(not_done, pop_failure);
     131           0 :     eState = e_none;
     132             : }
     133             : 
     134             : void
     135        3595 : PE_Property::Process_Punctuation( const TokPunctuation & i_rToken )
     136             : {
     137        3595 :     switch (eState)
     138             :     {
     139             :         case e_start:
     140         221 :             SetResult(done, stay);
     141         221 :             break;
     142             :         case expect_variable:
     143        3374 :             if (i_rToken.Id() == TokPunctuation::Semicolon)
     144             :             {
     145        3166 :                 SetResult(done, pop_success);
     146        3166 :                 eState = e_none;
     147             :             }
     148         208 :             else if (i_rToken.Id() == TokPunctuation::Comma)
     149         208 :                 SetResult(done, stay);
     150             :             else
     151           0 :                 SetResult(not_done, pop_failure);
     152        3374 :             break;
     153             :         default:
     154             :             csv_assert(false);
     155             :     }
     156        3595 : }
     157             : 
     158             : void
     159        3166 : PE_Property::Process_Default()
     160             : {
     161        3166 :     if (eState == expect_variable)
     162             :     {
     163        3166 :         SetResult(not_done, push_sure, pPE_Variable.Ptr());
     164        3166 :         eState = in_variable;
     165             :     }
     166             :     else
     167           0 :         SetResult(not_done, pop_failure);
     168        3166 : }
     169             : 
     170             : void
     171        3166 : PE_Property::InitData()
     172             : {
     173        3166 :     eState = e_start;
     174             : 
     175        3166 :     nCurParsedType = 0;
     176        3166 :     sCurParsedName = "";
     177             : 
     178             :     // bIsOptional and
     179             :     // aStereotypes
     180             :     //   may be preset by the PE_Service-(or PE_Interface-)parent
     181             :     //   with PresetOptional() or
     182             :     //   PresetStereotype()
     183             :     //   - therefore it must not be set here!
     184        3166 : }
     185             : 
     186             : void
     187        3166 : PE_Property::TransferData()
     188             : {
     189        3166 :     if (bIsOptional)
     190             :     {
     191        1058 :         SetOptional();
     192        1058 :         bIsOptional = false;
     193             :     }
     194             : 
     195             :     ary::idl::CodeEntity *
     196        3166 :         pCe = 0;
     197             :     csv_assert(pCurOwner->IsValid());
     198             : 
     199        3166 :     pCe = &Gate().Ces().Store_Property( *pCurOwner,
     200             :                                         sCurParsedName,
     201             :                                         nCurParsedType,
     202        3166 :                                         aStereotypes );
     203             : 
     204             :     csv_assert(pCe != 0);
     205        3166 :     PassDocuAt(*pCe);
     206             : 
     207        3166 :     nCurParsedType = 0;
     208        3166 :     sCurParsedName.clear();
     209        3166 :     aStereotypes = Stereotypes();
     210             : 
     211        3166 :     eState = e_none;
     212        3166 : }
     213             : 
     214             : void
     215        3166 : PE_Property::ReceiveData()
     216             : {
     217        3166 :     eState = expect_variable;
     218        3166 : }
     219             : 
     220             : 
     221             : UnoIDL_PE &
     222           6 : PE_Property::MyPE()
     223             : {
     224           6 :     return *this;
     225             : }
     226             : 
     227             : 
     228             : }   // namespace uidl
     229           3 : }   // namespace csi
     230             : 
     231             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10