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