idl/source/prj/parser.cxx

   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 #include <sal/config.h>
  21
  22 #include <algorithm>
  23
  24 #include <parser.hxx>
  25 #include <database.hxx>
  26 #include <globals.hxx>
  27 #include <osl/file.hxx>
  28
  29 void SvIdlParser::ReadSvIdl( const OUString & rPath )
  30 {
  31     rBase.SetPath(rPath); // only valid for this iteration
  32     SvToken& rTok = rInStm.GetToken();
  33
  34     while( true )
  35     {
  36         rTok = rInStm.GetToken();
  37         if( rTok.IsEof() )
  38             return;
  39
  40         Read( SvHash_module() );
  41         tools::SvRef<SvMetaModule> aModule = new SvMetaModule;
  42         ReadModuleHeader(*aModule);
  43         rBase.GetModuleList().push_back( aModule.get() );
  44     }
  45 }
  46
  47 void SvIdlParser::ReadModuleHeader(SvMetaModule& rModule)
  48 {
  49     OString aName = ReadIdentifier();
  50     rModule.SetName( aName );
  51     rBase.Push( &rModule ); // onto the context stack
  52     ReadModuleBody(rModule);
  53     rBase.GetStack().pop_back(); // remove from stack
  54 }
  55
  56 void SvIdlParser::ReadModuleBody(SvMetaModule& rModule)
  57 {
  58     if( ReadIf( '[' ) )
  59     {
  60         while( true )
  61         {
  62             OString aSlotIdFile;
  63             if( !ReadStringSvIdl( SvHash_SlotIdFile(), rInStm, aSlotIdFile ) )
  64                 break;
  65             if( !rBase.ReadIdFile( aSlotIdFile ) )
  66             {
  67                 throw SvParseException( rInStm, "cannot read file: " + aSlotIdFile );
  68             }
  69             ReadIfDelimiter();
  70         }
  71         Read( ']' );
  72     }
  73
  74     if( !ReadIf( '{' ) )
  75         return;
  76
  77     sal_uInt32 nBeginPos = 0;
  78     while( nBeginPos != rInStm.Tell() )
  79     {
  80         nBeginPos = rInStm.Tell();
  81         ReadModuleElement( rModule );
  82         ReadIfDelimiter();
  83     }
  84     Read( '}' );
  85 }
  86
  87 void SvIdlParser::ReadModuleElement( SvMetaModule& rModule )
  88 {
  89     if( ReadIf( SvHash_interface() ) )
  90     {
  91         ReadInterfaceOrShell(rModule, MetaTypeType::Interface);
  92     }
  93     else if( ReadIf( SvHash_shell() ) )
  94     {
  95         ReadInterfaceOrShell(rModule, MetaTypeType::Shell);
  96     }
  97     else if( ReadIf( SvHash_enum() ) )
  98     {
  99         ReadEnum();
 100     }
 101     else if( ReadIf( SvHash_item() ) )
 102     {
 103         ReadItem();
 104     }
 105     else if( ReadIf( SvHash_struct() ) )
 106     {
 107         ReadStruct();
 108     }
 109     else if( ReadIf( SvHash_include() ) )
 110     {
 111         ReadInclude(rModule);
 112     }
 113     else
 114     {
 115         tools::SvRef<SvMetaSlot> xSlot( new SvMetaSlot() );
 116
 117         if (ReadSlot(*xSlot))
 118         {
 119             if( xSlot->Test( rInStm ) )
 120             {
 121                 // announce globally
 122                 rBase.AppendSlot( xSlot.get() );
 123             }
 124         }
 125     }
 126 }
 127
 128 void SvIdlParser::ReadInclude( SvMetaModule& rModule )
 129 {
 130     sal_uInt32  nTokPos = rInStm.Tell();
 131     bool bOk = false;
 132     OUString aFullName(OStringToOUString(ReadString(), RTL_TEXTENCODING_ASCII_US));
 133     rBase.StartNewFile( aFullName );
 134     osl::FileBase::RC searchError = osl::File::searchFileURL(aFullName, rBase.GetPath(), aFullName);
 135     if( osl::FileBase::E_None != searchError )
 136     {
 137         OString aStr = "cannot find file:" +
 138             OUStringToOString(aFullName, RTL_TEXTENCODING_UTF8);
 139         throw SvParseException(aStr, rInStm.GetToken());
 140     }
 141     osl::FileBase::getSystemPathFromFileURL( aFullName, aFullName );
 142     rBase.AddDepFile( aFullName );
 143     SvTokenStream aTokStm( aFullName );
 144     if( ERRCODE_NONE != aTokStm.GetStream().GetError() )
 145     {
 146         OString aStr = "cannot open file: " +
 147             OUStringToOString(aFullName, RTL_TEXTENCODING_UTF8);
 148         throw SvParseException(aStr, rInStm.GetToken());
 149     }
 150     // rescue error from old file
 151     SvIdlError aOldErr = rBase.GetError();
 152     // reset error
 153     rBase.SetError( SvIdlError() );
 154
 155     try {
 156         SvIdlParser aIncludeParser( rBase, aTokStm );
 157         sal_uInt32 nBeginPos = 0xFFFFFFFF; // can not happen with Tell
 158         while( nBeginPos != aTokStm.Tell() )
 159         {
 160             nBeginPos = aTokStm.Tell();
 161             aIncludeParser.ReadModuleElement(rModule);
 162             aTokStm.ReadIfDelimiter();
 163         }
 164     } catch (const SvParseException& ex) {
 165         rBase.SetError(ex.aError);
 166         rBase.WriteError(aTokStm);
 167     }
 168     bOk = aTokStm.GetToken().IsEof();
 169     if( !bOk )
 170     {
 171         rBase.WriteError( aTokStm );
 172     }
 173     // recover error from old file
 174     rBase.SetError( aOldErr );
 175     if( !bOk )
 176         rInStm.Seek( nTokPos );
 177 }
 178
 179 void SvIdlParser::ReadStruct()
 180 {
 181     tools::SvRef<SvMetaType> xStruct(new SvMetaType() );
 182     xStruct->SetType( MetaTypeType::Struct );
 183     xStruct->SetName( ReadIdentifier() );
 184     Read( '{' );
 185     while( true )
 186     {
 187         tools::SvRef<SvMetaAttribute> xAttr( new SvMetaAttribute() );
 188         xAttr->aType = ReadKnownType();
 189         xAttr->SetName(ReadIdentifier());
 190         xAttr->aSlotId.setString(ReadIdentifier());
 191         sal_uLong n;
 192         if( !rBase.FindId( xAttr->aSlotId.getString(), &n ) )
 193             throw SvParseException( rInStm, "no value for identifier <" + xAttr->aSlotId.getString() + "> " );
 194         xAttr->aSlotId.SetValue(n);
 195         xStruct->GetAttrList().push_back( xAttr.get() );
 196         if( !ReadIfDelimiter() )
 197             break;
 198         if( rInStm.GetToken().IsChar() && rInStm.GetToken().GetChar() == '}')
 199             break;
 200     }
 201     Read( '}' );
 202     ReadDelimiter();
 203     // announce globally
 204     rBase.GetTypeList().push_back( xStruct.get() );
 205 }
 206
 207 void SvIdlParser::ReadItem()
 208 {
 209     tools::SvRef<SvMetaType> xItem(new SvMetaType() );
 210     xItem->SetItem(true);
 211     xItem->SetRef( ReadKnownType() );
 212     xItem->SetName( ReadIdentifier() );
 213     // announce globally
 214     rBase.GetTypeList().push_back( xItem.get() );
 215 }
 216
 217 void SvIdlParser::ReadEnum()
 218 {
 219     tools::SvRef<SvMetaTypeEnum> xEnum( new SvMetaTypeEnum() );
 220     xEnum->SetType( MetaTypeType::Enum );
 221     xEnum->SetName( ReadIdentifier() );
 222
 223     Read('{');
 224     while( true )
 225     {
 226         ReadEnumValue( *xEnum );
 227         if( !ReadIfDelimiter() )
 228             break;
 229     }
 230     Read( '}' );
 231     // announce globally
 232     rBase.GetTypeList().push_back( xEnum.get() );
 233 }
 234
 235 static OString getCommonSubPrefix(const OString &rA, const OString &rB)
 236 {
 237     sal_Int32 nMax = std::min(rA.getLength(), rB.getLength());
 238     sal_Int32 nI = 0;
 239     while (nI < nMax)
 240     {
 241         if (rA[nI] != rB[nI])
 242             break;
 243         ++nI;
 244     }
 245     return rA.copy(0, nI);
 246 }
 247
 248 void SvIdlParser::ReadEnumValue( SvMetaTypeEnum& rEnum )
 249 {
 250     tools::SvRef<SvMetaEnumValue> aEnumVal = new SvMetaEnumValue();
 251     aEnumVal->SetName( ReadIdentifier() );
 252     if( rEnum.aEnumValueList.empty() )
 253     {
 254        // the first
 255        rEnum.aPrefix = aEnumVal->GetName();
 256     }
 257     else
 258     {
 259         rEnum.aPrefix = getCommonSubPrefix(rEnum.aPrefix, aEnumVal->GetName());
 260     }
 261     rEnum.aEnumValueList.push_back( aEnumVal.get() );
 262 }
 263
 264 void SvIdlParser::ReadInterfaceOrShell( SvMetaModule& rModule, MetaTypeType aMetaTypeType )
 265 {
 266     tools::SvRef<SvMetaClass> aClass( new SvMetaClass() );
 267
 268     aClass->SetType( aMetaTypeType );
 269
 270     aClass->SetName( ReadIdentifier() );
 271
 272     if( ReadIf( ':' ) )
 273     {
 274         aClass->aSuperClass = ReadKnownClass();
 275     }
 276     if( ReadIf( '{' ) )
 277     {
 278         sal_uInt32 nBeginPos = 0; // can not happen with Tell
 279         while( nBeginPos != rInStm.Tell() )
 280         {
 281             nBeginPos = rInStm.Tell();
 282             ReadInterfaceOrShellEntry(*aClass);
 283             ReadIfDelimiter();
 284         }
 285         Read( '}' );
 286     }
 287     rModule.aClassList.push_back( aClass.get() );
 288     // announce globally
 289     rBase.GetClassList().push_back( aClass.get() );
 290 }
 291
 292 void SvIdlParser::ReadInterfaceOrShellEntry(SvMetaClass& rClass)
 293 {
 294     if( ReadIf( SvHash_import() ) )
 295     {
 296         SvMetaClass * pClass = ReadKnownClass();
 297         SvClassElement aEle(pClass);
 298         SvToken& rTok = rInStm.GetToken();
 299         if( rTok.IsString() )
 300         {
 301             aEle.SetPrefix( rTok.GetString() );
 302             rInStm.GetToken_Next();
 303         }
 304         rClass.aClassElementList.push_back( aEle );
 305     }
 306     else
 307     {
 308         SvMetaType * pType = rBase.ReadKnownType( rInStm );
 309         tools::SvRef<SvMetaAttribute> xAttr;
 310         bool bOk = false;
 311         if( !pType || pType->IsItem() )
 312         {
 313             xAttr = new SvMetaSlot( pType );
 314             bOk = ReadSlot(static_cast<SvMetaSlot&>(*xAttr));
 315         }
 316         else
 317         {
 318             xAttr = new SvMetaAttribute( pType );
 319             ReadInterfaceOrShellMethod(*xAttr);
 320             bOk = true;
 321         }
 322         if( bOk )
 323             bOk = xAttr->Test( rInStm );
 324         if( bOk )
 325             bOk = rClass.TestAttribute( rBase, rInStm, *xAttr );
 326         if( bOk )
 327         {
 328             if( !xAttr->GetSlotId().IsSet() )
 329                 xAttr->SetSlotId( SvIdentifier(rBase.GetUniqueId()) );
 330             rClass.aAttrList.push_back( xAttr.get() );
 331         }
 332     }
 333 }
 334
 335 bool SvIdlParser::ReadSlot(SvMetaSlot& rSlot)
 336 {
 337     sal_uInt32  nTokPos = rInStm.Tell();
 338     bool        bOk     = true;
 339
 340     SvMetaAttribute * pAttr = rBase.ReadKnownAttr( rInStm, rSlot.GetType() );
 341     if( pAttr )
 342     {
 343         SvMetaSlot * pKnownSlot = dynamic_cast<SvMetaSlot*>( pAttr );
 344         if( !pKnownSlot )
 345             throw SvParseException( rInStm, "attribute " + pAttr->GetName() + " is method or variable but not a slot" );
 346         rSlot.SetRef( pKnownSlot );
 347         rSlot.SetName( pKnownSlot->GetName() );
 348         if( ReadIf( '[' ) )
 349         {
 350             sal_uInt32 nBeginPos = 0; // can not happen with Tell
 351             while( nBeginPos != rInStm.Tell() )
 352             {
 353                 nBeginPos = rInStm.Tell();
 354                 ReadSlotAttribute(rSlot);
 355                 ReadIfDelimiter();
 356             }
 357             Read( ']' );
 358         }
 359     }
 360     else
 361     {
 362         bOk = rSlot.SvMetaAttribute::ReadSvIdl( rBase, rInStm );
 363         SvMetaAttribute *pAttr2 = rBase.FindKnownAttr( rSlot.GetSlotId() );
 364         if( pAttr2 )
 365         {
 366             SvMetaSlot * pKnownSlot = dynamic_cast<SvMetaSlot*>( pAttr2 );
 367             if( !pKnownSlot )
 368                 throw SvParseException( rInStm, "attribute " + pAttr2->GetName() + " is method or variable but not a slot" );
 369             rSlot.SetRef( pKnownSlot );
 370             // names may differ, because explicitly given
 371             if ( pKnownSlot->GetName() != rSlot.GetName() )
 372                 throw SvParseException( rInStm, "Illegal definition!" );
 373         }
 374     }
 375
 376     if( !bOk )
 377         rInStm.Seek( nTokPos );
 378
 379     return bOk;
 380 }
 381
 382 void SvIdlParser::ReadSlotAttribute( SvMetaSlot& rSlot )
 383 {
 384     ReadIfIdAttribute(rSlot.aGroupId, SvHash_GroupId() );
 385     ReadIfIdAttribute(rSlot.aExecMethod, SvHash_ExecMethod() );
 386     ReadIfIdAttribute(rSlot.aStateMethod, SvHash_StateMethod() );
 387     ReadStringSvIdl( SvHash_DisableFlags(), rInStm, rSlot.aDisableFlags );
 388     ReadIfBoolAttribute(rSlot.aReadOnlyDoc, SvHash_ReadOnlyDoc() );
 389     ReadIfBoolAttribute(rSlot.aExport, SvHash_Export() );
 390
 391     ReadIfBoolAttribute(rSlot.aToggle, SvHash_Toggle() );
 392     ReadIfBoolAttribute(rSlot.aAutoUpdate, SvHash_AutoUpdate() );
 393     ReadIfBoolAttribute(rSlot.aAsynchron, SvHash_Asynchron() );
 394     ReadIfBoolAttribute(rSlot.aRecordAbsolute, SvHash_RecordAbsolute() );
 395
 396     if( ReadIfBoolAttribute(rSlot.aRecordPerItem, SvHash_RecordPerItem()) )
 397     {
 398         if (rSlot.aRecordPerSet.IsSet() || rSlot.aNoRecord.IsSet())
 399             throw SvParseException(rInStm, "conflicting attributes");
 400         rSlot.SetRecordPerItem( rSlot.aRecordPerItem );
 401     }
 402     if( ReadIfBoolAttribute(rSlot.aRecordPerSet, SvHash_RecordPerSet() ) )
 403     {
 404         if (rSlot.aRecordPerItem.IsSet() || rSlot.aNoRecord.IsSet())
 405             throw SvParseException(rInStm, "conflicting attributes");
 406         rSlot.SetRecordPerSet( rSlot.aRecordPerSet );
 407     }
 408     if( ReadIfBoolAttribute(rSlot.aNoRecord, SvHash_NoRecord() ) )
 409     {
 410         if (rSlot.aRecordPerItem.IsSet() || rSlot.aRecordPerSet.IsSet())
 411             throw SvParseException(rInStm, "conflicting attributes");
 412         rSlot.SetNoRecord( rSlot.aNoRecord );
 413     }
 414
 415     ReadIfBoolAttribute(rSlot.aMenuConfig, SvHash_MenuConfig() );
 416     ReadIfBoolAttribute(rSlot.aToolBoxConfig, SvHash_ToolBoxConfig() );
 417     ReadIfBoolAttribute(rSlot.aAccelConfig, SvHash_AccelConfig() );
 418
 419     ReadIfBoolAttribute(rSlot.aFastCall, SvHash_FastCall() );
 420     ReadIfBoolAttribute(rSlot.aContainer, SvHash_Container() );
 421 }
 422
 423 void SvIdlParser::ReadInterfaceOrShellMethod( SvMetaAttribute& rAttr )
 424 {
 425     rAttr.SetName( ReadIdentifier() );
 426     ReadSlotId( rAttr.aSlotId );
 427
 428     // read method arguments
 429     Read( '(' );
 430     tools::SvRef<SvMetaType> xT(new SvMetaType() );
 431     xT->SetRef(rAttr.GetType() );
 432     rAttr.aType = xT;
 433     rAttr.aType->SetType( MetaTypeType::Method );
 434     if (!ReadIf(')'))
 435     {
 436         while (true)
 437         {
 438             tools::SvRef<SvMetaAttribute> xParamAttr( new SvMetaAttribute() );
 439             xParamAttr->aType = ReadKnownType();
 440             xParamAttr->SetName( ReadIdentifier() );
 441             ReadSlotId(xParamAttr->aSlotId);
 442             rAttr.aType->GetAttrList().push_back( xParamAttr.get() );
 443             if (!ReadIfDelimiter())
 444                 break;
 445         }
 446         Read(')');
 447     }
 448 }
 449
 450 void SvIdlParser::ReadSlotId(SvIdentifier& rSlotId)
 451 {
 452     rSlotId.setString( ReadIdentifier() );
 453     sal_uLong n;
 454     if( !rBase.FindId( rSlotId.getString(), &n ) )
 455         throw SvParseException( rInStm, "no value for identifier <" + rSlotId.getString() + "> " );
 456     rSlotId.SetValue(n);
 457 }
 458
 459 SvMetaClass * SvIdlParser::ReadKnownClass()
 460 {
 461     OString aName(ReadIdentifier());
 462     SvMetaClass* pClass = rBase.FindKnownClass( aName );
 463     if( !pClass )
 464         throw SvParseException( rInStm, "unknown class" );
 465     return pClass;
 466 }
 467
 468 SvMetaType * SvIdlParser::ReadKnownType()
 469 {
 470     OString aName = ReadIdentifier();
 471     for( const auto& aType : rBase.GetTypeList() )
 472     {
 473         if( aType->GetName() == aName )
 474             return aType;
 475     }
 476     throw SvParseException( rInStm, "wrong typedef: ");
 477 }
 478
 479 bool SvIdlParser::ReadIfBoolAttribute( SvBOOL& rBool, SvStringHashEntry const * pName )
 480 {
 481     sal_uInt32 nTokPos = rInStm.Tell();
 482     SvToken& rTok = rInStm.GetToken_Next();
 483
 484     if( rTok.Is( pName ) )
 485     {
 486         if( rInStm.ReadIf( '=' ) )
 487         {
 488             rTok = rInStm.GetToken();
 489             if( !rTok.IsBool() )
 490                 throw SvParseException(rInStm, "xxx");
 491             rBool = rTok.GetBool();
 492             rInStm.GetToken_Next();
 493         }
 494         else
 495             rBool = true; //default action set to TRUE
 496         return true;
 497     }
 498     rInStm.Seek( nTokPos );
 499     return false;
 500 }
 501
 502 void SvIdlParser::ReadIfIdAttribute( SvIdentifier& rIdentifier, SvStringHashEntry const * pName )
 503 {
 504     sal_uInt32 nTokPos = rInStm.Tell();
 505     SvToken& rTok = rInStm.GetToken_Next();
 506
 507     if( rTok.Is( pName ) )
 508     {
 509         if( rInStm.ReadIf( '=' ) )
 510         {
 511             rTok = rInStm.GetToken();
 512             if( !rTok.IsIdentifier() )
 513                 throw SvParseException(rInStm, "expected identifier");
 514             rIdentifier.setString(rTok.GetString());
 515             rInStm.GetToken_Next();
 516         }
 517     }
 518     else
 519         rInStm.Seek( nTokPos );
 520 }
 521
 522 void SvIdlParser::ReadDelimiter()
 523 {
 524     if( !ReadIfDelimiter() )
 525         throw SvParseException(rInStm, "expected delimiter");
 526 }
 527
 528 bool SvIdlParser::ReadIfDelimiter()
 529 {
 530     if( rInStm.GetToken().IsChar()
 531         && (';' == rInStm.GetToken().GetChar()
 532              || ',' == rInStm.GetToken().GetChar()) )
 533     {
 534         rInStm.GetToken_Next();
 535         return true;
 536     }
 537     return false;
 538 }
 539
 540 OString SvIdlParser::ReadIdentifier()
 541 {
 542     SvToken& rTok = rInStm.GetToken();
 543     if( !rTok.IsIdentifier() )
 544         throw SvParseException("expected identifier", rTok);
 545     rInStm.GetToken_Next();
 546     return rTok.GetString();
 547 }
 548
 549 OString SvIdlParser::ReadString()
 550 {
 551     SvToken& rTok = rInStm.GetToken();
 552     if( !rTok.IsString() )
 553         throw SvParseException("expected string", rTok);
 554     rInStm.GetToken_Next();
 555     return rTok.GetString();
 556 }
 557
 558 void SvIdlParser::Read(char cChar)
 559 {
 560     if( !ReadIf(cChar) )
 561         throw SvParseException(rInStm, "expected char '" + OStringChar(cChar) + "'");
 562 }
 563
 564 bool SvIdlParser::ReadIf(char cChar)
 565 {
 566     if( rInStm.GetToken().IsChar() && rInStm.GetToken().GetChar() == cChar )
 567     {
 568         rInStm.GetToken_Next();
 569         return true;
 570     }
 571     return false;
 572 }
 573
 574 void SvIdlParser::Read(SvStringHashEntry const * entry)
 575 {
 576     if( !rInStm.GetToken().Is(entry) )
 577         throw SvParseException("expected " + entry->GetName(), rInStm.GetToken());
 578     rInStm.GetToken_Next();
 579 }
 580
 581 bool SvIdlParser::ReadIf(SvStringHashEntry const * entry)
 582 {
 583     if( rInStm.GetToken().Is(entry) )
 584     {
 585         rInStm.GetToken_Next();
 586         return true;
 587     }
 588     return false;
 589 }
 590 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */