Branch data 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 : : /****************** I N C L U D E S **************************************/
21 : :
22 : : // C and C++ Includes.
23 : : #include <stdlib.h>
24 : : #include <stdio.h>
25 : : #include <string.h>
26 : :
27 : : // Programmabh�ngige Includes.
28 : : #include <rsccont.hxx>
29 : :
30 : : #include <tools/rcid.h>
31 : :
32 : : /****************** C O D E **********************************************/
33 : : /****************** E N T R Y S T R U C T ********************************/
34 : : /*************************************************************************
35 : : |*
36 : : |* ENTRYSTRUCT::Destroy()
37 : : |*
38 : : *************************************************************************/
39 : 118180 : void ENTRY_STRUCT::Destroy()
40 : : {
41 : 118180 : aName.Destroy();
42 [ + - ]: 118180 : if( aInst.IsInst() ){
43 : 118180 : aInst.pClass->Destroy( aInst );
44 : 118180 : rtl_freeMemory( aInst.pData );
45 : : };
46 : 118180 : }
47 : :
48 : : /****************** R s c B a s e C o n t ********************************/
49 : : /*************************************************************************
50 : : |*
51 : : |* RscBaseCont::RscBaseCont()
52 : : |*
53 : : *************************************************************************/
54 : 15840 : RscBaseCont::RscBaseCont( Atom nId, sal_uInt32 nTypeId, RscTop * pSuper,
55 : : sal_Bool bNoIdent )
56 : : : RscTop( nId, nTypeId, pSuper ),
57 : 15840 : nSize( 0 )
58 : : {
59 : 15840 : pTypeClass = NULL;
60 : 15840 : pTypeClass1 = NULL;
61 : 15840 : bNoId = bNoIdent;
62 [ + - ]: 15840 : nOffInstData = RscTop::Size();
63 : 15840 : nSize = nOffInstData + ALIGNED_SIZE( sizeof( RscBaseContInst ) );
64 : 15840 : }
65 : :
66 : : /*************************************************************************
67 : : |*
68 : : |* RscBaseCont::~RscBaseCont()
69 : : |*
70 : : *************************************************************************/
71 : 15840 : RscBaseCont::~RscBaseCont()
72 : : {
73 [ - + ]: 17280 : }
74 : :
75 : : /*************************************************************************
76 : : |*
77 : : |* RscBaseCont::GetClassType()
78 : : |*
79 : : *************************************************************************/
80 : 0 : RSCCLASS_TYPE RscBaseCont::GetClassType() const
81 : : {
82 : 0 : return RSCCLASS_COMPLEX;
83 : : }
84 : :
85 : : /*************************************************************************
86 : : |*
87 : : |* DestroyElements()
88 : : |*
89 : : *************************************************************************/
90 : 135688 : void RscBaseCont::DestroyElements( RscBaseContInst * pClassData )
91 : : {
92 [ + + ]: 135688 : if( pClassData->nEntries ){
93 [ + + ]: 118176 : for (sal_uInt32 i = 0; i < pClassData->nEntries; i++ )
94 : : {
95 : 105036 : pClassData->pEntries[ i ].Destroy();
96 : : };
97 : 13140 : rtl_freeMemory( pClassData->pEntries );
98 : 13140 : pClassData->pEntries = NULL;
99 : 13140 : pClassData->nEntries = 0;
100 : : };
101 : 135688 : }
102 : :
103 : : /*************************************************************************
104 : : |*
105 : : |* RscBaseCont::Create()
106 : : |*
107 : : *************************************************************************/
108 : 133248 : RSCINST RscBaseCont::Create( RSCINST * pInst, const RSCINST & rDflt,
109 : : sal_Bool bOwnClass )
110 : : {
111 : 133248 : RSCINST aInst;
112 : : RscBaseContInst * pClassData;
113 : :
114 [ + + ]: 133248 : if( !pInst ){
115 : 5068 : aInst.pClass = this;
116 : 5068 : aInst.pData = (CLASS_DATA) rtl_allocateMemory( Size() );
117 : : }
118 : : else
119 : 128180 : aInst = *pInst;
120 [ + + ][ + + ]: 133248 : if( !bOwnClass && rDflt.IsInst() )
[ + + ]
121 : 1072 : bOwnClass = rDflt.pClass->InHierarchy( this );
122 : :
123 : 133248 : RscTop::Create( &aInst, rDflt, bOwnClass );
124 : :
125 : 133248 : pClassData = (RscBaseContInst *)(aInst.pData + nOffInstData);
126 : 133248 : pClassData->nEntries = 0;
127 : 133248 : pClassData->pEntries = NULL;
128 : 133248 : pClassData->bDflt = sal_True;
129 : :
130 [ + + ]: 133248 : if( bOwnClass ){
131 : : RscBaseContInst * pDfltClassData;
132 : 1476 : RSCINST aDfltI;
133 : :
134 : 1476 : pDfltClassData = (RscBaseContInst *)(rDflt.pData + nOffInstData);
135 : :
136 [ + + ]: 1476 : if( 0 != pDfltClassData->nEntries ){
137 : 48 : *pClassData = *pDfltClassData;
138 : : pClassData->pEntries =
139 : : (ENTRY_STRUCT *)rtl_allocateMemory( sizeof( ENTRY_STRUCT )
140 : 48 : * pClassData->nEntries );
141 [ + + ]: 1822 : for (sal_uInt32 i = 0; i < pClassData->nEntries; i++ )
142 : : {
143 : 346 : pClassData->pEntries[ i ].Create();
144 : 346 : pClassData->pEntries[ i ].aName =
145 [ + - ]: 346 : pDfltClassData->pEntries[ i ].aName;
146 : 346 : aDfltI = pDfltClassData->pEntries[ i ].aInst;
147 : : pClassData->pEntries[ i ].aInst =
148 [ + - ]: 346 : aDfltI.pClass->Create( NULL, aDfltI );
149 : : };
150 : : };
151 : : }
152 : :
153 : 133248 : return( aInst );
154 : : }
155 : :
156 : : /*************************************************************************
157 : : |*
158 : : |* RscBaseCont::Destroy()
159 : : |*
160 : : *************************************************************************/
161 : 133248 : void RscBaseCont::Destroy( const RSCINST & rInst ){
162 : : RscBaseContInst * pClassData;
163 : :
164 : 133248 : RscTop::Destroy( rInst);
165 : :
166 : 133248 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
167 : 133248 : DestroyElements( pClassData );
168 : 133248 : }
169 : :
170 : : /*************************************************************************
171 : : |*
172 : : |* RscBaseCont::SearchEle()
173 : : |*
174 : : *************************************************************************/
175 : 63660 : RSCINST RscBaseCont::SearchElePos( const RSCINST & rInst, const RscId & rEleName,
176 : : RscTop * pClass, sal_uInt32 nPos )
177 : : {
178 : : RscBaseContInst * pClassData;
179 : :
180 : 63660 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
181 [ - + ]: 63660 : if( !pClass )
182 : 0 : pClass = pTypeClass;
183 : :
184 [ + - ]: 63660 : if( rEleName.IsId() ){
185 [ + + ]: 1875902 : for (sal_uInt32 i = nPos; i < pClassData->nEntries; i++ )
186 : : {
187 [ + + ][ - + ]: 1812242 : if( pClassData->pEntries[ i ].aName == rEleName
[ - + ]
188 : 13056 : && pClassData->pEntries[ i ].aInst.pClass == pClass )
189 : : {
190 : 0 : return( pClassData->pEntries[ i ].aInst );
191 : : };
192 : : };
193 : : };
194 : 63660 : return RSCINST();
195 : : }
196 : :
197 : : /*************************************************************************
198 : : |*
199 : : |* RscBaseCont::SearchEle()
200 : : |*
201 : : *************************************************************************/
202 : 63660 : RSCINST RscBaseCont::SearchEle( const RSCINST & rInst, const RscId & rEleName,
203 : : RscTop * pClass )
204 : : {
205 : 63660 : return SearchElePos( rInst, rEleName, pClass, 0 );
206 : : }
207 : :
208 : : /*************************************************************************
209 : : |*
210 : : |* RscBaseCont::GetElement()
211 : : |*
212 : : *************************************************************************/
213 : 117834 : ERRTYPE RscBaseCont::GetElement( const RSCINST & rInst, const RscId & rEleName,
214 : : RscTop * pCreateClass,
215 : : const RSCINST & rCreateInst, RSCINST * pGetInst )
216 : : {
217 : : RscBaseContInst * pClassData;
218 : 117834 : RSCINST aTmpI;
219 : 117834 : ERRTYPE aError;
220 : :
221 [ - + ][ - + ]: 117834 : if( !bNoId && !rEleName.IsId() )
[ + + ]
222 [ # # ]: 0 : aError = WRN_CONT_NOID;
223 : 117834 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
224 : :
225 [ + + ]: 117834 : if( pCreateClass ){
226 [ + - ][ + + ]: 106538 : if( !pCreateClass->InHierarchy( pTypeClass ) ){
227 [ + - ]: 8116 : if( pTypeClass1 ){
228 [ + - ][ - + ]: 8116 : if( !pCreateClass->InHierarchy( pTypeClass1 ) ){
229 : : // Falscher Typ
230 : 0 : return ERR_CONT_INVALIDTYPE;
231 : : }
232 : : }
233 : : else{
234 : : // Falscher Typ
235 : 0 : return ERR_CONT_INVALIDTYPE;
236 : : };
237 : : };
238 : : }
239 : : else
240 : 11296 : pCreateClass = pTypeClass;
241 : :
242 : 117834 : pClassData->bDflt = sal_False;
243 [ + + ]: 117834 : if( !bNoId )
244 [ + - ]: 63660 : aTmpI = SearchEle( rInst, rEleName, pCreateClass );
245 : : // Eintrag gefunden
246 [ - + ]: 117834 : if( aTmpI.IsInst() ){
247 [ # # ]: 0 : aError = WRN_CONT_DOUBLEID;
248 [ # # ]: 0 : if( rCreateInst.IsInst() ){
249 [ # # ]: 0 : aTmpI.pClass->Destroy( aTmpI );
250 [ # # ]: 0 : aTmpI.pClass->Create( &aTmpI, rCreateInst );
251 : : };
252 : : }
253 : : else {
254 [ + + ]: 117834 : if( pClassData->pEntries ){
255 : : pClassData->pEntries =
256 : : (ENTRY_STRUCT *)rtl_reallocateMemory( pClassData->pEntries,
257 : 104742 : sizeof( ENTRY_STRUCT ) * (pClassData->nEntries +1) );
258 : : }
259 : : else {
260 : : pClassData->pEntries =
261 : : (ENTRY_STRUCT *)rtl_allocateMemory( sizeof( ENTRY_STRUCT )
262 : 13092 : * (pClassData->nEntries +1) );
263 : : };
264 : :
265 : 117834 : pClassData->pEntries[ pClassData->nEntries ].Create();
266 [ + - ]: 117834 : pClassData->pEntries[ pClassData->nEntries ].aName = rEleName;
267 : :
268 [ - + ]: 117834 : if( rCreateInst.IsInst() ){
269 : : // Instanz mit CreateInst-Daten initialisieren
270 : : pClassData->pEntries[ pClassData->nEntries ].aInst =
271 [ # # ]: 0 : pCreateClass->Create( NULL, rCreateInst );
272 : : }
273 : : else {
274 : : pClassData->pEntries[ pClassData->nEntries ].aInst =
275 [ + - ]: 117834 : pCreateClass->Create( NULL, RSCINST() );
276 : : };
277 : :
278 : 117834 : pClassData->nEntries++;
279 : 117834 : aTmpI = pClassData->pEntries[ pClassData->nEntries -1 ].aInst;
280 : : }
281 : :
282 : 117834 : *pGetInst = aTmpI;
283 : 117834 : return aError;
284 : : }
285 : :
286 : : /*************************************************************************
287 : : |*
288 : : |* RscBaseCont::GetCount()
289 : : |*
290 : : *************************************************************************/
291 : 11644 : sal_uInt32 RscBaseCont::GetCount( const RSCINST & rInst ){
292 : : RscBaseContInst * pClassData;
293 : :
294 : 11644 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
295 : 11644 : return( pClassData->nEntries );
296 : : }
297 : :
298 : : /*************************************************************************
299 : : |*
300 : : |* RscBaseCont::GetPosEle()
301 : : |*
302 : : *************************************************************************/
303 : 0 : RSCINST RscBaseCont::GetPosEle( const RSCINST & rInst, sal_uInt32 nPos ){
304 : : RscBaseContInst * pClassData;
305 : :
306 : 0 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
307 : :
308 [ # # ]: 0 : if( nPos < pClassData->nEntries )
309 : 0 : return( pClassData->pEntries[ nPos ].aInst );
310 : 0 : return RSCINST();
311 : : }
312 : :
313 : : /*************************************************************************
314 : : |*
315 : : |* RscBaseCont::MovePosEle()
316 : : |*
317 : : *************************************************************************/
318 : 0 : ERRTYPE RscBaseCont::MovePosEle( const RSCINST & rInst, sal_uInt32 nDestPos,
319 : : sal_uInt32 nSourcePos )
320 : : {
321 : 0 : ERRTYPE aError;
322 : : RscBaseContInst * pClassData;
323 : :
324 : 0 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
325 : :
326 [ # # ][ # # ]: 0 : if( (nDestPos < pClassData->nEntries) && (nSourcePos < pClassData->nEntries) ){
327 [ # # ]: 0 : ENTRY_STRUCT aEntry;
328 : 0 : int nInc = 1;
329 : 0 : sal_uInt32 i = 0;
330 : :
331 : : // Quelle Merken
332 [ # # ]: 0 : aEntry = pClassData->pEntries[ nSourcePos ];
333 : : // Richtung der for-Schleife bestimmen
334 [ # # ]: 0 : if( nDestPos < nSourcePos )
335 : 0 : nInc = -1;
336 : :
337 [ # # ]: 0 : for( i = nSourcePos; i != nDestPos; i += nInc )
338 [ # # ]: 0 : pClassData->pEntries[ i ] = pClassData->pEntries[ i + nInc ];
339 : :
340 : : // Zuweisung Quelle auf Ziel
341 [ # # ][ # # ]: 0 : pClassData->pEntries[ nDestPos ] = aEntry;
342 : : }
343 : : else
344 [ # # ]: 0 : aError = ERR_RSCCONT;
345 : 0 : return aError;
346 : : }
347 : :
348 : : /*************************************************************************
349 : : |*
350 : : |* RscBaseCont::SetPosRscId()
351 : : |*
352 : : *************************************************************************/
353 : 0 : ERRTYPE RscBaseCont::SetPosRscId( const RSCINST & rInst, sal_uInt32 nPos,
354 : : const RscId & rId ){
355 : : RscBaseContInst * pClassData;
356 : 0 : RSCINST aTmpI;
357 : 0 : ERRTYPE aError;
358 : :
359 : 0 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
360 : :
361 [ # # ]: 0 : if( nPos < pClassData->nEntries ){
362 [ # # ][ # # ]: 0 : if( ! (rId == pClassData->pEntries[ nPos ].aName) )
363 : : aTmpI = SearchEle( rInst, rId,
364 [ # # ]: 0 : pClassData->pEntries[ nPos ].aInst.pClass );
365 [ # # ]: 0 : if( !aTmpI.IsInst() )
366 [ # # ]: 0 : pClassData->pEntries[ nPos ].aName = rId;
367 : : else
368 [ # # ]: 0 : aError = ERR_RSCCONT;
369 : : }
370 : : else
371 [ # # ]: 0 : aError = ERR_RSCCONT;
372 : 0 : return( aError );
373 : : }
374 : :
375 : : /*************************************************************************
376 : : |*
377 : : |* RscBaseCont::GetInfoEle()
378 : : |*
379 : : *************************************************************************/
380 : 0 : SUBINFO_STRUCT RscBaseCont::GetInfoEle( const RSCINST & rInst, sal_uInt32 nPos ){
381 : : RscBaseContInst * pClassData;
382 : 0 : SUBINFO_STRUCT aInfo;
383 : :
384 : 0 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
385 : :
386 [ # # ]: 0 : if( nPos < pClassData->nEntries ){
387 [ # # ]: 0 : aInfo.aId = pClassData->pEntries[ nPos ].aName;
388 : 0 : aInfo.nPos = nPos;
389 : 0 : aInfo.pClass = pClassData->pEntries[ nPos ].aInst.pClass;
390 : : }
391 : 0 : return( aInfo );
392 : : }
393 : :
394 : : /*************************************************************************
395 : : |*
396 : : |* RscBaseCont::SetString()
397 : : |*
398 : : *************************************************************************/
399 : 1670 : ERRTYPE RscBaseCont::SetString( const RSCINST & rInst, const char * pStr )
400 : : {
401 : : RscBaseContInst * pClassData;
402 : 1670 : RSCINST aTmpI;
403 : 1670 : ERRTYPE aError;
404 : : char *pTmpStr;
405 : :
406 : 1670 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
407 : :
408 : : //?B 040991
409 : : //?W 040991 sonst Endlosrekursion moeglich
410 [ + - ]: 1670 : if( RSC_NOTYPE == pTypeClass->GetTypId() ){
411 [ + - ][ + - ]: 1670 : aError = GetElement( rInst, RscId(), pTypeClass, RSCINST(), &aTmpI );
[ + - ]
412 [ + - ][ + - ]: 1670 : aError = aTmpI.pClass->GetString( aTmpI, &pTmpStr );
413 [ + + ]: 1670 : if( aError.IsOk() )
414 [ + - ][ + - ]: 300 : aError = aTmpI.pClass->SetString( aTmpI, pStr );
415 : : else {
416 : 1370 : aError.Clear();
417 [ + - ]: 1370 : DeletePos( rInst, pClassData->nEntries -1 );
418 [ + - ][ + - ]: 1370 : aError = GetElement( rInst, RscId(), pTypeClass1, RSCINST(), &aTmpI );
[ + - ]
419 [ + - ][ + - ]: 1370 : aError = aTmpI.pClass->GetString( aTmpI, &pTmpStr );
420 [ + + ]: 1370 : if( aError.IsOk() )
421 [ + - ][ + - ]: 1152 : aError = aTmpI.pClass->SetString( aTmpI, pStr );
422 : : }
423 [ + + ]: 1670 : if( aError.IsError() )
424 [ + - ]: 218 : DeletePos( rInst, pClassData->nEntries -1 );
425 : : }
426 : : else
427 [ # # ]: 1670 : aError = ERR_UNKNOWN_METHOD;
428 : :
429 : 1670 : return( aError );
430 : : }
431 : :
432 : : /*************************************************************************
433 : : |*
434 : : |* RscBaseCont::SetNumber()
435 : : |*
436 : : *************************************************************************/
437 : 6964 : ERRTYPE RscBaseCont::SetNumber( const RSCINST & rInst, sal_Int32 lValue ){
438 : : RscBaseContInst * pClassData;
439 : 6964 : RSCINST aTmpI;
440 : 6964 : ERRTYPE aError;
441 : : sal_Int32 lNumber;
442 : :
443 : 6964 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
444 : :
445 : : //?B 040991
446 : : //?W 040991 sonst Endlosrekursion moeglich
447 [ + - ]: 6964 : if( RSC_NOTYPE == pTypeClass->GetTypId() ){
448 [ + - ][ + - ]: 6964 : aError = GetElement( rInst, RscId(), pTypeClass, RSCINST(), &aTmpI );
[ + - ]
449 [ + - ][ + - ]: 6964 : aError = aTmpI.pClass->GetNumber( aTmpI, &lNumber );
450 [ + - ]: 6964 : if( aError.IsOk() )
451 [ + - ][ + - ]: 6964 : aError = aTmpI.pClass->SetNumber( aTmpI, lValue );
452 : : else {
453 : 0 : aError.Clear();
454 [ # # ]: 0 : DeletePos( rInst, pClassData->nEntries -1 );
455 [ # # ][ # # ]: 0 : aError = GetElement( rInst, RscId(), pTypeClass1, RSCINST(), &aTmpI );
[ # # ]
456 [ # # ][ # # ]: 0 : aError = aTmpI.pClass->GetNumber( aTmpI, &lNumber );
457 [ # # ]: 0 : if( aError.IsOk() )
458 [ # # ][ # # ]: 0 : aError = aTmpI.pClass->SetNumber( aTmpI, lValue );
459 : : }
460 [ - + ]: 6964 : if( aError.IsError() )
461 [ # # ]: 0 : DeletePos( rInst, pClassData->nEntries -1 );
462 : : }
463 : : else
464 [ # # ]: 6964 : aError = ERR_UNKNOWN_METHOD;
465 : :
466 : 6964 : return( aError );
467 : : }
468 : :
469 : : //==================================================================
470 : 0 : ERRTYPE RscBaseCont::SetBool
471 : : (
472 : : const RSCINST & rInst,
473 : : sal_Bool bValue
474 : : )
475 : : {
476 : : RscBaseContInst * pClassData;
477 : 0 : RSCINST aTmpI;
478 : 0 : ERRTYPE aError;
479 : : sal_Bool bBool;
480 : :
481 : 0 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
482 : :
483 : : //?B 040991
484 : : //?W 040991 sonst Endlosrekursion moeglich
485 [ # # ]: 0 : if( RSC_NOTYPE == pTypeClass->GetTypId() )
486 : : {
487 [ # # ][ # # ]: 0 : aError = GetElement( rInst, RscId(), pTypeClass, RSCINST(), &aTmpI );
[ # # ]
488 [ # # ][ # # ]: 0 : aError = aTmpI.pClass->GetBool( aTmpI, &bBool );
489 [ # # ]: 0 : if( aError.IsOk() )
490 [ # # ][ # # ]: 0 : aError = aTmpI.pClass->SetBool( aTmpI, bValue );
491 : : else {
492 : 0 : aError.Clear();
493 [ # # ]: 0 : DeletePos( rInst, pClassData->nEntries -1 );
494 [ # # ][ # # ]: 0 : aError = GetElement( rInst, RscId(), pTypeClass1, RSCINST(), &aTmpI );
[ # # ]
495 [ # # ][ # # ]: 0 : aError = aTmpI.pClass->GetBool( aTmpI, &bBool );
496 [ # # ]: 0 : if( aError.IsOk() )
497 [ # # ][ # # ]: 0 : aError = aTmpI.pClass->SetBool( aTmpI, bValue );
498 : : }
499 [ # # ]: 0 : if( aError.IsError() )
500 [ # # ]: 0 : DeletePos( rInst, pClassData->nEntries -1 );
501 : : }
502 : : else
503 [ # # ]: 0 : aError = ERR_UNKNOWN_METHOD;
504 : :
505 : 0 : return( aError );
506 : : }
507 : :
508 : : //==================================================================
509 : 0 : ERRTYPE RscBaseCont::SetConst
510 : : (
511 : : const RSCINST & rInst,
512 : : Atom nValueId,
513 : : sal_Int32 lValue
514 : : )
515 : : {
516 : : RscBaseContInst * pClassData;
517 : 0 : RSCINST aTmpI;
518 : 0 : ERRTYPE aError;
519 : : Atom nConst;
520 : :
521 : 0 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
522 : :
523 : : //?B 040991
524 : : //?W 040991 sonst Endlosrekursion moeglich
525 [ # # ]: 0 : if( RSC_NOTYPE == pTypeClass->GetTypId() ){
526 [ # # ][ # # ]: 0 : aError = GetElement( rInst, RscId(), pTypeClass, RSCINST(), &aTmpI );
[ # # ]
527 [ # # ][ # # ]: 0 : aError = aTmpI.pClass->GetConst( aTmpI, &nConst );
528 [ # # ]: 0 : if( aError.IsOk() )
529 [ # # ][ # # ]: 0 : aError = aTmpI.pClass->SetConst( aTmpI, nValueId, lValue );
530 : : else {
531 : 0 : aError.Clear();
532 [ # # ]: 0 : DeletePos( rInst, pClassData->nEntries -1 );
533 [ # # ][ # # ]: 0 : aError = GetElement( rInst, RscId(), pTypeClass1, RSCINST(), &aTmpI );
[ # # ]
534 [ # # ][ # # ]: 0 : aError = aTmpI.pClass->GetConst( aTmpI, &nConst );
535 [ # # ]: 0 : if( aError.IsOk() )
536 [ # # ][ # # ]: 0 : aError = aTmpI.pClass->SetConst( aTmpI, nValueId, lValue );
537 : : }
538 [ # # ]: 0 : if( aError.IsError() )
539 [ # # ]: 0 : DeletePos( rInst, pClassData->nEntries -1 );
540 : : }
541 : : else
542 [ # # ]: 0 : aError = ERR_UNKNOWN_METHOD;
543 : :
544 : 0 : return( aError );
545 : : }
546 : :
547 : : /*************************************************************************
548 : : |*
549 : : |* RscBaseCont::SetRef()
550 : : |*
551 : : *************************************************************************/
552 : 8372 : ERRTYPE RscBaseCont::SetRef( const RSCINST & rInst, const RscId & rRefId ){
553 : : RscBaseContInst * pClassData;
554 : 8372 : RSCINST aTmpI;
555 : 8372 : ERRTYPE aError;
556 : 8372 : RscId aId;
557 : :
558 : 8372 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
559 : :
560 : : //?B 040991
561 : : //?W 040991 sonst Endlosrekursion moeglich
562 [ + - ]: 8372 : if( RSC_NOTYPE == pTypeClass->GetTypId() ){
563 [ + - ][ + - ]: 8372 : aError = GetElement( rInst, RscId(), pTypeClass, RSCINST(), &aTmpI );
[ + - ]
564 [ + - ][ + - ]: 8372 : aError = aTmpI.pClass->GetRef( aTmpI, &aId );
565 [ + + ]: 8372 : if( aError.IsOk() )
566 [ + - ][ + - ]: 1408 : aError = aTmpI.pClass->SetRef( aTmpI, rRefId );
567 : : else {
568 : 6964 : aError.Clear();
569 [ + - ]: 6964 : DeletePos( rInst, pClassData->nEntries -1 );
570 [ + - ][ + - ]: 6964 : aError = GetElement( rInst, RscId(), pTypeClass1, RSCINST(), &aTmpI );
[ + - ]
571 [ + - ][ + - ]: 6964 : aError = aTmpI.pClass->GetRef( aTmpI, &aId );
572 [ + - ]: 6964 : if( aError.IsOk() )
573 [ + - ][ + - ]: 6964 : aError = aTmpI.pClass->SetNumber( aTmpI, rRefId );
[ + - ]
574 : : }
575 [ + + ]: 8372 : if( aError.IsError() )
576 [ + - ]: 6964 : DeletePos( rInst, pClassData->nEntries -1 );
577 : : }
578 : : else
579 [ # # ]: 0 : aError = ERR_UNKNOWN_METHOD;
580 : :
581 [ + - ]: 8372 : return( aError );
582 : : }
583 : :
584 : : /*************************************************************************
585 : : |*
586 : : |* RscBaseCont::IsConsistent()
587 : : |*
588 : : *************************************************************************/
589 : 0 : sal_Bool RscBaseCont::IsConsistent( const RSCINST & rInst ) {
590 : 0 : sal_uInt32 i = 0;
591 : : RscBaseContInst * pClassData;
592 : : sal_Bool bRet;
593 : :
594 : 0 : bRet = RscTop::IsConsistent( rInst );
595 : :
596 : 0 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
597 : :
598 : : // auf doppelten Id Testen und Reihenfolge beibehalten
599 : : // Komplexitaet = n^2 / 2
600 [ # # ]: 0 : for( i = 0; i < pClassData->nEntries; i++ ){
601 [ # # ]: 0 : if( !bNoId ){
602 [ # # # # ]: 0 : if( (sal_Int32)pClassData->pEntries[ i ].aName > 0x7FFF
[ # # ]
603 : 0 : || (sal_Int32)pClassData->pEntries[ i ].aName < 1 ){
604 : 0 : bRet = sal_False;
605 : : }
606 [ # # ]: 0 : else if( SearchElePos( rInst, pClassData->pEntries[ i ].aName,
607 : 0 : pClassData->pEntries[ i ].aInst.pClass, i +1 ).IsInst() )
608 : : {
609 : 0 : bRet = sal_False;
610 : : };
611 : : }
612 [ # # ]: 0 : if( ! pClassData->pEntries[ i ].aInst.pClass->
613 : 0 : IsConsistent( pClassData->pEntries[ i ].aInst ) )
614 : 0 : bRet = sal_False;
615 : : };
616 : :
617 : 0 : return( bRet );
618 : : }
619 : :
620 : : /*************************************************************************
621 : : |*
622 : : |* RscBaseCont::SetToDefault()
623 : : |*
624 : : *************************************************************************/
625 : 1058 : void RscBaseCont::SetToDefault( const RSCINST & rInst )
626 : : {
627 : 1058 : sal_uInt32 i = 0;
628 : : RscBaseContInst * pClassData;
629 : :
630 : 1058 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
631 : :
632 [ + + ]: 1126 : for( i = 0; i < pClassData->nEntries; i++ )
633 : : {
634 : 204 : pClassData->pEntries[ i ].aInst.pClass->
635 : 68 : SetToDefault( pClassData->pEntries[ i ].aInst );
636 : : };
637 : :
638 : 1058 : RscTop::SetToDefault( rInst );
639 : 1058 : }
640 : :
641 : : /*************************************************************************
642 : : |*
643 : : |* RscBaseCont::IsDefault()
644 : : |*
645 : : *************************************************************************/
646 : 880 : sal_Bool RscBaseCont::IsDefault( const RSCINST & rInst ){
647 : 880 : sal_uInt32 i = 0;
648 : : RscBaseContInst * pClassData;
649 : :
650 : 880 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
651 : :
652 [ + - ]: 880 : if( !pClassData->bDflt )
653 : 880 : return sal_False;
654 : :
655 [ # # ]: 0 : for( i = 0; i < pClassData->nEntries; i++ ){
656 [ # # ]: 0 : if( ! pClassData->pEntries[ i ].aInst.pClass->
657 : 0 : IsDefault( pClassData->pEntries[ i ].aInst ) )
658 : : {
659 : 0 : return( sal_False );
660 : : };
661 : : };
662 : :
663 : 880 : return( RscTop::IsDefault( rInst ) );
664 : : }
665 : :
666 : : /*************************************************************************
667 : : |*
668 : : |* RscBaseCont::IsValueDefault()
669 : : |*
670 : : *************************************************************************/
671 : 5564 : sal_Bool RscBaseCont::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef )
672 : : {
673 : : RscBaseContInst * pClassData;
674 : :
675 [ - + ]: 5564 : if( !RscTop::IsValueDefault( rInst, pDef ) )
676 : 0 : return sal_False;
677 : :
678 : 5564 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
679 : :
680 [ + + ]: 5564 : if( pClassData->nEntries )
681 : 3198 : return sal_False;
682 : : else
683 : 5564 : return sal_True;
684 : : }
685 : :
686 : : /*************************************************************************
687 : : |*
688 : : |* RscBaseCont::Delete()
689 : : |*
690 : : *************************************************************************/
691 : 0 : void RscBaseCont::Delete( const RSCINST & rInst, RscTop * pClass,
692 : : const RscId & rId )
693 : : {
694 : 0 : sal_uInt32 i = 0;
695 : : RscBaseContInst * pClassData;
696 : :
697 : 0 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
698 [ # # ]: 0 : if( !pClass )
699 : 0 : pClass = pTypeClass;
700 : :
701 [ # # ]: 0 : for( i = 0; i < pClassData->nEntries; i++ ){
702 [ # # ]: 0 : if( pClassData->pEntries[ i ].aName == rId )
703 [ # # ][ # # ]: 0 : if( pClassData->pEntries[ i ].aInst.pClass == pClass || !pClass ){
704 : 0 : DeletePos( rInst, i );
705 : 0 : return;
706 : : };
707 : : };
708 : :
709 : : }
710 : :
711 : : /*************************************************************************
712 : : |*
713 : : |* RscBaseCont::DeletePos()
714 : : |*
715 : : *************************************************************************/
716 : 15584 : void RscBaseCont::DeletePos( const RSCINST & rInst, sal_uInt32 nPos ){
717 : : RscBaseContInst * pClassData;
718 : :
719 : 15584 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
720 : :
721 [ + - ]: 15584 : if( nPos < pClassData->nEntries ){
722 [ + + ]: 15584 : if( 1 == pClassData->nEntries )
723 : 2440 : DestroyElements( pClassData );
724 : : else{
725 : 13144 : pClassData->pEntries[ nPos ].Destroy();
726 : 13144 : pClassData->nEntries--;
727 [ - + ]: 13144 : for (sal_uInt32 i = nPos; i < pClassData->nEntries; i++ )
728 : 0 : pClassData->pEntries[ i ] = pClassData->pEntries[ i + 1 ];
729 : : };
730 : : };
731 : 15584 : }
732 : :
733 : : /*************************************************************************
734 : : |*
735 : : |* RscBaseCont::ContWriteSrc()
736 : : |*
737 : : *************************************************************************/
738 : 65350 : void RscBaseCont::ContWriteSrc( const RSCINST & rInst, FILE * fOutput,
739 : : RscTypCont * pTC, sal_uInt32 nTab,
740 : : const char * pVarName )
741 : : {
742 : 65350 : sal_uInt32 i = 0, t = 0;
743 : : RscBaseContInst * pClassData;
744 : :
745 : 65350 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
746 : :
747 [ + + ]: 116648 : for( i = 0; i < pClassData->nEntries; i++ )
748 : : {
749 [ + + ]: 147876 : for( t = 0; t < nTab; t++ )
750 : 96578 : fputc( '\t', fOutput );
751 : 153894 : pClassData->pEntries[ i ].aInst.pClass->
752 : 51298 : WriteSrcHeader( pClassData->pEntries[ i ].aInst,
753 : : fOutput, pTC, nTab,
754 : 51298 : pClassData->pEntries[ i ].aName, pVarName );
755 : 51298 : fprintf( fOutput, ";\n" );
756 : : };
757 : 65350 : }
758 : :
759 : : /*************************************************************************
760 : : |*
761 : : |* RscBaseCont::ContWriteRc()
762 : : |*
763 : : *************************************************************************/
764 : 116204 : ERRTYPE RscBaseCont::ContWriteRc( const RSCINST & rInst, RscWriteRc & rMem,
765 : : RscTypCont * pTC, sal_uInt32 nDeep, sal_Bool bExtra )
766 : : {
767 : : RscBaseContInst * pClassData;
768 : 116204 : ERRTYPE aError;
769 : :
770 [ + + ][ + + ]: 116204 : if( bExtra || bNoId )
771 : : { // Nur Subresourcen schreiben, wenn bExtra == sal_True
772 : 104284 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
773 : :
774 [ + + ][ + - ]: 155578 : for (sal_uInt32 i = 0; i < pClassData->nEntries && aError.IsOk(); i++ )
[ + + ]
775 : : {
776 : 153882 : aError = pClassData->pEntries[ i ].aInst.pClass->
777 : 51294 : WriteRcHeader( pClassData->pEntries[ i ].aInst,
778 : : rMem, pTC,
779 : 51294 : pClassData->pEntries[ i ].aName,
780 [ + - ]: 51294 : nDeep, bExtra );
781 : : }
782 : : }
783 : :
784 : 116204 : return( aError );
785 : : }
786 : :
787 : : //==================================================================
788 : 0 : void RscBaseCont::ContWriteRcAccess
789 : : (
790 : : FILE * fOutput,
791 : : RscTypCont * pTC,
792 : : const char * pName,
793 : : sal_Bool bWriteSize
794 : : )
795 : : {
796 [ # # ][ # # ]: 0 : if( (bNoId || bWriteSize) && !pTypeClass1 )
[ # # ]
797 : : {
798 : 0 : fprintf( fOutput, "\t\tsal_uInt32 nItems = *(sal_uInt32 *)(pResData+nOffset) );\n" );
799 : 0 : fprintf( fOutput, "\t\tnOffset += sizeof( sal_uInt32 );\n" );
800 : :
801 : 0 : fprintf( fOutput, "\t\t// Items hinzufuegen\n" );
802 : 0 : fprintf( fOutput, "\t\tfor( sal_uInt32 i = 0; i < nItems; i++ )\n" );
803 : 0 : fprintf( fOutput, "\t\t{\n" );
804 : 0 : pTypeClass->WriteRcAccess( fOutput, pTC, "Item" );
805 : 0 : fprintf( fOutput, "\t\t}\n" );
806 : : }
807 : : else
808 : : {
809 : 0 : fprintf( fOutput, "\t\tSet%s( %s ", pName, pHS->getString( GetId() ).getStr() );
810 : 0 : fprintf( fOutput, "%s ", aCallPar2.getStr() );
811 : 0 : fprintf( fOutput, "ResId( (RSHEADER_TYPE*)(pResData+nOffset) ) ) );\n" );
812 : 0 : fprintf( fOutput, "\t\tnOffset += GetObjSizeRes( (RSHEADER_TYPE*)(pResData+nOffset) );\n" );
813 : : }
814 : 0 : }
815 : :
816 : :
817 : : /*************************************************************************
818 : : |*
819 : : |* RscBaseCont::WriteSrc()
820 : : |*
821 : : *************************************************************************/
822 : 62164 : void RscBaseCont::WriteSrc( const RSCINST & rInst, FILE * fOutput,
823 : : RscTypCont * pTC, sal_uInt32 nTab,
824 : : const char * pVarName )
825 : : {
826 : 62164 : RscTop::WriteSrc( rInst, fOutput, pTC, nTab, pVarName );
827 : 62164 : ContWriteSrc( rInst, fOutput, pTC, nTab, pVarName );
828 : 62164 : }
829 : :
830 : : /*************************************************************************
831 : : |*
832 : : |* RscBaseCont::WriteRc()
833 : : |*
834 : : *************************************************************************/
835 : 112752 : ERRTYPE RscBaseCont::WriteRc( const RSCINST & rInst, RscWriteRc & rMem,
836 : : RscTypCont * pTC, sal_uInt32 nDeep, sal_Bool bExtra )
837 : : {
838 : 112752 : ERRTYPE aError;
839 : :
840 [ + - ]: 112752 : aError = RscTop::WriteRc( rInst, rMem, pTC, nDeep, bExtra );
841 [ + - ]: 112752 : if( aError.IsOk() )
842 [ + - ]: 112752 : aError = ContWriteRc( rInst, rMem, pTC, nDeep, bExtra );
843 : :
844 : 112752 : return( aError );
845 : : }
846 : :
847 : : /*************************************************************************
848 : : |*
849 : : |* RscBaseCont::WriteHxx()
850 : : |*
851 : : *************************************************************************/
852 : 0 : ERRTYPE RscBaseCont::WriteHxx( const RSCINST & rInst, FILE * fOutput,
853 : : RscTypCont * pTC, const RscId & rRscId )
854 : : {
855 : 0 : sal_uInt32 i = 0;
856 : : RscBaseContInst * pClassData;
857 : 0 : ERRTYPE aError;
858 : :
859 [ # # ]: 0 : aError = RscTop::WriteHxx( rInst, fOutput, pTC, rRscId );
860 : :
861 : 0 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
862 : :
863 [ # # ][ # # ]: 0 : for( i = 0; i < pClassData->nEntries && aError.IsOk(); i++ )
[ # # ]
864 : : {
865 [ # # # # ]: 0 : if( pClassData->pEntries[ i ].aName.IsId()
[ # # ]
866 : 0 : && pClassData->pEntries[ i ].aInst.pClass->IsCodeWriteable() )
867 : : {
868 : 0 : aError = pClassData->pEntries[ i ].aInst.pClass->
869 : 0 : WriteHxx( pClassData->pEntries[ i ].aInst,
870 : : fOutput, pTC,
871 [ # # ]: 0 : pClassData->pEntries[ i ].aName );
872 : : }
873 : : };
874 : :
875 : 0 : return( aError );
876 : : }
877 : :
878 : : /*************************************************************************
879 : : |*
880 : : |* RscBaseCont::WriteCxx()
881 : : |*
882 : : *************************************************************************/
883 : 0 : ERRTYPE RscBaseCont::WriteCxx( const RSCINST & rInst, FILE * fOutput,
884 : : RscTypCont * pTC, const RscId & rRscId )
885 : : {
886 : 0 : sal_uInt32 i = 0;
887 : : RscBaseContInst * pClassData;
888 : 0 : ERRTYPE aError;
889 : :
890 [ # # ]: 0 : aError = RscTop::WriteCxx( rInst, fOutput, pTC, rRscId );
891 : :
892 : 0 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
893 : :
894 [ # # ][ # # ]: 0 : for( i = 0; i < pClassData->nEntries && aError.IsOk(); i++ )
[ # # ]
895 : : {
896 [ # # # # ]: 0 : if( pClassData->pEntries[ i ].aName.IsId()
[ # # ]
897 : 0 : && pClassData->pEntries[ i ].aInst.pClass->IsCodeWriteable() )
898 : : {
899 : 0 : aError = pClassData->pEntries[ i ].aInst.pClass->
900 : 0 : WriteCxx( pClassData->pEntries[ i ].aInst,
901 : : fOutput, pTC,
902 [ # # ]: 0 : pClassData->pEntries[ i ].aName );
903 : : }
904 : : };
905 : :
906 : 0 : return( aError );
907 : : }
908 : :
909 : : /*************** R s c C o n t W r i t e S r c ***************************/
910 : : /*************************************************************************
911 : : |*
912 : : |* RscContWriteSrc::RscContWriteSrc()
913 : : |*
914 : : *************************************************************************/
915 : 14400 : RscContWriteSrc::RscContWriteSrc( Atom nId, sal_uInt32 nTypeId,
916 : : RscTop * pSuper, sal_Bool bNoIdent )
917 : 14400 : : RscBaseCont( nId, nTypeId, pSuper, bNoIdent )
918 : 14400 : {}
919 : :
920 : : /*************************************************************************
921 : : |*
922 : : |* RscContWriteSrc::WriteSrc()
923 : : |*
924 : : *************************************************************************/
925 : 3186 : void RscContWriteSrc::WriteSrc( const RSCINST & rInst, FILE * fOutput,
926 : : RscTypCont * pTC, sal_uInt32 nTab,
927 : : const char * pVarName )
928 : : {
929 : : sal_uInt32 i;
930 : :
931 : 3186 : RscTop::WriteSrc( rInst, fOutput, pTC, nTab, pVarName );
932 : :
933 : 3186 : fprintf( fOutput, "\n" );
934 [ + + ]: 10136 : for( i = 0; i < nTab; i++ )
935 : 6950 : fputc( '\t', fOutput );
936 : 3186 : fprintf( fOutput, "{\n" );
937 : :
938 : 3186 : ContWriteSrc( rInst, fOutput, pTC, nTab +1, pVarName );
939 : :
940 [ + + ]: 10136 : for( i = 0; i < nTab; i++ )
941 : 6950 : fputc( '\t', fOutput );
942 : 3186 : fprintf( fOutput, "}" );
943 : 3186 : }
944 : :
945 : : /*************** R s c C o n t *******************************************/
946 : : /*************************************************************************
947 : : |*
948 : : |* RscCont::RscCont()
949 : : |*
950 : : *************************************************************************/
951 : 12960 : RscCont::RscCont( Atom nId, sal_uInt32 nTypeId, RscTop * pSuper, sal_Bool bNoIdent )
952 : 12960 : : RscContWriteSrc( nId, nTypeId, pSuper, bNoIdent )
953 : 12960 : {}
954 : :
955 : : /*************************************************************************
956 : : |*
957 : : |* RscCont::WriteRc()
958 : : |*
959 : : *************************************************************************/
960 : 3452 : ERRTYPE RscCont::WriteRc( const RSCINST & rInst, RscWriteRc & rMem,
961 : : RscTypCont * pTC, sal_uInt32 nDeep, sal_Bool bExtra )
962 : : {
963 : : RscBaseContInst * pClassData;
964 : 3452 : ERRTYPE aError;
965 : :
966 [ + - ]: 3452 : aError = RscTop::WriteRc( rInst, rMem, pTC, nDeep, bExtra );
967 : :
968 : 3452 : pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
969 : :
970 : 3452 : rMem.Put( pClassData->nEntries );
971 : :
972 [ + - ]: 3452 : if( aError.IsOk() )
973 [ + - ]: 3452 : aError = ContWriteRc( rInst, rMem, pTC, nDeep, bExtra );
974 : :
975 : 3452 : return aError;
976 : : }
977 : :
978 : : //==================================================================
979 : 0 : void RscCont::WriteRcAccess
980 : : (
981 : : FILE * fOutput,
982 : : RscTypCont * pTC,
983 : : const char * pName
984 : : )
985 : : {
986 : 0 : ContWriteRcAccess( fOutput, pTC, pName, sal_True );
987 : 0 : }
988 : :
989 : : /*************************************************************************
990 : : |*
991 : : |* RscContExtraData::RscContExtraData()
992 : : |*
993 : : *************************************************************************/
994 : 1440 : RscContExtraData::RscContExtraData( Atom nId, sal_uInt32 nTypeId,
995 : : RscTop * pSuper, sal_Bool bNoIdent )
996 : 1440 : : RscContWriteSrc( nId, nTypeId, pSuper, bNoIdent )
997 : 1440 : {}
998 : :
999 : : /*************************************************************************
1000 : : |*
1001 : : |* RscContExtraData::WriteRc()
1002 : : |*
1003 : : *************************************************************************/
1004 : 62336 : ERRTYPE RscContExtraData::WriteRc( const RSCINST & rInst, RscWriteRc & rMem,
1005 : : RscTypCont * pTC, sal_uInt32 nDeep, sal_Bool bExtra )
1006 : : {
1007 : 62336 : ERRTYPE aError;
1008 : :
1009 [ + + ]: 62336 : if( bExtra )
1010 [ + - ]: 50416 : aError = RscContWriteSrc::WriteRc( rInst, rMem, pTC, nDeep, bExtra );
1011 : : else
1012 [ + - ]: 11920 : aError = RscTop::WriteRc( rInst, rMem, pTC, nDeep, bExtra );
1013 : :
1014 : 62336 : return aError;
1015 : : }
1016 : :
1017 : : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
