idl/source/prj/database.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: database.cxx,v $
  10  * $Revision: 1.9 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_idl.hxx"
  33
  34 #include <ctype.h>
  35 #include <stdio.h>
  36 #include <stdlib.h>
  37 #include <tools/fsys.hxx>
  38 #include <tools/debug.hxx>
  39 #include <database.hxx>
  40 #include <globals.hxx>
  41
  42 /****************** SvIdlDataBase ****************************************/
  43 /*************************************************************************
  44 |*    SvIdlDataBase::SvIdlDataBase()
  45 |*
  46 |*    Beschreibung
  47 *************************************************************************/
  48 /*
  49 void PrimeNumber(){
  50     USHORT i, n;
  51     for( i = 5001; i < 5500; i += 2 ){
  52         for( n = 2; n < i && ((i % n) != 0); n++ );
  53         if( n == i ){
  54             printf( "\nPrimzahl: %d\n", i );
  55             return;
  56         }
  57     }
  58 }
  59 */
  60
  61 SvIdlDataBase::SvIdlDataBase()
  62     : bExport( FALSE )
  63     , nUniqueId( 0 )
  64     , bIsModified( FALSE )
  65     , aPersStream( *IDLAPP->pClassMgr, NULL )
  66     , pIdTable( NULL )
  67 {
  68     //PrimeNumber();
  69 }
  70
  71 /*************************************************************************
  72 |*    SvIdlDataBase::~SvIdlDataBase()
  73 |*
  74 |*    Beschreibung
  75 *************************************************************************/
  76 SvIdlDataBase::~SvIdlDataBase()
  77 {
  78     String * pStr = aIdFileList.First();
  79     while( pStr )
  80     {
  81         delete pStr;
  82         pStr = aIdFileList.Next();
  83     }
  84     delete pIdTable;
  85 }
  86
  87 /*************************************************************************
  88 |*    SvIdlDataBase::GetTypeList()
  89 |*
  90 |*    Beschreibung
  91 *************************************************************************/
  92 #define ADD_TYPE( Name, OdlName, ParserChar, CName, BasName, BasPost )            \
  93     aTypeList.Append( new SvMetaType( SvHash_##Name()->GetName(),       \
  94                      BasName, OdlName, ParserChar, CName, BasName, BasPost ) );
  95
  96 SvMetaTypeMemberList & SvIdlDataBase::GetTypeList()
  97 {
  98     if( aTypeList.Count() == 0 )
  99     { // Initial fuellen
 100         aTypeList.Append( new SvMetaTypeString() );
 101         aTypeList.Append( new SvMetaTypevoid() );
 102
 103         // MI: IDispatch::Invoke kann keine unsigned
 104         ADD_TYPE( UINT16,    "long", 'h', "unsigned short", "Long", "&" );
 105         ADD_TYPE( INT16,     "short", 'h', "short", "Integer", "%" );
 106         ADD_TYPE( UINT32,    "long", 'l', "unsigned long", "Long", "&" );
 107         ADD_TYPE( INT32,     "long", 'l', "long", "Long", "&" );
 108         ADD_TYPE( int,       "int", 'i', "int", "Integer", "%" );
 109         ADD_TYPE( BOOL,      "boolean", 'b', "unsigned char", "Boolean", "" );
 110         ADD_TYPE( char,      "char", 'c', "char", "Integer", "%" );
 111         ADD_TYPE( BYTE,      "char", 'c', "unsigned char", "Integer", "%" );
 112         ADD_TYPE( float,     "float", 'f', "float", "Single", "!" );
 113         ADD_TYPE( double,    "double", 'F', "double", "Double", "#" );
 114         ADD_TYPE( SbxObject, "VARIANT", 'o', "C_Object", "Object", "" );
 115
 116         // A c h t u n g !!!, bei hinzufuegen von Typen werden alle
 117         // bin„ren Datenbasen inkompatibel
 118
 119     /*
 120         // So tun als ob die Init-Daten auf einem Stream gelesen wurden
 121         SvMemoryStream aStm;
 122         aPersStream.SetStream( &aStm );
 123         // Alle Init-Daten Streamen
 124         aPersStream << aTypeList;
 125         // Nur die Id-Zuordnung merken
 126         aPersStream.SetStream( NULL );
 127     */
 128     }
 129     return aTypeList;
 130 }
 131
 132 /*************************************************************************
 133 |*
 134 |*    SvIdlDataBase::GetModuleInfo()
 135 |*
 136 |*    Beschreibung
 137 |*    Ersterstellung    MM 13.12.94
 138 |*    Letzte Aenderung  MM 13.12.94
 139 |*
 140 *************************************************************************/
 141 SvMetaModule * SvIdlDataBase::GetModule( const ByteString & rName )
 142 {
 143     for( ULONG n = 0; n < aModuleList.Count(); n++ )
 144         if( aModuleList.GetObject( n )->GetName() == rName )
 145             return aModuleList.GetObject( n );
 146     return NULL;
 147 }
 148
 149 /*************************************************************************
 150 |*
 151 |*    SvIdlDataBase::IsBinaryFormat()
 152 |*
 153 |*    Beschreibung
 154 |*
 155 *************************************************************************/
 156 #define DATABASE_SIGNATURE  (UINT32)0x13B799F2
 157 #define DATABASE_VER 0x0006
 158 BOOL SvIdlDataBase::IsBinaryFormat( SvStream & rStm )
 159 {
 160     UINT32  nSig = 0;
 161     ULONG   nPos = rStm.Tell();
 162     rStm >> nSig;
 163     rStm.Seek( nPos );
 164
 165     return nSig == DATABASE_SIGNATURE;
 166 }
 167
 168 /*************************************************************************
 169 |*
 170 |*    SvIdlDataBase::Load()
 171 |*
 172 |*    Beschreibung
 173 |*
 174 *************************************************************************/
 175 void SvIdlDataBase::Load( SvStream & rStm )
 176 {
 177     DBG_ASSERT( aTypeList.Count() == 0, "type list already initialized" );
 178     SvPersistStream aPStm( *IDLAPP->pClassMgr, &rStm );
 179
 180     USHORT  nVersion = 0;
 181     UINT32  nSig = 0;
 182
 183     aPStm >> nSig;
 184     aPStm >> nVersion;
 185     if( nSig != DATABASE_SIGNATURE )
 186     {
 187         aPStm.SetError( SVSTREAM_FILEFORMAT_ERROR );
 188         return;
 189     }
 190     if( nVersion != DATABASE_VER )
 191     {
 192         aPStm.SetError( SVSTREAM_WRONGVERSION );
 193         return;
 194     }
 195     aPStm >> aClassList;
 196     aPStm >> aTypeList;
 197     aPStm >> aAttrList;
 198     aPStm >> aModuleList;
 199     aPStm >> nUniqueId;
 200
 201     if( aPStm.IsEof() )
 202         aPStm.SetError( SVSTREAM_GENERALERROR );
 203 }
 204
 205 /*************************************************************************
 206 |*    SvIdlDataBase::Save()
 207 |*
 208 |*    Beschreibung
 209 *************************************************************************/
 210 void SvIdlDataBase::Save( SvStream & rStm, UINT32 nFlags )
 211 {
 212     SvPersistStream aPStm( *IDLAPP->pClassMgr, &rStm );
 213     aPStm.SetContextFlags( nFlags );
 214
 215     aPStm << (UINT32)DATABASE_SIGNATURE;
 216     aPStm << (USHORT)DATABASE_VER;
 217
 218     BOOL bOnlyStreamedObjs = FALSE;
 219     if( nFlags & IDL_WRITE_CALLING )
 220         bOnlyStreamedObjs = TRUE;
 221
 222     if( bOnlyStreamedObjs )
 223     {
 224         SvMetaClassMemberList aList;
 225         for( ULONG n = 0; n < GetModuleList().Count(); n++ )
 226         {
 227             SvMetaModule * pModule = GetModuleList().GetObject( n );
 228             if( !pModule->IsImported() )
 229                 aList.Append( pModule->GetClassList() );
 230         }
 231         aPStm << aList;
 232     }
 233     else
 234         aPStm << aClassList;
 235
 236     //aClassList.WriteObjects( aPStm, bOnlyStreamedObjs );
 237     aTypeList.WriteObjects( aPStm, bOnlyStreamedObjs );
 238     aAttrList.WriteObjects( aPStm, bOnlyStreamedObjs );
 239     aModuleList.WriteObjects( aPStm, bOnlyStreamedObjs );
 240     aPStm << nUniqueId;
 241 }
 242
 243 /*************************************************************************
 244 |*    SvIdlDataBase::SetError()
 245 |*
 246 |*    Beschreibung
 247 *************************************************************************/
 248 void SvIdlDataBase::SetError( const ByteString & rError, SvToken * pTok )
 249 {
 250     if( pTok->GetLine() > 10000 )
 251         aError.SetText( "hgchcg" );
 252
 253     if( aError.nLine < pTok->GetLine()
 254       || (aError.nLine == pTok->GetLine() && aError.nColumn < pTok->GetColumn()) )
 255     {
 256         aError = SvIdlError( pTok->GetLine(), pTok->GetColumn() );
 257         aError.SetText( rError );
 258     }
 259 }
 260
 261 /*************************************************************************
 262 |*    SvIdlDataBase::Push()
 263 |*
 264 |*    Beschreibung
 265 *************************************************************************/
 266 void SvIdlDataBase::Push( SvMetaObject * pObj )
 267 {
 268     GetStack().Push( pObj );
 269 }
 270
 271 #ifdef IDL_COMPILER
 272 /*************************************************************************
 273 |*
 274 |*    SvIdlDataBase::FindId()
 275 |*
 276 |*    Beschreibung
 277 |*
 278 *************************************************************************/
 279 BOOL SvIdlDataBase::FindId( const ByteString & rIdName, ULONG * pVal )
 280 {
 281     if( pIdTable )
 282     {
 283         UINT32 nHash;
 284         if( pIdTable->Test( rIdName, &nHash ) )
 285         {
 286             *pVal = pIdTable->Get( nHash )->GetValue();
 287             return TRUE;
 288         }
 289     }
 290     return FALSE;
 291 }
 292
 293 /*************************************************************************
 294 |*
 295 |*    SvIdlDataBase::InsertId()
 296 |*
 297 |*    Beschreibung
 298 |*
 299 *************************************************************************/
 300 BOOL SvIdlDataBase::InsertId( const ByteString & rIdName, ULONG nVal )
 301 {
 302     if( !pIdTable )
 303         pIdTable = new SvStringHashTable( 20003 );
 304
 305     UINT32 nHash;
 306     if( pIdTable->Insert( rIdName, &nHash ) )
 307     {
 308         pIdTable->Get( nHash )->SetValue( nVal );
 309         return TRUE;
 310     }
 311     return FALSE;
 312 }
 313
 314 /*************************************************************************
 315 |*    SvIdlDataBase::ReadIdFile()
 316 |*
 317 |*    Beschreibung
 318 *************************************************************************/
 319 BOOL SvIdlDataBase::ReadIdFile( const String & rFileName )
 320 {
 321     DirEntry aFullName( rFileName );
 322     aFullName.Find( GetPath() );
 323
 324     String * pIdFile = aIdFileList.First();
 325     while( pIdFile )
 326     {
 327         if( *pIdFile == rFileName )
 328             return TRUE; // schon eingelesen
 329         pIdFile = aIdFileList.Next();
 330     }
 331
 332     aIdFileList.Insert( new String( rFileName ), LIST_APPEND );
 333
 334     SvTokenStream aTokStm( aFullName.GetFull() );
 335     if( aTokStm.GetStream().GetError() == SVSTREAM_OK )
 336     {
 337         SvToken * pTok = aTokStm.GetToken_Next();
 338
 339         while( !pTok->IsEof() )
 340         {
 341             if( pTok->IsChar() && pTok->GetChar() == '#' )
 342             {
 343                 pTok = aTokStm.GetToken_Next();
 344                 if( pTok->Is( SvHash_define() ) )
 345                 {
 346                     pTok = aTokStm.GetToken_Next();
 347                     ByteString aDefName;
 348                     if( pTok->IsIdentifier() )
 349                         aDefName = pTok->GetString();
 350                     else
 351                     {
 352                         ByteString aStr( "unexpected token after define" );
 353                         // Fehler setzen
 354                         SetError( aStr, pTok );
 355                         WriteError( aTokStm );
 356                         return FALSE;
 357                     }
 358
 359                     ULONG nVal = 0;
 360                     BOOL bOk = TRUE;
 361                     while( bOk )
 362                     {
 363                         pTok = aTokStm.GetToken_Next();
 364                         if( pTok->IsIdentifier() )
 365                         {
 366                             ULONG n;
 367                             if( FindId( pTok->GetString(), &n ) )
 368                                 nVal += n;
 369                             else
 370                                 bOk = FALSE;
 371                         }
 372                         else if( pTok->IsChar() )
 373                         {
 374                             if( pTok->GetChar() == '-'
 375                               || pTok->GetChar() == '/'
 376                               || pTok->GetChar() == '*'
 377                               || pTok->GetChar() == '&'
 378                               || pTok->GetChar() == '|'
 379                               || pTok->GetChar() == '^'
 380                               || pTok->GetChar() == '~' )
 381                             {
 382                                 ByteString aStr( "unknown operator '" );
 383                                 aStr += pTok->GetChar();
 384                                 aStr += "'in define";
 385                                 // Fehler setzen
 386                                 SetError( aStr, pTok );
 387                                 WriteError( aTokStm );
 388                                 return FALSE;
 389                             }
 390                             if( pTok->GetChar() != '+'
 391                               && pTok->GetChar() != '('
 392                               && pTok->GetChar() != ')' )
 393                                 // nur + erlaubt, Klammern spielen kein Rolle,
 394                                 // da + komutativ ist
 395                                 break;
 396                         }
 397                         else if( pTok->IsInteger() )
 398                         {
 399                             nVal += pTok->GetNumber();
 400                         }
 401                         else
 402                             break;
 403                     }
 404                     if( bOk )
 405                     {
 406                         if( !InsertId( aDefName, nVal ) )
 407                         {
 408                             ByteString aStr = "hash table overflow: ";
 409                             SetError( aStr, pTok );
 410                             WriteError( aTokStm );
 411                             return FALSE;
 412                         }
 413                     }
 414                 }
 415                 else if( pTok->Is( SvHash_include() ) )
 416                 {
 417                     pTok = aTokStm.GetToken_Next();
 418                     ByteString aName;
 419                     if( pTok->IsString() )
 420                         aName = pTok->GetString();
 421                     else if( pTok->IsChar() && pTok->GetChar() == '<' )
 422                     {
 423                         pTok = aTokStm.GetToken_Next();
 424                         while( !pTok->IsEof()
 425                           && !(pTok->IsChar() && pTok->GetChar() == '>') )
 426                         {
 427                             aName += pTok->GetTokenAsString();
 428                             pTok = aTokStm.GetToken_Next();
 429                         }
 430                         if( pTok->IsEof() )
 431                         {
 432                             ByteString aStr( "unexpected eof in #include" );
 433                             // Fehler setzen
 434                             SetError( aStr, pTok );
 435                             WriteError( aTokStm );
 436                             return FALSE;
 437                         }
 438                     }
 439                     if( !ReadIdFile( String::CreateFromAscii(aName.GetBuffer()) ) )
 440                     {
 441                         ByteString aStr = "cannot read file: ";
 442                         aStr += aName;
 443                         SetError( aStr, pTok );
 444                         WriteError( aTokStm );
 445                         return FALSE;
 446                     }
 447                 }
 448             }
 449             else
 450                 pTok = aTokStm.GetToken_Next();
 451         }
 452     }
 453     else
 454         return FALSE;
 455     return TRUE;
 456 }
 457
 458 /*************************************************************************
 459 |*    SvIdlDataBase::FindType()
 460 |*
 461 |*    Beschreibung
 462 *************************************************************************/
 463 SvMetaType * SvIdlDataBase::FindType( const SvMetaType * pPType,
 464                                     SvMetaTypeMemberList & rList )
 465 {
 466     SvMetaType * pType = rList.First();
 467     while( pType && pPType != pType )
 468         pType = rList.Next();
 469     return pType;
 470 }
 471
 472 SvMetaType * SvIdlDataBase::FindType( const ByteString & rName )
 473 {
 474     SvMetaType * pType = aTypeList.First();
 475     while( pType && rName != pType->GetName() )
 476         pType = aTypeList.Next();
 477     return pType;
 478 }
 479
 480 /*************************************************************************
 481 |*    SvIdlDataBase::ReadKnownType()
 482 |*
 483 |*    Beschreibung
 484 *************************************************************************/
 485 SvMetaType * SvIdlDataBase::ReadKnownType( SvTokenStream & rInStm )
 486 {
 487     BOOL bIn    = FALSE;
 488     BOOL bOut   = FALSE;
 489     int nCall0  = CALL_VALUE;
 490     int nCall1  = CALL_VALUE;
 491     BOOL bSet   = FALSE; //irgent ein Attribut gesetzt
 492
 493     UINT32  nTokPos = rInStm.Tell();
 494     SvToken * pTok = rInStm.GetToken_Next();
 495
 496     if( pTok->HasHash() )
 497     {
 498         UINT32 nBeginPos = 0; // kann mit Tell nicht vorkommen
 499         while( nBeginPos != rInStm.Tell() )
 500         {
 501             nBeginPos = rInStm.Tell();
 502             if( pTok->Is( SvHash_in() ) )
 503             {
 504                 bIn  = TRUE;
 505                 pTok = rInStm.GetToken_Next();
 506                 bSet = TRUE;
 507             }
 508             if( pTok->Is( SvHash_out() ) )
 509             {
 510                 bOut = TRUE;
 511                 pTok = rInStm.GetToken_Next();
 512                 bSet = TRUE;
 513             }
 514             if( pTok->Is( SvHash_inout() ) )
 515             {
 516                 bIn  = TRUE;
 517                 bOut = TRUE;
 518                 pTok = rInStm.GetToken_Next();
 519                 bSet = TRUE;
 520             }
 521         }
 522     }
 523 /*
 524     SvMetaTypeList aTmpTypeList;
 525     if( FillTypeList( aTmpTypeList, pTok ) )
 526 */
 527     if( pTok->IsIdentifier() )
 528     {
 529         ByteString aName = pTok->GetString();
 530         SvMetaTypeMemberList & rList = GetTypeList();
 531         SvMetaType * pType = rList.First();
 532         while( pType )
 533         {
 534             if( pType->GetName() == aName )
 535                 break;
 536             pType = rList.Next();
 537         }
 538         if( pType )
 539         {
 540             pTok = rInStm.GetToken();
 541             if( pTok->IsChar() )
 542             {
 543                 if( pTok->GetChar() == '&' || pTok->GetChar() == '*' )
 544                 {
 545                     nCall0 = (pTok->GetChar() == '&') ? CALL_REFERENCE :
 546                                                         CALL_POINTER;
 547                     rInStm.GetToken_Next();
 548                     pTok = rInStm.GetToken();
 549                     if( pTok->GetChar() == '&' || pTok->GetChar() == '*' )
 550                     {
 551                         nCall1 = (pTok->GetChar() == '&') ? CALL_REFERENCE :
 552                                                             CALL_POINTER;
 553                         rInStm.GetToken_Next();
 554                     }
 555                     bSet = TRUE;
 556                 }
 557             }
 558             /*
 559             SvMetaType * pMetaType = aTmpTypeList.First();
 560             while( pMetaType )
 561             {
 562                 if( pMetaType->GetIn() == bIn
 563                   && pMetaType->GetOut() == bOut
 564                   && pMetaType->GetCall0() == nCall0
 565                   && pMetaType->GetCall1() == nCall1 )
 566                 {
 567                     return pMetaType;
 568                 }
 569                 pMetaType = aTmpTypeList.Next();
 570             }
 571             */
 572             //SvMetaType * pType = aTmpTypeList.First();
 573             if( !bSet )
 574                 // Ist genau dieser Typ
 575                 return pType;
 576
 577             DBG_ASSERT( aTmpTypeList.First(), "mindestens ein Element" );
 578             SvMetaTypeRef xType = new SvMetaType( pType->GetName(), 'h', "dummy" );
 579             xType->SetRef( pType );
 580             xType->SetIn( bIn );
 581             xType->SetOut( bOut );
 582             xType->SetCall0( nCall0 );
 583             xType->SetCall1( nCall1 );
 584
 585             aTmpTypeList.Append( xType );
 586             return xType;
 587         }
 588     }
 589     rInStm.Seek( nTokPos );
 590     return NULL;
 591 }
 592
 593 /*************************************************************************
 594 |*
 595 |*    SvIdlDataBase::ReadKnownAttr()
 596 |*
 597 |*    Beschreibung
 598 |*
 599 *************************************************************************/
 600 SvMetaAttribute * SvIdlDataBase::ReadKnownAttr
 601 (
 602     SvTokenStream & rInStm,
 603     SvMetaType *        pType   /* Wenn der pType == NULL, dann muss der Typ
 604                                noch gelesen werden. */
 605 )
 606 {
 607     UINT32  nTokPos = rInStm.Tell();
 608
 609     if( !pType )
 610         pType = ReadKnownType( rInStm );
 611
 612     if( pType )
 613     {
 614         // Wenn wir Slots auf die Wiese stellen, d"urfen wir nicht voraussetzen,
 615         // da\s jeder Slot einen anderen Namen hat!
 616 /*
 617         SvToken * pTok = rInStm.GetToken_Next();
 618         if( pTok->IsIdentifier() )
 619             for( ULONG n = 0; n < aAttrList.Count(); n++ )
 620             {
 621                 SvMetaAttribute * pAttr = aAttrList.GetObject( n );
 622                 if( pAttr->GetName() == pTok->GetString() )
 623                     return pAttr;
 624             }
 625 */
 626     }
 627     else
 628     {
 629         // sonst SlotId?
 630         SvToken * pTok = rInStm.GetToken_Next();
 631         if( pTok->IsIdentifier() )
 632         {
 633             ULONG n;
 634             if( FindId( pTok->GetString(), &n ) )
 635             {
 636                 for( ULONG i = 0; i < aAttrList.Count(); i++ )
 637                 {
 638                     SvMetaAttribute * pAttr = aAttrList.GetObject( i );
 639                     if( pAttr->GetSlotId() == pTok->GetString() )
 640                         return pAttr;
 641                 }
 642             }
 643
 644             ByteString aStr( "Nicht gefunden : " );
 645             aStr += pTok->GetString();
 646             DBG_ERROR( aStr.GetBuffer() );
 647         }
 648     }
 649
 650     rInStm.Seek( nTokPos );
 651     return NULL;
 652 }
 653
 654 SvMetaAttribute* SvIdlDataBase::SearchKnownAttr
 655 (
 656     const SvNumberIdentifier& rId
 657 )
 658 {
 659     ULONG n;
 660     if( FindId( rId, &n ) )
 661     {
 662         for( ULONG i = 0; i < aAttrList.Count(); i++ )
 663         {
 664             SvMetaAttribute * pAttr = aAttrList.GetObject( i );
 665             if( pAttr->GetSlotId() == rId )
 666                 return pAttr;
 667         }
 668     }
 669
 670     return NULL;
 671 }
 672
 673 /*************************************************************************
 674 |*    SvIdlDataBase::ReadKnownClass()
 675 |*
 676 |*    Beschreibung
 677 *************************************************************************/
 678 SvMetaClass * SvIdlDataBase::ReadKnownClass( SvTokenStream & rInStm )
 679 {
 680     UINT32  nTokPos = rInStm.Tell();
 681     SvToken * pTok = rInStm.GetToken_Next();
 682
 683     if( pTok->IsIdentifier() )
 684         for( ULONG n = 0; n < aClassList.Count(); n++ )
 685         {
 686             SvMetaClass * pClass = aClassList.GetObject( n );
 687             if( pClass->GetName() == pTok->GetString() )
 688                 return pClass;
 689         }
 690
 691     rInStm.Seek( nTokPos );
 692     return NULL;
 693 }
 694
 695 /*************************************************************************
 696 |*    SvIdlDataBase::Write()
 697 |*
 698 |*    Beschreibung
 699 *************************************************************************/
 700 void SvIdlDataBase::Write( const ByteString & rText )
 701 {
 702 #ifndef W31
 703         fprintf( stdout, "%s", rText.GetBuffer() );
 704 #endif
 705 }
 706
 707 /*************************************************************************
 708 |*    SvIdlDataBase::WriteError()
 709 |*
 710 |*    Beschreibung
 711 *************************************************************************/
 712 void SvIdlDataBase::WriteError( const ByteString & rErrWrn,
 713                                 const ByteString & rFileName,
 714                                 const ByteString & rErrorText,
 715                                 ULONG nRow, ULONG nColumn ) const
 716 {
 717     //Fehlerbehandlung
 718 #ifndef W31
 719     fprintf( stderr, "\n%s --- %s: ( %ld, %ld )\n",
 720              rFileName.GetBuffer(), rErrWrn.GetBuffer(), nRow, nColumn );
 721
 722     if( rErrorText.Len() )
 723     { // Fehler gesetzt
 724         fprintf( stderr, "\t%s\n", rErrorText.GetBuffer() );
 725     }
 726 #endif
 727 }
 728
 729 /*************************************************************************
 730 |*    SvIdlDataBase::WriteError()
 731 |*
 732 |*    Beschreibung
 733 *************************************************************************/
 734 void SvIdlDataBase::WriteError( SvTokenStream & rInStm )
 735 {
 736     //Fehlerbehandlung
 737 #ifndef W31
 738     String aFileName( rInStm.GetFileName() );
 739     ByteString aErrorText;
 740     ULONG       nRow = 0, nColumn = 0;
 741
 742     rInStm.SeekEnd();
 743     SvToken *pTok = rInStm.GetToken();
 744
 745     // Fehlerposition
 746     nRow        = pTok->GetLine();
 747     nColumn = pTok->GetColumn();
 748
 749     if( aError.IsError() )
 750     { // Fehler gesetzt
 751         // Fehler Token suchen
 752         // Fehlertext
 753         if( aError.GetText().Len() )
 754         {
 755             aErrorText = "may be <";
 756             aErrorText += aError.GetText();
 757         }
 758         SvToken * pPrevTok = NULL;
 759         while( pTok != pPrevTok )
 760         {
 761             pPrevTok = pTok;
 762             if( pTok->GetLine() == aError.nLine
 763               && pTok->GetColumn() == aError.nColumn )
 764                 break;
 765             pTok = rInStm.GetToken_PrevAll();
 766         }
 767
 768         // Fehlerposition
 769         aErrorText += "> at ( ";
 770         aErrorText += ByteString::CreateFromInt64(aError.nLine);
 771         aErrorText += ", ";
 772         aErrorText += ByteString::CreateFromInt64(aError.nColumn);
 773         aErrorText += " )";
 774
 775         // Fehler zuruecksetzen
 776         aError = SvIdlError();
 777     }
 778
 779     WriteError( "error", ByteString( aFileName, RTL_TEXTENCODING_UTF8 ), aErrorText, nRow, nColumn );
 780
 781     DBG_ASSERT( pTok, "token must be found" );
 782     if( !pTok )
 783         return;
 784
 785     // Identifier in der Naehe suchen
 786     if( !pTok->IsIdentifier() )
 787     {
 788         rInStm.GetToken_PrevAll();
 789         pTok = rInStm.GetToken();
 790     }
 791     if( pTok && pTok->IsIdentifier() )
 792     {
 793         ByteString aN = IDLAPP->pHashTable->GetNearString( pTok->GetString() );
 794         if( aN.Len() )
 795             fprintf( stderr, "%s versus %s\n", pTok->GetString().GetBuffer(), aN.GetBuffer() );
 796     }
 797 #endif
 798 }
 799
 800 /****************** SvIdlWorkingBase ****************************************/
 801 /*************************************************************************
 802 |*    SvIdlWorkingBase::SvIdlWorkingBase()
 803 |*
 804 |*    Beschreibung
 805 *************************************************************************/
 806 SvIdlWorkingBase::SvIdlWorkingBase()
 807 {
 808 }
 809
 810 /*************************************************************************
 811 |*    SvIdlWorkingBase::ReadSvIdl()
 812 |*
 813 |*    Beschreibung
 814 *************************************************************************/
 815 BOOL SvIdlWorkingBase::ReadSvIdl( SvTokenStream & rInStm, BOOL bImported, const String & rPath )
 816 {
 817     aPath = rPath; // nur fuer den durchlauf gueltig
 818     SvToken * pTok;
 819     BOOL bOk = TRUE;
 820         pTok = rInStm.GetToken();
 821         // nur ein import ganz am Anfang
 822         if( pTok->Is( SvHash_import() ) )
 823         {
 824             rInStm.GetToken_Next();
 825             rInStm.Read( '(' ); // optional
 826             pTok = rInStm.GetToken_Next();
 827             if( pTok->IsString() )
 828             {
 829                 DirEntry aFullName( String::CreateFromAscii( pTok->GetString().GetBuffer() ) );
 830                 if( aFullName.Find( rPath ) )
 831                 {
 832                     SvFileStream aStm( aFullName.GetFull(),
 833                                         STREAM_STD_READ | STREAM_NOCREATE );
 834                     Load( aStm );
 835                     if( aStm.GetError() != SVSTREAM_OK )
 836                     {
 837                         if( aStm.GetError() == SVSTREAM_WRONGVERSION )
 838                         {
 839                             ByteString aStr( "wrong version, file " );
 840                             aStr += ByteString( aFullName.GetFull(), RTL_TEXTENCODING_UTF8 );
 841                             SetError( aStr, pTok );
 842                             WriteError( rInStm );
 843                             bOk = FALSE;
 844                         }
 845                         else
 846                         {
 847                             aStm.Seek( 0 );
 848                             aStm.ResetError();
 849                             SvTokenStream aTokStm( aStm, aFullName.GetFull() );
 850                             bOk = ReadSvIdl( aTokStm, TRUE, rPath );
 851                         }
 852                     }
 853                 }
 854                 else
 855                     bOk = FALSE;
 856             }
 857             else
 858                 bOk = FALSE;
 859         }
 860
 861     UINT32 nBeginPos = 0xFFFFFFFF; // kann mit Tell nicht vorkommen
 862
 863     while( bOk && nBeginPos != rInStm.Tell() )
 864     {
 865         nBeginPos = rInStm.Tell();
 866         pTok = rInStm.GetToken();
 867         if( pTok->IsEof() )
 868             return TRUE;
 869         if( pTok->IsEmpty() )
 870             bOk = FALSE;
 871
 872         // nur ein import ganz am Anfang
 873         /*else */if( pTok->Is( SvHash_module() ) )
 874         {
 875             SvMetaModuleRef aModule = new SvMetaModule( rInStm.GetFileName(), bImported );
 876             if( aModule->ReadSvIdl( *this, rInStm ) )
 877                 GetModuleList().Append( aModule );
 878             else
 879                 bOk = FALSE;
 880         }
 881         else
 882             bOk = FALSE;
 883     }
 884     if( !bOk || !pTok->IsEof() )
 885     {
 886          //Fehlerbehandlung
 887          WriteError( rInStm );
 888          return FALSE;
 889     }
 890     return TRUE;
 891 }
 892
 893 /*************************************************************************
 894 |*    SvIdlWorkingBase::WriteSvIdl()
 895 |*
 896 |*    Beschreibung
 897 *************************************************************************/
 898 BOOL SvIdlWorkingBase::WriteSvIdl( SvStream & rOutStm )
 899 {
 900     if( rOutStm.GetError() != SVSTREAM_OK )
 901         return FALSE;
 902
 903     SvStringHashList aList;
 904     if( GetIdTable() )
 905     {
 906         GetIdTable()->FillHashList( &aList );
 907         SvStringHashEntry * pEntry = aList.First();
 908         while( pEntry )
 909         {
 910             rOutStm << "#define " << pEntry->GetName().GetBuffer()
 911                     << '\t'
 912                     << ByteString::CreateFromInt64(
 913                         pEntry->GetValue() ).GetBuffer()
 914                     << endl;
 915             pEntry = aList.Next();
 916         }
 917     }
 918
 919     for( ULONG n = 0; n < GetModuleList().Count(); n++ )
 920     {
 921         SvMetaModule * pModule = GetModuleList().GetObject( n );
 922         //if( !pModule->IsImported() )
 923             pModule->WriteSvIdl( *this, rOutStm, 0 );
 924     }
 925     return TRUE;
 926 }
 927
 928 /*************************************************************************
 929 |*    SvIdlWorkingBase::WriteSfx()
 930 |*
 931 |*    Beschreibung
 932 *************************************************************************/
 933 BOOL SvIdlWorkingBase::WriteSfx( SvStream & rOutStm )
 934 {
 935     if( rOutStm.GetError() != SVSTREAM_OK )
 936         return FALSE;
 937
 938     // alle Tmp-Variablen fuer das Schreiben zuruecksetzen
 939     WriteReset();
 940     SvMemoryStream aTmpStm( 256000, 256000 );
 941     ULONG n;
 942     for( n = 0; n < GetModuleList().Count(); n++ )
 943     {
 944         SvMetaModule * pModule = GetModuleList().GetObject( n );
 945         if( !pModule->IsImported() )
 946             pModule->WriteSfx( *this, aTmpStm );
 947         aTmpStm.Seek( 0 );
 948     }
 949     for( n = 0; n < aUsedTypes.Count(); n++ )
 950     {
 951         SvMetaType * pType = aUsedTypes.GetObject( n );
 952         pType->WriteSfx( *this, rOutStm );
 953     }
 954     aUsedTypes.Clear();
 955     rOutStm << aTmpStm;
 956     return TRUE;
 957 }
 958
 959 BOOL SvIdlWorkingBase::WriteHelpIds( SvStream& rOutStm )
 960 {
 961     if( rOutStm.GetError() != SVSTREAM_OK )
 962         return FALSE;
 963
 964     Table aIdTable;
 965     ULONG n;
 966     for( n = 0; n < GetModuleList().Count(); n++ )
 967     {
 968         SvMetaModule * pModule = GetModuleList().GetObject( n );
 969         //if( !pModule->IsImported() )
 970             pModule->WriteHelpIds( *this, rOutStm, &aIdTable );
 971     }
 972
 973     const SvMetaAttributeMemberList & rAttrList = GetAttrList();
 974     for( n = 0; n < rAttrList.Count(); n++ )
 975     {
 976         SvMetaAttribute * pAttr = rAttrList.GetObject( n );
 977         pAttr->WriteHelpId( *this, rOutStm, &aIdTable );
 978     }
 979
 980     return TRUE;
 981 }
 982
 983 /*************************************************************************
 984 |*    SvIdlWorkingBase::WriteSfxItem()
 985 |*
 986 |*    Beschreibung
 987 *************************************************************************/
 988 BOOL SvIdlWorkingBase::WriteSfxItem( SvStream & )
 989 {
 990     return FALSE;
 991 }
 992
 993 void SvIdlDataBase::StartNewFile( const String& rName )
 994 {
 995     bExport = ( aExportFile.EqualsIgnoreCaseAscii( rName ) );
 996 }
 997
 998 void SvIdlDataBase::AppendAttr( SvMetaAttribute *pAttr )
 999 {
1000     aAttrList.Append( pAttr );
1001     if ( bExport )
1002         pAttr->SetNewAttribute( TRUE );
1003 }
1004
1005 BOOL SvIdlWorkingBase::WriteCSV( SvStream& rStrm )
1006 {
1007     SvMetaAttributeMemberList &rList = GetAttrList();
1008     ULONG nCount = rList.Count();
1009     for ( ULONG n=0; n<nCount; n++ )
1010     {
1011         if ( rList.GetObject(n)->IsNewAttribute() )
1012         {
1013             rList.GetObject(n)->WriteCSV( *this, rStrm );
1014         }
1015     }
1016
1017     if ( rStrm.GetError() != SVSTREAM_OK )
1018         return FALSE;
1019     else
1020         return TRUE;
1021 }
1022
1023 /*************************************************************************
1024 |*    SvIdlWorkingBase::WriteDocumentation()
1025 |*
1026 |*    Beschreibung
1027 *************************************************************************/
1028 BOOL SvIdlWorkingBase::WriteDocumentation( SvStream & rOutStm )
1029 {
1030     if( rOutStm.GetError() != SVSTREAM_OK )
1031         return FALSE;
1032
1033     for( ULONG n = 0; n < GetModuleList().Count(); n++ )
1034     {
1035         SvMetaModule * pModule = GetModuleList().GetObject( n );
1036         if( !pModule->IsImported() )
1037             pModule->Write( *this, rOutStm, 0, WRITE_DOCU );
1038     }
1039     return TRUE;
1040 }
1041
1042
1043
1044 #endif // IDL_COMPILER
1045