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_func2.hxx>
22 :
23 :
24 : // NOT FULLY DEFINED SERVICES
25 : #include <ary/idl/i_function.hxx>
26 : #include <ary/idl/i_type.hxx>
27 : #include <ary/idl/i_gate.hxx>
28 : #include <ary/idl/ip_ce.hxx>
29 : #include <ary/idl/ip_type.hxx>
30 : #include <ary/doc/d_oldidldocu.hxx>
31 : #include <s2_luidl/pe_type2.hxx>
32 : #include <s2_luidl/pe_vari2.hxx>
33 : #include <s2_luidl/tk_keyw.hxx>
34 : #include <s2_luidl/tk_ident.hxx>
35 : #include <s2_luidl/tk_punct.hxx>
36 : #include <x_parse2.hxx>
37 :
38 :
39 : namespace csi
40 : {
41 : namespace uidl
42 : {
43 :
44 :
45 3 : PE_Function::PE_Function( const RParent & i_rCurInterface )
46 : : eState(e_none),
47 : sData_Name(),
48 : nData_ReturnType(0),
49 : bData_Oneway(false),
50 : pCurFunction(0),
51 : pCurParent(&i_rCurInterface),
52 : pPE_Type(0),
53 : nCurParsedType(0),
54 : sName(),
55 : pPE_Variable(0),
56 : eCurParsedParam_Direction(ary::idl::param_in),
57 : nCurParsedParam_Type(0),
58 : sCurParsedParam_Name(),
59 3 : bIsForConstructors(false)
60 : {
61 3 : pPE_Type = new PE_Type(nCurParsedType);
62 3 : pPE_Variable = new PE_Variable(nCurParsedParam_Type, sCurParsedParam_Name);
63 3 : }
64 :
65 3 : PE_Function::PE_Function( const RParent & i_rCurService,
66 : E_Constructor )
67 : : eState(expect_name),
68 : sData_Name(),
69 : nData_ReturnType(0),
70 : bData_Oneway(false),
71 : pCurFunction(0),
72 : pCurParent(&i_rCurService),
73 : pPE_Type(0),
74 : nCurParsedType(0),
75 : sName(),
76 : pPE_Variable(0),
77 : eCurParsedParam_Direction(ary::idl::param_in),
78 : nCurParsedParam_Type(0),
79 : sCurParsedParam_Name(),
80 3 : bIsForConstructors(true)
81 : {
82 3 : pPE_Type = new PE_Type(nCurParsedType);
83 3 : pPE_Variable = new PE_Variable(nCurParsedParam_Type, sCurParsedParam_Name);
84 3 : }
85 :
86 : void
87 6 : PE_Function::EstablishContacts( UnoIDL_PE * io_pParentPE,
88 : ary::Repository & io_rRepository,
89 : TokenProcessing_Result & o_rResult )
90 : {
91 6 : UnoIDL_PE::EstablishContacts(io_pParentPE,io_rRepository,o_rResult);
92 6 : pPE_Type->EstablishContacts(this,io_rRepository,o_rResult);
93 6 : pPE_Variable->EstablishContacts(this,io_rRepository,o_rResult);
94 6 : }
95 :
96 12 : PE_Function::~PE_Function()
97 : {
98 12 : }
99 :
100 : void
101 54539 : PE_Function::ProcessToken( const Token & i_rToken )
102 : {
103 54539 : i_rToken.Trigger(*this);
104 54539 : }
105 :
106 : void
107 0 : PE_Function::Process_Stereotype( const TokStereotype & i_rToken )
108 : {
109 0 : if (eState == e_start)
110 : {
111 0 : switch (i_rToken.Id())
112 : {
113 : case TokStereotype::ste_oneway:
114 0 : bData_Oneway = true;
115 0 : SetResult(done, stay);
116 0 : break;
117 : default:
118 0 : OnDefault();
119 : } // end switch
120 : }
121 : else
122 0 : OnDefault();
123 0 : }
124 :
125 : void
126 10504 : PE_Function::Process_Identifier( const TokIdentifier & i_rToken )
127 : {
128 10504 : switch (eState)
129 : {
130 : case e_start:
131 1061 : GoIntoReturnType();
132 1061 : break;
133 : case expect_name:
134 5595 : sData_Name = i_rToken.Text();
135 5595 : SetResult(done,stay);
136 5595 : eState = expect_params_list;
137 :
138 5595 : if (NOT bIsForConstructors)
139 : {
140 5502 : pCurFunction = &Gate().Ces().Store_Function(
141 : *pCurParent,
142 : sData_Name,
143 : nData_ReturnType,
144 5502 : bData_Oneway );
145 : }
146 : else
147 : {
148 93 : pCurFunction = &Gate().Ces().Store_ServiceConstructor(
149 : *pCurParent,
150 93 : sData_Name );
151 : }
152 5595 : PassDocuAt(*pCurFunction);
153 5595 : break;
154 : case expect_parameter_variable:
155 1816 : GoIntoParameterVariable();
156 1816 : break;
157 : case expect_exception:
158 2032 : GoIntoException();
159 2032 : break;
160 : default:
161 0 : OnDefault();
162 : }
163 10504 : }
164 :
165 : void
166 23424 : PE_Function::Process_Punctuation( const TokPunctuation & i_rToken )
167 : {
168 23424 : switch (eState)
169 : {
170 : case e_start:
171 0 : SetResult(done,stay);
172 0 : break;
173 : case expect_params_list:
174 5595 : if (i_rToken.Id() != TokPunctuation::BracketOpen)
175 : {
176 0 : OnDefault();
177 0 : return;
178 : }
179 5595 : SetResult(done,stay);
180 5595 : eState = expect_parameter;
181 5595 : break;
182 : case expect_parameter:
183 2055 : if (i_rToken.Id() == TokPunctuation::BracketClose)
184 : {
185 2055 : SetResult(done,stay);
186 2055 : eState = params_finished;
187 : }
188 : else
189 : {
190 0 : OnDefault();
191 0 : return;
192 : }
193 2055 : break;
194 : case expect_parameter_separator:
195 5658 : if (i_rToken.Id() == TokPunctuation::Comma)
196 : {
197 2118 : SetResult(done,stay);
198 2118 : eState = expect_parameter;
199 : }
200 3540 : else if (i_rToken.Id() == TokPunctuation::BracketClose)
201 : {
202 3540 : SetResult(done,stay);
203 3540 : eState = params_finished;
204 : }
205 : else
206 : {
207 0 : OnDefault();
208 0 : return;
209 : }
210 5658 : break;
211 : case params_finished:
212 : case exceptions_finished:
213 5595 : if (i_rToken.Id() != TokPunctuation::Semicolon)
214 : {
215 0 : OnDefault();
216 0 : return;
217 : }
218 5595 : SetResult(done,pop_success);
219 5595 : eState = e_none;
220 5595 : break;
221 : case expect_exceptions_list:
222 1848 : if (i_rToken.Id() != TokPunctuation::BracketOpen)
223 : {
224 0 : OnDefault();
225 0 : return;
226 : }
227 1848 : SetResult(done,stay);
228 1848 : eState = expect_exception;
229 1848 : break;
230 : case expect_exception_separator:
231 2673 : if (i_rToken.Id() == TokPunctuation::Comma)
232 : {
233 825 : SetResult(done,stay);
234 825 : eState = expect_exception;
235 : }
236 1848 : else if (i_rToken.Id() == TokPunctuation::BracketClose)
237 : {
238 1848 : SetResult(done,stay);
239 1848 : eState = exceptions_finished;
240 : }
241 : else
242 : {
243 0 : OnDefault();
244 0 : return;
245 : }
246 2673 : break;
247 : default:
248 0 : OnDefault();
249 : }
250 : }
251 :
252 : void
253 7000 : PE_Function::Process_BuiltInType( const TokBuiltInType & i_rToken )
254 : {
255 7000 : switch (eState)
256 : {
257 : case e_start:
258 3892 : GoIntoReturnType();
259 3892 : break;
260 : case expect_parameter_variable:
261 3108 : GoIntoParameterVariable();
262 3108 : break;
263 : case expect_parameter_separator:
264 0 : if (i_rToken.Id() != TokBuiltInType::bty_ellipse)
265 : {
266 0 : OnDefault();
267 : }
268 : else
269 : {
270 0 : pCurFunction->Set_Ellipse();
271 0 : SetResult(done,stay);
272 : // eState stays the same, because we wait for the closing ")" now.
273 : }
274 0 : break;
275 : case expect_exception:
276 0 : GoIntoException();
277 0 : break;
278 : default:
279 0 : OnDefault();
280 : } // end switch
281 7000 : }
282 :
283 : void
284 5658 : PE_Function::Process_ParameterHandling( const TokParameterHandling & i_rToken )
285 : {
286 5658 : if (eState != expect_parameter)
287 : {
288 0 : OnDefault();
289 5658 : return;
290 : }
291 :
292 5658 : switch (i_rToken.Id())
293 : {
294 : case TokParameterHandling::ph_in:
295 5581 : eCurParsedParam_Direction = ary::idl::param_in;
296 5581 : break;
297 : case TokParameterHandling::ph_out:
298 59 : eCurParsedParam_Direction = ary::idl::param_out;
299 59 : break;
300 : case TokParameterHandling::ph_inout:
301 18 : eCurParsedParam_Direction = ary::idl::param_inout;
302 18 : break;
303 : default:
304 : csv_assert(false);
305 : }
306 5658 : SetResult(done,stay);
307 5658 : eState = expect_parameter_variable;
308 : }
309 :
310 : void
311 1848 : PE_Function::Process_Raises()
312 : {
313 1848 : if (eState != params_finished)
314 : {
315 0 : OnDefault();
316 1848 : return;
317 : }
318 1848 : SetResult(done,stay);
319 1848 : eState = expect_exceptions_list;
320 : }
321 :
322 : void
323 1924 : PE_Function::Process_Default()
324 : {
325 1924 : switch (eState)
326 : {
327 : case e_start:
328 549 : GoIntoReturnType();
329 549 : break;
330 : case expect_parameter_variable:
331 734 : GoIntoParameterVariable();
332 734 : break;
333 : case expect_exception:
334 641 : GoIntoException();
335 641 : break;
336 : default:
337 0 : OnDefault();
338 : } // end switch
339 1924 : }
340 :
341 : void
342 5502 : PE_Function::GoIntoReturnType()
343 : {
344 5502 : SetResult(not_done, push_sure, pPE_Type.Ptr());
345 5502 : eState = in_return_type;
346 5502 : }
347 :
348 : void
349 5658 : PE_Function::GoIntoParameterVariable()
350 : {
351 5658 : SetResult(not_done, push_sure, pPE_Variable.Ptr());
352 5658 : eState = in_parameter_variable;
353 5658 : }
354 :
355 : void
356 2673 : PE_Function::GoIntoException()
357 : {
358 2673 : SetResult(not_done, push_sure, pPE_Type.Ptr());
359 2673 : eState = in_exception;
360 2673 : }
361 :
362 : void
363 0 : PE_Function::OnDefault()
364 : {
365 0 : throw X_AutodocParser(X_AutodocParser::x_Any);
366 : }
367 :
368 : void
369 5595 : PE_Function::InitData()
370 : {
371 5595 : eState = e_start;
372 :
373 5595 : sData_Name.clear();
374 5595 : nData_ReturnType = 0;
375 5595 : bData_Oneway = false;
376 5595 : pCurFunction = 0;
377 :
378 5595 : nCurParsedType = 0;
379 5595 : eCurParsedParam_Direction = ary::idl::param_in;
380 5595 : nCurParsedParam_Type = 0;
381 5595 : sCurParsedParam_Name.clear();
382 :
383 5595 : if (bIsForConstructors)
384 : {
385 93 : eState = expect_name;
386 : }
387 5595 : }
388 :
389 : void
390 13833 : PE_Function::ReceiveData()
391 : {
392 13833 : switch (eState)
393 : {
394 : case in_return_type:
395 5502 : nData_ReturnType = nCurParsedType;
396 5502 : nCurParsedType = 0;
397 5502 : eState = expect_name;
398 5502 : break;
399 : case in_parameter_variable:
400 : csv_assert(pCurFunction != 0);
401 : pCurFunction->Add_Parameter(
402 : sCurParsedParam_Name,
403 : nCurParsedParam_Type,
404 5658 : eCurParsedParam_Direction );
405 5658 : sCurParsedParam_Name = "";
406 5658 : nCurParsedParam_Type = 0;
407 5658 : eCurParsedParam_Direction = ary::idl::param_in;
408 5658 : eState = expect_parameter_separator;
409 5658 : break;
410 : case in_exception:
411 : csv_assert(pCurFunction != 0);
412 2673 : pCurFunction->Add_Exception(nCurParsedType);
413 2673 : eState = expect_exception_separator;
414 2673 : break;
415 : default:
416 : csv_assert(false);
417 : } // end switch
418 13833 : }
419 :
420 : void
421 5595 : PE_Function::TransferData()
422 : {
423 5595 : pCurFunction = 0;
424 5595 : eState = e_none;
425 5595 : }
426 :
427 : UnoIDL_PE &
428 4181 : PE_Function::MyPE()
429 : {
430 4181 : return *this;
431 : }
432 :
433 :
434 :
435 : } // namespace uidl
436 3 : } // namespace csi
437 :
438 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
