LCOV - code coverage report
Current view: top level - idl/source/prj - database.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 248 374 66.3 %
Date: 2015-06-13 12:38:46 Functions: 27 29 93.1 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : 
      21             : #include <ctype.h>
      22             : #include <stdio.h>
      23             : #include <stdlib.h>
      24             : #include <tools/debug.hxx>
      25             : #include <database.hxx>
      26             : #include <globals.hxx>
      27             : #include <rtl/strbuf.hxx>
      28             : #include <osl/file.hxx>
      29             : 
      30           8 : SvIdlDataBase::SvIdlDataBase( const SvCommand& rCmd )
      31             :     : bExport( false )
      32             :     , nUniqueId( 0 )
      33             :     , nVerbosity( rCmd.nVerbosity )
      34           8 :     , pIdTable( NULL )
      35             : {
      36           8 :     sSlotMapFile = rCmd.aSlotMapFile;
      37           8 : }
      38             : 
      39          16 : SvIdlDataBase::~SvIdlDataBase()
      40             : {
      41           8 :     aIdFileList.clear();
      42             : 
      43           8 :     delete pIdTable;
      44           8 : }
      45             : 
      46             : #define ADD_TYPE( Name, OdlName, ParserChar, CName, BasName, BasPost )            \
      47             :     aTypeList.push_back( new SvMetaType( SvHash_##Name()->GetName(),   \
      48             :                      BasName, OdlName, ParserChar, CName, BasName, BasPost ) );
      49             : 
      50       32987 : SvMetaTypeMemberList & SvIdlDataBase::GetTypeList()
      51             : {
      52       32987 :     if( aTypeList.empty() )
      53             :     { // fill initially
      54           8 :         aTypeList.push_back( new SvMetaTypeString() );
      55           8 :         aTypeList.push_back( new SvMetaTypevoid() );
      56             : 
      57             :         // MI: IDispatch::Invoke can not unsigned
      58           8 :         ADD_TYPE( UINT16,    "long", 'h', "unsigned short", "Long", "&" );
      59           8 :         ADD_TYPE( INT16,     "short", 'h', "short", "Integer", "%" );
      60           8 :         ADD_TYPE( UINT32,    "long", 'l', "unsigned long", "Long", "&" );
      61           8 :         ADD_TYPE( INT32,     "long", 'l', "long", "Long", "&" );
      62           8 :         ADD_TYPE( int,       "int", 'i', "int", "Integer", "%" );
      63           8 :         ADD_TYPE( BOOL,      "boolean", 'b', "unsigned char", "Boolean", "" );
      64           8 :         ADD_TYPE( char,      "char", 'c', "char", "Integer", "%" );
      65           8 :         ADD_TYPE( BYTE,      "char", 'c', "unsigned char", "Integer", "%" );
      66           8 :         ADD_TYPE( float,     "float", 'f', "float", "Single", "!" );
      67           8 :         ADD_TYPE( double,    "double", 'F', "double", "Double", "#" );
      68           8 :         ADD_TYPE( SbxObject, "VARIANT", 'o', "C_Object", "Object", "" );
      69             : 
      70             :         // Attention! When adding types all binary data bases get incompatible
      71             : 
      72             :     }
      73       32987 :     return aTypeList;
      74             : }
      75             : 
      76           8 : SvMetaModule * SvIdlDataBase::GetModule( const OString& rName )
      77             : {
      78           8 :     for( sal_uLong n = 0; n < aModuleList.size(); n++ )
      79           0 :         if( aModuleList[n]->GetName().getString().equals(rName) )
      80           0 :             return aModuleList[n];
      81           8 :     return NULL;
      82             : }
      83             : 
      84        5045 : void SvIdlDataBase::SetError( const OString& rError, SvToken * pTok )
      85             : {
      86        5045 :     if( pTok->GetLine() > 10000 )
      87         809 :         aError.SetText( "line count overflow" );
      88             : 
      89       10090 :     if( aError.nLine < pTok->GetLine()
      90        5045 :       || (aError.nLine == pTok->GetLine() && aError.nColumn < pTok->GetColumn()) )
      91             :     {
      92        5010 :         aError = SvIdlError( pTok->GetLine(), pTok->GetColumn() );
      93        5010 :         aError.SetText( rError );
      94             :     }
      95        5045 : }
      96             : 
      97           8 : void SvIdlDataBase::Push( SvMetaObject * pObj )
      98             : {
      99           8 :     GetStack().Push( pObj );
     100           8 : }
     101             : 
     102       42507 : bool SvIdlDataBase::FindId( const OString& rIdName, sal_uLong * pVal )
     103             : {
     104       42507 :     if( pIdTable )
     105             :     {
     106             :         sal_uInt32 nHash;
     107       42507 :         if( pIdTable->Test( rIdName, &nHash ) )
     108             :         {
     109       42146 :             *pVal = pIdTable->Get( nHash )->GetValue();
     110       42146 :             return true;
     111             :         }
     112             :     }
     113         361 :     return false;
     114             : }
     115             : 
     116       20239 : bool SvIdlDataBase::InsertId( const OString& rIdName, sal_uLong nVal )
     117             : {
     118       20239 :     if( !pIdTable )
     119           8 :         pIdTable = new SvStringHashTable( 20003 );
     120             : 
     121             :     sal_uInt32 nHash;
     122       20239 :     if( pIdTable->Insert( rIdName, &nHash ) )
     123             :     {
     124       20239 :         pIdTable->Get( nHash )->SetValue( nVal );
     125       20239 :         return true;
     126             :     }
     127           0 :     return false;
     128             : }
     129             : 
     130         185 : bool SvIdlDataBase::ReadIdFile( const OUString & rFileName )
     131             : {
     132         185 :     OUString aFullName;
     133         185 :     osl::File::searchFileURL( rFileName, GetPath(), aFullName);
     134         185 :     osl::FileBase::getSystemPathFromFileURL( aFullName, aFullName );
     135             : 
     136        1051 :     for ( size_t i = 0, n = aIdFileList.size(); i < n; ++i )
     137         958 :         if ( aIdFileList[ i ] == rFileName )
     138          92 :             return true;
     139             : 
     140          93 :     aIdFileList.push_back( rFileName );
     141          93 :     this->AddDepFile( aFullName );
     142         186 :     SvTokenStream aTokStm( aFullName );
     143          93 :     if( aTokStm.GetStream().GetError() == SVSTREAM_OK )
     144             :     {
     145          93 :         SvToken * pTok = aTokStm.GetToken_Next();
     146             : 
     147       22772 :         while( !pTok->IsEof() )
     148             :         {
     149       22586 :             if( pTok->IsChar() && pTok->GetChar() == '#' )
     150             :             {
     151       20758 :                 pTok = aTokStm.GetToken_Next();
     152       20758 :                 if( pTok->Is( SvHash_define() ) )
     153             :                 {
     154       20243 :                     pTok = aTokStm.GetToken_Next();
     155       20243 :                     OString aDefName;
     156       20243 :                     if( pTok->IsIdentifier() )
     157       20243 :                         aDefName = pTok->GetString();
     158             :                     else
     159             :                     {
     160           0 :                         OString aStr("unexpected token after define");
     161             :                         // set error
     162           0 :                         SetError( aStr, pTok );
     163           0 :                         WriteError( aTokStm );
     164           0 :                         return false;
     165             :                     }
     166             : 
     167       20243 :                     sal_uLong nVal = 0;
     168       20243 :                     bool bOk = true;
     169      125860 :                     while( bOk )
     170             :                     {
     171      105613 :                         pTok = aTokStm.GetToken_Next();
     172      105613 :                         if( pTok->IsIdentifier() )
     173             :                         {
     174             :                             sal_uLong n;
     175       16934 :                             if( FindId( pTok->GetString(), &n ) )
     176       16930 :                                 nVal += n;
     177             :                             else
     178           4 :                                 bOk = false;
     179             :                         }
     180       88679 :                         else if( pTok->IsChar() )
     181             :                         {
     182      137668 :                             if( pTok->GetChar() == '-'
     183       68834 :                               || pTok->GetChar() == '/'
     184       68834 :                               || pTok->GetChar() == '*'
     185       68834 :                               || pTok->GetChar() == '&'
     186       68834 :                               || pTok->GetChar() == '|'
     187       68834 :                               || pTok->GetChar() == '^'
     188      137668 :                               || pTok->GetChar() == '~' )
     189             :                             {
     190           0 :                                 OStringBuffer aStr("unknown operator '");
     191           0 :                                 aStr.append(pTok->GetChar());
     192           0 :                                 aStr.append("'in define");
     193             :                                 // set error
     194           0 :                                 SetError( aStr.makeStringAndClear(), pTok );
     195           0 :                                 WriteError( aTokStm );
     196           0 :                                 return false;
     197             :                             }
     198      137668 :                             if( pTok->GetChar() != '+'
     199       52220 :                               && pTok->GetChar() != '('
     200      104562 :                               && pTok->GetChar() != ')' )
     201             :                                 // only + is allowed, parentheses are immaterial
     202             :                                 // because + is commutative
     203       19236 :                                 break;
     204             :                         }
     205       19845 :                         else if( pTok->IsInteger() )
     206             :                         {
     207       18842 :                             nVal += pTok->GetNumber();
     208             :                         }
     209             :                         else
     210        1003 :                             break;
     211             :                     }
     212       20243 :                     if( bOk )
     213             :                     {
     214       20239 :                         if( !InsertId( aDefName, nVal ) )
     215             :                         {
     216           0 :                             OString aStr("hash table overflow: ");
     217           0 :                             SetError( aStr, pTok );
     218           0 :                             WriteError( aTokStm );
     219           0 :                             return false;
     220             :                         }
     221       20243 :                     }
     222             :                 }
     223         515 :                 else if( pTok->Is( SvHash_include() ) )
     224             :                 {
     225         174 :                     pTok = aTokStm.GetToken_Next();
     226         174 :                     OStringBuffer aName;
     227         174 :                     if( pTok->IsString() )
     228           9 :                         aName.append(pTok->GetString());
     229         165 :                     else if( pTok->IsChar() && pTok->GetChar() == '<' )
     230             :                     {
     231         165 :                         pTok = aTokStm.GetToken_Next();
     232        2121 :                         while( !pTok->IsEof()
     233         978 :                           && !(pTok->IsChar() && pTok->GetChar() == '>') )
     234             :                         {
     235         813 :                             aName.append(pTok->GetTokenAsString());
     236         813 :                             pTok = aTokStm.GetToken_Next();
     237             :                         }
     238         165 :                         if( pTok->IsEof() )
     239             :                         {
     240           0 :                             OString aStr("unexpected eof in #include");
     241             :                             // set error
     242           0 :                             SetError(aStr, pTok);
     243           0 :                             WriteError( aTokStm );
     244           0 :                             return false;
     245             :                         }
     246             :                     }
     247         348 :                     if (!ReadIdFile(OStringToOUString(aName.toString(),
     248         348 :                         RTL_TEXTENCODING_ASCII_US)))
     249             :                     {
     250           0 :                         OStringBuffer aStr("cannot read file: ");
     251           0 :                         aStr.append(aName.makeStringAndClear());
     252           0 :                         SetError(aStr.makeStringAndClear(), pTok);
     253           0 :                         WriteError( aTokStm );
     254           0 :                         return false;
     255         174 :                     }
     256             :                 }
     257             :             }
     258             :             else
     259        1828 :                 pTok = aTokStm.GetToken_Next();
     260             :         }
     261             :     }
     262             :     else
     263           0 :         return false;
     264         278 :     return true;
     265             : }
     266             : 
     267       11843 : SvMetaType * SvIdlDataBase::FindType( const SvMetaType * pPType,
     268             :                                     SvMetaTypeMemberList & rList )
     269             : {
     270     1205431 :     for( SvMetaTypeMemberList::const_iterator it = rList.begin(); it != rList.end(); ++it )
     271     1203086 :         if( *it == pPType )
     272        9498 :             return *it;
     273        2345 :     return NULL;
     274             : }
     275             : 
     276        2982 : SvMetaType * SvIdlDataBase::FindType( const OString& rName )
     277             : {
     278       44132 :     for( SvMetaTypeMemberList::const_iterator it = aTypeList.begin(); it != aTypeList.end(); ++it )
     279       44132 :         if( rName.equals((*it)->GetName().getString()) )
     280        2982 :             return *it;
     281           0 :     return NULL;
     282             : }
     283             : 
     284       36854 : SvMetaType * SvIdlDataBase::ReadKnownType( SvTokenStream & rInStm )
     285             : {
     286       36854 :     bool bIn    = false;
     287       36854 :     bool bOut   = false;
     288       36854 :     int nCall0  = CALL_VALUE;
     289       36854 :     int nCall1  = CALL_VALUE;
     290       36854 :     bool bSet   = false; // any attribute set
     291             : 
     292       36854 :     sal_uInt32  nTokPos = rInStm.Tell();
     293       36854 :     SvToken * pTok = rInStm.GetToken_Next();
     294             : 
     295       36854 :     if( pTok->HasHash() )
     296             :     {
     297        1847 :         sal_uInt32 nBeginPos = 0; // can not happen with Tell
     298        5541 :         while( nBeginPos != rInStm.Tell() )
     299             :         {
     300        1847 :             nBeginPos = rInStm.Tell();
     301        1847 :             if( pTok->Is( SvHash_in() ) )
     302             :             {
     303           0 :                 bIn  = true;
     304           0 :                 pTok = rInStm.GetToken_Next();
     305           0 :                 bSet = true;
     306             :             }
     307        1847 :             if( pTok->Is( SvHash_out() ) )
     308             :             {
     309           0 :                 bOut = true;
     310           0 :                 pTok = rInStm.GetToken_Next();
     311           0 :                 bSet = true;
     312             :             }
     313        1847 :             if( pTok->Is( SvHash_inout() ) )
     314             :             {
     315           0 :                 bIn  = true;
     316           0 :                 bOut = true;
     317           0 :                 pTok = rInStm.GetToken_Next();
     318           0 :                 bSet = true;
     319             :             }
     320             :         }
     321             :     }
     322             : 
     323       36854 :     if( pTok->IsIdentifier() )
     324             :     {
     325       31288 :         OString aName = pTok->GetString();
     326       31288 :         SvMetaTypeMemberList & rList = GetTypeList();
     327       31288 :         SvMetaTypeMemberList::const_iterator it = rList.begin();
     328       31288 :         SvMetaType * pType = NULL;
     329     2737461 :         while( it != rList.end() )
     330             :         {
     331     2698033 :             if( (*it)->GetName().getString().equals(aName) )
     332             :             {
     333       23148 :                 pType = *it;
     334       23148 :                 break;
     335             :             }
     336     2674885 :             ++it;
     337             :         }
     338       31288 :         if( pType )
     339             :         {
     340       23148 :             pTok = rInStm.GetToken();
     341       23148 :             if( pTok->IsChar() )
     342             :             {
     343          17 :                 if( pTok->GetChar() == '&' || pTok->GetChar() == '*' )
     344             :                 {
     345           0 :                     nCall0 = (pTok->GetChar() == '&') ? CALL_REFERENCE :
     346           0 :                                                         CALL_POINTER;
     347           0 :                     rInStm.GetToken_Next();
     348           0 :                     pTok = rInStm.GetToken();
     349           0 :                     if( pTok->GetChar() == '&' || pTok->GetChar() == '*' )
     350             :                     {
     351           0 :                         nCall1 = (pTok->GetChar() == '&') ? CALL_REFERENCE :
     352           0 :                                                             CALL_POINTER;
     353           0 :                         rInStm.GetToken_Next();
     354             :                     }
     355           0 :                     bSet = true;
     356             :                 }
     357             :             }
     358             : 
     359       23148 :             if( !bSet )
     360             :                 // is exactly this type
     361       23148 :                 return pType;
     362             : 
     363             :             DBG_ASSERT( aTmpTypeList.front(), "mindestens ein Element" );
     364           0 :             SvMetaTypeRef xType = new SvMetaType( pType->GetName().getString(), 'h', "dummy" );
     365           0 :             xType->SetRef( pType );
     366           0 :             xType->SetIn( bIn );
     367           0 :             xType->SetOut( bOut );
     368           0 :             xType->SetCall0( nCall0 );
     369           0 :             xType->SetCall1( nCall1 );
     370             : 
     371           0 :             aTmpTypeList.push_back( xType );
     372           0 :             return xType;
     373        8140 :         }
     374             :     }
     375       13706 :     rInStm.Seek( nTokPos );
     376       13706 :     return NULL;
     377             : }
     378             : 
     379       12582 : SvMetaAttribute * SvIdlDataBase::ReadKnownAttr
     380             : (
     381             :     SvTokenStream & rInStm,
     382             :     SvMetaType *    pType   /* If pType == NULL, then the type has
     383             :                                still to be read. */
     384             : )
     385             : {
     386       12582 :     sal_uInt32  nTokPos = rInStm.Tell();
     387             : 
     388       12582 :     if( !pType )
     389       12556 :         pType = ReadKnownType( rInStm );
     390             : 
     391       12582 :     if( !pType )
     392             :     {
     393             :         // otherwise SlotId?
     394        4401 :         SvToken * pTok = rInStm.GetToken_Next();
     395        4401 :         if( pTok->IsIdentifier() )
     396             :         {
     397             :             sal_uLong n;
     398        4070 :             if( FindId( pTok->GetString(), &n ) )
     399             :             {
     400     2918649 :                 for( sal_uLong i = 0; i < aAttrList.size(); i++ )
     401             :                 {
     402     2918649 :                     SvMetaAttribute * pAttr = aAttrList[i];
     403     2918649 :                     if( pAttr->GetSlotId().getString().equals(pTok->GetString()) )
     404        4070 :                         return pAttr;
     405             :                 }
     406             :             }
     407             : 
     408           0 :             OStringBuffer aStr("Nicht gefunden : ");
     409           0 :             aStr.append(pTok->GetString());
     410           0 :             OSL_FAIL(aStr.getStr());
     411             :         }
     412             :     }
     413             : 
     414        8512 :     rInStm.Seek( nTokPos );
     415        8512 :     return NULL;
     416             : }
     417             : 
     418        8512 : SvMetaAttribute* SvIdlDataBase::SearchKnownAttr
     419             : (
     420             :     const SvNumberIdentifier& rId
     421             : )
     422             : {
     423             :     sal_uLong n;
     424        8512 :     if( FindId( rId.getString(), &n ) )
     425             :     {
     426     4524267 :         for( sal_uLong i = 0; i < aAttrList.size(); i++ )
     427             :         {
     428     4516161 :             SvMetaAttribute * pAttr = aAttrList[i];
     429     4516161 :             if( pAttr->GetSlotId().getString() == rId.getString() )
     430          49 :                 return pAttr;
     431             :         }
     432             :     }
     433             : 
     434        8463 :     return NULL;
     435             : }
     436             : 
     437         171 : SvMetaClass * SvIdlDataBase::ReadKnownClass( SvTokenStream & rInStm )
     438             : {
     439         171 :     sal_uInt32  nTokPos = rInStm.Tell();
     440         171 :     SvToken * pTok = rInStm.GetToken_Next();
     441             : 
     442         171 :     if( pTok->IsIdentifier() )
     443        3993 :         for( sal_uLong n = 0; n < aClassList.size(); n++ )
     444             :         {
     445        3993 :             SvMetaClass * pClass = aClassList[n];
     446        3993 :             if( pClass->GetName().getString().equals(pTok->GetString()) )
     447         171 :                 return pClass;
     448             :         }
     449             : 
     450           0 :     rInStm.Seek( nTokPos );
     451           0 :     return NULL;
     452             : }
     453             : 
     454        1670 : void SvIdlDataBase::Write(const OString& rText)
     455             : {
     456        1670 :     if( nVerbosity != 0 )
     457           0 :         fprintf( stdout, "%s", rText.getStr() );
     458        1670 : }
     459             : 
     460           0 : void SvIdlDataBase::WriteError( const OString& rErrWrn,
     461             :                                 const OString& rFileName,
     462             :                                 const OString& rErrorText,
     463             :                                 sal_uLong nRow, sal_uLong nColumn )
     464             : {
     465             :     // error treatment
     466             :     fprintf( stderr, "\n%s --- %s: ( %ld, %ld )\n",
     467           0 :              rFileName.getStr(), rErrWrn.getStr(), nRow, nColumn );
     468             : 
     469           0 :     if( !rErrorText.isEmpty() )
     470             :     { // error set
     471           0 :         fprintf( stderr, "\t%s\n", rErrorText.getStr() );
     472             :     }
     473           0 : }
     474             : 
     475           0 : void SvIdlDataBase::WriteError( SvTokenStream & rInStm )
     476             : {
     477             :     // error treatment
     478           0 :     OUString aFileName( rInStm.GetFileName() );
     479           0 :     OStringBuffer aErrorText;
     480           0 :     sal_uLong   nRow = 0, nColumn = 0;
     481             : 
     482           0 :     rInStm.SeekEnd();
     483           0 :     SvToken *pTok = rInStm.GetToken();
     484             : 
     485             :     // error position
     486           0 :     nRow    = pTok->GetLine();
     487           0 :     nColumn = pTok->GetColumn();
     488             : 
     489           0 :     if( aError.IsError() )
     490             :     { // error set
     491             :         // search error token
     492             :         // error text
     493           0 :         if( !aError.GetText().isEmpty() )
     494             :         {
     495           0 :             aErrorText.append("may be <");
     496           0 :             aErrorText.append(aError.GetText());
     497             :         }
     498           0 :         SvToken * pPrevTok = NULL;
     499           0 :         while( pTok != pPrevTok )
     500             :         {
     501           0 :             pPrevTok = pTok;
     502           0 :             if( pTok->GetLine() == aError.nLine
     503           0 :               && pTok->GetColumn() == aError.nColumn )
     504           0 :                 break;
     505           0 :             pTok = rInStm.GetToken_PrevAll();
     506             :         }
     507             : 
     508             :         // error position
     509           0 :         aErrorText.append("> at ( ");
     510           0 :         aErrorText.append(static_cast<sal_Int64>(aError.nLine));
     511           0 :         aErrorText.append(", ");
     512           0 :         aErrorText.append(static_cast<sal_Int64>(aError.nColumn));
     513           0 :         aErrorText.append(" )");
     514             : 
     515             :         // reset error
     516           0 :         aError = SvIdlError();
     517             :     }
     518             : 
     519             :     WriteError("error", OUStringToOString(aFileName,
     520           0 :         RTL_TEXTENCODING_UTF8), aErrorText.makeStringAndClear(), nRow, nColumn);
     521             : 
     522             :     DBG_ASSERT( pTok, "token must be found" );
     523           0 :     if( !pTok )
     524           0 :         return;
     525             : 
     526             :     // look for identifier close by
     527           0 :     if( !pTok->IsIdentifier() )
     528             :     {
     529           0 :         rInStm.GetToken_PrevAll();
     530           0 :         pTok = rInStm.GetToken();
     531             :     }
     532           0 :     if( pTok && pTok->IsIdentifier() )
     533             :     {
     534           0 :         OString aN = IDLAPP->pHashTable->GetNearString( pTok->GetString() );
     535           0 :         if( !aN.isEmpty() )
     536           0 :             fprintf( stderr, "%s versus %s\n", pTok->GetString().getStr(), aN.getStr() );
     537           0 :     }
     538             : }
     539             : 
     540           8 : SvIdlWorkingBase::SvIdlWorkingBase(const SvCommand& rCmd) : SvIdlDataBase(rCmd)
     541             : {
     542           8 : }
     543             : 
     544           8 : bool SvIdlWorkingBase::ReadSvIdl( SvTokenStream & rInStm, bool bImported, const OUString & rPath )
     545             : {
     546           8 :     aPath = rPath; // only valid for this iteration
     547           8 :     bool bOk = true;
     548           8 :     SvToken * pTok = rInStm.GetToken();
     549             :     // only one import at the very beginning
     550           8 :     if( pTok->Is( SvHash_import() ) )
     551             :     {
     552           0 :         rInStm.GetToken_Next();
     553           0 :         bOk = rInStm.Read( '(' ); // optional
     554           0 :         pTok = bOk ? rInStm.GetToken_Next() : NULL;
     555           0 :         if( pTok && pTok->IsString() )
     556             :         {
     557           0 :             OUString aFullName;
     558           0 :             if( osl::FileBase::E_None == osl::File::searchFileURL(
     559           0 :                 OStringToOUString(pTok->GetString(), RTL_TEXTENCODING_ASCII_US),
     560             :                 rPath,
     561           0 :                 aFullName) )
     562             :             {
     563           0 :                 osl::FileBase::getSystemPathFromFileURL( aFullName, aFullName );
     564           0 :                 this->AddDepFile(aFullName);
     565           0 :                 SvFileStream aStm( aFullName, STREAM_STD_READ | StreamMode::NOCREATE );
     566           0 :                 SvTokenStream aTokStm( aStm, aFullName );
     567           0 :                 bOk = ReadSvIdl( aTokStm, true, rPath );
     568             :             }
     569             :             else
     570           0 :                 bOk = false;
     571             :         }
     572             :         else
     573           0 :             bOk = false;
     574             :     }
     575             : 
     576           8 :     sal_uInt32 nBeginPos = 0xFFFFFFFF; // can not happen with Tell
     577             : 
     578          24 :     while( bOk && nBeginPos != rInStm.Tell() )
     579             :     {
     580          16 :         nBeginPos = rInStm.Tell();
     581          16 :         pTok = rInStm.GetToken();
     582          16 :         if( pTok->IsEof() )
     583           8 :             return true;
     584           8 :         if( pTok->IsEmpty() )
     585           0 :             bOk = false;
     586             : 
     587             :         // only one import at the very beginning
     588           8 :         if( pTok->Is( SvHash_module() ) )
     589             :         {
     590           8 :             SvMetaModuleRef aModule = new SvMetaModule( rInStm.GetFileName(), bImported );
     591           8 :             if( aModule->ReadSvIdl( *this, rInStm ) )
     592           8 :                 GetModuleList().push_back( aModule );
     593             :             else
     594           0 :                 bOk = false;
     595             :         }
     596             :         else
     597           0 :             bOk = false;
     598             :     }
     599           0 :     if( !bOk || !pTok->IsEof() )
     600             :     {
     601             :          // error treatment
     602           0 :          WriteError( rInStm );
     603           0 :          return false;
     604             :     }
     605           0 :     return true;
     606             : }
     607             : 
     608           8 : bool SvIdlWorkingBase::WriteSfx( SvStream & rOutStm )
     609             : {
     610           8 :     if( rOutStm.GetError() != SVSTREAM_OK )
     611           0 :         return false;
     612             : 
     613             :     // reset all tmp variables for writing
     614           8 :     WriteReset();
     615           8 :     SvMemoryStream aTmpStm( 256000, 256000 );
     616             :     sal_uLong n;
     617          16 :     for( n = 0; n < GetModuleList().size(); n++ )
     618             :     {
     619           8 :         SvMetaModule * pModule = GetModuleList()[n];
     620           8 :         if( !pModule->IsImported() )
     621           8 :             pModule->WriteSfx( *this, aTmpStm );
     622           8 :         aTmpStm.Seek( 0 );
     623             :     }
     624        2353 :     for( n = 0; n < aUsedTypes.size(); n++ )
     625             :     {
     626        2345 :         SvMetaType * pType = aUsedTypes[n];
     627        2345 :         pType->WriteSfx( *this, rOutStm );
     628             :     }
     629           8 :     aUsedTypes.clear();
     630           8 :     rOutStm.WriteStream( aTmpStm );
     631           8 :     return true;
     632             : }
     633             : 
     634         133 : void SvIdlDataBase::StartNewFile( const OUString& rName )
     635             : {
     636         133 :     bExport = ( aExportFile.equalsIgnoreAsciiCase( rName ) );
     637         133 : }
     638             : 
     639        8129 : void SvIdlDataBase::AppendAttr( SvMetaAttribute *pAttr )
     640             : {
     641        8129 :     aAttrList.push_back( pAttr );
     642        8129 :     if ( bExport )
     643           0 :         pAttr->SetNewAttribute( true );
     644        8129 : }
     645             : 
     646         234 : void SvIdlDataBase::AddDepFile(OUString const& rFileName)
     647             : {
     648         234 :     m_DepFiles.insert(rFileName);
     649         234 : }
     650             : 
     651             : struct WriteDep
     652             : {
     653             :     SvFileStream & m_rStream;
     654           8 :     explicit WriteDep(SvFileStream & rStream) : m_rStream(rStream) { }
     655         234 :     void operator() (OUString const& rItem)
     656             :     {
     657         234 :         m_rStream.WriteCharPtr( " \\\n " );
     658         234 :         m_rStream.WriteCharPtr( OUStringToOString(rItem, RTL_TEXTENCODING_UTF8).getStr() );
     659         234 :     }
     660             : };
     661             : 
     662             : // write a dummy target for one included file, so the incremental build does
     663             : // not break with "No rule to make target" if the included file is removed
     664             : struct WriteDummy
     665             : {
     666             :     SvFileStream & m_rStream;
     667           8 :     explicit WriteDummy(SvFileStream & rStream) : m_rStream(rStream) { }
     668         234 :     void operator() (OUString const& rItem)
     669             :     {
     670         234 :         m_rStream.WriteCharPtr( OUStringToOString(rItem, RTL_TEXTENCODING_UTF8).getStr() );
     671         234 :         m_rStream.WriteCharPtr( " :\n\n" );
     672         234 :     }
     673             : };
     674             : 
     675           8 : bool SvIdlDataBase::WriteDepFile(
     676             :         SvFileStream & rStream, OUString const& rTarget)
     677             : {
     678           8 :     rStream.WriteCharPtr( OUStringToOString(rTarget, RTL_TEXTENCODING_UTF8).getStr() );
     679           8 :     rStream.WriteCharPtr( " :" );
     680           8 :     ::std::for_each(m_DepFiles.begin(), m_DepFiles.end(), WriteDep(rStream));
     681           8 :     rStream.WriteCharPtr( "\n\n" );
     682           8 :     ::std::for_each(m_DepFiles.begin(), m_DepFiles.end(), WriteDummy(rStream));
     683           8 :     return rStream.GetError() == SVSTREAM_OK;
     684             : }
     685             : 
     686             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11