idl/source/objects/bastype.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2000, 2010 Oracle and/or its affiliates.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * This file is part of OpenOffice.org.
  10  *
  11  * OpenOffice.org is free software: you can redistribute it and/or modify
  12  * it under the terms of the GNU Lesser General Public License version 3
  13  * only, as published by the Free Software Foundation.
  14  *
  15  * OpenOffice.org is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU Lesser General Public License version 3 for more details
  19  * (a copy is included in the LICENSE file that accompanied this code).
  20  *
  21  * You should have received a copy of the GNU Lesser General Public License
  22  * version 3 along with OpenOffice.org.  If not, see
  23  * <http://www.openoffice.org/license.html>
  24  * for a copy of the LGPLv3 License.
  25  *
  26  ************************************************************************/
  27
  28 // MARKER(update_precomp.py): autogen include statement, do not remove
  29 #include "precompiled_idl.hxx"
  30
  31 #include <tools/debug.hxx>
  32
  33 #include <limits.h>
  34 #include <ctype.h>
  35 #include <bastype.hxx>
  36 #include <lex.hxx>
  37 #include <globals.hxx>
  38 #include <hash.hxx>
  39 #include <database.hxx>
  40
  41 #ifdef IDL_COMPILER
  42 /************************************************************************/
  43 static sal_Bool ReadRangeSvIdl( SvStringHashEntry * pName, SvTokenStream & rInStm,
  44                             sal_uLong nMin, sal_uLong nMax, sal_uLong* pValue )
  45 {
  46     sal_uInt32 nTokPos = rInStm.Tell();
  47     SvToken * pTok = rInStm.GetToken_Next();
  48     if( pTok->Is( pName ) )
  49     {
  50         sal_Bool bOk = sal_False;
  51         if( rInStm.Read( '=' ) )
  52         {
  53             pTok = rInStm.GetToken_Next();
  54             if( pTok->IsInteger() )
  55             {
  56                 sal_uLong n = pTok->GetNumber();
  57                 if ( n >= nMin && n <= nMax )
  58                 {
  59                     *pValue = n;
  60                     bOk = sal_True;
  61                 }
  62             }
  63         }
  64
  65         if( bOk )
  66             return sal_True;
  67     }
  68
  69     rInStm.Seek( nTokPos );
  70     return sal_False;
  71 }
  72 #endif
  73
  74 /*************************************************************************
  75 |*
  76 |*    SvUINT32::Read()
  77 |*    SvUINT32::Write()
  78 |*
  79 |*    Beschreibung
  80 |*    Ersterstellung    MM 12.12.94
  81 |*    Letzte Aenderung  MM 12.12.94
  82 |*
  83 *************************************************************************/
  84 sal_uInt32 SvUINT32::Read( SvStream & rStm )
  85 {
  86     return SvPersistStream::ReadCompressed( rStm );
  87 }
  88
  89 void SvUINT32::Write( SvStream & rStm, sal_uInt32 nVal )
  90 {
  91     SvPersistStream::WriteCompressed( rStm, nVal );
  92 }
  93
  94 /*************************************************************************
  95 |*
  96 |*    SvStream& operator << ( SvBOOL )
  97 |*    SvStream& operator >> ( SvBOOL )
  98 |*
  99 |*    Beschreibung
 100 |*    Ersterstellung    MM 12.12.94
 101 |*    Letzte Aenderung  MM 12.12.94
 102 |*
 103 *************************************************************************/
 104 SvStream& operator << (SvStream & rStm, const SvBOOL & rb )
 105 {
 106     sal_uInt8 n = rb.nVal;
 107     if( rb.bSet )
 108         n |= 0x02;
 109     rStm << n;
 110     return rStm;
 111 }
 112 SvStream& operator >> (SvStream & rStm, SvBOOL & rb )
 113 {
 114     sal_uInt8 n;
 115     rStm >> n;
 116     rb.nVal = (n & 0x01) ? sal_True : sal_False;
 117     rb.bSet = (n & 0x02) ? sal_True : sal_False;
 118     if( n & ~0x03 )
 119     {
 120         rStm.SetError( SVSTREAM_FILEFORMAT_ERROR );
 121         DBG_ERROR( "format error" );
 122     }
 123     return rStm;
 124 }
 125
 126 /*************************************************************************
 127 |*
 128 |*    SvStream& operator << ( SvVersion )
 129 |*    SvStream& operator >> ( SvVersion )
 130 |*
 131 |*    Beschreibung
 132 |*    Ersterstellung    MM 12.12.94
 133 |*    Letzte Aenderung  MM 12.12.94
 134 |*
 135 *************************************************************************/
 136 SvStream& operator << (SvStream & rStm, const SvVersion & r )
 137 {
 138     if( (r.GetMajorVersion() || r.GetMinorVersion())
 139       && r.GetMajorVersion() <= 0x0F && r.GetMinorVersion() <= 0x0F )
 140     { // Versionsnummer in 1 Byte komprimieren
 141         // Format 4 Bit fuer Major, dann 4 Bit fuer Minor.
 142         // 0.0 wird nicht komprimiert
 143
 144         int n = r.GetMajorVersion() << 4;
 145         n |= r.GetMinorVersion();
 146         rStm << (sal_uInt8)n;
 147     }
 148     else
 149     {
 150         rStm << (sal_uInt8)0;
 151         rStm << r.GetMajorVersion();
 152         rStm << r.GetMinorVersion();
 153     }
 154     return rStm;
 155 }
 156
 157 SvStream& operator >> (SvStream & rStm, SvVersion & r )
 158 {
 159     sal_uInt8 n;
 160     rStm >> n;
 161     if( n == 0 )
 162     { // nicht komprimiert
 163         rStm >> r.nMajorVersion;
 164         rStm >> r.nMinorVersion;
 165     }
 166     else
 167     { // komprimiert
 168         r.nMajorVersion = (n >> 4) & 0x0F;
 169         r.nMinorVersion = n & 0x0F;
 170     }
 171     return rStm;
 172 }
 173
 174
 175 #ifdef IDL_COMPILER
 176 /************************************************************************/
 177
 178 /*************************************************************************
 179 |*
 180 |*    SvBOOL::ReadSvIdl()
 181 |*
 182 |*    Beschreibung
 183 |*    Ersterstellung    MM 12.12.94
 184 |*    Letzte Aenderung  MM 12.12.94
 185 |*
 186 *************************************************************************/
 187 sal_Bool SvBOOL::ReadSvIdl( SvStringHashEntry * pName, SvTokenStream & rInStm )
 188 {
 189     sal_uInt32 nTokPos = rInStm.Tell();
 190     SvToken * pTok = rInStm.GetToken_Next();
 191
 192     if( pTok->Is( pName ) )
 193     {
 194         sal_Bool bOk = sal_True;
 195         sal_Bool bBraket = rInStm.Read( '(' );
 196         if( bBraket || rInStm.Read( '=' ) )
 197         {
 198             pTok = rInStm.GetToken();
 199             if( pTok->IsBool() )
 200             {
 201                 *this = pTok->GetBool();
 202
 203                 rInStm.GetToken_Next();
 204             }
 205             if( bOk && bBraket )
 206                 bOk = rInStm.Read( ')' );
 207         }
 208         else
 209             *this = sal_True; //Defaultaktion ist auf sal_True setzen
 210         if( bOk )
 211             return sal_True;
 212     }
 213     rInStm.Seek( nTokPos );
 214     return sal_False;
 215 }
 216
 217 /*************************************************************************
 218 |*
 219 |*    SvBOOL::WriteSvIdl()
 220 |*
 221 |*    Beschreibung
 222 |*
 223 *************************************************************************/
 224 sal_Bool SvBOOL::WriteSvIdl( SvStringHashEntry * pName, SvStream & rOutStm )
 225 {
 226     if( nVal )
 227         rOutStm << pName->GetName().GetBuffer();
 228     else
 229         rOutStm << pName->GetName().GetBuffer() << "(FALSE)";
 230     return sal_True;
 231 }
 232
 233 /*************************************************************************
 234 |*
 235 |*    SvBOOL::WriteSvIdl()
 236 |*
 237 |*    Beschreibung
 238 |*
 239 *************************************************************************/
 240 ByteString SvBOOL::GetSvIdlString( SvStringHashEntry * pName )
 241 {
 242     if( nVal )
 243         return pName->GetName();
 244     else
 245     {
 246         ByteString aTmp( pName->GetName() );
 247         aTmp += "(FALSE)";
 248         return aTmp;
 249     }
 250 }
 251
 252
 253 /************************************************************************/
 254 /*************************************************************************
 255 |*
 256 |*    SvIdentifier::ReadSvIdl()
 257 |*
 258 |*    Beschreibung
 259 |*
 260 *************************************************************************/
 261 sal_Bool SvIdentifier::ReadSvIdl( SvStringHashEntry * pName, SvTokenStream & rInStm )
 262 {
 263     sal_uInt32 nTokPos = rInStm.Tell();
 264     SvToken * pTok = rInStm.GetToken_Next();
 265
 266     if( pTok->Is( pName ) )
 267     {
 268         sal_Bool bOk = sal_True;
 269         sal_Bool bBraket = rInStm.Read( '(' );
 270         if( bBraket || rInStm.Read( '=' ) )
 271         {
 272             pTok = rInStm.GetToken();
 273             if( pTok->IsIdentifier() )
 274             {
 275                 *(ByteString *)this = pTok->GetString();
 276                 rInStm.GetToken_Next();
 277             }
 278             if( bOk && bBraket )
 279                 bOk = rInStm.Read( ')' );
 280         }
 281         if( bOk )
 282             return sal_True;
 283     }
 284     rInStm.Seek( nTokPos );
 285     return sal_False;
 286 }
 287
 288 /*************************************************************************
 289 |*
 290 |*    SvIdentifier::WriteSvIdl()
 291 |*
 292 |*    Beschreibung
 293 |*
 294 *************************************************************************/
 295 sal_Bool SvIdentifier::WriteSvIdl( SvStringHashEntry * pName,
 296                                SvStream & rOutStm,
 297                                sal_uInt16 /*nTab */ )
 298 {
 299     rOutStm << pName->GetName().GetBuffer() << '(';
 300     rOutStm << GetBuffer() << ')';
 301     return sal_True;
 302 }
 303
 304 SvStream& operator << (SvStream & rStm, const SvIdentifier & r )
 305 {
 306     rStm.WriteByteString( r );
 307     return rStm;
 308 }
 309
 310 SvStream& operator >> (SvStream & rStm, SvIdentifier & r )
 311 {
 312     rStm.ReadByteString( r );
 313     return rStm;
 314 }
 315
 316
 317 /************************************************************************/
 318 /*************************************************************************
 319 |*
 320 |*    SvNumberIdentifier::ReadSvIdl()
 321 |*
 322 |*    Beschreibung
 323 |*
 324 *************************************************************************/
 325 sal_Bool SvNumberIdentifier::ReadSvIdl( SvIdlDataBase & rBase,
 326                                     SvStringHashEntry * pName,
 327                                     SvTokenStream & rInStm )
 328 {
 329     if( SvIdentifier::ReadSvIdl( pName, rInStm ) )
 330     {
 331         sal_uLong n;
 332         if( rBase.FindId( *this, &n ) )
 333         {
 334             nValue = n;
 335             return sal_True;
 336         }
 337         else
 338         {
 339             ByteString aStr ("no value for identifier <");
 340             aStr += *this;
 341             aStr += "> ";
 342             rBase.SetError( aStr, rInStm.GetToken() );
 343             rBase.WriteError( rInStm );
 344         }
 345     }
 346     return sal_False;
 347 }
 348
 349 /*************************************************************************
 350 |*
 351 |*    SvNumberIdentifier::ReadSvIdl()
 352 |*
 353 |*    Beschreibung
 354 |*
 355 *************************************************************************/
 356 sal_Bool SvNumberIdentifier::ReadSvIdl( SvIdlDataBase & rBase,
 357                                     SvTokenStream & rInStm )
 358 {
 359     sal_uInt32 nTokPos = rInStm.Tell();
 360     SvToken * pTok = rInStm.GetToken_Next();
 361
 362     if( pTok->IsIdentifier() )
 363     {
 364         sal_uLong n;
 365         if( rBase.FindId( pTok->GetString(), &n ) )
 366         {
 367             *(ByteString *)this = pTok->GetString();
 368             nValue = n;
 369             return sal_True;
 370         }
 371         else
 372         {
 373             ByteString aStr ("no value for identifier <");
 374             aStr += *this;
 375             aStr += "> ";
 376             rBase.SetError( aStr, rInStm.GetToken() );
 377             rBase.WriteError( rInStm );
 378         }
 379     }
 380     rInStm.Seek( nTokPos );
 381     return sal_False;
 382 }
 383
 384 /*************************************************************************
 385 |*
 386 |*    SvStream& operator << ( SvNumberIdentifier )
 387 |*    SvStream& operator >> ( SvNumberIdentifier )
 388 |*
 389 |*    Beschreibung
 390 |*    Ersterstellung    MM 12.12.94
 391 |*    Letzte Aenderung  MM 12.12.94
 392 |*
 393 *************************************************************************/
 394 SvStream& operator << (SvStream & rStm, const SvNumberIdentifier & r )
 395 {
 396     rStm << (SvIdentifier &)r;
 397     SvPersistStream::WriteCompressed( rStm, r.nValue );
 398     return rStm;
 399 }
 400
 401 SvStream& operator >> (SvStream & rStm, SvNumberIdentifier & r )
 402 {
 403     rStm >> (SvIdentifier &)r;
 404     r.nValue = SvPersistStream::ReadCompressed( rStm );
 405     return rStm;
 406 }
 407
 408
 409 /************************************************************************/
 410 /*************************************************************************
 411 |*
 412 |*    SvString::ReadSvIdl()
 413 |*
 414 |*    Beschreibung
 415 |*    Ersterstellung    MM 12.12.94
 416 |*    Letzte Aenderung  MM 12.12.94
 417 |*
 418 *************************************************************************/
 419 sal_Bool SvString::ReadSvIdl( SvStringHashEntry * pName, SvTokenStream & rInStm )
 420 {
 421     sal_uInt32 nTokPos = rInStm.Tell();
 422     SvToken * pTok = rInStm.GetToken_Next();
 423
 424     if( pTok->Is( pName ) )
 425     {
 426         sal_Bool bOk = sal_True;
 427         sal_Bool bBraket = rInStm.Read( '(' );
 428         if( bBraket || rInStm.Read( '=' ) )
 429         {
 430             pTok = rInStm.GetToken();
 431             if( pTok->IsString() )
 432             {
 433                 *(ByteString *)this = pTok->GetString();
 434                 rInStm.GetToken_Next();
 435             }
 436             if( bOk && bBraket )
 437                 bOk = rInStm.Read( ')' );
 438         }
 439         if( bOk )
 440             return sal_True;
 441     }
 442     rInStm.Seek( nTokPos );
 443     return sal_False;
 444 }
 445
 446 /*************************************************************************
 447 |*
 448 |*    SvString::WriteSvIdl()
 449 |*
 450 |*    Beschreibung
 451 |*    Ersterstellung    MM 12.12.94
 452 |*    Letzte Aenderung  MM 12.12.94
 453 |*
 454 *************************************************************************/
 455 sal_Bool SvString::WriteSvIdl( SvStringHashEntry * pName, SvStream & rOutStm,
 456                            sal_uInt16 /*nTab */ )
 457 {
 458     rOutStm << pName->GetName().GetBuffer() << "(\"";
 459     rOutStm << GetBuffer() << "\")";
 460     return sal_True;
 461 }
 462
 463 SvStream& operator << (SvStream & rStm, const SvString & r )
 464 {
 465     rStm.WriteByteString( r );
 466     return rStm;
 467 }
 468
 469 SvStream& operator >> (SvStream & rStm, SvString & r )
 470 {
 471     rStm.ReadByteString( r );
 472     return rStm;
 473 }
 474
 475
 476 /*************************************************************************
 477 |*
 478 |*    SvHelpText::ReadSvIdl()
 479 |*
 480 |*    Beschreibung
 481 |*    Ersterstellung    MM 12.12.94
 482 |*    Letzte Aenderung  MM 12.12.94
 483 |*
 484 *************************************************************************/
 485 sal_Bool SvHelpText::ReadSvIdl( SvIdlDataBase &, SvTokenStream & rInStm )
 486 {
 487     return SvString::ReadSvIdl( SvHash_HelpText(), rInStm );
 488 }
 489
 490 /*************************************************************************
 491 |*
 492 |*    SvHelpText::WriteSvIdl()
 493 |*
 494 |*    Beschreibung
 495 |*    Ersterstellung    MM 12.12.94
 496 |*    Letzte Aenderung  MM 12.12.94
 497 |*
 498 *************************************************************************/
 499 sal_Bool SvHelpText::WriteSvIdl( SvIdlDataBase &, SvStream & rOutStm, sal_uInt16 nTab )
 500 {
 501     return SvString::WriteSvIdl( SvHash_HelpText(), rOutStm, nTab );
 502 }
 503
 504 /************************************************************************/
 505 /*************************************************************************
 506 |*
 507 |*    SvUUId::ReadSvIdl()
 508 |*
 509 |*    Beschreibung
 510 |*    Ersterstellung    MM 12.12.94
 511 |*    Letzte Aenderung  MM 12.12.94
 512 |*
 513 *************************************************************************/
 514 sal_Bool SvUUId::ReadSvIdl( SvIdlDataBase &, SvTokenStream & rInStm )
 515 {
 516     sal_uInt32 nTokPos = rInStm.Tell();
 517     SvToken * pTok = rInStm.GetToken_Next();
 518
 519     if( pTok->Is( SvHash_uuid() ) )
 520     {
 521         sal_Bool bOk = sal_True;
 522         sal_Bool bBraket = rInStm.Read( '(' );
 523         if( bBraket || rInStm.Read( '=' ) )
 524         {
 525             pTok = rInStm.GetToken();
 526             if( pTok->IsString() )
 527             {
 528                 pTok = rInStm.GetToken_Next();
 529                 bOk = MakeId( String::CreateFromAscii( pTok->GetString().GetBuffer() ) );
 530             }
 531             if( bOk && bBraket )
 532                 bOk = rInStm.Read( ')' );
 533         }
 534         if( bOk )
 535             return sal_True;
 536     }
 537     rInStm.Seek( nTokPos );
 538     return sal_False;
 539 }
 540
 541 /*************************************************************************
 542 |*
 543 |*    SvMetaObject::WriteSvIdl()
 544 |*
 545 |*    Beschreibung
 546 |*    Ersterstellung    MM 12.12.94
 547 |*    Letzte Aenderung  MM 12.12.94
 548 |*
 549 *************************************************************************/
 550 sal_Bool SvUUId::WriteSvIdl( SvStream & rOutStm )
 551 {
 552     // Global Id schreiben
 553     rOutStm << SvHash_uuid()->GetName().GetBuffer() << "(\"";
 554     rOutStm << ByteString( GetHexName(), RTL_TEXTENCODING_UTF8 ).GetBuffer() << "\")";
 555     return sal_True;
 556 }
 557
 558
 559 /************************************************************************/
 560 /*************************************************************************
 561 |*
 562 |*    SvVersion::ReadSvIdl()
 563 |*
 564 |*    Beschreibung
 565 |*    Ersterstellung    MM 12.12.94
 566 |*    Letzte Aenderung  MM 12.12.94
 567 |*
 568 *************************************************************************/
 569 sal_Bool SvVersion::ReadSvIdl( SvTokenStream & rInStm )
 570 {
 571     sal_uLong n = 0;
 572
 573     sal_uInt32 nTokPos = rInStm.Tell();
 574     if( ReadRangeSvIdl( SvHash_Version(), rInStm, 0 , 0xFFFF, &n ) )
 575     {
 576         nMajorVersion = (sal_uInt16)n;
 577         if( rInStm.Read( '.' ) )
 578         {
 579             SvToken * pTok = rInStm.GetToken_Next();
 580             if( pTok->IsInteger() && pTok->GetNumber() <= 0xFFFF )
 581             {
 582                 nMinorVersion = (sal_uInt16)pTok->GetNumber();
 583                 return sal_True;
 584             }
 585         }
 586         else
 587             return sal_True;
 588     }
 589     rInStm.Seek( nTokPos );
 590     return sal_False;
 591 }
 592
 593 /*************************************************************************
 594 |*
 595 |*    SvVersion::WriteSvIdl()
 596 |*
 597 |*    Beschreibung
 598 |*    Ersterstellung    MM 12.12.94
 599 |*    Letzte Aenderung  MM 12.12.94
 600 |*
 601 *************************************************************************/
 602 sal_Bool SvVersion::WriteSvIdl( SvStream & rOutStm )
 603 {
 604     rOutStm << SvHash_Version()->GetName().GetBuffer() << '('
 605             << ByteString::CreateFromInt32( nMajorVersion ).GetBuffer() << '.'
 606             << ByteString::CreateFromInt32( nMinorVersion ).GetBuffer() << ')';
 607     return sal_True;
 608 }
 609 #endif //IDL_COMPILER
 610
 611