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 <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 : 387360 : RscTop::RscTop( Atom nId, sal_uInt32 nTypIdent, RscTop * pSuperCl )
37 : : : RefNode( nId )
38 : : , pSuperClass( pSuperCl )
39 : 387360 : , nTypId( nTypIdent )
40 : : {
41 : 387360 : pRefClass = this;
42 [ + + ]: 387360 : if( pSuperClass )
43 : : SetCallPar( pSuperClass->aCallPar1, pSuperClass->aCallPar2,
44 : 151200 : pSuperClass->aCallParType );
45 : 387360 : }
46 : :
47 : : /*************************************************************************
48 : : |*
49 : : |* RscTop::SetCallPar()
50 : : |*
51 : : *************************************************************************/
52 : 277920 : void RscTop::SetCallPar(const rtl::OString& rPar1, const rtl::OString& rPar2,
53 : : const rtl::OString& rParType)
54 : : {
55 : 277920 : aCallPar1 = rPar1;
56 : 277920 : aCallPar2 = rPar2;
57 : 277920 : aCallParType = rParType;
58 : 277920 : }
59 : :
60 : : /*************************************************************************
61 : : |*
62 : : |* RscTop::GetDefault()
63 : : |*
64 : : *************************************************************************/
65 : 536836 : RSCINST RscTop::GetDefault()
66 : : {
67 [ + + ]: 536836 : if( !aDfltInst.IsInst() )
68 [ + - ]: 13512 : aDfltInst = this->Create( NULL, RSCINST() );
69 : 536836 : return aDfltInst;
70 : : }
71 : :
72 : : /*************************************************************************
73 : : |*
74 : : |* RscTop::Pre_dtor()
75 : : |*
76 : : *************************************************************************/
77 : 370080 : void RscTop :: Pre_dtor(){
78 [ + + ]: 370080 : if( aDfltInst.IsInst() ){
79 : 11146 : aDfltInst.pClass->Destroy( aDfltInst );
80 : 11146 : rtl_freeMemory( aDfltInst.pData );
81 : 11146 : aDfltInst = RSCINST();
82 : : };
83 : 370080 : }
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 : 171360 : sal_uInt32 RscTop :: Size()
113 : : {
114 [ + + ]: 171360 : if( pSuperClass )
115 : 151200 : return pSuperClass->Size();
116 : : else
117 : 171360 : return 0;
118 : : }
119 : :
120 : : /*************************************************************************
121 : : |*
122 : : |* RscTop::GetRef()
123 : : |*
124 : : *************************************************************************/
125 : 6996 : ERRTYPE RscTop :: GetRef( const RSCINST & rInst, RscId * pRscId ){
126 [ + + ]: 6996 : if( pSuperClass )
127 : 32 : return pSuperClass->GetRef( rInst, pRscId );
128 : : else
129 : 6996 : return ERR_UNKNOWN_METHOD;
130 : : }
131 : :
132 : : /*************************************************************************
133 : : |*
134 : : |* RscTop::InHierarchy()
135 : : |*
136 : : *************************************************************************/
137 : 461610 : sal_Bool RscTop::InHierarchy( RscTop * pClass ){
138 [ + + ]: 461610 : if( this == pClass )
139 : 205268 : return( sal_True );
140 [ + + ]: 256342 : if( pSuperClass )
141 : 248226 : return( pSuperClass->InHierarchy( pClass ) );
142 : 461610 : 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 : 1135756 : 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 [ + - ]: 1135756 : if( pSuperClass )
188 : : return pSuperClass->
189 : 1135756 : GetVariable( rInst, nVarName, rInitInst, bInitDflt, pCreateClass );
190 : : else
191 : 1135756 : return RSCINST();
192 : : }
193 : :
194 : : /*************************************************************************
195 : : |*
196 : : |* RscTop::GetCopyVar()
197 : : |*
198 : : *************************************************************************/
199 : 631026 : RSCINST RscTop::GetCopyVar( const RSCINST & rInst, Atom nVarName )
200 : : {
201 [ + - ]: 631026 : if( pSuperClass )
202 : : return pSuperClass->
203 : 631026 : GetCopyVar( rInst, nVarName );
204 : : else
205 : 631026 : return RSCINST();
206 : : }
207 : :
208 : : /*************************************************************************
209 : : |*
210 : : |* RscTop::GetTupelVar()
211 : : |*
212 : : *************************************************************************/
213 : 32 : RSCINST RscTop::GetTupelVar( const RSCINST & rInst, sal_uInt32 nPos,
214 : : const RSCINST & rInitInst )
215 : : {
216 [ + - ]: 32 : if( pSuperClass )
217 : 32 : return pSuperClass->GetTupelVar( rInst, nPos, rInitInst );
218 : : else
219 : 32 : return RSCINST();
220 : : }
221 : :
222 : : /*************************************************************************
223 : : |*
224 : : |* RscTop::GetElement()
225 : : |*
226 : : *************************************************************************/
227 : 190968 : ERRTYPE RscTop::GetElement( const RSCINST & rInst, const RscId & rEleName,
228 : : RscTop *pCreateClass, const RSCINST & rCreateInst,
229 : : RSCINST * pGetInst )
230 : : {
231 [ + - ]: 190968 : if( pSuperClass )
232 : : return pSuperClass->
233 : : GetElement( rInst, rEleName,
234 : : pCreateClass, rCreateInst,
235 : 190968 : pGetInst );
236 : : else
237 : 190968 : 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 : 12970 : sal_uInt32 RscTop::GetCount( const RSCINST & rInst ){
355 [ + + ]: 12970 : if( pSuperClass )
356 : 12874 : return pSuperClass->GetCount( rInst );
357 : : else
358 : 12970 : return 0;
359 : : }
360 : :
361 : : /*************************************************************************
362 : : |*
363 : : |* RscTop::SetNumber()
364 : : |*
365 : : *************************************************************************/
366 : 6964 : ERRTYPE RscTop::SetNumber( const RSCINST & rInst, sal_Int32 lValue ){
367 [ - + ]: 6964 : if( pSuperClass )
368 : : return pSuperClass->
369 : 0 : SetNumber( rInst, lValue );
370 : : else
371 : 6964 : 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 : 52878 : ERRTYPE RscTop::SetString( const RSCINST & rInst, const char * pStr ){
419 [ + - ]: 52878 : if( pSuperClass )
420 : : return pSuperClass->
421 : 52878 : SetString( rInst, pStr );
422 : : else
423 : 52878 : 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 : 1588 : ERRTYPE RscTop::GetString( const RSCINST & rInst, char ** ppStr ){
471 [ - + ]: 1588 : if( pSuperClass )
472 : : return pSuperClass->
473 : 0 : GetString( rInst, ppStr );
474 : : else
475 : 1588 : return ERR_UNKNOWN_METHOD;
476 : : }
477 : :
478 : : /*************************************************************************
479 : : |*
480 : : |* RscTop::Create()
481 : : |*
482 : : *************************************************************************/
483 : 643972 : RSCINST RscTop::Create( RSCINST * pInst, const RSCINST & rDefInst, sal_Bool bOwnRange )
484 : : {
485 [ + + ]: 643972 : if( pSuperClass )
486 : : return pSuperClass->
487 : 478600 : Create( pInst, rDefInst, bOwnRange );
488 : : else{
489 [ + - ]: 165372 : if( pInst )
490 : 165372 : return *pInst;
491 : 643972 : return RSCINST();
492 : : }
493 : : }
494 : :
495 : : /*************************************************************************
496 : : |*
497 : : |* RscTop::Destroy()
498 : : |*
499 : : *************************************************************************/
500 : 1287042 : void RscTop::Destroy( const RSCINST & rInst ){
501 [ + + ]: 1287042 : if( pSuperClass )
502 : 477286 : pSuperClass->Destroy( rInst );
503 : 1287042 : }
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 : 1144 : void RscTop::SetToDefault( const RSCINST & rInst )
524 : : {
525 [ - + ]: 1144 : if( pSuperClass )
526 : 0 : pSuperClass->SetToDefault( rInst );
527 : 1144 : }
528 : :
529 : : /*************************************************************************
530 : : |*
531 : : |* RscTop::IsDefault()
532 : : |*
533 : : *************************************************************************/
534 : 5504 : sal_Bool RscTop::IsDefault( const RSCINST & rInst ){
535 [ + - ]: 5504 : if( pSuperClass )
536 : 5504 : return pSuperClass->IsDefault( rInst );
537 : : else
538 : 5504 : return sal_True;
539 : : }
540 : :
541 : : /*************************************************************************
542 : : |*
543 : : |* RscTop::IsValueDefault()
544 : : |*
545 : : *************************************************************************/
546 : 59366 : sal_Bool RscTop::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef ){
547 [ + + ]: 59366 : if( pSuperClass )
548 : 53770 : return pSuperClass->IsValueDefault( rInst, pDef );
549 : : else
550 : 59366 : 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 : 11612 : ERRTYPE RscTop::SetRef( const RSCINST & rInst, const RscId & rRefId ){
605 [ + + ]: 11612 : if( pSuperClass )
606 : 24 : return pSuperClass->SetRef( rInst, rRefId );
607 : : else
608 : 11612 : 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 : 404354 : void RscTop::WriteSrcHeader( const RSCINST & rInst, FILE * fOutput,
671 : : RscTypCont * pTC, sal_uInt32 nTab,
672 : : const RscId & rId, const char * pVarName )
673 : : {
674 [ + + ]: 404354 : if( pSuperClass )
675 : 115776 : pSuperClass->WriteSrcHeader( rInst, fOutput, pTC, nTab, rId, pVarName );
676 : : else
677 : 288578 : rInst.pClass->WriteSrc( rInst, fOutput, pTC, nTab, pVarName );
678 : 404354 : }
679 : :
680 : : /*************************************************************************
681 : : |*
682 : : |* RscTop::WriteSrc()
683 : : |*
684 : : *************************************************************************/
685 : 248160 : void RscTop::WriteSrc( const RSCINST & rInst, FILE * fOutput,
686 : : RscTypCont * pTC, sal_uInt32 nTab, const char * pVarName )
687 : : {
688 [ + + ]: 248160 : if( pSuperClass )
689 : 177930 : pSuperClass->WriteSrc( rInst, fOutput, pTC, nTab, pVarName );
690 : 248160 : }
691 : :
692 : : /*************************************************************************
693 : : |*
694 : : |* RscTop::WriteRcHeader()
695 : : |*
696 : : *************************************************************************/
697 : 746396 : ERRTYPE RscTop::WriteRcHeader( const RSCINST & rInst, RscWriteRc & rMem,
698 : : RscTypCont * pTC, const RscId & rId,
699 : : sal_uInt32 nDeep, sal_Bool bExtra )
700 : : {
701 [ + + ]: 746396 : if( pSuperClass )
702 : : return( pSuperClass->
703 : 168434 : WriteRcHeader( rInst, rMem, pTC, rId, nDeep, bExtra ) );
704 : : else
705 : 746396 : return( rInst.pClass->WriteRc( rInst, rMem, pTC, nDeep, bExtra ) );
706 : : }
707 : :
708 : : /*************************************************************************
709 : : |*
710 : : |* RscTop::WriteRc()
711 : : |*
712 : : *************************************************************************/
713 : 478994 : ERRTYPE RscTop::WriteRc( const RSCINST & rInst, RscWriteRc & rMem,
714 : : RscTypCont * pTC, sal_uInt32 nDeep, sal_Bool bExtra )
715 : : {
716 [ + + ]: 478994 : if( pSuperClass )
717 : : return( pSuperClass->
718 : 266170 : WriteRc( rInst, rMem, pTC, nDeep, bExtra ) );
719 : : else
720 : 478994 : 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: */
|
