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_attri.hxx>
22 :
23 :
24 : // NOT FULLY DEFINED SERVICES
25 : #include <ary/idl/i_gate.hxx>
26 : #include <ary/idl/i_attribute.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_type2.hxx>
31 : #include <s2_luidl/pe_vari2.hxx>
32 : #include <s2_luidl/tk_keyw.hxx>
33 : #include <s2_luidl/tk_ident.hxx>
34 : #include <s2_luidl/tk_punct.hxx>
35 :
36 :
37 :
38 : namespace csi
39 : {
40 : namespace uidl
41 : {
42 :
43 :
44 :
45 3 : PE_Attribute::PE_Attribute( const Ce_id & i_rCurOwner )
46 : : eState(e_none),
47 : pCurOwner(&i_rCurOwner),
48 : pPE_Variable(0),
49 : pPE_Exception(0),
50 : pCurAttribute(0),
51 : nCurParsedType(0),
52 : sCurParsedName(),
53 : bReadOnly(false),
54 3 : bBound(false)
55 : {
56 3 : pPE_Variable = new PE_Variable(nCurParsedType, sCurParsedName);
57 3 : pPE_Exception = new PE_Type(nCurParsedType);
58 3 : }
59 :
60 : void
61 3 : PE_Attribute::EstablishContacts( UnoIDL_PE * io_pParentPE,
62 : ary::Repository & io_rRepository,
63 : TokenProcessing_Result & o_rResult )
64 : {
65 3 : UnoIDL_PE::EstablishContacts(io_pParentPE,io_rRepository,o_rResult);
66 3 : pPE_Variable->EstablishContacts(this,io_rRepository,o_rResult);
67 3 : pPE_Exception->EstablishContacts(this,io_rRepository,o_rResult);
68 3 : }
69 :
70 6 : PE_Attribute::~PE_Attribute()
71 : {
72 6 : }
73 :
74 : void
75 3789 : PE_Attribute::ProcessToken( const Token & i_rToken )
76 : {
77 3789 : i_rToken.Trigger(*this);
78 3789 : }
79 :
80 : void
81 487 : PE_Attribute::Process_Identifier( const TokIdentifier & i_rToken )
82 : {
83 487 : switch (eState)
84 : {
85 : case e_start:
86 104 : SetResult(not_done, push_sure, pPE_Variable.Ptr());
87 104 : eState = in_variable;
88 104 : break;
89 : case in_raise_std:
90 190 : if (strcmp(i_rToken.Text(),"get") == 0)
91 : {
92 83 : SetResult(done, stay);
93 83 : eState = in_get;
94 : }
95 107 : else if (strcmp(i_rToken.Text(),"set") == 0)
96 : {
97 107 : SetResult(done, stay);
98 107 : eState = in_set;
99 : }
100 : else
101 : {
102 0 : SetResult(not_done, pop_failure);
103 0 : eState = e_none;
104 : }
105 190 : break;
106 : case in_get:
107 : case in_set:
108 193 : SetResult(not_done, push_sure, pPE_Exception.Ptr());
109 193 : break;
110 : default:
111 0 : SetResult(not_done, pop_failure);
112 : } // end switch
113 487 : }
114 :
115 : void
116 280 : PE_Attribute::Process_Stereotype( const TokStereotype & i_rToken )
117 : {
118 280 : if (eState != e_start)
119 : {
120 0 : SetResult(not_done, pop_failure);
121 0 : eState = e_none;
122 0 : return;
123 : }
124 :
125 280 : switch (i_rToken.Id())
126 : {
127 : case TokStereotype::ste_readonly:
128 129 : bReadOnly = true;
129 129 : break;
130 : case TokStereotype::ste_bound:
131 151 : bBound = true;
132 151 : break;
133 : default:
134 0 : SetResult(not_done, pop_failure);
135 0 : eState = e_none;
136 0 : return;
137 : } // end switch
138 :
139 280 : SetResult(done, stay);
140 : }
141 :
142 : void
143 513 : PE_Attribute::Process_MetaType( const TokMetaType & i_rToken )
144 : {
145 513 : if (eState != e_start OR i_rToken.Id() != TokMetaType::mt_attribute)
146 : {
147 0 : SetResult(not_done, pop_failure);
148 0 : eState = e_none;
149 513 : return;
150 : }
151 :
152 513 : SetResult(done, stay);
153 : }
154 :
155 : void
156 1599 : PE_Attribute::Process_Punctuation( const TokPunctuation & i_rToken )
157 : {
158 1599 : switch (eState)
159 : {
160 : case e_start:
161 280 : SetResult(done, stay);
162 280 : break;
163 : case expect_end:
164 626 : switch(i_rToken.Id())
165 : {
166 : case TokPunctuation::Semicolon:
167 513 : SetResult(done, pop_success);
168 513 : eState = e_none;
169 513 : break;
170 : case TokPunctuation::Comma:
171 0 : SetResult(not_done, pop_failure);
172 0 : Cerr() << "Autodoc does not support comma separated attributes, because those are discouraged by IDL policies." << Endl();
173 0 : break;
174 : case TokPunctuation::CurledBracketOpen:
175 113 : SetResult(done, stay);
176 113 : eState = in_raise_std;
177 113 : break;
178 : default:
179 0 : SetResult(not_done, pop_failure);
180 : } // end switch
181 626 : break;
182 : case in_raise_std:
183 113 : SetResult(done, stay);
184 113 : if (i_rToken.Id() == TokPunctuation::CurledBracketClose)
185 : {
186 113 : eState = expect_end;
187 : }
188 113 : break;
189 : case in_get:
190 : case in_set:
191 580 : SetResult(done, stay);
192 580 : if (i_rToken.Id() == TokPunctuation::Semicolon)
193 : {
194 190 : eState = in_raise_std;
195 : }
196 580 : break;
197 : default:
198 : csv_assert(false);
199 : }
200 1599 : }
201 :
202 : void
203 190 : PE_Attribute::Process_Raises()
204 : {
205 190 : if (eState == in_get OR eState == in_set)
206 : {
207 190 : SetResult(done, stay);
208 : }
209 : else
210 0 : SetResult(not_done, pop_failure);
211 190 : }
212 :
213 : void
214 416 : PE_Attribute::Process_Default()
215 : {
216 416 : if (eState == e_start)
217 : {
218 409 : SetResult(not_done, push_sure, pPE_Variable.Ptr());
219 409 : eState = in_variable;
220 : }
221 7 : else if (eState == in_get OR eState == in_set)
222 7 : SetResult(not_done, push_sure, pPE_Exception.Ptr());
223 : else
224 0 : SetResult(not_done, pop_failure);
225 416 : }
226 :
227 : void
228 513 : PE_Attribute::InitData()
229 : {
230 513 : eState = e_start;
231 :
232 513 : pCurAttribute = 0;
233 513 : nCurParsedType = 0;
234 513 : sCurParsedName = "";
235 513 : bReadOnly = false;
236 513 : bBound = false;
237 513 : }
238 :
239 : void
240 513 : PE_Attribute::TransferData()
241 : {
242 513 : eState = e_none;
243 513 : }
244 :
245 : void
246 713 : PE_Attribute::ReceiveData()
247 : {
248 713 : switch (eState)
249 : {
250 : case in_variable:
251 : csv_assert(pCurOwner->IsValid());
252 513 : pCurAttribute = &Gate().Ces().Store_Attribute(
253 : *pCurOwner,
254 : sCurParsedName,
255 : nCurParsedType,
256 : bReadOnly,
257 513 : bBound );
258 513 : PassDocuAt(*pCurAttribute);
259 513 : nCurParsedType = 0;
260 513 : eState = expect_end;
261 513 : break;
262 : case in_get:
263 : csv_assert(pCurAttribute != 0);
264 83 : pCurAttribute->Add_GetException(nCurParsedType);
265 83 : nCurParsedType = 0;
266 83 : break;
267 : case in_set:
268 : csv_assert(pCurAttribute != 0);
269 117 : pCurAttribute->Add_SetException(nCurParsedType);
270 117 : nCurParsedType = 0;
271 117 : break;
272 : default:
273 : csv_assert(false);
274 : } // end switch
275 713 : }
276 :
277 :
278 : UnoIDL_PE &
279 304 : PE_Attribute::MyPE()
280 : {
281 304 : return *this;
282 : }
283 :
284 :
285 : } // namespace uidl
286 3 : } // namespace csi
287 :
288 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
