autodoc/source/parser_i/inc/s2_luidl/distrib.hxx

   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 #ifndef LUIDL_DISTRIB_HXX
  21 #define LUIDL_DISTRIB_HXX
  22
  23
  24
  25 // USED SERVICES
  26     // BASE CLASSES
  27 #include <s2_luidl/tokrecv.hxx>
  28 #include <s2_dsapi/tokrecv.hxx>
  29 #include <s2_luidl/tokproct.hxx>
  30     // COMPONENTS
  31     // PARAMETERS
  32
  33
  34 class ParserInfo;
  35
  36 namespace ary
  37 {
  38     class Repository;
  39
  40 namespace doc
  41 {
  42     class OldIdlDocu;
  43 }   // namespace inf
  44 }   // namespace ary)
  45
  46
  47
  48 namespace csi
  49 {
  50 namespace dsapi
  51 {
  52     class Token_Receiver;
  53     class SapiDocu_PE;
  54 }
  55
  56
  57
  58 namespace uidl
  59 {
  60
  61
  62 typedef std::vector< DYN Token * >  TokenQueue;
  63 typedef TokenQueue::iterator        TokenIterator;
  64
  65 class TokenParser_Uidl;
  66 class UnoIDL_PE;
  67 class Token;
  68
  69
  70 class TokenDistributor : private TokenProcessing_Types
  71
  72 {
  73   public:
  74                         TokenDistributor(
  75                             ary::Repository &   io_rRepository,
  76                             ParserInfo &            io_rParserInfo );
  77     void                SetTokenProvider(
  78                             TokenParser_Uidl &  io_rTokenSource );
  79     void                SetTopParseEnvironment(
  80                             UnoIDL_PE &         io_pTopParseEnvironment );
  81                         ~TokenDistributor();
  82
  83
  84     void                Reset()                 { aDocumentation.Reset(); }
  85     /** calls pTokenSource->GetNextToken() and checks the incoming tokens, until a
  86         usable token is found. This token will be forwarded to
  87         pTopParseEnv;
  88     */
  89     void                TradeToken();
  90
  91     csi::uidl::Token_Receiver &
  92                         CodeTokens_Receiver();
  93     csi::dsapi::Token_Receiver &
  94                         DocuTokens_Receiver();
  95
  96     /** Used from PE_File, if there is a docu to get without
  97         an environment to push (this is the case for modules).
  98     */
  99     DYN ary::doc::OldIdlDocu *
 100                         ReleaseLastParsedDocu()
 101                             { return aDocumentation.ReleaseLastParsedDocu(); }
 102
 103     /** Used from PE_File, if the term "published" was parsed.
 104         The next opened parse environment will be set to be published
 105         (call ->UnoIDL_PE::SetPublished()).
 106     */
 107     void                Set_PublishedOn()
 108                             { aProcessingData.Set_PublishedOn(); }
 109
 110
 111   private:
 112     class Documentation;
 113     class ProcessingData;
 114     friend class ProcessingData;
 115
 116     class  ProcessingData : public  csi::uidl::Token_Receiver,
 117                             private TokenProcessing_Types
 118     {
 119       public:
 120                             ProcessingData(
 121                                 ary::Repository &   io_rRepository,
 122                                 Documentation &         i_rDocuProcessor,
 123                                 ParserInfo &            io_rParserInfo );
 124                             ~ProcessingData();
 125         void                SetTopParseEnvironment(
 126                                 UnoIDL_PE &         io_pTopParseEnvironment );
 127
 128
 129         /** is called from pTokenSource before finishing a ::TokenParse2::GetNextToken()
 130             call and passes the just parsed token to this class.
 131         */
 132         virtual void        Receive(
 133                                 DYN csi::uidl::Token &
 134                                                 let_drToken );
 135         virtual void        Increment_CurLine();
 136
 137         void                ProcessCurToken();
 138
 139         UnoIDL_PE &         CurEnvironment() const;
 140         bool                NextTokenExists() const;
 141         void                Set_PublishedOn()
 142                                 { bPublishedRecentlyOn = true; }
 143
 144       private:
 145         typedef uintt   TokenQ_Position;
 146         typedef std::pair< UnoIDL_PE *, TokenQ_Position >   EnvironmentInfo;
 147         typedef std::vector< EnvironmentInfo >              EnvironmentStack;
 148
 149         void                AcknowledgeResult();
 150         const csi::uidl::Token &
 151                             CurToken() const;
 152         UnoIDL_PE &         CurEnv() const;
 153         UnoIDL_PE &         PushEnv() const;
 154         uintt               CurTokenPosition() const;
 155         uintt               CurEnv_TriedTokenPosition() const;
 156         void                DecrementTryCount();
 157
 158         EnvironmentStack    aEnvironments;
 159         TokenQueue          aTokenQueue;
 160         TokenIterator       itCurToken;
 161         TokenProcessing_Result
 162                             aCurResult;
 163         uintt               nTryCount;
 164         ary::Repository &
 165                             rRepository;
 166         ParserInfo &        rParserInfo;
 167         Documentation *     pDocuProcessor;
 168         bool                bPublishedRecentlyOn;
 169     };
 170
 171     class Documentation : public csi::dsapi::Token_Receiver
 172     {
 173       public:
 174                             Documentation(
 175                                 ParserInfo &    io_rParserInfo);
 176                             ~Documentation();
 177
 178         void                Reset()             { bIsPassedFirstDocu = false; }
 179
 180         virtual void        Receive(
 181                                 DYN csi::dsapi::Token &
 182                                                 let_drToken );
 183         virtual void        Increment_CurLine();
 184         DYN ary::doc::OldIdlDocu *
 185                             ReleaseLastParsedDocu()
 186                                                 { return pMostRecentDocu.Release(); }
 187       private:
 188         Dyn<csi::dsapi::SapiDocu_PE>
 189                             pDocuParseEnv;
 190         ParserInfo &        rParserInfo;
 191         Dyn<ary::doc::OldIdlDocu>
 192                             pMostRecentDocu;
 193         bool                bIsPassedFirstDocu;
 194     };
 195
 196     // DATA
 197     TokenParser_Uidl *  pTokenSource;
 198     Documentation       aDocumentation;
 199     ProcessingData      aProcessingData;
 200 };
 201
 202
 203
 204 // IMPLEMENTATION
 205
 206 inline void
 207 TokenDistributor::SetTokenProvider( TokenParser_Uidl &  io_rTokenSource )
 208     { pTokenSource = &io_rTokenSource; }
 209
 210 inline void
 211 TokenDistributor::SetTopParseEnvironment( UnoIDL_PE & io_pTopParseEnvironment )
 212     { aProcessingData.SetTopParseEnvironment(io_pTopParseEnvironment); }
 213
 214 inline csi::uidl::Token_Receiver &
 215 TokenDistributor::CodeTokens_Receiver()
 216     { return aProcessingData; }
 217
 218 inline csi::dsapi::Token_Receiver &
 219 TokenDistributor::DocuTokens_Receiver()
 220     { return aDocumentation; }
 221
 222 inline const csi::uidl::Token &
 223 TokenDistributor::ProcessingData::CurToken() const
 224 {
 225     csv_assert( itCurToken != aTokenQueue.end() );
 226     csv_assert( *itCurToken != 0 );
 227     return *(*itCurToken);
 228 }
 229
 230 inline UnoIDL_PE &
 231 TokenDistributor::ProcessingData::CurEnv() const
 232 {
 233     csv_assert( aEnvironments.size() > 0 );
 234     csv_assert( aEnvironments.back().first != 0 );
 235     return *aEnvironments.back().first;
 236 }
 237
 238 inline UnoIDL_PE &
 239 TokenDistributor::ProcessingData::PushEnv() const
 240 {
 241     csv_assert( aCurResult.pEnv2Push != 0 );
 242     return *aCurResult.pEnv2Push;
 243 }
 244
 245 inline uintt
 246 TokenDistributor::ProcessingData::CurTokenPosition() const
 247 {
 248     return itCurToken - aTokenQueue.begin();
 249 }
 250
 251 inline uintt
 252 TokenDistributor::ProcessingData::CurEnv_TriedTokenPosition() const
 253 {
 254     csv_assert( aEnvironments.size() > 0 );
 255     return aEnvironments.back().second;
 256 }
 257
 258
 259 }   // namespace uidl
 260 }   // namespace csi
 261
 262 #endif
 263
 264 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */