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 <stdio.h>
24 : #include <string.h>
25 :
26 : // Solar Definitionen
27 : #include <tools/solar.h>
28 : #include <rsctop.hxx>
29 : /****************** C O D E **********************************************/
30 : /****************** R s c T o p ******************************************/
31 : /*************************************************************************
32 : |*
33 : |* RscTop::RscTop()
34 : |*
35 : *************************************************************************/
36 185879 : RscTop::RscTop( Atom nId, sal_uInt32 nTypIdent, RscTop * pSuperCl )
37 : : RefNode( nId )
38 : , pSuperClass( pSuperCl )
39 185879 : , nTypId( nTypIdent )
40 : {
41 185879 : pRefClass = this;
42 185879 : if( pSuperClass )
43 : SetCallPar( pSuperClass->aCallPar1, pSuperClass->aCallPar2,
44 72555 : pSuperClass->aCallParType );
45 185879 : }
46 :
47 : /*************************************************************************
48 : |*
49 : |* RscTop::SetCallPar()
50 : |*
51 : *************************************************************************/
52 133363 : void RscTop::SetCallPar(const rtl::OString& rPar1, const rtl::OString& rPar2,
53 : const rtl::OString& rParType)
54 : {
55 133363 : aCallPar1 = rPar1;
56 133363 : aCallPar2 = rPar2;
57 133363 : aCallParType = rParType;
58 133363 : }
59 :
60 : /*************************************************************************
61 : |*
62 : |* RscTop::GetDefault()
63 : |*
64 : *************************************************************************/
65 241753 : RSCINST RscTop::GetDefault()
66 : {
67 241753 : if( !aDfltInst.IsInst() )
68 6166 : aDfltInst = this->Create( NULL, RSCINST() );
69 241753 : return aDfltInst;
70 : }
71 :
72 : /*************************************************************************
73 : |*
74 : |* RscTop::Pre_dtor()
75 : |*
76 : *************************************************************************/
77 177587 : void RscTop :: Pre_dtor(){
78 177587 : if( aDfltInst.IsInst() ){
79 5059 : aDfltInst.pClass->Destroy( aDfltInst );
80 5059 : rtl_freeMemory( aDfltInst.pData );
81 5059 : aDfltInst = RSCINST();
82 : };
83 177587 : }
84 :
85 : /*************************************************************************
86 : |*
87 : |* RscTop::GetConstant()
88 : |*
89 : *************************************************************************/
90 0 : Atom RscTop :: GetConstant( sal_uInt32 ){
91 0 : return InvalidAtom;
92 : }
93 :
94 : /*************************************************************************
95 : |*
96 : |* RscTop::GetIndexType()
97 : |*
98 : *************************************************************************/
99 0 : RscTop * RscTop::GetTypeClass() const
100 : {
101 0 : if( pSuperClass )
102 0 : return pSuperClass->GetTypeClass();
103 : else
104 0 : return NULL;
105 : }
106 :
107 : /*************************************************************************
108 : |*
109 : |* RscTop::Size()
110 : |*
111 : *************************************************************************/
112 82229 : sal_uInt32 RscTop :: Size()
113 : {
114 82229 : if( pSuperClass )
115 72555 : return pSuperClass->Size();
116 : else
117 9674 : return 0;
118 : }
119 :
120 : /*************************************************************************
121 : |*
122 : |* RscTop::GetRef()
123 : |*
124 : *************************************************************************/
125 3552 : ERRTYPE RscTop :: GetRef( const RSCINST & rInst, RscId * pRscId ){
126 3552 : if( pSuperClass )
127 16 : return pSuperClass->GetRef( rInst, pRscId );
128 : else
129 3536 : return ERR_UNKNOWN_METHOD;
130 : }
131 :
132 : /*************************************************************************
133 : |*
134 : |* RscTop::InHierarchy()
135 : |*
136 : *************************************************************************/
137 217349 : sal_Bool RscTop::InHierarchy( RscTop * pClass ){
138 217349 : if( this == pClass )
139 99197 : return( sal_True );
140 118152 : if( pSuperClass )
141 114032 : return( pSuperClass->InHierarchy( pClass ) );
142 4120 : return( sal_False );
143 : }
144 :
145 : /*************************************************************************
146 : |*
147 : |* RscTop::SetVariable()
148 : |*
149 : *************************************************************************/
150 0 : ERRTYPE RscTop::SetVariable( Atom nVarName, RscTop * pClass,
151 : RSCINST * pDflt, RSCVAR nVarType, sal_uInt32 nMask,
152 : Atom nDataBaseName )
153 : {
154 0 : if( pSuperClass )
155 : return pSuperClass->
156 : SetVariable( nVarName, pClass, pDflt,
157 0 : nVarType, nMask, nDataBaseName );
158 : else
159 0 : return ERR_UNKNOWN_METHOD;
160 : }
161 :
162 : /*************************************************************************
163 : |*
164 : |* RscTop::EnumVariable()
165 : |*
166 : *************************************************************************/
167 0 : void RscTop::EnumVariables( void * pData, VarEnumCallbackProc pProc )
168 : {
169 0 : if( pSuperClass )
170 0 : pSuperClass->EnumVariables( pData, pProc );
171 0 : }
172 :
173 : /*************************************************************************
174 : |*
175 : |* RscTop::GetVariable()
176 : |*
177 : *************************************************************************/
178 495391 : RSCINST RscTop::GetVariable
179 : (
180 : const RSCINST & rInst,
181 : Atom nVarName,
182 : const RSCINST & rInitInst,
183 : sal_Bool bInitDflt,
184 : RscTop * pCreateClass
185 : )
186 : {
187 495391 : if( pSuperClass )
188 : return pSuperClass->
189 495391 : GetVariable( rInst, nVarName, rInitInst, bInitDflt, pCreateClass );
190 : else
191 0 : return RSCINST();
192 : }
193 :
194 : /*************************************************************************
195 : |*
196 : |* RscTop::GetCopyVar()
197 : |*
198 : *************************************************************************/
199 273746 : RSCINST RscTop::GetCopyVar( const RSCINST & rInst, Atom nVarName )
200 : {
201 273746 : if( pSuperClass )
202 : return pSuperClass->
203 273746 : GetCopyVar( rInst, nVarName );
204 : else
205 0 : return RSCINST();
206 : }
207 :
208 : /*************************************************************************
209 : |*
210 : |* RscTop::GetTupelVar()
211 : |*
212 : *************************************************************************/
213 16 : RSCINST RscTop::GetTupelVar( const RSCINST & rInst, sal_uInt32 nPos,
214 : const RSCINST & rInitInst )
215 : {
216 16 : if( pSuperClass )
217 16 : return pSuperClass->GetTupelVar( rInst, nPos, rInitInst );
218 : else
219 0 : return RSCINST();
220 : }
221 :
222 : /*************************************************************************
223 : |*
224 : |* RscTop::GetElement()
225 : |*
226 : *************************************************************************/
227 85354 : ERRTYPE RscTop::GetElement( const RSCINST & rInst, const RscId & rEleName,
228 : RscTop *pCreateClass, const RSCINST & rCreateInst,
229 : RSCINST * pGetInst )
230 : {
231 85354 : if( pSuperClass )
232 : return pSuperClass->
233 : GetElement( rInst, rEleName,
234 : pCreateClass, rCreateInst,
235 85354 : pGetInst );
236 : else
237 0 : return ERR_UNKNOWN_METHOD;
238 : }
239 :
240 : /*************************************************************************
241 : |*
242 : |* RscTop::GetArrayEle()
243 : |*
244 : *************************************************************************/
245 0 : ERRTYPE RscTop::GetArrayEle
246 : (
247 : const RSCINST & rInst,
248 : Atom nId,
249 : RscTop * pCreateClass,
250 : RSCINST * pGetInst
251 : )
252 : {
253 0 : if( pSuperClass )
254 0 : return pSuperClass->GetArrayEle( rInst, nId, pCreateClass, pGetInst );
255 : else
256 0 : return ERR_UNKNOWN_METHOD;
257 : }
258 :
259 : /*************************************************************************
260 : |*
261 : |* RscTop::GetValueEle()
262 : |*
263 : *************************************************************************/
264 0 : ERRTYPE RscTop::GetValueEle
265 : (
266 : const RSCINST & rInst,
267 : sal_Int32 lValue,
268 : RscTop * pCreateClass,
269 : RSCINST * pGetInst
270 : )
271 : {
272 0 : if( pSuperClass )
273 0 : return pSuperClass->GetValueEle( rInst, lValue, pCreateClass, pGetInst );
274 : else
275 0 : return ERR_UNKNOWN_METHOD;
276 : }
277 :
278 : /*************************************************************************
279 : |*
280 : |* RscTop::SearchEle()
281 : |*
282 : *************************************************************************/
283 0 : RSCINST RscTop::SearchEle( const RSCINST & rInst, const RscId & rEleName,
284 : RscTop * pClass )
285 : {
286 0 : if( pSuperClass )
287 : return pSuperClass->
288 0 : SearchEle( rInst, rEleName, pClass );
289 : else
290 0 : return RSCINST();
291 : }
292 :
293 : /*************************************************************************
294 : |*
295 : |* RscTop::GetPosEle()
296 : |*
297 : *************************************************************************/
298 0 : RSCINST RscTop::GetPosEle( const RSCINST & rInst, sal_uInt32 nPos ){
299 0 : if( pSuperClass )
300 : return pSuperClass->
301 0 : GetPosEle( rInst, nPos );
302 : else
303 0 : return RSCINST();
304 : }
305 :
306 : /*************************************************************************
307 : |*
308 : |* RscTop::MovePosEle()
309 : |*
310 : *************************************************************************/
311 0 : ERRTYPE RscTop::MovePosEle( const RSCINST & rInst, sal_uInt32 nDestPos,
312 : sal_uInt32 nSourcePos )
313 : {
314 0 : if( pSuperClass )
315 : return pSuperClass->
316 0 : MovePosEle( rInst, nDestPos, nSourcePos );
317 : else
318 0 : return ERR_UNKNOWN_METHOD;
319 : }
320 :
321 : /*************************************************************************
322 : |*
323 : |* RscTop::SetPosRscId()
324 : |*
325 : *************************************************************************/
326 0 : ERRTYPE RscTop::SetPosRscId( const RSCINST & rInst, sal_uInt32 nPos,
327 : const RscId & rRscId )
328 : {
329 0 : if( pSuperClass )
330 : return pSuperClass->
331 0 : SetPosRscId( rInst, nPos, rRscId );
332 : else
333 0 : return ERR_UNKNOWN_METHOD;
334 : }
335 :
336 : /*************************************************************************
337 : |*
338 : |* RscTop::GetInfoEle()
339 : |*
340 : *************************************************************************/
341 0 : SUBINFO_STRUCT RscTop::GetInfoEle( const RSCINST & rInst, sal_uInt32 nPos ){
342 0 : if( pSuperClass )
343 : return pSuperClass->
344 0 : GetInfoEle( rInst, nPos );
345 : else
346 0 : return SUBINFO_STRUCT();
347 : }
348 :
349 : /*************************************************************************
350 : |*
351 : |* RscTop::GetCount()
352 : |*
353 : *************************************************************************/
354 6182 : sal_uInt32 RscTop::GetCount( const RSCINST & rInst ){
355 6182 : if( pSuperClass )
356 6135 : return pSuperClass->GetCount( rInst );
357 : else
358 47 : return 0;
359 : }
360 :
361 : /*************************************************************************
362 : |*
363 : |* RscTop::SetNumber()
364 : |*
365 : *************************************************************************/
366 3536 : ERRTYPE RscTop::SetNumber( const RSCINST & rInst, sal_Int32 lValue ){
367 3536 : if( pSuperClass )
368 : return pSuperClass->
369 0 : SetNumber( rInst, lValue );
370 : else
371 3536 : return ERR_UNKNOWN_METHOD;
372 : }
373 :
374 : /*************************************************************************
375 : |*
376 : |* RscTop::SetBool()
377 : |*
378 : *************************************************************************/
379 0 : ERRTYPE RscTop::SetBool( const RSCINST & rInst, sal_Bool bValue ){
380 0 : if( pSuperClass )
381 : return pSuperClass->
382 0 : SetBool( rInst, bValue );
383 : else
384 0 : return ERR_UNKNOWN_METHOD;
385 : }
386 :
387 : /*************************************************************************
388 : |*
389 : |* RscTop::SetConst()
390 : |*
391 : *************************************************************************/
392 0 : ERRTYPE RscTop::SetConst( const RSCINST & rInst, Atom nId, sal_Int32 nVal )
393 : {
394 0 : if( pSuperClass )
395 0 : return pSuperClass->SetConst( rInst, nId, nVal );
396 : else
397 0 : return ERR_UNKNOWN_METHOD;
398 : }
399 :
400 : /*************************************************************************
401 : |*
402 : |* RscTop::SetNotConst()
403 : |*
404 : *************************************************************************/
405 0 : ERRTYPE RscTop::SetNotConst( const RSCINST & rInst, Atom nId ){
406 0 : if( pSuperClass )
407 : return pSuperClass->
408 0 : SetNotConst( rInst, nId );
409 : else
410 0 : return ERR_UNKNOWN_METHOD;
411 : }
412 :
413 : /*************************************************************************
414 : |*
415 : |* RscTop::SetString()
416 : |*
417 : *************************************************************************/
418 26099 : ERRTYPE RscTop::SetString( const RSCINST & rInst, const char * pStr ){
419 26099 : if( pSuperClass )
420 : return pSuperClass->
421 26099 : SetString( rInst, pStr );
422 : else
423 0 : return ERR_UNKNOWN_METHOD;
424 : }
425 :
426 : /*************************************************************************
427 : |*
428 : |* RscTop::GetNumber()
429 : |*
430 : *************************************************************************/
431 0 : ERRTYPE RscTop::GetNumber( const RSCINST & rInst, sal_Int32 * pN ){
432 0 : if( pSuperClass )
433 : return pSuperClass->
434 0 : GetNumber( rInst, pN );
435 : else
436 0 : return ERR_UNKNOWN_METHOD;
437 : }
438 :
439 : /*************************************************************************
440 : |*
441 : |* RscTop::GetBool()
442 : |*
443 : *************************************************************************/
444 0 : ERRTYPE RscTop::GetBool( const RSCINST & rInst, sal_Bool * pB ){
445 0 : if( pSuperClass )
446 : return pSuperClass->
447 0 : GetBool( rInst, pB );
448 : else
449 0 : return ERR_UNKNOWN_METHOD;
450 : }
451 :
452 : /*************************************************************************
453 : |*
454 : |* RscTop::GetCont()
455 : |*
456 : *************************************************************************/
457 0 : ERRTYPE RscTop::GetConst( const RSCINST & rInst, Atom * pH ){
458 0 : if( pSuperClass )
459 : return pSuperClass->
460 0 : GetConst( rInst, pH );
461 : else
462 0 : return ERR_UNKNOWN_METHOD;
463 : }
464 :
465 : /*************************************************************************
466 : |*
467 : |* RscTop::GetString()
468 : |*
469 : *************************************************************************/
470 916 : ERRTYPE RscTop::GetString( const RSCINST & rInst, char ** ppStr ){
471 916 : if( pSuperClass )
472 : return pSuperClass->
473 0 : GetString( rInst, ppStr );
474 : else
475 916 : return ERR_UNKNOWN_METHOD;
476 : }
477 :
478 : /*************************************************************************
479 : |*
480 : |* RscTop::Create()
481 : |*
482 : *************************************************************************/
483 305118 : RSCINST RscTop::Create( RSCINST * pInst, const RSCINST & rDefInst, sal_Bool bOwnRange )
484 : {
485 305118 : if( pSuperClass )
486 : return pSuperClass->
487 225966 : Create( pInst, rDefInst, bOwnRange );
488 : else{
489 79152 : if( pInst )
490 79152 : return *pInst;
491 0 : return RSCINST();
492 : }
493 : }
494 :
495 : /*************************************************************************
496 : |*
497 : |* RscTop::Destroy()
498 : |*
499 : *************************************************************************/
500 593537 : void RscTop::Destroy( const RSCINST & rInst ){
501 593537 : if( pSuperClass )
502 225339 : pSuperClass->Destroy( rInst );
503 593537 : }
504 :
505 : /*************************************************************************
506 : |*
507 : |* RscTop::IsConsistent()
508 : |*
509 : *************************************************************************/
510 0 : sal_Bool RscTop::IsConsistent( const RSCINST & rInst )
511 : {
512 0 : if( pSuperClass )
513 0 : return pSuperClass->IsConsistent( rInst );
514 : else
515 0 : return sal_True;
516 : }
517 :
518 : /*************************************************************************
519 : |*
520 : |* RscTop::SetToDefault()
521 : |*
522 : *************************************************************************/
523 512 : void RscTop::SetToDefault( const RSCINST & rInst )
524 : {
525 512 : if( pSuperClass )
526 0 : pSuperClass->SetToDefault( rInst );
527 512 : }
528 :
529 : /*************************************************************************
530 : |*
531 : |* RscTop::IsDefault()
532 : |*
533 : *************************************************************************/
534 2840 : sal_Bool RscTop::IsDefault( const RSCINST & rInst ){
535 2840 : if( pSuperClass )
536 2840 : return pSuperClass->IsDefault( rInst );
537 : else
538 0 : return sal_True;
539 : }
540 :
541 : /*************************************************************************
542 : |*
543 : |* RscTop::IsValueDefault()
544 : |*
545 : *************************************************************************/
546 28938 : sal_Bool RscTop::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef ){
547 28938 : if( pSuperClass )
548 26276 : return pSuperClass->IsValueDefault( rInst, pDef );
549 : else
550 2662 : return sal_True;
551 : }
552 :
553 : /*************************************************************************
554 : |*
555 : |* RscTop::SetDefault()
556 : |*
557 : *************************************************************************/
558 0 : void RscTop::SetDefault( const RSCINST & rInst, Atom nVarId ){
559 0 : if( pSuperClass )
560 0 : pSuperClass->SetDefault( rInst, nVarId );
561 0 : }
562 :
563 : /*************************************************************************
564 : |*
565 : |* RscTop::GetDefault()
566 : |*
567 : *************************************************************************/
568 0 : RSCINST RscTop::GetDefault( Atom nVarId ){
569 0 : if( pSuperClass )
570 : return pSuperClass->
571 0 : GetDefault( nVarId );
572 : else
573 0 : return RSCINST();
574 : }
575 :
576 : /*************************************************************************
577 : |*
578 : |* RscTop::Delete()
579 : |*
580 : *************************************************************************/
581 0 : void RscTop::Delete( const RSCINST & rInst, RscTop * pClass,
582 : const RscId & rId )
583 : {
584 0 : if( pSuperClass )
585 0 : pSuperClass->Delete( rInst, pClass, rId );
586 0 : }
587 :
588 : /*************************************************************************
589 : |*
590 : |* RscTop::DeletePos()
591 : |*
592 : *************************************************************************/
593 0 : void RscTop::DeletePos( const RSCINST & rInst, sal_uInt32 nPos )
594 : {
595 0 : if( pSuperClass )
596 0 : pSuperClass->DeletePos( rInst, nPos );
597 0 : }
598 :
599 : /*************************************************************************
600 : |*
601 : |* RscTop::SetRef()
602 : |*
603 : *************************************************************************/
604 5551 : ERRTYPE RscTop::SetRef( const RSCINST & rInst, const RscId & rRefId ){
605 5551 : if( pSuperClass )
606 12 : return pSuperClass->SetRef( rInst, rRefId );
607 : else
608 5539 : return ERR_UNKNOWN_METHOD;
609 : }
610 :
611 : /*************************************************************************
612 : |*
613 : |* RscTop::WriteHxxHeader()
614 : |*
615 : *************************************************************************/
616 0 : ERRTYPE RscTop::WriteHxxHeader( const RSCINST & rInst, FILE * fOutput,
617 : RscTypCont * pTC, const RscId & rId )
618 : {
619 0 : if( pSuperClass )
620 0 : return pSuperClass->WriteHxxHeader( rInst, fOutput, pTC, rId );
621 : else
622 0 : return rInst.pClass->WriteHxx( rInst, fOutput, pTC, rId );
623 : }
624 :
625 : /*************************************************************************
626 : |*
627 : |* RscTop::WriteHxx()
628 : |*
629 : *************************************************************************/
630 0 : ERRTYPE RscTop::WriteHxx( const RSCINST & rInst, FILE * fOutput,
631 : RscTypCont * pTC, const RscId & rId ){
632 0 : if( pSuperClass )
633 0 : return pSuperClass->WriteHxx( rInst, fOutput, pTC, rId );
634 : else
635 0 : return( ERR_OK );
636 : }
637 :
638 : /*************************************************************************
639 : |*
640 : |* RscTop::WriteCxxHeader()
641 : |*
642 : *************************************************************************/
643 0 : ERRTYPE RscTop::WriteCxxHeader( const RSCINST & rInst, FILE * fOutput,
644 : RscTypCont * pTC, const RscId & rId )
645 : {
646 0 : if( pSuperClass )
647 0 : return pSuperClass->WriteCxxHeader( rInst, fOutput, pTC, rId );
648 : else
649 0 : return rInst.pClass->WriteCxx( rInst, fOutput, pTC, rId );
650 : }
651 :
652 : /*************************************************************************
653 : |*
654 : |* RscTop::WriteCxx()
655 : |*
656 : *************************************************************************/
657 0 : ERRTYPE RscTop::WriteCxx( const RSCINST & rInst, FILE * fOutput,
658 : RscTypCont * pTC, const RscId & rId ){
659 0 : if( pSuperClass )
660 0 : return pSuperClass->WriteCxx( rInst, fOutput, pTC, rId );
661 : else
662 0 : return ERR_OK;
663 : }
664 :
665 : /*************************************************************************
666 : |*
667 : |* RscTop::WriteSrcHeader()
668 : |*
669 : *************************************************************************/
670 186465 : void RscTop::WriteSrcHeader( const RSCINST & rInst, FILE * fOutput,
671 : RscTypCont * pTC, sal_uInt32 nTab,
672 : const RscId & rId, const char * pVarName )
673 : {
674 186465 : if( pSuperClass )
675 53423 : pSuperClass->WriteSrcHeader( rInst, fOutput, pTC, nTab, rId, pVarName );
676 : else
677 133042 : rInst.pClass->WriteSrc( rInst, fOutput, pTC, nTab, pVarName );
678 186465 : }
679 :
680 : /*************************************************************************
681 : |*
682 : |* RscTop::WriteSrc()
683 : |*
684 : *************************************************************************/
685 117449 : void RscTop::WriteSrc( const RSCINST & rInst, FILE * fOutput,
686 : RscTypCont * pTC, sal_uInt32 nTab, const char * pVarName )
687 : {
688 117449 : if( pSuperClass )
689 83470 : pSuperClass->WriteSrc( rInst, fOutput, pTC, nTab, pVarName );
690 117449 : }
691 :
692 : /*************************************************************************
693 : |*
694 : |* RscTop::WriteRcHeader()
695 : |*
696 : *************************************************************************/
697 340006 : ERRTYPE RscTop::WriteRcHeader( const RSCINST & rInst, RscWriteRc & rMem,
698 : RscTypCont * pTC, const RscId & rId,
699 : sal_uInt32 nDeep, sal_Bool bExtra )
700 : {
701 340006 : if( pSuperClass )
702 : return( pSuperClass->
703 79295 : WriteRcHeader( rInst, rMem, pTC, rId, nDeep, bExtra ) );
704 : else
705 260711 : return( rInst.pClass->WriteRc( rInst, rMem, pTC, nDeep, bExtra ) );
706 : }
707 :
708 : /*************************************************************************
709 : |*
710 : |* RscTop::WriteRc()
711 : |*
712 : *************************************************************************/
713 221797 : ERRTYPE RscTop::WriteRc( const RSCINST & rInst, RscWriteRc & rMem,
714 : RscTypCont * pTC, sal_uInt32 nDeep, sal_Bool bExtra )
715 : {
716 221797 : if( pSuperClass )
717 : return( pSuperClass->
718 122642 : WriteRc( rInst, rMem, pTC, nDeep, bExtra ) );
719 : else
720 99155 : return( ERR_OK );
721 : }
722 :
723 : /*************************************************************************
724 : |*
725 : |* RscTop::WriteSyntaxHeader()
726 : |*
727 : *************************************************************************/
728 0 : void RscTop::WriteSyntaxHeader( FILE * fOutput, RscTypCont * pTC )
729 : {
730 0 : if( GetId() != InvalidAtom )
731 : {
732 0 : fprintf( fOutput, "class %s \n{\n", pHS->getString( GetId() ).getStr() );
733 0 : WriteSyntax( fOutput, pTC );
734 0 : fprintf( fOutput, "};\n\n" );
735 : }
736 0 : }
737 :
738 : /*************************************************************************
739 : |*
740 : |* RscTop::WriteSyntax()
741 : |*
742 : *************************************************************************/
743 0 : void RscTop::WriteSyntax( FILE * fOutput, RscTypCont * pTC )
744 : {
745 0 : if( pSuperClass )
746 0 : pSuperClass->WriteSyntax( fOutput, pTC );
747 0 : }
748 :
749 : //========================================================================
750 0 : void RscTop::WriteRcAccess
751 : (
752 : FILE * fOutput,
753 : RscTypCont * /*pTC*/,
754 : const char * pName
755 : )
756 : {
757 0 : if( GetId() != InvalidAtom )
758 : {
759 : fprintf( fOutput, "\t\t//%s %s\n",
760 0 : pHS->getString( GetId() ).getStr(), pName );
761 : }
762 0 : }
763 :
764 : //========================================================================
765 0 : void RscTop::WriteRcCtor( FILE * fOutput, RscTypCont * pTC )
766 : {
767 0 : if( pSuperClass )
768 0 : pSuperClass->WriteRcCtor( fOutput, pTC );
769 0 : }
770 :
771 :
772 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
