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_servi.hxx>
22 :
23 :
24 : // NOT FULLY DEFINED SERVICES
25 : #include <ary/idl/i_gate.hxx>
26 : #include <ary/idl/i_service.hxx>
27 : #include <ary/idl/i_siservice.hxx>
28 : #include <ary/idl/ip_ce.hxx>
29 : #include <ary/doc/d_oldidldocu.hxx>
30 : #include <s2_luidl/pe_func2.hxx>
31 : #include <s2_luidl/pe_property.hxx>
32 : #include <s2_luidl/pe_type2.hxx>
33 : #include <s2_luidl/tk_keyw.hxx>
34 : #include <s2_luidl/tk_ident.hxx>
35 : #include <s2_luidl/tk_punct.hxx>
36 :
37 :
38 :
39 : namespace csi
40 : {
41 : namespace uidl
42 : {
43 :
44 :
45 :
46 3 : PE_Service::PE_Service()
47 : : eState(e_none),
48 : sData_Name(),
49 : bIsPreDeclaration(false),
50 : pCurService(0),
51 : pCurSiService(0),
52 : nCurService(0),
53 : pPE_Property(0),
54 : nCurParsed_Property(0),
55 : pPE_Type(0),
56 : nCurParsed_Type(0),
57 : pPE_Constructor(0),
58 3 : bOptionalMember(false)
59 : {
60 3 : pPE_Property = new PE_Property(nCurService);
61 3 : pPE_Type = new PE_Type(nCurParsed_Type);
62 3 : pPE_Constructor = new PE_Function(nCurService, PE_Function::constructor);
63 3 : }
64 :
65 : void
66 3 : PE_Service::EstablishContacts( UnoIDL_PE * io_pParentPE,
67 : ary::Repository & io_rRepository,
68 : TokenProcessing_Result & o_rResult )
69 : {
70 3 : UnoIDL_PE::EstablishContacts(io_pParentPE,io_rRepository,o_rResult);
71 3 : pPE_Property->EstablishContacts(this,io_rRepository,o_rResult);
72 3 : pPE_Type->EstablishContacts(this,io_rRepository,o_rResult);
73 3 : pPE_Constructor->EstablishContacts(this,io_rRepository,o_rResult);
74 3 : }
75 :
76 6 : PE_Service::~PE_Service()
77 : {
78 6 : }
79 :
80 : void
81 37710 : PE_Service::ProcessToken( const Token & i_rToken )
82 : {
83 37710 : i_rToken.Trigger(*this);
84 37710 : }
85 :
86 :
87 : void
88 7011 : PE_Service::Process_MetaType( const TokMetaType & i_rToken )
89 : {
90 7011 : switch ( i_rToken.Id() )
91 : {
92 : case TokMetaType::mt_service:
93 2110 : if (eState == need_name)
94 1296 : SetResult(done, stay );
95 814 : else if (eState == e_std)
96 : {
97 814 : SetResult(done, push_sure, pPE_Type.Ptr());
98 814 : eState = in_service_type;
99 : }
100 : else
101 0 : On_Default();
102 2110 : break;
103 : case TokMetaType::mt_interface:
104 1949 : if (eState == e_std)
105 : {
106 1949 : SetResult(done, push_sure, pPE_Type.Ptr());
107 1949 : eState = in_ifc_type;
108 : }
109 : else
110 0 : On_Default();
111 1949 : break;
112 : case TokMetaType::mt_property:
113 2952 : if (eState == e_std)
114 : {
115 2952 : StartProperty();
116 : }
117 : else
118 0 : On_Default();
119 2952 : break;
120 : default:
121 : // KORR_FUTURE:
122 : // Should throw syntax error warning.
123 : ;
124 : } // end switch
125 7011 : }
126 :
127 : void
128 1389 : PE_Service::Process_Identifier( const TokIdentifier & i_rToken )
129 : {
130 1389 : if (eState == need_name)
131 : {
132 1296 : sData_Name = i_rToken.Text();
133 1296 : SetResult(done, stay);
134 1296 : eState = need_curlbr_open;
135 : }
136 93 : else if (eState == e_std_sib)
137 : {
138 93 : SetResult(not_done, push_sure, pPE_Constructor.Ptr());
139 : }
140 : else
141 0 : On_Default();
142 1389 : }
143 :
144 : void
145 7582 : PE_Service::Process_Punctuation( const TokPunctuation & i_rToken )
146 : {
147 7582 : switch (i_rToken.Id())
148 : {
149 : case TokPunctuation::Colon:
150 221 : if (eState == need_curlbr_open)
151 : {
152 221 : SetResult(done, push_sure, pPE_Type.Ptr());
153 221 : eState = need_base_interface;
154 : }
155 : else
156 0 : On_Default();
157 221 : break;
158 :
159 : case TokPunctuation::CurledBracketOpen:
160 1154 : if (eState == need_curlbr_open)
161 : {
162 1075 : pCurService = &Gate().Ces().Store_Service(
163 1075 : CurNamespace().CeId(),
164 2150 : sData_Name );
165 1075 : nCurService = pCurService->CeId();
166 1075 : PassDocuAt(*pCurService);
167 1075 : SetResult(done, stay);
168 1075 : eState = e_std;
169 : }
170 79 : else if (eState == need_curlbr_open_sib)
171 : {
172 79 : SetResult(done, stay);
173 79 : eState = e_std_sib;
174 : }
175 : else
176 0 : On_Default();
177 1154 : break;
178 : case TokPunctuation::CurledBracketClose:
179 1154 : if (eState == e_std OR eState == e_std_sib)
180 : {
181 1154 : SetResult(done, stay);
182 1154 : eState = need_finish;
183 : }
184 : else
185 0 : On_Default();
186 1154 : break;
187 : case TokPunctuation::Comma:
188 994 : if (eState == expect_ifc_separator)
189 : {
190 0 : SetResult(done, push_sure, pPE_Type.Ptr());
191 0 : eState = in_ifc_type;
192 : }
193 994 : else if (eState == expect_service_separator)
194 : {
195 0 : SetResult(done, push_sure, pPE_Type.Ptr());
196 0 : eState = in_service_type;
197 : }
198 994 : else if (eState == e_std)
199 : {
200 994 : SetResult(done, stay);
201 : }
202 : else
203 0 : On_Default();
204 994 : break;
205 : case TokPunctuation::Semicolon:
206 4059 : switch (eState)
207 : {
208 : case need_curlbr_open:
209 0 : sData_Name.clear();
210 0 : bIsPreDeclaration = true;
211 0 : SetResult(done, pop_success);
212 0 : eState = e_none;
213 0 : break;
214 : case need_curlbr_open_sib:
215 142 : SetResult(done, pop_success);
216 142 : eState = e_none;
217 142 : break;
218 : case expect_ifc_separator:
219 : case expect_service_separator:
220 2763 : SetResult(done, stay);
221 2763 : eState = e_std;
222 2763 : break;
223 : case need_finish:
224 1154 : SetResult(done, pop_success);
225 1154 : eState = e_none;
226 1154 : break;
227 : case at_ignore:
228 0 : SetResult(done, stay);
229 0 : eState = e_std;
230 0 : break;
231 : default:
232 0 : On_Default();
233 : } // end switch
234 4059 : break;
235 : default:
236 0 : On_Default();
237 : } // end switch
238 7582 : }
239 :
240 : void
241 1580 : PE_Service::Process_Stereotype( const TokStereotype & i_rToken )
242 : {
243 1580 : if (i_rToken.Id() == TokStereotype::ste_optional)
244 : {
245 1366 : bOptionalMember = true;
246 1366 : SetResult(done, stay);
247 : }
248 214 : else if ( eState == e_std )
249 : {
250 214 : StartProperty();
251 : }
252 : else
253 0 : On_Default();
254 1580 : }
255 :
256 : void
257 0 : PE_Service::Process_Needs()
258 : {
259 0 : SetResult(done,stay);
260 0 : eState = at_ignore;
261 0 : }
262 :
263 : void
264 0 : PE_Service::Process_Observes()
265 : {
266 0 : SetResult(done,stay);
267 0 : eState = at_ignore;
268 0 : }
269 :
270 : void
271 0 : PE_Service::Process_Default()
272 : {
273 0 : On_Default();
274 0 : }
275 :
276 :
277 : void
278 0 : PE_Service::On_Default()
279 : {
280 0 : if (eState == at_ignore)
281 0 : SetResult(done, stay);
282 : else
283 0 : SetResult(not_done, pop_failure);
284 0 : }
285 :
286 : void
287 1296 : PE_Service::InitData()
288 : {
289 1296 : eState = need_name;
290 1296 : sData_Name.clear();
291 1296 : bIsPreDeclaration = false;
292 1296 : pCurService = 0;
293 1296 : pCurSiService = 0;
294 1296 : nCurService = 0;
295 1296 : nCurParsed_Property = 0;
296 1296 : nCurParsed_Type = 0;
297 1296 : bOptionalMember = false;
298 1296 : }
299 :
300 : void
301 1296 : PE_Service::TransferData()
302 : {
303 1296 : if (NOT bIsPreDeclaration)
304 : {
305 : csv_assert(sData_Name.size() > 0);
306 : csv_assert( (pCurService != 0) != (pCurSiService != 0) );
307 : }
308 :
309 1296 : eState = e_none;
310 1296 : }
311 :
312 : void
313 6243 : PE_Service::ReceiveData()
314 : {
315 6243 : switch (eState)
316 : {
317 : case in_property:
318 3166 : eState = e_std;
319 3166 : break;
320 : case in_ifc_type:
321 1949 : if (bOptionalMember)
322 : {
323 306 : pPE_Type->SetOptional();
324 : }
325 : pCurService->AddRef_SupportedInterface(
326 : nCurParsed_Type,
327 1949 : pPE_Type->ReleaseDocu());
328 1949 : nCurParsed_Type = 0;
329 1949 : eState = expect_ifc_separator;
330 1949 : break;
331 : case in_service_type:
332 814 : if (bOptionalMember)
333 : {
334 66 : pPE_Type->SetOptional();
335 : }
336 : pCurService->AddRef_IncludedService(
337 : nCurParsed_Type,
338 814 : pPE_Type->ReleaseDocu());
339 814 : nCurParsed_Type = 0;
340 814 : eState = expect_service_separator;
341 814 : break;
342 : case need_base_interface:
343 221 : pCurSiService = &Gate().Ces().Store_SglIfcService(
344 221 : CurNamespace().CeId(),
345 : sData_Name,
346 442 : nCurParsed_Type );
347 221 : nCurService = pCurSiService->CeId();
348 221 : PassDocuAt(*pCurSiService);
349 :
350 221 : nCurParsed_Type = 0;
351 221 : eState = need_curlbr_open_sib;
352 221 : break;
353 : case e_std_sib:
354 93 : break;
355 : default:
356 : csv_assert(false);
357 : }
358 :
359 6243 : bOptionalMember = false;
360 6243 : }
361 :
362 :
363 : UnoIDL_PE &
364 20148 : PE_Service::MyPE()
365 : {
366 20148 : return *this;
367 : }
368 :
369 : void
370 3166 : PE_Service::StartProperty()
371 : {
372 3166 : SetResult(not_done, push_sure, pPE_Property.Ptr());
373 3166 : eState = in_property;
374 :
375 3166 : if (bOptionalMember)
376 : {
377 994 : pPE_Property->PresetOptional();
378 994 : bOptionalMember = false;
379 : }
380 3166 : }
381 :
382 :
383 : } // namespace uidl
384 3 : } // namespace csi
385 :
386 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
