idl/source/objects/types.cxx

   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
  21 #include <ctype.h>
  22 #include <stdio.h>
  23
  24 #include <tools/debug.hxx>
  25
  26 #include <types.hxx>
  27 #include <globals.hxx>
  28 #include <database.hxx>
  29
  30 TYPEINIT1( SvMetaAttribute, SvMetaReference );
  31 SvMetaAttribute::SvMetaAttribute()
  32     : aAutomation( true, false )
  33     , aExport( true, false )
  34     , aIsCollection ( false, false )
  35     , aReadOnlyDoc ( true, false )
  36     , aHidden( false, false )
  37     , bNewAttr( false )
  38 {
  39 }
  40
  41 SvMetaAttribute::SvMetaAttribute( SvMetaType * pType )
  42     : aType( pType )
  43     , aAutomation( true, false )
  44     , aExport( true, false )
  45     , aIsCollection ( false, false)
  46     , aReadOnlyDoc ( true, false)
  47     , aHidden( false, false )
  48     , bNewAttr( false )
  49 {
  50 }
  51
  52 SvMetaType * SvMetaAttribute::GetType() const
  53 {
  54     if( aType.Is() || !GetRef() ) return aType;
  55     return static_cast<SvMetaAttribute *>(GetRef())->GetType();
  56 }
  57
  58 const SvNumberIdentifier & SvMetaAttribute::GetSlotId() const
  59 {
  60     if( aSlotId.IsSet() || !GetRef() ) return aSlotId;
  61     return static_cast<SvMetaAttribute *>(GetRef())->GetSlotId();
  62 }
  63
  64 bool SvMetaAttribute::GetReadonly() const
  65 {
  66     if( aReadonly.IsSet() || !GetRef() ) return aReadonly;
  67     return static_cast<SvMetaAttribute *>(GetRef())->GetReadonly();
  68 }
  69
  70 bool SvMetaAttribute::GetExport() const
  71 {
  72     if( aExport.IsSet() || !GetRef() ) return aExport;
  73     return static_cast<SvMetaAttribute *>(GetRef())->GetExport();
  74 }
  75
  76 bool SvMetaAttribute::GetHidden() const
  77 {
  78     // when export is set, but hidden is not the default is used
  79     if ( aExport.IsSet() && !aHidden.IsSet() )
  80         return !aExport;
  81     else if( aHidden.IsSet() || !GetRef() )
  82         return aHidden;
  83     else
  84         return static_cast<SvMetaAttribute *>(GetRef())->GetHidden();
  85 }
  86
  87 bool SvMetaAttribute::GetAutomation() const
  88 {
  89     if( aAutomation.IsSet() || !GetRef() ) return aAutomation;
  90     return static_cast<SvMetaAttribute *>(GetRef())->GetAutomation();
  91 }
  92
  93 bool SvMetaAttribute::GetIsCollection() const
  94 {
  95     if( aIsCollection.IsSet() || !GetRef() )
  96     {
  97         return aIsCollection;
  98     }
  99
 100     return static_cast<SvMetaSlot *>(GetRef())->GetIsCollection();
 101 }
 102
 103 bool SvMetaAttribute::GetReadOnlyDoc() const
 104 {
 105     if( aReadOnlyDoc.IsSet() || !GetRef() ) return aReadOnlyDoc;
 106     return static_cast<SvMetaSlot *>(GetRef())->GetReadOnlyDoc();
 107 }
 108
 109 bool SvMetaAttribute::IsMethod() const
 110 {
 111     SvMetaType * pType = GetType();
 112     DBG_ASSERT( pType, "no type for attribute" );
 113     return pType->GetType() == TYPE_METHOD;
 114 }
 115
 116 bool SvMetaAttribute::IsVariable() const
 117 {
 118     SvMetaType * pType = GetType();
 119     return pType->GetType() != TYPE_METHOD;
 120 }
 121
 122 OString SvMetaAttribute::GetMangleName( bool ) const
 123 {
 124     return GetName().getString();
 125 }
 126
 127 bool SvMetaAttribute::Test( SvIdlDataBase & rBase,
 128                             SvTokenStream & rInStm )
 129 {
 130     bool bOk = true;
 131     if( GetType()->IsItem() && !GetSlotId().IsSet() )
 132     {
 133         rBase.SetError( "slot without id declared", rInStm.GetToken() );
 134         rBase.WriteError( rInStm );
 135         bOk = false;
 136     }
 137     return bOk;
 138 }
 139
 140 bool SvMetaAttribute::ReadSvIdl( SvIdlDataBase & rBase,
 141                                  SvTokenStream & rInStm )
 142 {
 143     sal_uInt32  nTokPos     = rInStm.Tell();
 144     if( !GetType() )
 145         // no type in ctor passed on
 146         aType = rBase.ReadKnownType( rInStm );
 147     bool bOk = false;
 148     if( GetType() )
 149     {
 150         ReadNameSvIdl( rBase, rInStm );
 151         aSlotId.ReadSvIdl( rBase, rInStm );
 152
 153         bOk = true;
 154         SvToken * pTok  = rInStm.GetToken();
 155         if( bOk && pTok->IsChar() && pTok->GetChar() == '(' )
 156         {
 157             SvMetaTypeRef xT = new SvMetaType();
 158             xT->SetRef( GetType() );
 159             aType = xT;
 160             bOk = aType->ReadMethodArgs( rBase, rInStm );
 161         }
 162         if( bOk )
 163             bOk = SvMetaName::ReadSvIdl( rBase, rInStm );
 164     }
 165     else
 166     {
 167         SvToken *pTok = rInStm.GetToken();
 168         rBase.SetError( "unknown type of token. Each new SID needs an "
 169                         "item statement in an SDI file, eg. "
 170                         "SfxVoidItem FooItem  " + pTok->GetTokenAsString() +
 171                         " ... which describes the slot more fully", pTok );
 172     }
 173
 174     if( !bOk )
 175         rInStm.Seek( nTokPos );
 176     return bOk;
 177 }
 178
 179 void SvMetaAttribute::ReadAttributesSvIdl( SvIdlDataBase & rBase,
 180                                              SvTokenStream & rInStm )
 181 {
 182     SvMetaReference::ReadAttributesSvIdl( rBase, rInStm );
 183     aSlotId.ReadSvIdl( rBase, SvHash_SlotId(), rInStm );
 184     aExport.ReadSvIdl( SvHash_Export(), rInStm );
 185     aHidden.ReadSvIdl( SvHash_Hidden(), rInStm );
 186     aAutomation.ReadSvIdl( SvHash_Automation(), rInStm );
 187     aIsCollection.ReadSvIdl( SvHash_IsCollection(), rInStm );
 188     aReadOnlyDoc.ReadSvIdl( SvHash_ReadOnlyDoc(), rInStm );
 189     if( aReadonly.ReadSvIdl( SvHash_Readonly(), rInStm ) )
 190     {
 191         if( GetType()->GetType() == TYPE_METHOD )
 192         {
 193             // set error
 194             rBase.SetError( "Readonly in function attribute", rInStm.GetToken() );
 195             rBase.WriteError( rInStm );
 196         }
 197     }
 198 }
 199
 200 sal_uLong SvMetaAttribute::MakeSfx( OStringBuffer& rAttrArray )
 201 {
 202     SvMetaType * pType = GetType();
 203     DBG_ASSERT( pType, "no type for attribute" );
 204     SvMetaType * pBaseType = pType->GetBaseType();
 205     DBG_ASSERT( pBaseType, "no base type for attribute" );
 206     if( pBaseType->GetType() == TYPE_STRUCT )
 207         return pBaseType->MakeSfx( rAttrArray );
 208     else
 209     {
 210         rAttrArray.append('{');
 211         rAttrArray.append(GetSlotId().getString());
 212         rAttrArray.append(",\"");
 213         rAttrArray.append(GetName().getString());
 214         rAttrArray.append("\"}");
 215         return 1;
 216     }
 217 }
 218
 219 void SvMetaAttribute::Insert (SvSlotElementList&, const OString&, SvIdlDataBase&)
 220 {
 221 }
 222
 223 TYPEINIT1( SvMetaType, SvMetaExtern );
 224 #define CTOR                            \
 225     : aCall0( CALL_VALUE, false )       \
 226     , aCall1( CALL_VALUE, false )       \
 227     , aSbxDataType( 0, false )          \
 228     , pAttrList( NULL )                 \
 229     , nType( TYPE_BASE )                \
 230     , bIsItem( false )                  \
 231     , bIsShell( false )                 \
 232     , cParserChar( 'h' )
 233
 234 SvMetaType::SvMetaType()
 235     CTOR
 236 {
 237 }
 238
 239 SvMetaType::SvMetaType( const OString& rName, char cPC,
 240                         const OString& rCName )
 241     CTOR
 242 {
 243     SetName( rName );
 244     cParserChar = cPC;
 245     aCName.setString(rCName);
 246 }
 247
 248 SvMetaType::SvMetaType( const OString& rName,
 249                         const OString& rSbxName,
 250                         const OString& rOdlName,
 251                         char cPc,
 252                         const OString& rCName,
 253                         const OString& rBasicName,
 254                         const OString& rBasicPostfix )
 255     CTOR
 256 {
 257     SetName( rName );
 258     aSbxName.setString(rSbxName);
 259     aOdlName.setString(rOdlName);
 260     cParserChar = cPc;
 261     aCName.setString(rCName);
 262     aBasicName.setString(rBasicName);
 263     aBasicPostfix.setString(rBasicPostfix);
 264 }
 265
 266 SvMetaType::~SvMetaType() {
 267     delete pAttrList;
 268 }
 269
 270 SvMetaAttributeMemberList & SvMetaType::GetAttrList() const
 271 {
 272     if( !pAttrList )
 273         const_cast<SvMetaType *>(this)->pAttrList = new SvMetaAttributeMemberList();
 274     return *pAttrList;
 275 }
 276
 277 void SvMetaType::SetType( int nT )
 278 {
 279     nType = nT;
 280     if( nType == TYPE_ENUM )
 281     {
 282         aOdlName.setString("short");
 283     }
 284     else if( nType == TYPE_CLASS )
 285     {
 286         OStringBuffer aTmp(C_PREF);
 287         aTmp.append("Object *");
 288         aCName.setString(aTmp.makeStringAndClear());
 289     }
 290 }
 291
 292 SvMetaType * SvMetaType::GetBaseType() const
 293 {
 294     if( GetRef() && GetType() == TYPE_BASE )
 295         return static_cast<SvMetaType *>(GetRef())->GetBaseType();
 296     return const_cast<SvMetaType *>(this);
 297 }
 298
 299 SvMetaType * SvMetaType::GetReturnType() const
 300 {
 301     DBG_ASSERT( GetType() == TYPE_METHOD, "no method" );
 302     DBG_ASSERT( GetRef(), "no return type" );
 303     return static_cast<SvMetaType *>(GetRef());
 304 }
 305
 306 const OString& SvMetaType::GetBasicName() const
 307 {
 308     if( aBasicName.IsSet() || !GetRef() )
 309         return aBasicName.getString();
 310     else
 311         return static_cast<SvMetaType*>(GetRef())->GetBasicName();
 312 }
 313
 314 bool SvMetaType::GetIn() const
 315 {
 316     if( aIn.IsSet() || !GetRef() )
 317         return aIn;
 318     else
 319         return static_cast<SvMetaType *>(GetRef())->GetIn();
 320 }
 321
 322 bool SvMetaType::GetOut() const
 323 {
 324     if( aOut.IsSet() || !GetRef() )
 325         return aOut;
 326     else
 327         return static_cast<SvMetaType *>(GetRef())->GetOut();
 328 }
 329
 330 void SvMetaType::SetCall0( int e )
 331 {
 332     aCall0 = (int)e;
 333     if( aCall0 == CALL_VALUE && aCall1 == CALL_VALUE )
 334     {
 335           if( GetType() == TYPE_POINTER )
 336             SetType( TYPE_BASE );
 337     }
 338     else
 339     {
 340         DBG_ASSERT( nType == TYPE_POINTER || nType == TYPE_BASE,
 341                     "set no base type to pointer" );
 342         SetType( TYPE_POINTER );
 343     }
 344 }
 345
 346 int SvMetaType::GetCall0() const
 347 {
 348     if( aCall0.IsSet() || !GetRef() )
 349         return aCall0;
 350     else
 351         return static_cast<SvMetaType *>(GetRef())->GetCall0();
 352 }
 353
 354 void SvMetaType::SetCall1( int e )
 355 {
 356     aCall1 = (int)e;
 357     if( aCall0 == CALL_VALUE && aCall1 == CALL_VALUE )
 358     {
 359           if( GetType() == TYPE_POINTER )
 360             SetType( TYPE_BASE );
 361     }
 362     else
 363     {
 364         DBG_ASSERT( nType == TYPE_POINTER || nType == TYPE_BASE,
 365                     "set no base type to pointer" );
 366         SetType( TYPE_POINTER );
 367     }
 368 }
 369
 370 int SvMetaType::GetCall1() const
 371 {
 372     if( aCall1.IsSet() || !GetRef() )
 373         return aCall1;
 374     else
 375         return static_cast<SvMetaType *>(GetRef())->GetCall1();
 376 }
 377
 378 const OString& SvMetaType::GetSvName() const
 379 {
 380     if( aSvName.IsSet() || !GetRef() )
 381         return aSvName.getString();
 382     else
 383         return static_cast<SvMetaType *>(GetRef())->GetSvName();
 384 }
 385
 386 const OString& SvMetaType::GetSbxName() const
 387 {
 388     if( aSbxName.IsSet() || !GetRef() )
 389         return aSbxName.getString();
 390     else
 391         return static_cast<SvMetaType *>(GetRef())->GetSbxName();
 392 }
 393
 394 const OString& SvMetaType::GetOdlName() const
 395 {
 396     if( aOdlName.IsSet() || !GetRef() )
 397         return aOdlName.getString();
 398     else
 399         return static_cast<SvMetaType *>(GetRef())->GetOdlName();
 400 }
 401
 402 const OString& SvMetaType::GetCName() const
 403 {
 404     if( aCName.IsSet() || !GetRef() )
 405         return aCName.getString();
 406     else
 407         return static_cast<SvMetaType *>(GetRef())->GetCName();
 408 }
 409
 410 bool SvMetaType::SetName( const OString& rName, SvIdlDataBase * pBase )
 411 {
 412     aSvName.setString(rName);
 413     aSbxName.setString(rName);
 414     aCName.setString(rName);
 415     if( GetType() != TYPE_ENUM )
 416         aOdlName.setString(rName);
 417     return SvMetaReference::SetName( rName, pBase );
 418 }
 419
 420 bool SvMetaType::ReadHeaderSvIdl( SvIdlDataBase & rBase,
 421                                   SvTokenStream & rInStm )
 422 {
 423     bool bOk = false;
 424     sal_uInt32  nTokPos = rInStm.Tell();
 425     SvToken * pTok = rInStm.GetToken_Next();
 426
 427     if( pTok->Is( SvHash_interface() )
 428       || pTok->Is( SvHash_shell() ) )
 429     {
 430         if( pTok->Is( SvHash_shell() ) )
 431             bIsShell = true;
 432         SetType( TYPE_CLASS );
 433         bOk = ReadNamesSvIdl( rBase, rInStm );
 434
 435     }
 436     else if( pTok->Is( SvHash_struct() ) )
 437     {
 438         SetType( TYPE_STRUCT );
 439         bOk = ReadNamesSvIdl( rBase, rInStm );
 440     }
 441     else if( pTok->Is( SvHash_union() ) )
 442     {
 443         SetType( TYPE_UNION );
 444         if( ReadNameSvIdl( rBase, rInStm ) )
 445             return true;
 446     }
 447     else if( pTok->Is( SvHash_enum() ) )
 448     {
 449         SetType( TYPE_ENUM );
 450         bOk = ReadNameSvIdl( rBase, rInStm );
 451     }
 452     else if( pTok->Is( SvHash_typedef() )
 453       || pTok->Is( SvHash_item() ) )
 454     {
 455           if( pTok->Is( SvHash_item() ) )
 456             bIsItem = true;
 457
 458         SvMetaType * pType = rBase.ReadKnownType( rInStm );
 459         if( pType )
 460         {
 461             SetRef( pType );
 462             if( ReadNameSvIdl( rBase, rInStm ) )
 463             {
 464                 if( rInStm.Read( '(' ) )
 465                 {
 466                     DoReadContextSvIdl( rBase, rInStm );
 467                     if( rInStm.Read( ')' ) )
 468                     {
 469                         SetType( TYPE_METHOD );
 470                         bOk = true;
 471                     }
 472                 }
 473                 else
 474                 {
 475                     bOk = true;
 476                 }
 477             }
 478         }
 479         else
 480         {
 481             OString aStr("wrong typedef: ");
 482             rBase.SetError( aStr, rInStm.GetToken() );
 483             rBase.WriteError( rInStm );
 484         }
 485     }
 486     if( bOk )
 487         SetModule( rBase );
 488     else
 489         rInStm.Seek( nTokPos );
 490     return bOk;
 491 }
 492
 493 bool SvMetaType::ReadSvIdl( SvIdlDataBase & rBase,
 494                             SvTokenStream & rInStm )
 495 {
 496     if( ReadHeaderSvIdl( rBase, rInStm ) )
 497     {
 498         rBase.Write(OString('.'));
 499         return SvMetaExtern::ReadSvIdl( rBase, rInStm );
 500     }
 501     return false;
 502 }
 503
 504 bool SvMetaType::ReadNamesSvIdl( SvIdlDataBase & rBase,
 505                                  SvTokenStream & rInStm )
 506 {
 507     bool bOk = ReadNameSvIdl( rBase, rInStm );
 508
 509     return bOk;
 510 }
 511
 512 void SvMetaType::ReadAttributesSvIdl( SvIdlDataBase & rBase,
 513                                       SvTokenStream & rInStm )
 514 {
 515     SvMetaExtern::ReadAttributesSvIdl( rBase, rInStm );
 516     aSvName.ReadSvIdl( SvHash_SvName(), rInStm );
 517     aSbxName.ReadSvIdl( SvHash_SbxName(), rInStm );
 518     aOdlName.ReadSvIdl( SvHash_OdlName(), rInStm );
 519 }
 520
 521 void SvMetaType::ReadContextSvIdl( SvIdlDataBase & rBase,
 522                                       SvTokenStream & rInStm )
 523 {
 524     SvMetaAttributeRef xAttr = new SvMetaAttribute();
 525     if( xAttr->ReadSvIdl( rBase, rInStm ) )
 526     {
 527         if( xAttr->Test( rBase, rInStm ) )
 528             GetAttrList().push_back( xAttr );
 529     }
 530 }
 531
 532 sal_uLong SvMetaType::MakeSfx( OStringBuffer& rAttrArray )
 533 {
 534     sal_uLong nC = 0;
 535
 536     if( GetBaseType()->GetType() == TYPE_STRUCT )
 537     {
 538         sal_uLong nAttrCount = GetAttrCount();
 539         // write the single attributes
 540         for( sal_uLong n = 0; n < nAttrCount; n++ )
 541         {
 542             nC += (*pAttrList)[n]->MakeSfx( rAttrArray );
 543             if( n +1 < nAttrCount )
 544                 rAttrArray.append(", ");
 545         }
 546     }
 547     return nC;
 548 }
 549
 550 void SvMetaType::WriteSfxItem(
 551     const OString& rItemName, SvIdlDataBase& rBase, SvStream& rOutStm )
 552 {
 553     WriteStars( rOutStm );
 554     OStringBuffer aVarName(" a");
 555     aVarName.append(rItemName).append("_Impl");
 556
 557     OStringBuffer aTypeName("SfxType");
 558     OStringBuffer aAttrArray;
 559     sal_uLong   nAttrCount = MakeSfx( aAttrArray );
 560     OString aAttrCount(
 561         OString::number(nAttrCount));
 562     aTypeName.append(aAttrCount);
 563
 564     bool bExport = false, bReturn = false;
 565     // these are exported from sfx library
 566     if (rItemName == "SfxBoolItem" ||
 567         rItemName == "SfxStringItem" ||
 568         rItemName == "SfxUInt16Item" ||
 569         rItemName == "SfxUInt32Item" ||
 570         rItemName == "SfxVoidItem")
 571     {
 572         bExport = true;
 573         if (!rBase.sSlotMapFile.endsWith("sfxslots.hxx"))
 574             bReturn = true;
 575     }
 576
 577     rOutStm.WriteCharPtr( "extern " );
 578     if (bExport)
 579         rOutStm.WriteCharPtr( "SFX2_DLLPUBLIC " );
 580     rOutStm.WriteCharPtr( aTypeName.getStr() )
 581            .WriteCharPtr( aVarName.getStr() ).WriteChar( ';' ) << endl;
 582     if (bReturn)
 583         return;
 584
 585     // write the implementation part
 586     rOutStm.WriteCharPtr( "#ifdef SFX_TYPEMAP" ) << endl;
 587     rOutStm.WriteCharPtr( "#if !defined(_WIN32) && ((defined(DISABLE_DYNLOADING) && (defined(ANDROID) || defined(IOS))) || STATIC_LINKING)" ) << endl;
 588     rOutStm.WriteCharPtr( "__attribute__((__weak__))" ) << endl;
 589     rOutStm.WriteCharPtr( "#endif" ) << endl;
 590     if (bExport)
 591         rOutStm.WriteCharPtr( "SFX2_DLLPUBLIC " );
 592     rOutStm.WriteCharPtr( aTypeName.getStr() ).WriteCharPtr( aVarName.getStr() )
 593            .WriteCharPtr( " = " ) << endl;
 594     rOutStm.WriteChar( '{' ) << endl;
 595     rOutStm.WriteCharPtr( "\tTYPE(" ).WriteCharPtr( rItemName.getStr() ).WriteCharPtr( "), " )
 596            .WriteCharPtr( aAttrCount.getStr() );
 597     if( nAttrCount )
 598     {
 599         rOutStm.WriteCharPtr( ", { " );
 600         // write the single attributes
 601         rOutStm.WriteCharPtr( aAttrArray.getStr() );
 602         rOutStm.WriteCharPtr( " }" );
 603     }
 604     rOutStm << endl;
 605     rOutStm.WriteCharPtr( "};" ) << endl;
 606     rOutStm.WriteCharPtr( "#endif" ) << endl << endl;
 607 }
 608
 609 void SvMetaType::WriteSfx( SvIdlDataBase & rBase, SvStream & rOutStm )
 610 {
 611     if( IsItem() )
 612     {
 613         if( GetBaseType()->GetType() == TYPE_STRUCT )
 614             GetBaseType()->WriteSfxItem( GetName().getString(), rBase, rOutStm );
 615         else
 616             WriteSfxItem( GetName().getString(), rBase, rOutStm );
 617     }
 618 }
 619
 620 bool SvMetaType::ReadMethodArgs( SvIdlDataBase & rBase,
 621                                  SvTokenStream & rInStm )
 622 {
 623     sal_uInt32  nTokPos = rInStm.Tell();
 624     if( rInStm.Read( '(' ) )
 625     {
 626         DoReadContextSvIdl( rBase, rInStm );
 627         if( rInStm.Read( ')' ) )
 628         {
 629             SetType( TYPE_METHOD );
 630             return true;
 631         }
 632     }
 633     rInStm.Seek( nTokPos );
 634     return false;
 635 }
 636
 637 OString SvMetaType::GetParserString() const
 638 {
 639     SvMetaType * pBT = GetBaseType();
 640     if( pBT != this )
 641         return pBT->GetParserString();
 642
 643     int type = GetType();
 644     OString aPStr;
 645
 646     if( TYPE_METHOD == type || TYPE_STRUCT == type )
 647     {
 648         sal_uLong nAttrCount = GetAttrCount();
 649         // write the single attributes
 650         for( sal_uLong n = 0; n < nAttrCount; n++ )
 651         {
 652             SvMetaAttribute * pT = (*pAttrList)[n];
 653             aPStr += pT->GetType()->GetParserString();
 654         }
 655     }
 656     else
 657         aPStr = OString(GetParserChar());
 658     return aPStr;
 659 }
 660
 661 TYPEINIT1( SvMetaTypeString, SvMetaType );
 662 SvMetaTypeString::SvMetaTypeString()
 663     : SvMetaType( "String", "SbxSTRING", "BSTR", 's', "char *", "String", "$" )
 664 {
 665 }
 666
 667 TYPEINIT1( SvMetaEnumValue, SvMetaName );
 668 SvMetaEnumValue::SvMetaEnumValue()
 669 {
 670 }
 671
 672 bool SvMetaEnumValue::ReadSvIdl( SvIdlDataBase & rBase,
 673                                  SvTokenStream & rInStm )
 674 {
 675     if( !ReadNameSvIdl( rBase, rInStm ) )
 676         return false;
 677     return true;
 678 }
 679
 680 TYPEINIT1( SvMetaTypeEnum, SvMetaType );
 681 SvMetaTypeEnum::SvMetaTypeEnum()
 682 {
 683     SetBasicName("Integer");
 684 }
 685
 686 namespace
 687 {
 688     OString getCommonSubPrefix(const OString &rA, const OString &rB)
 689     {
 690         sal_Int32 nMax = std::min(rA.getLength(), rB.getLength());
 691         sal_Int32 nI = 0;
 692         while (nI < nMax)
 693         {
 694             if (rA[nI] != rB[nI])
 695                 break;
 696             ++nI;
 697         }
 698         return rA.copy(0, nI);
 699     }
 700 }
 701
 702 void SvMetaTypeEnum::ReadContextSvIdl( SvIdlDataBase & rBase,
 703                                        SvTokenStream & rInStm )
 704 {
 705     sal_uInt32 nTokPos = rInStm.Tell();
 706
 707     SvMetaEnumValueRef aEnumVal = new SvMetaEnumValue();
 708     bool bOk = aEnumVal->ReadSvIdl( rBase, rInStm );
 709     if( bOk )
 710     {
 711         if( aEnumValueList.empty() )
 712         {
 713            // the first
 714            aPrefix = aEnumVal->GetName().getString();
 715         }
 716         else
 717         {
 718             aPrefix = getCommonSubPrefix(aPrefix, aEnumVal->GetName().getString());
 719         }
 720         aEnumValueList.push_back( aEnumVal );
 721     }
 722     if( !bOk )
 723         rInStm.Seek( nTokPos );
 724 }
 725
 726 bool SvMetaTypeEnum::ReadSvIdl( SvIdlDataBase & rBase,
 727                                 SvTokenStream & rInStm )
 728 {
 729     sal_uInt32  nTokPos = rInStm.Tell();
 730     if( SvMetaType::ReadHeaderSvIdl( rBase, rInStm )
 731       && GetType() == TYPE_ENUM )
 732     {
 733         if( SvMetaName::ReadSvIdl( rBase, rInStm ) )
 734              return true;
 735     }
 736     rInStm.Seek( nTokPos );
 737     return false;
 738 }
 739
 740 TYPEINIT1( SvMetaTypevoid, SvMetaType );
 741 SvMetaTypevoid::SvMetaTypevoid()
 742     : SvMetaType( "void", "SbxVOID", "void", 'v', "void", "", "" )
 743 {
 744 }
 745
 746 OString SvMetaAttribute::Compare( SvMetaAttribute* pAttr )
 747 {
 748     OStringBuffer aStr;
 749
 750     if ( aType.Is() )
 751     {
 752         if ( aType->GetType() == TYPE_METHOD )
 753         {
 754             // Test only when the attribute is a method not if it has one!
 755             if ( pAttr->GetType()->GetType() != TYPE_METHOD )
 756                 aStr.append("    IsMethod\n");
 757             else if ( aType->GetReturnType() &&
 758                 aType->GetReturnType()->GetType() != pAttr->GetType()->GetReturnType()->GetType() )
 759             {
 760                 aStr.append("    ReturnType\n");
 761             }
 762
 763             if ( aType->GetAttrCount() )
 764             {
 765                 sal_uLong nCount = aType->GetAttrCount();
 766                 SvMetaAttributeMemberList& rList = aType->GetAttrList();
 767                 SvMetaAttributeMemberList& rOtherList = pAttr->GetType()->GetAttrList();
 768                 if ( pAttr->GetType()->GetAttrCount() != nCount )
 769                 {
 770                     aStr.append("    AttributeCount\n");
 771                 }
 772                 else
 773                 {
 774                     for ( sal_uInt16 n=0; n<nCount; n++ )
 775                     {
 776                         SvMetaAttribute *pAttr1 = rList[n];
 777                         SvMetaAttribute *pAttr2 = rOtherList[n];
 778                         pAttr1->Compare( pAttr2 );
 779                     }
 780                 }
 781             }
 782         }
 783
 784         if ( GetType()->GetType() != pAttr->GetType()->GetType() )
 785             aStr.append("    Type\n");
 786
 787         if ( !GetType()->GetSvName().equals( pAttr->GetType()->GetSvName() ) )
 788             aStr.append("    ItemType\n");
 789     }
 790
 791     if ( GetExport() != pAttr->GetExport() )
 792         aStr.append("    Export\n");
 793
 794     if ( GetAutomation() != pAttr->GetAutomation() )
 795         aStr.append("    Automation\n");
 796
 797     if ( GetIsCollection() != pAttr->GetIsCollection() )
 798         aStr.append("    IsCollection\n");
 799
 800     if ( GetReadOnlyDoc() != pAttr->GetReadOnlyDoc() )
 801         aStr.append("    ReadOnlyDoc\n");
 802
 803     if ( GetExport() && GetReadonly() != pAttr->GetReadonly() )
 804         aStr.append("    Readonly\n");
 805
 806     return aStr.makeStringAndClear();
 807 }
 808
 809 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */