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 #include <precomp.h>
23 #include <s2_luidl/pe_excp.hxx>
24 
25 
26 // NOT FULLY DECLARED SERVICES
27 #include <ary/idl/i_exception.hxx>
28 #include <ary/idl/i_gate.hxx>
29 #include <ary/idl/i_structelem.hxx>
30 #include <ary/idl/ip_ce.hxx>
31 #include <ary/doc/d_oldidldocu.hxx>
32 #include <s2_luidl/tk_ident.hxx>
33 #include <s2_luidl/tk_punct.hxx>
34 #include <s2_luidl/tk_keyw.hxx>
35 #include <s2_luidl/pe_type2.hxx>
36 #include <s2_luidl/pe_selem.hxx>
37 
38 
39 
40 namespace csi
41 {
42 namespace uidl
43 {
44 
45 
46 PE_Exception::PE_Exception()
47 	// :	aWork,
48 	//      pStati
49 {
50 	pStati = new S_Stati(*this);
51 }
52 
53 void
54 PE_Exception::EstablishContacts( UnoIDL_PE *				io_pParentPE,
55 							  ary::Repository &			io_rRepository,
56 							  TokenProcessing_Result & 	o_rResult )
57 {
58 	UnoIDL_PE::EstablishContacts(io_pParentPE,io_rRepository,o_rResult);
59 	Work().pPE_Element->EstablishContacts(this,io_rRepository,o_rResult);
60 	Work().pPE_Type->EstablishContacts(this,io_rRepository,o_rResult);
61 }
62 
63 PE_Exception::~PE_Exception()
64 {
65 }
66 
67 void
68 PE_Exception::ProcessToken( const Token & i_rToken )
69 {
70 	i_rToken.Trigger(*Stati().pCurStatus);
71 }
72 
73 
74 void
75 PE_Exception::InitData()
76 {
77 	Work().InitData();
78 	Stati().pCurStatus = &Stati().aWaitForName;
79 }
80 
81 void
82 PE_Exception::TransferData()
83 {
84 	if (NOT Work().bIsPreDeclaration)
85 	{
86 		csv_assert(Work().sData_Name.size() > 0);
87 		csv_assert(Work().nCurStruct.IsValid());
88 	}
89 	Stati().pCurStatus = &Stati().aNone;
90 }
91 
92 void
93 PE_Exception::ReceiveData()
94 {
95 	Stati().pCurStatus->On_SubPE_Left();
96 }
97 
98 PE_Exception::S_Work::S_Work()
99 	:	sData_Name(),
100 		bIsPreDeclaration(false),
101 		nCurStruct(0),
102 		pPE_Element(0),
103 		nCurParsed_ElementRef(0),
104 		pPE_Type(0),
105 		nCurParsed_Base(0)
106 
107 {
108 	pPE_Element = new PE_StructElement(nCurParsed_ElementRef,nCurStruct);
109 	pPE_Type = new PE_Type(nCurParsed_Base);
110 }
111 
112 void
113 PE_Exception::S_Work::InitData()
114 {
115 	sData_Name.clear();
116 	bIsPreDeclaration = false;
117 	nCurStruct = 0;
118 
119     nCurParsed_ElementRef = 0;
120     nCurParsed_Base = 0;
121 }
122 
123 void
124 PE_Exception::S_Work::Prepare_PE_QualifiedName()
125 {
126 	nCurParsed_ElementRef = 0;
127 }
128 
129 void
130 PE_Exception::S_Work::Prepare_PE_Element()
131 {
132 	nCurParsed_Base = 0;
133 }
134 
135 void
136 PE_Exception::S_Work::Data_Set_Name( const char * i_sName )
137 {
138 	sData_Name = i_sName;
139 }
140 
141 PE_Exception::S_Stati::S_Stati(PE_Exception & io_rStruct)
142 	:	aNone(io_rStruct),
143 		aWaitForName(io_rStruct),
144 		aGotName(io_rStruct),
145 		aWaitForBase(io_rStruct),
146 		aGotBase(io_rStruct),
147 		aWaitForElement(io_rStruct),
148 		aWaitForFinish(io_rStruct),
149 		pCurStatus(0)
150 {
151 	pCurStatus = &aNone;
152 }
153 
154 
155 //***********************		Stati		***************************//
156 
157 
158 UnoIDL_PE &
159 PE_Exception::PE_StructState::MyPE()
160 {
161 	return rStruct;
162 }
163 
164 
165 void
166 PE_Exception::State_WaitForName::Process_Identifier( const TokIdentifier & i_rToken )
167 {
168 	Work().Data_Set_Name(i_rToken.Text());
169 	MoveState( Stati().aGotName );
170 	SetResult(done,stay);
171 }
172 
173 void
174 PE_Exception::State_GotName::Process_Punctuation( const TokPunctuation & i_rToken )
175 {
176 	if ( i_rToken.Id() != TokPunctuation::Semicolon )
177     {
178 		switch (i_rToken.Id())
179 		{
180 			case TokPunctuation::Colon:
181 				MoveState( Stati().aWaitForBase );
182 				SetResult(done,push_sure,Work().pPE_Type.Ptr());
183 				Work().Prepare_PE_QualifiedName();
184 				break;
185 			case TokPunctuation::CurledBracketOpen:
186 			    PE().store_Exception();
187 				MoveState( Stati().aWaitForElement );
188 				SetResult(done,stay);
189 				break;
190 			default:
191 				SetResult(not_done,pop_failure);
192 		}	// end switch
193 	}
194 	else
195 	{
196 		Work().sData_Name.clear();
197 		SetResult(done,pop_success);
198 	}
199 }
200 
201 void
202 PE_Exception::State_WaitForBase::On_SubPE_Left()
203 {
204 	MoveState(Stati().aGotBase);
205 }
206 
207 void
208 PE_Exception::State_GotBase::Process_Punctuation( const TokPunctuation & i_rToken )
209 {
210 	if ( i_rToken.Id() == TokPunctuation::CurledBracketOpen )
211 	{
212 	    PE().store_Exception();
213 		MoveState( Stati().aWaitForElement );
214 		SetResult(done,stay);
215 	}
216 	else
217 	{
218 		SetResult(not_done,pop_failure);
219 	}
220 }
221 
222 void
223 PE_Exception::State_WaitForElement::Process_Identifier( const TokIdentifier & )
224 {
225 	SetResult( not_done, push_sure, Work().pPE_Element.Ptr() );
226 	Work().Prepare_PE_Element();
227 }
228 
229 void
230 PE_Exception::State_WaitForElement::Process_NameSeparator()
231 {
232 	SetResult( not_done, push_sure, Work().pPE_Element.Ptr());
233 	Work().Prepare_PE_Element();
234 }
235 
236 void
237 PE_Exception::State_WaitForElement::Process_BuiltInType( const TokBuiltInType & )
238 {
239 	SetResult( not_done, push_sure, Work().pPE_Element.Ptr());
240 	Work().Prepare_PE_Element();
241 }
242 
243 void
244 PE_Exception::State_WaitForElement::Process_TypeModifier(const TokTypeModifier & )
245 {
246 	SetResult( not_done, push_sure, Work().pPE_Element.Ptr());
247 	Work().Prepare_PE_Element();
248 }
249 
250 void
251 PE_Exception::State_WaitForElement::Process_Punctuation( const TokPunctuation & i_rToken )
252 {
253 	if ( i_rToken.Id() == TokPunctuation::CurledBracketClose )
254 	{
255 		MoveState( Stati().aWaitForFinish );
256 		SetResult( done, stay );
257 	}
258 	else
259 	{
260 		SetResult( not_done, pop_failure );
261 	}
262 }
263 
264 void
265 PE_Exception::State_WaitForFinish::Process_Punctuation( const TokPunctuation & i_rToken )
266 {
267 	if (i_rToken.Id() == TokPunctuation::Semicolon)
268 	{
269 		MoveState( Stati().aNone );
270 		SetResult( done, pop_success );
271 	}
272 	else
273 	{
274 		SetResult( not_done, pop_failure );
275 	}
276 }
277 
278 void
279 PE_Exception::store_Exception()
280 {
281     ary::idl::Exception &
282         rCe = Gate().Ces().Store_Exception(
283 						    CurNamespace().CeId(),
284 						    Work().sData_Name,
285                             Work().nCurParsed_Base );
286     PassDocuAt(rCe);
287     Work().nCurStruct = rCe.Id();
288 }
289 
290 
291 }   // namespace uidl
292 }   // namespace csi
293