xref: /aoo41x/main/rsc/source/res/rscarray.cxx (revision cdf0e10c) 
1 /*************************************************************************
2  *
3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4  *
5  * Copyright 2000, 2010 Oracle and/or its affiliates.
6  *
7  * OpenOffice.org - a multi-platform office productivity suite
8  *
9  * This file is part of OpenOffice.org.
10  *
11  * OpenOffice.org is free software: you can redistribute it and/or modify
12  * it under the terms of the GNU Lesser General Public License version 3
13  * only, as published by the Free Software Foundation.
14  *
15  * OpenOffice.org is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU Lesser General Public License version 3 for more details
19  * (a copy is included in the LICENSE file that accompanied this code).
20  *
21  * You should have received a copy of the GNU Lesser General Public License
22  * version 3 along with OpenOffice.org.  If not, see
23  * <http://www.openoffice.org/license.html>
24  * for a copy of the LGPLv3 License.
25  *
26  ************************************************************************/
27 
28 // MARKER(update_precomp.py): autogen include statement, do not remove
29 #include "precompiled_rsc.hxx"
30 /****************** I N C L U D E S **************************************/
31 
32 // C and C++ Includes.
33 #include <stdlib.h>
34 #include <stdio.h>
35 #include <string.h>
36 
37 // Programmabhaengige Includes.
38 #include <rscconst.hxx>
39 #ifndef _RSCSARRAY_HXX
40 #include <rscarray.hxx>
41 #endif
42 #include <rscdb.hxx>
43 
44 /****************** C O D E **********************************************/
45 /****************** R s c I n s t N o d e ********************************/
46 /*************************************************************************
47 |*
48 |*    RscInstNode::RscInstNode()
49 |*
50 |*    Beschreibung
51 |*    Ersterstellung    MM 06.08.91
52 |*    Letzte Aenderung  MM 06.08.91
53 |*
54 *************************************************************************/
55 RscInstNode::RscInstNode( sal_uInt32 nId )
56 {
57     nTypeId = nId;
58 }
59 
60 /*************************************************************************
61 |*
62 |*    RscInstNode::~RscInstNode()
63 |*
64 |*    Beschreibung
65 |*    Ersterstellung    MM 06.08.91
66 |*    Letzte Aenderung  MM 06.08.91
67 |*
68 *************************************************************************/
69 RscInstNode::~RscInstNode()
70 {
71     if( aInst.IsInst() )
72     {
73         aInst.pClass->Destroy( aInst );
74         rtl_freeMemory( aInst.pData );
75     }
76 }
77 
78 /*************************************************************************
79 |*
80 |*    RscInstNode::GetId()
81 |*
82 |*    Beschreibung
83 |*    Ersterstellung    MM 06.08.91
84 |*    Letzte Aenderung  MM 06.08.91
85 |*
86 *************************************************************************/
87 sal_uInt32 RscInstNode::GetId() const
88 {
89     return nTypeId;
90 }
91 
92 /****************** R s c A r r a y *************************************/
93 /*************************************************************************
94 |*
95 |*    RscArray::RscArray()
96 |*
97 |*    Beschreibung
98 |*    Ersterstellung    MM 25.05.91
99 |*    Letzte Aenderung  MM 25.05.91
100 |*
101 *************************************************************************/
102 RscArray::RscArray( Atom nId, sal_uInt32 nTypeId, RscTop * pSuper, RscEnum * pTypeCl )
103         : RscTop( nId, nTypeId, pSuper )
104 {
105     pTypeClass = pTypeCl;
106     nOffInstData = RscTop::Size();
107     nSize = nOffInstData + ALIGNED_SIZE( sizeof( RscArrayInst ) );
108 }
109 
110 /*************************************************************************
111 |*
112 |*    RscArray::~RscArray()
113 |*
114 |*    Beschreibung
115 |*    Ersterstellung    MM 25.05.91
116 |*    Letzte Aenderung  MM 25.05.91
117 |*
118 *************************************************************************/
119 RscArray::~RscArray()
120 {
121 }
122 
123 /*************************************************************************
124 |*
125 |*    RscArray::~RscArray()
126 |*
127 |*    Beschreibung
128 |*    Ersterstellung    MM 25.05.91
129 |*    Letzte Aenderung  MM 25.05.91
130 |*
131 *************************************************************************/
132 RSCCLASS_TYPE RscArray::GetClassType() const
133 {
134     return RSCCLASS_ENUMARRAY;
135 }
136 
137 /*************************************************************************
138 |*
139 |*    RscArray::GetIndexType()
140 |*
141 |*    Beschreibung
142 |*    Ersterstellung    MM 23.12.92
143 |*    Letzte Aenderung  MM
144 |*
145 *************************************************************************/
146 RscTop * RscArray::GetTypeClass() const
147 {
148     return pTypeClass;
149 }
150 
151 /*************************************************************************
152 |*
153 |*    RscArray::Create()
154 |*
155 |*    Beschreibung
156 |*    Ersterstellung    MM 26.04.91
157 |*    Letzte Aenderung  MM 26.04.91
158 |*
159 *************************************************************************/
160 static RscInstNode * Create( RscInstNode * pNode )
161 {
162     RscInstNode * pRetNode = NULL;
163     RscInstNode * pTmpNode;
164 
165     if( pNode )
166     {
167         pRetNode = new RscInstNode( pNode->GetId() );
168         pRetNode->aInst = pNode->aInst.pClass->Create( NULL, pNode->aInst );
169         if( (pTmpNode = Create( pNode->Left() )) != NULL )
170             pRetNode->Insert( pTmpNode );
171         if( (pTmpNode = Create( pNode->Right() )) != NULL )
172             pRetNode->Insert( pTmpNode );
173     }
174 
175     return pRetNode;
176 }
177 
178 RSCINST RscArray::Create( RSCINST * pInst, const RSCINST & rDflt,
179                           sal_Bool bOwnClass )
180 {
181     RSCINST aInst;
182     RscArrayInst *  pClassData;
183 
184     if( !pInst )
185 	{
186         aInst.pClass = this;
187         aInst.pData = (CLASS_DATA) rtl_allocateMemory( Size() );
188     }
189     else
190         aInst = *pInst;
191     if( !bOwnClass && rDflt.IsInst() )
192         bOwnClass = rDflt.pClass->InHierarchy( this );
193 
194     RscTop::Create( &aInst, rDflt, bOwnClass );
195 
196     pClassData          = (RscArrayInst *)(aInst.pData + nOffInstData);
197     pClassData->pNode   = NULL;
198     if( bOwnClass )
199     {
200         RscArrayInst *   pDfltClassData;
201 
202         pDfltClassData = (RscArrayInst *)(rDflt.pData + nOffInstData);
203 
204         pClassData->pNode = ::Create( pDfltClassData->pNode );
205     }
206     return( aInst );
207 }
208 
209 /*************************************************************************
210 |*
211 |*    RscArray::Destroy()
212 |*
213 |*    Beschreibung
214 |*
215 *************************************************************************/
216 static void Destroy( RscInstNode * pNode )
217 {
218     if( pNode )
219     {
220         Destroy( pNode->Left() );
221         Destroy( pNode->Right() );
222         delete pNode;
223     }
224 }
225 
226 void RscArray::Destroy( const RSCINST & rInst )
227 {
228     RscArrayInst *  pClassData;
229 
230     RscTop::Destroy( rInst );
231 
232     pClassData = (RscArrayInst *)(rInst.pData + nOffInstData);
233 
234     //Baum rekursiv loeschen
235     ::Destroy( pClassData->pNode );
236 }
237 
238 /*************************************************************************
239 |*
240 |*    RscArray::GetValueEle()
241 |*
242 |*    Beschreibung
243 |*
244 *************************************************************************/
245 ERRTYPE RscArray::GetValueEle
246 (
247 	const RSCINST & rInst,
248 	sal_Int32 lValue,
249 	RscTop * pCreateClass,
250     RSCINST * pGetInst
251 )
252 {
253     RscArrayInst *  pClassData;
254     RscInstNode *   pNode;
255 
256     pClassData = (RscArrayInst *)(rInst.pData + nOffInstData);
257 
258     ERRTYPE     aError;
259 
260     Atom  nId;
261     if( !pTypeClass->GetValueConst( sal_uInt32(lValue), &nId ) )
262     { // nicht gefunden
263         return ERR_ARRAY_INVALIDINDEX;
264     }
265 
266     if( pClassData->pNode )
267         pNode = pClassData->pNode->Search( sal_uInt32(lValue) );
268     else
269         pNode = NULL;
270 
271 /*
272     if( pNode )
273     {
274         if( pNode->aInst.pClass->IsDefault( pNode->aInst ) )
275         {
276             GetSuperClass()->Destroy( pNode->aInst );
277             GetSuperClass()->Create( &pNode->aInst, rInst );
278             pNode->aInst.pClass->SetToDefault( pNode->aInst );
279         }
280     }
281     else
282 */
283     if( !pNode )
284     {
285         pNode = new RscInstNode( sal_uInt32(lValue) );
286 		if( pCreateClass && GetSuperClass()->InHierarchy( pCreateClass ) )
287 	        pNode->aInst = pCreateClass->Create( NULL, rInst );
288 		else
289 	        pNode->aInst = GetSuperClass()->Create( NULL, rInst );
290         pNode->aInst.pClass->SetToDefault( pNode->aInst );
291         if( pClassData->pNode )
292             pClassData->pNode->Insert( pNode );
293         else
294             pClassData->pNode = pNode;
295     }
296 
297     *pGetInst = pNode->aInst;
298     return aError;
299 }
300 
301 /*************************************************************************
302 |*
303 |*    RscArray::GetArrayEle()
304 |*
305 |*    Beschreibung
306 |*
307 *************************************************************************/
308 ERRTYPE RscArray::GetArrayEle
309 (
310 	const RSCINST & rInst,
311 	Atom nId,
312 	RscTop * pCreateClass,
313 	RSCINST * pGetInst
314 )
315 {
316     sal_Int32  lValue;
317     if( !pTypeClass->GetConstValue( nId, &lValue ) )
318     { // nicht gefunden
319         return ERR_ARRAY_INVALIDINDEX;
320     }
321 
322     return GetValueEle( rInst, lValue, pCreateClass, pGetInst );
323 }
324 
325 /*************************************************************************
326 |*
327 |*    RscArray::IsConsistent()
328 |*
329 |*    Beschreibung
330 |*    Ersterstellung    MM 23.09.91
331 |*    Letzte Aenderung  MM 23.09.91
332 |*
333 *************************************************************************/
334 static sal_Bool IsConsistent( RscInstNode * pNode, RscInconsList * pList )
335 {
336     sal_Bool bRet = sal_True;
337 
338     if( pNode )
339     {
340         bRet = pNode->aInst.pClass->IsConsistent( pNode->aInst, pList );
341         if( !IsConsistent( pNode->Left(), pList ) )
342             bRet = sal_False;
343         if( !IsConsistent( pNode->Right(), pList ) )
344             bRet = sal_False;
345     }
346     return bRet;
347 }
348 
349 sal_Bool RscArray::IsConsistent( const RSCINST & rInst, RscInconsList * pList )
350 {
351     RscArrayInst * pClassData;
352     sal_Bool    bRet;
353 
354     bRet = RscTop::IsConsistent( rInst, pList );
355 
356     pClassData = (RscArrayInst *)(rInst.pData + nOffInstData);
357     if( !::IsConsistent( pClassData->pNode, pList ) )
358         bRet = sal_False;
359 
360     return( bRet );
361 }
362 
363 /*************************************************************************
364 |*
365 |*    RscArray::SetToDefault()
366 |*
367 |*    Beschreibung
368 |*    Ersterstellung    MM 25.04.91
369 |*    Letzte Aenderung  MM 25.04.91
370 |*
371 *************************************************************************/
372 static void SetToDefault( RscInstNode * pNode )
373 {
374     if( pNode )
375     {
376         pNode->aInst.pClass->SetToDefault( pNode->aInst );
377         SetToDefault( pNode->Left() );
378         SetToDefault( pNode->Right() );
379     }
380 }
381 
382 void RscArray::SetToDefault( const RSCINST & rInst )
383 {
384     RscArrayInst * pClassData;
385 
386     pClassData = (RscArrayInst *)(rInst.pData + nOffInstData);
387 
388     ::SetToDefault( pClassData->pNode );
389 
390     RscTop::SetToDefault( rInst );
391 }
392 
393 /*************************************************************************
394 |*
395 |*    RscArray::IsDefault()
396 |*
397 |*    Beschreibung
398 |*    Ersterstellung    MM 25.04.91
399 |*    Letzte Aenderung  MM 25.04.91
400 |*
401 *************************************************************************/
402 static sal_Bool IsDefault( RscInstNode * pNode )
403 {
404     sal_Bool bRet = sal_True;
405 
406     if( pNode )
407     {
408         bRet = pNode->aInst.pClass->IsDefault( pNode->aInst );
409         if( bRet )
410             bRet = IsDefault( pNode->Left() );
411         if( bRet )
412             bRet = IsDefault( pNode->Right() );
413     }
414     return bRet;
415 }
416 
417 sal_Bool RscArray::IsDefault( const RSCINST & rInst )
418 {
419     RscArrayInst * pClassData;
420 
421     pClassData = (RscArrayInst *)(rInst.pData + nOffInstData);
422 
423     sal_Bool bRet = ::IsDefault( pClassData->pNode );
424 
425     if( bRet )
426         bRet = RscTop::IsDefault( rInst );
427     return bRet;
428 }
429 
430 /*************************************************************************
431 |*
432 |*    RscArray::IsValueDefault()
433 |*
434 |*    Beschreibung
435 |*    Ersterstellung    MM 25.04.91
436 |*    Letzte Aenderung  MM 15.01.92
437 |*
438 *************************************************************************/
439 static sal_Bool IsValueDefault( RscInstNode * pNode, CLASS_DATA pDef )
440 {
441     sal_Bool bRet = sal_True;
442 
443     if( pNode )
444     {
445         bRet = pNode->aInst.pClass->IsValueDefault( pNode->aInst, pDef );
446         if( bRet )
447             bRet = IsValueDefault( pNode->Left(), pDef );
448         if( bRet )
449             bRet = IsValueDefault( pNode->Right(), pDef );
450     }
451     return bRet;
452 }
453 
454 sal_Bool RscArray::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef )
455 {
456     RscArrayInst * pClassData;
457     sal_Bool bRet;
458 
459     bRet = RscTop::IsValueDefault( rInst, pDef );
460 
461     if( bRet )
462     {
463         pClassData = (RscArrayInst *)(rInst.pData + nOffInstData);
464 
465         bRet = ::IsValueDefault( pClassData->pNode, pDef );
466     }
467     return bRet;
468 }
469 
470 /*************************************************************************
471 |*    RscArray::WriteSrcHeader()
472 |*
473 |*    Beschreibung
474 *************************************************************************/
475 void RscArray::WriteSrcHeader( const RSCINST & rInst, FILE * fOutput,
476                                RscTypCont * pTC, sal_uInt32 nTab,
477                                const RscId & aId, const char * pVarName )
478 {
479     RscArrayInst * pClassData;
480 
481     pClassData = (RscArrayInst *)(rInst.pData + nOffInstData);
482 
483 	if( pTC->IsSrsDefault() )
484 	{ // nur einen Wert schreiben
485 	    RscInstNode *   pNode = NULL;
486 	    if( pClassData->pNode )
487 		{
488             std::vector< sal_uInt32 >::const_iterator it;
489             for( it = pTC->GetFallbacks().begin(); !pNode && it != pTC->GetFallbacks().end(); ++it )
490                 pNode = pClassData->pNode->Search( *it );
491 		}
492 
493 	    if( pNode )
494 		{
495 	        if( pNode->aInst.pClass->IsDefault( pNode->aInst ) )
496 		        fprintf( fOutput, "Default" );
497 			else
498 		        pNode->aInst.pClass->WriteSrcHeader(
499 										pNode->aInst, fOutput,
500 										pTC, nTab, aId, pVarName );
501 			return;
502 	    }
503 	}
504 
505 	if( IsDefault( rInst ) )
506 		fprintf( fOutput, "Default" );
507 	else
508 	{
509 		RSCINST aSuper( GetSuperClass(), rInst.pData );
510 		aSuper.pClass->WriteSrcHeader( aSuper, fOutput, pTC,
511 										nTab, aId, pVarName );
512 	}
513 	if( !pTC->IsSrsDefault() )
514 		WriteSrc( rInst, fOutput, pTC, nTab, pVarName );
515 }
516 
517 /*************************************************************************
518 |*    RscArray::WriteSrc()
519 |*
520 |*    Beschreibung
521 *************************************************************************/
522 static void WriteSrc( RscInstNode * pNode, FILE * fOutput, RscTypCont * pTC,
523                          sal_uInt32 nTab, const char * pVarName,
524                          CLASS_DATA pDfltData, RscConst * pTypeClass )
525 {
526     if( pNode )
527     {
528         WriteSrc( pNode->Left(), fOutput, pTC, nTab, pVarName,
529                     pDfltData, pTypeClass );
530         if( !pNode->aInst.pClass->IsValueDefault( pNode->aInst, pDfltData ) )
531         {
532             fprintf( fOutput, ";\n" );
533             for( sal_uInt32 n = 0; n < nTab; n++ )
534                 fputc( '\t', fOutput );
535 
536             Atom  nIdxId;
537             pTypeClass->GetValueConst( pNode->GetId(), &nIdxId );
538             fprintf( fOutput, "%s[ %s ] = ", pVarName, pHS->getString( nIdxId ).getStr() );
539             pNode->aInst.pClass->WriteSrcHeader( pNode->aInst, fOutput, pTC,
540                                                 nTab, RscId(), pVarName );
541         }
542         WriteSrc( pNode->Right(), fOutput, pTC, nTab, pVarName,
543                     pDfltData, pTypeClass );
544     }
545 }
546 
547 void RscArray::WriteSrcArray( const RSCINST & rInst, FILE * fOutput,
548                          	RscTypCont * pTC, sal_uInt32 nTab,
549                          	const char * pVarName )
550 {
551     RscArrayInst * pClassData;
552 
553     pClassData = (RscArrayInst *)(rInst.pData + nOffInstData);
554 
555     ::WriteSrc( pClassData->pNode, fOutput, pTC, nTab, pVarName,
556                 rInst.pData, pTypeClass );
557 };
558 
559 void RscArray::WriteSrc( const RSCINST & rInst, FILE * fOutput,
560                          RscTypCont * pTC, sal_uInt32 nTab,
561                          const char * pVarName )
562 {
563 	WriteSrcArray( rInst, fOutput, pTC, nTab, pVarName );
564 }
565 
566 /*************************************************************************
567 |*    RscArray::WriteRc()
568 |*
569 |*    Beschreibung
570 *************************************************************************/
571 ERRTYPE RscArray::WriteRc( const RSCINST & rInst, RscWriteRc & rMem,
572                             RscTypCont * pTC, sal_uInt32 nDeep, sal_Bool bExtra )
573 {
574     ERRTYPE aError;
575     RscArrayInst * pClassData;
576     RscInstNode *   pNode = NULL;
577 
578     pClassData = (RscArrayInst *)(rInst.pData + nOffInstData);
579 
580     if( pClassData->pNode )
581 	{
582 #if OSL_DEBUG_LEVEL > 2
583         fprintf( stderr, "RscArray::WriteRc: Fallback " );
584 #endif
585         std::vector< sal_uInt32 >::const_iterator it;
586         for( it = pTC->GetFallbacks().begin(); !pNode && it != pTC->GetFallbacks().end(); ++it )
587         {
588             pNode = pClassData->pNode->Search( *it );
589 #if OSL_DEBUG_LEVEL > 2
590             fprintf( stderr, " 0x%hx", *it );
591 #endif
592         }
593 #if OSL_DEBUG_LEVEL > 2
594             fprintf( stderr, "\n" );
595 #endif
596 	}
597 
598     if( pNode )
599         aError = pNode->aInst.pClass->WriteRc( pNode->aInst, rMem, pTC,
600                                                 nDeep, bExtra );
601     else
602         aError = RscTop::WriteRc( rInst, rMem, pTC, nDeep, bExtra );
603 
604     return aError;
605 }
606 
607 //========================================================================
608 void RscArray::WriteRcAccess
609 (
610 	FILE * fOutput,
611 	RscTypCont * pTC,
612 	const char * pName
613 )
614 {
615 	GetSuperClass()->WriteRcAccess( fOutput, pTC, pName );
616 }
617 
618 /*************************************************************************
619 |*
620 |*    RscClassArray::RscClassArray()
621 |*
622 |*    Beschreibung
623 |*    Ersterstellung    MM 25.05.91
624 |*    Letzte Aenderung  MM 25.05.91
625 |*
626 *************************************************************************/
627 RscClassArray::RscClassArray( Atom nId, sal_uInt32 nTypeId, RscTop * pSuper,
628                               RscEnum * pTypeCl )
629     : RscArray( nId, nTypeId, pSuper, pTypeCl )
630 {
631 }
632 
633 /*************************************************************************
634 |*
635 |*    RscClassArray::~RscClassArray()
636 |*
637 |*    Beschreibung
638 |*    Ersterstellung    MM 25.05.91
639 |*    Letzte Aenderung  MM 25.05.91
640 |*
641 *************************************************************************/
642 RscClassArray::~RscClassArray()
643 {
644 }
645 
646 /*************************************************************************
647 |*
648 |*    RscClassArray::WriteSrcHeader()
649 |*
650 |*    Beschreibung
651 |*    Ersterstellung    MM 25.05.91
652 |*    Letzte Aenderung  MM 25.05.91
653 |*
654 *************************************************************************/
655 void RscClassArray::WriteSrcHeader( const RSCINST & rInst, FILE * fOutput,
656 									RscTypCont * pTC, sal_uInt32 nTab,
657 									const RscId & aId, const char * pName )
658 {
659 	RscArray::WriteSrcHeader( rInst, fOutput, pTC, nTab, aId, pName );
660 }
661 
662 /*************************************************************************
663 |*
664 |*    RscClassArray::WriteSrc()
665 |*
666 |*    Beschreibung
667 |*    Ersterstellung    MM 25.05.91
668 |*    Letzte Aenderung  MM 25.05.91
669 |*
670 *************************************************************************/
671 void RscClassArray::WriteSrc( const RSCINST & rInst, FILE * fOutput,
672             	             RscTypCont * pTC, sal_uInt32 nTab,
673 	               	          const char * pVarName )
674 {
675 	RscArray::WriteSrc( rInst, fOutput, pTC, nTab, pVarName );
676 }
677 
678 /*************************************************************************
679 |*
680 |*    RscClassArray::WriteRcHeader()
681 |*
682 |*    Beschreibung
683 |*    Ersterstellung    MM 25.05.91
684 |*    Letzte Aenderung  MM 25.05.91
685 |*
686 *************************************************************************/
687 ERRTYPE RscClassArray::WriteRcHeader( const RSCINST & rInst, RscWriteRc & aMem,
688 									   RscTypCont * pTC, const RscId & aId,
689 									   sal_uInt32 nDeep, sal_Bool bExtra )
690 {
691 	// Eigenen Typ schreiben
692 	return GetSuperClass()->WriteRcHeader( rInst, aMem, pTC, aId,
693 										nDeep, bExtra );
694 }
695 
696 /*************************************************************************
697 |*
698 |*    RscLangArray::RscLangArray()
699 |*
700 |*    Beschreibung
701 |*    Ersterstellung    MM 25.05.91
702 |*    Letzte Aenderung  MM 25.05.91
703 |*
704 *************************************************************************/
705 RscLangArray::RscLangArray( Atom nId, sal_uInt32 nTypeId, RscTop * pSuper,
706                           RscEnum * pTypeCl )
707     : RscArray( nId, nTypeId, pSuper, pTypeCl )
708 {
709 }
710 
711 /*************************************************************************
712 |*
713 |*    RscLangArray::RscLangArray()
714 |*
715 |*    Beschreibung
716 |*    Ersterstellung    MM 25.05.91
717 |*    Letzte Aenderung  MM 25.05.91
718 |*
719 *************************************************************************/
720 RSCCLASS_TYPE RscLangArray::GetClassType() const
721 {
722     if( GetSuperClass() )
723         return GetSuperClass()->GetClassType();
724     else
725         return RscArray::GetClassType();
726 
727 }
728 
729