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 612