idl/source/objects/basobj.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * Copyright 2000, 2010 Oracle and/or its affiliates.
   7  *
   8  * OpenOffice.org - a multi-platform office productivity suite
   9  *
  10  * This file is part of OpenOffice.org.
  11  *
  12  * OpenOffice.org is free software: you can redistribute it and/or modify
  13  * it under the terms of the GNU Lesser General Public License version 3
  14  * only, as published by the Free Software Foundation.
  15  *
  16  * OpenOffice.org is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU Lesser General Public License version 3 for more details
  20  * (a copy is included in the LICENSE file that accompanied this code).
  21  *
  22  * You should have received a copy of the GNU Lesser General Public License
  23  * version 3 along with OpenOffice.org.  If not, see
  24  * <http://www.openoffice.org/license.html>
  25  * for a copy of the LGPLv3 License.
  26  *
  27  ************************************************************************/
  28
  29
  30 #include <ctype.h>
  31 #include <stdio.h>
  32
  33 #include <tools/debug.hxx>
  34
  35 #include <basobj.hxx>
  36 #include <module.hxx>
  37 #include <globals.hxx>
  38 #include <database.hxx>
  39
  40 SV_IMPL_META_FACTORY1( SvMetaObject, SvRttiBase )
  41 SvMetaObject::SvMetaObject()
  42 {
  43 }
  44
  45 void SvMetaObject::Load( SvPersistStream & )
  46 {
  47 }
  48
  49 void SvMetaObject::Save( SvPersistStream & )
  50 {
  51 }
  52
  53 void SvMetaObject::WriteTab( SvStream & rOutStm, sal_uInt16 nTab )
  54 {
  55     while( nTab-- )
  56         rOutStm << "    ";
  57 }
  58
  59 void SvMetaObject::WriteStars( SvStream & rOutStm )
  60 {
  61     rOutStm << '/';
  62     for( int i = 6; i > 0; i-- )
  63         rOutStm << "**********";
  64     rOutStm << '/' << endl;
  65 }
  66
  67 sal_Bool SvMetaObject::TestAndSeekSpaceOnly( SvStream & rOutStm, sal_uLong nBegPos )
  68 {
  69     // write no empty brackets
  70     sal_uLong nPos = rOutStm.Tell();
  71     rOutStm.Seek( nBegPos );
  72     sal_Bool bOnlySpace = sal_True;
  73     while( bOnlySpace && rOutStm.Tell() < nPos )
  74     {
  75         char c;
  76         rOutStm >> c;
  77         if( !isspace( c ) )
  78             bOnlySpace = sal_False;
  79     }
  80     if( bOnlySpace )
  81         // nothing written
  82         rOutStm.Seek( nBegPos );
  83     else
  84         rOutStm.Seek( nPos );
  85     return bOnlySpace;
  86 }
  87
  88 void SvMetaObject::Back2Delemitter( SvStream & rOutStm )
  89 {
  90     // write no empty brackets
  91     sal_uLong nPos = rOutStm.Tell();
  92     rOutStm.SeekRel( -1 );
  93     char c = 0;
  94     rOutStm >> c;
  95
  96     while( isspace( c ) && rOutStm.Tell() != 1 )
  97     {
  98         rOutStm.SeekRel( -2 );
  99         rOutStm >> c;
 100     }
 101
 102     if( c == ';' || c == ',' )
 103         rOutStm.SeekRel( -1 );
 104     else
 105         rOutStm.Seek( nPos );
 106 }
 107
 108 sal_Bool SvMetaObject::ReadSvIdl( SvIdlDataBase &, SvTokenStream & )
 109 {
 110     return sal_False;
 111 }
 112
 113 void SvMetaObject::WriteSvIdl( SvIdlDataBase &, SvStream &, sal_uInt16 /*nTab */ )
 114 {
 115 }
 116
 117 void SvMetaObject::Write( SvIdlDataBase &, SvStream &, sal_uInt16 /*nTab */,
 118                              WriteType, WriteAttribute )
 119 {
 120 }
 121
 122 SV_IMPL_META_FACTORY1( SvMetaName, SvMetaObject );
 123 SvMetaName::SvMetaName()
 124 {
 125 }
 126
 127 void SvMetaName::Load( SvPersistStream & rStm )
 128 {
 129     SvMetaObject::Load( rStm );
 130     sal_uInt8 nMask;
 131     rStm >> nMask;
 132
 133     if( nMask >= 0x20 )
 134     {
 135         rStm.SetError( SVSTREAM_FILEFORMAT_ERROR );
 136         OSL_FAIL( "wrong format" );
 137         return;
 138     }
 139     if( nMask & 0x01 )  rStm >> aName;
 140     if( nMask & 0x02 )  rStm >> aHelpContext;
 141     if( nMask & 0x04 )  rStm >> aHelpText;
 142     if( nMask & 0x08 )  rStm >> aConfigName;
 143     if( nMask & 0x10 )  rStm >> aDescription;
 144 }
 145
 146 void SvMetaName::Save( SvPersistStream & rStm )
 147 {
 148     SvMetaObject::Save( rStm );
 149     sal_uInt8 nMask = 0;
 150     if( aName.IsSet() )         nMask |= 0x01;
 151     if( aHelpContext.IsSet() )  nMask |= 0x02;
 152     if( aHelpText.IsSet() )     nMask |= 0x04;
 153     if( aConfigName.IsSet() )   nMask |= 0x08;
 154     if( aDescription.IsSet() )  nMask |= 0x10;
 155
 156     rStm << nMask;
 157     if( nMask & 0x01 ) rStm << aName;
 158     if( nMask & 0x02 ) rStm << aHelpContext;
 159     if( nMask & 0x04 ) rStm << aHelpText;
 160     if( nMask & 0x08 ) rStm << aConfigName;
 161     if( nMask & 0x10 ) rStm << aDescription;
 162 }
 163
 164 sal_Bool SvMetaName::SetName( const rtl::OString& rName, SvIdlDataBase * )
 165 {
 166     aName.setString(rName);
 167     return sal_True;
 168 }
 169
 170 sal_Bool SvMetaName::ReadNameSvIdl( SvIdlDataBase & rBase,
 171                                 SvTokenStream & rInStm )
 172 {
 173     sal_uInt32 nTokPos = rInStm.Tell();
 174     SvToken * pTok = rInStm.GetToken_Next();
 175
 176     // read module name
 177     if( pTok->IsIdentifier() )
 178         if( SetName( pTok->GetString(), &rBase ) )
 179             return sal_True;
 180
 181     rInStm.Seek( nTokPos );
 182     return sal_False;
 183 }
 184
 185 void SvMetaName::ReadAttributesSvIdl( SvIdlDataBase & rBase,
 186                                       SvTokenStream & rInStm )
 187 {
 188     sal_uInt32 nTokPos = rInStm.Tell();
 189     if( aName.ReadSvIdl( SvHash_Name(), rInStm ) )
 190     {
 191         if( !SetName( aName.getString(), &rBase ) )
 192             rInStm.Seek( nTokPos );
 193     }
 194     aHelpContext.ReadSvIdl( rBase, SvHash_HelpContext(), rInStm );
 195     aHelpText.ReadSvIdl( rBase, rInStm );
 196     aConfigName.ReadSvIdl( SvHash_ConfigName(), rInStm );
 197     aDescription.ReadSvIdl( SvHash_Description(), rInStm );
 198 }
 199
 200 void SvMetaName::DoReadContextSvIdl( SvIdlDataBase & rBase,
 201                                    SvTokenStream & rInStm, char cDel )
 202 {
 203     sal_uInt32 nBeginPos = 0; // can not happen with Tell
 204     while( nBeginPos != rInStm.Tell() )
 205     {
 206         nBeginPos = rInStm.Tell();
 207         ReadContextSvIdl( rBase, rInStm );
 208         if( cDel == '\0' )
 209             rInStm.ReadDelemiter();
 210         else
 211             rInStm.Read( cDel );
 212     }
 213 }
 214
 215 void SvMetaName::ReadContextSvIdl( SvIdlDataBase &, SvTokenStream & )
 216 {
 217 }
 218
 219 sal_Bool SvMetaName::Test( SvIdlDataBase &, SvTokenStream & )
 220 {
 221     return sal_True;
 222 }
 223
 224 void SvMetaName::WriteContextSvIdl( SvIdlDataBase &, SvStream &, sal_uInt16 )
 225 {
 226 }
 227
 228 void SvMetaName::WriteDescription( SvStream & rOutStm )
 229 {
 230     rOutStm << "<DESCRIPTION>" << endl;
 231
 232     rtl::OString aDesc( GetDescription().getString() );
 233     sal_Int32 nPos = aDesc.indexOf('\n');
 234     while ( nPos != -1 )
 235     {
 236         rOutStm << aDesc.copy( 0, nPos ).getStr() << endl;
 237         aDesc = aDesc.copy(nPos+1);
 238         nPos = aDesc.indexOf('\n');
 239     }
 240
 241     rOutStm << aDesc.getStr() << endl << "</DESCRIPTION>" << endl;
 242 }
 243
 244 void SvMetaName::WriteAttributesSvIdl( SvIdlDataBase & rBase,
 245                                        SvStream & rOutStm,
 246                                        sal_uInt16 nTab )
 247 {
 248     if( aHelpContext.IsSet() || aHelpText.IsSet() || aConfigName.IsSet() )
 249     {
 250         WriteTab( rOutStm, nTab );
 251         rOutStm << "// class SvMetaName" << endl;
 252     }
 253     if( aHelpContext.IsSet() )
 254     {
 255         WriteTab( rOutStm, nTab );
 256         aHelpContext.WriteSvIdl( SvHash_HelpContext(), rOutStm, nTab );
 257         rOutStm << ';' << endl;
 258     }
 259     if( aHelpText.IsSet() )
 260     {
 261         WriteTab( rOutStm, nTab );
 262         aHelpText.WriteSvIdl( rBase, rOutStm, nTab );
 263         rOutStm << ';' << endl;
 264     }
 265     if( aConfigName.IsSet() )
 266     {
 267         WriteTab( rOutStm, nTab );
 268         aConfigName.WriteSvIdl( SvHash_ConfigName(), rOutStm, nTab );
 269         rOutStm << ';' << endl;
 270     }
 271 }
 272
 273 sal_Bool SvMetaName::ReadSvIdl( SvIdlDataBase & rBase, SvTokenStream & rInStm )
 274 {
 275     sal_uInt32 nTokPos = rInStm.Tell();
 276     sal_Bool bOk = sal_True;
 277     if( rInStm.Read( '[' ) )
 278     {
 279         sal_uInt32 nBeginPos = 0; // can not happen with Tell
 280         while( nBeginPos != rInStm.Tell() )
 281         {
 282             nBeginPos = rInStm.Tell();
 283             ReadAttributesSvIdl( rBase, rInStm );
 284             rInStm.ReadDelemiter();
 285         }
 286         bOk = rInStm.Read( ']' );
 287     }
 288
 289     if( bOk )
 290     {
 291         if( rInStm.Read( '{' ) )
 292         {
 293             DoReadContextSvIdl( rBase, rInStm );
 294             bOk = rInStm.Read( '}' );
 295         }
 296     }
 297
 298     if( !bOk )
 299         rInStm.Seek( nTokPos );
 300     return bOk;
 301 }
 302
 303 void SvMetaName::WriteSvIdl( SvIdlDataBase & rBase, SvStream & rOutStm,
 304                              sal_uInt16 nTab )
 305 {
 306     sal_uLong nBeginPos = rOutStm.Tell();
 307     WriteTab( rOutStm, nTab );
 308     rOutStm << '[' << endl;
 309     sal_uLong nOldPos = rOutStm.Tell();
 310     WriteAttributesSvIdl( rBase, rOutStm, nTab +1 );
 311
 312     // write no empty brackets
 313     if( TestAndSeekSpaceOnly( rOutStm, nOldPos ) )
 314         // nothing written
 315         rOutStm.Seek( nBeginPos );
 316     else
 317     {
 318         WriteTab( rOutStm, nTab );
 319         rOutStm << ']';
 320         nBeginPos = rOutStm.Tell();
 321           rOutStm << endl;
 322     }
 323
 324     WriteTab( rOutStm, nTab );
 325     rOutStm << '{' << endl;
 326     nOldPos = rOutStm.Tell();
 327     WriteContextSvIdl( rBase, rOutStm, nTab +1 );
 328
 329     // write no empty brackets
 330     if( TestAndSeekSpaceOnly( rOutStm, nOldPos ) )
 331         // nothing written
 332         rOutStm.Seek( nBeginPos );
 333     else
 334     {
 335         WriteTab( rOutStm, nTab );
 336         rOutStm << '}';
 337     }
 338 }
 339
 340 void SvMetaName::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
 341                            sal_uInt16 nTab,
 342                          WriteType nT, WriteAttribute nA )
 343 {
 344     sal_uLong nBeginPos = rOutStm.Tell();
 345     WriteTab( rOutStm, nTab );
 346     rOutStm << '[' << endl;
 347     sal_uLong nOldPos = rOutStm.Tell();
 348     WriteAttributes( rBase, rOutStm, nTab +1, nT, nA );
 349
 350     // write no empty brackets
 351     sal_uLong nPos = rOutStm.Tell();
 352     rOutStm.Seek( nOldPos );
 353     sal_Bool bOnlySpace = sal_True;
 354     while( bOnlySpace && rOutStm.Tell() < nPos )
 355     {
 356         char c;
 357         rOutStm >> c;
 358         if( !isspace( c ) )
 359             bOnlySpace = sal_False;
 360     }
 361     if( bOnlySpace )
 362         // nothing written
 363         rOutStm.Seek( nBeginPos );
 364     else
 365     {
 366         rOutStm.Seek( nPos );
 367         WriteTab( rOutStm, nTab );
 368         rOutStm << ']' << endl;
 369     }
 370 }
 371
 372 void SvMetaName::WriteAttributes( SvIdlDataBase &, SvStream & rOutStm,
 373                                 sal_uInt16 nTab,
 374                                  WriteType, WriteAttribute )
 375 {
 376     if( GetHelpText().IsSet() || GetHelpContext().IsSet() )
 377     {
 378         WriteTab( rOutStm, nTab );
 379         rOutStm << "// class SvMetaName" << endl;
 380     }
 381     if( GetHelpText().IsSet() )
 382     {
 383         WriteTab( rOutStm, nTab );
 384         rOutStm << "helpstring(\"" << GetHelpText().getString().getStr() << "\")," << endl;
 385     }
 386     if( GetHelpContext().IsSet() )
 387     {
 388         WriteTab( rOutStm, nTab );
 389         rOutStm << "helpcontext("
 390                 << rtl::OString::valueOf(static_cast<sal_Int64>(
 391                     GetHelpContext().GetValue())).getStr()
 392                 << ")," << endl;
 393     }
 394 }
 395
 396 void SvMetaName::WriteContext( SvIdlDataBase &, SvStream &,
 397                                 sal_uInt16,
 398                                  WriteType, WriteAttribute )
 399 {
 400 }
 401
 402 SV_IMPL_META_FACTORY1( SvMetaReference, SvMetaName );
 403
 404 SvMetaReference::SvMetaReference()
 405 {
 406 }
 407
 408 void SvMetaReference::Load( SvPersistStream & rStm )
 409 {
 410     SvMetaName::Load( rStm );
 411
 412     sal_uInt8 nMask;
 413     rStm >> nMask;
 414     if( nMask >= 0x2 )
 415     {
 416         rStm.SetError( SVSTREAM_FILEFORMAT_ERROR );
 417         OSL_FAIL( "wrong format" );
 418         return;
 419     }
 420     if( nMask & 0x01 )
 421     {
 422         SvMetaReference * pRef;
 423         rStm >> pRef;
 424         aRef = pRef;
 425     }
 426 }
 427
 428 void SvMetaReference::Save( SvPersistStream & rStm )
 429 {
 430     SvMetaName::Save( rStm );
 431
 432     // create mask
 433     sal_uInt8 nMask = 0;
 434     if( aRef.Is() )
 435         nMask |= 0x01;
 436
 437     // write data
 438     rStm << nMask;
 439     if( nMask & 0x01 ) rStm << aRef;
 440 }
 441
 442 SV_IMPL_META_FACTORY1( SvMetaExtern, SvMetaReference );
 443
 444 SvMetaExtern::SvMetaExtern()
 445     : pModule( NULL )
 446     , bReadUUId( sal_False )
 447     , bReadVersion( sal_False )
 448 {
 449 }
 450
 451 void SvMetaExtern::Load( SvPersistStream & rStm )
 452 {
 453     SvMetaReference::Load( rStm );
 454
 455     sal_uInt8 nMask;
 456     rStm >> nMask;
 457     if( nMask >= 0x20 )
 458     {
 459         rStm.SetError( SVSTREAM_FILEFORMAT_ERROR );
 460         OSL_FAIL( "wrong format" );
 461         return;
 462     }
 463     if( nMask & 0x01 ) rStm >> pModule;
 464     if( nMask & 0x02 ) rStm >> aUUId;
 465     if( nMask & 0x04 ) rStm >> aVersion;
 466     if( nMask & 0x08 ) bReadUUId = sal_True;
 467     if( nMask & 0x10 ) bReadVersion = sal_True;
 468 }
 469
 470 void SvMetaExtern::Save( SvPersistStream & rStm )
 471 {
 472     SvMetaReference::Save( rStm );
 473
 474     // create mask
 475     sal_uInt8 nMask = 0;
 476     if( pModule )                   nMask |= 0x01;
 477     if( aUUId != SvGlobalName() )   nMask |= 0x02;
 478     if( aVersion != SvVersion() )   nMask |= 0x04;
 479     if( bReadUUId )                 nMask |= 0x08;
 480     if( bReadVersion )              nMask |= 0x10;
 481
 482     // write data
 483     rStm << nMask;
 484     if( nMask & 0x01 ) rStm << pModule;
 485     if( nMask & 0x02 ) rStm << aUUId;
 486     if( nMask & 0x04 ) rStm << aVersion;
 487 }
 488
 489 SvMetaModule * SvMetaExtern::GetModule() const
 490 {
 491     DBG_ASSERT( pModule != NULL, "module not set" );
 492     return pModule;
 493 }
 494
 495 const SvGlobalName & SvMetaExtern::GetUUId() const
 496 {
 497     if( aUUId == SvGlobalName() )
 498         GetModule()->FillNextName( &((SvMetaExtern *)this)->aUUId );
 499     return aUUId;
 500 }
 501
 502 void SvMetaExtern::SetModule( SvIdlDataBase & rBase )
 503 {
 504     pModule = (SvMetaModule *)rBase.GetStack().Get( TYPE( SvMetaModule ) );
 505 }
 506
 507 void SvMetaExtern::ReadAttributesSvIdl( SvIdlDataBase & rBase,
 508                                         SvTokenStream & rInStm )
 509 {
 510     SvMetaReference::ReadAttributesSvIdl( rBase, rInStm );
 511     if( aUUId.ReadSvIdl( rBase, rInStm ) )
 512         bReadUUId = sal_True;
 513     if( aVersion.ReadSvIdl( rInStm ) )
 514         bReadVersion = sal_True;
 515 }
 516
 517 void SvMetaExtern::WriteAttributesSvIdl( SvIdlDataBase & rBase,
 518                                          SvStream & rOutStm, sal_uInt16 nTab )
 519 {
 520     SvMetaReference::WriteAttributesSvIdl( rBase, rOutStm, nTab );
 521     if( bReadUUId || bReadVersion )
 522     {
 523         WriteTab( rOutStm, nTab );
 524         rOutStm << "// class SvMetaExtern" << endl;
 525
 526         if( bReadUUId )
 527         {
 528             WriteTab( rOutStm, nTab );
 529             aUUId.WriteSvIdl( rOutStm );
 530             rOutStm << ';' << endl;
 531         }
 532         if( bReadVersion )
 533         {
 534             WriteTab( rOutStm, nTab );
 535             aVersion.WriteSvIdl( rOutStm );
 536             rOutStm << ';' << endl;
 537         }
 538     }
 539 }
 540
 541 sal_Bool SvMetaExtern::ReadSvIdl( SvIdlDataBase & rBase, SvTokenStream & rInStm )
 542 {
 543     SetModule( rBase );
 544     GetUUId(); // id gets created
 545     return SvMetaReference::ReadSvIdl( rBase, rInStm );
 546 }
 547
 548 void SvMetaExtern::WriteSvIdl( SvIdlDataBase & rBase, SvStream & rOutStm,
 549                                sal_uInt16 nTab )
 550 {
 551     SvMetaReference::WriteSvIdl( rBase, rOutStm, nTab );
 552 }
 553
 554 void SvMetaExtern::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
 555                         sal_uInt16 nTab,
 556                          WriteType nT, WriteAttribute nA )
 557 {
 558     SvMetaReference::Write( rBase, rOutStm, nTab, nT, nA );
 559 }
 560
 561 void SvMetaExtern::WriteAttributes( SvIdlDataBase & rBase, SvStream & rOutStm,
 562                                      sal_uInt16 nTab,
 563                                      WriteType nT, WriteAttribute nA )
 564 {
 565     SvMetaReference::WriteAttributes( rBase, rOutStm, nTab, nT, nA );
 566
 567     WriteTab( rOutStm, nTab );
 568     rOutStm << "// class SvMetaExtern" << endl;
 569     WriteTab( rOutStm, nTab );
 570     rOutStm << "uuid(" << rtl::OUStringToOString(GetUUId().GetHexName(), RTL_TEXTENCODING_UTF8).getStr() << ")," << endl;
 571     WriteTab( rOutStm, nTab );
 572     rOutStm << "version("
 573         << rtl::OString::valueOf(static_cast<sal_Int32>(aVersion.GetMajorVersion())).getStr()
 574         << '.'
 575         << rtl::OString::valueOf(static_cast<sal_Int32>(aVersion.GetMinorVersion())).getStr()
 576         << ")," << endl;
 577 }
 578
 579 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */