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 <slot.hxx>
  28 #include <osl/file.hxx>
  29
  30 void SvIdlParser::ReadSvIdl( const OUString & rPath )
  31 {
  32     rBase.SetPath(rPath); // only valid for this iteration
  33     SvToken& rTok = rInStm.GetToken();
  34
  35     while( true )
  36     {
  37         rTok = rInStm.GetToken();
  38         if( rTok.IsEof() )
  39             return;
  40
  41         Read( SvHash_module() );
  42         tools::SvRef<SvMetaModule> aModule = new SvMetaModule;
  43         ReadModuleHeader(*aModule);
  44         rBase.GetModuleList().push_back( aModule.get() );
  45     }
  46 }
  47
  48 void SvIdlParser::ReadModuleHeader(SvMetaModule& rModule)
  49 {
  50     OString aName = ReadIdentifier();
  51     rModule.SetName( aName );
  52     rBase.Push( &rModule ); // onto the context stack
  53     ReadModuleBody(rModule);
  54     rBase.GetStack().pop_back(); // remove from stack
  55 }
  56
  57 void SvIdlParser::ReadModuleBody(SvMetaModule& rModule)
  58 {
  59     if( ReadIf( '[' ) )
  60     {
  61         while( true )
  62         {
  63             OString aSlotIdFile;
  64             if( !ReadStringSvIdl( SvHash_SlotIdFile(), rInStm, aSlotIdFile ) )
  65                 break;
  66             if( !rBase.ReadIdFile( aSlotIdFile ) )
  67             {
  68                 throw SvParseException( rInStm, "cannot read file: " + aSlotIdFile );
  69             }
  70             ReadIfDelimiter();
  71         }
  72         Read( ']' );
  73     }
  74
  75     if( !ReadIf( '{' ) )
  76         return;
  77
  78     sal_uInt32 nBeginPos = 0;
  79     while( nBeginPos != rInStm.Tell() )
  80     {
  81         nBeginPos = rInStm.Tell();
  82         ReadModuleElement( rModule );
  83         ReadIfDelimiter();
  84     }
  85     Read( '}' );
  86 }
  87
  88 void SvIdlParser::ReadModuleElement( SvMetaModule& rModule )
  89 {
  90     if( ReadIf( SvHash_interface() ) )
  91     {
  92         ReadInterfaceOrShell(rModule, MetaTypeType::Interface);
  93     }
  94     else if( ReadIf( SvHash_shell() ) )
  95     {
  96         ReadInterfaceOrShell(rModule, MetaTypeType::Shell);
  97     }
  98     else if( ReadIf( SvHash_enum() ) )
  99     {
 100         ReadEnum();
 101     }
 102     else if( ReadIf( SvHash_item() ) )
 103     {
 104         ReadItem();
 105     }
 106     else if( ReadIf( SvHash_struct() ) )
 107     {
 108         ReadStruct();
 109     }
 110     else if( ReadIf( SvHash_include() ) )
 111     {
 112         ReadInclude(rModule);
 113     }
 114     else
 115     {
 116         tools::SvRef<SvMetaSlot> xSlot( new SvMetaSlot() );
 117
 118         if (ReadSlot(*xSlot))
 119         {
 120             if( xSlot->Test( rInStm ) )
 121             {
 122                 // announce globally
 123                 rBase.AppendSlot( xSlot.get() );
 124             }
 125         }
 126     }
 127 }
 128
 129 void SvIdlParser::ReadInclude( SvMetaModule& rModule )
 130 {
 131     sal_uInt32  nTokPos = rInStm.Tell();
 132     bool bOk = false;
 133     OUString aFullName(OStringToOUString(ReadString(), RTL_TEXTENCODING_ASCII_US));
 134     rBase.StartNewFile( aFullName );
 135     osl::FileBase::RC searchError = osl::File::searchFileURL(aFullName, rBase.GetPath(), aFullName);
 136     if( osl::FileBase::E_None != searchError )
 137     {
 138         OString aStr = "cannot find file:" +
 139             OUStringToOString(aFullName, RTL_TEXTENCODING_UTF8);
 140         throw SvParseException(aStr, rInStm.GetToken());
 141     }
 142     osl::FileBase::getSystemPathFromFileURL( aFullName, aFullName );
 143     rBase.AddDepFile( aFullName );
 144     SvTokenStream aTokStm( aFullName );
 145     if( ERRCODE_NONE != aTokStm.GetStream().GetError() )
 146     {
 147         OString aStr = "cannot open file: " +
 148             OUStringToOString(aFullName, RTL_TEXTENCODING_UTF8);
 149         throw SvParseException(aStr, rInStm.GetToken());
 150     }
 151     // rescue error from old file
 152     SvIdlError aOldErr = rBase.GetError();
 153     // reset error
 154     rBase.SetError( SvIdlError() );
 155
 156     try {
 157         SvIdlParser aIncludeParser( rBase, aTokStm );
 158         sal_uInt32 nBeginPos = 0xFFFFFFFF; // can not happen with Tell
 159         while( nBeginPos != aTokStm.Tell() )
 160         {
 161             nBeginPos = aTokStm.Tell();
 162             aIncludeParser.ReadModuleElement(rModule);
 163             aTokStm.ReadIfDelimiter();
 164         }
 165     } catch (const SvParseException& ex) {
 166         rBase.SetError(ex.aError);
 167         rBase.WriteError(aTokStm);
 168     }
 169     bOk = aTokStm.GetToken().IsEof();
 170     if( !bOk )
 171     {
 172         rBase.WriteError( aTokStm );
 173     }
 174     // recover error from old file
 175     rBase.SetError( aOldErr );
 176     if( !bOk )
 177         rInStm.Seek( nTokPos );
 178 }
 179
 180 void SvIdlParser::ReadStruct()
 181 {
 182     tools::SvRef<SvMetaType> xStruct(new SvMetaType() );
 183     xStruct->SetType( MetaTypeType::Struct );
 184     xStruct->SetName( ReadIdentifier() );
 185     Read( '{' );
 186     while( true )
 187     {
 188         tools::SvRef<SvMetaAttribute> xAttr( new SvMetaAttribute() );
 189         xAttr->aType = ReadKnownType();
 190         xAttr->SetName(ReadIdentifier());
 191         xAttr->aSlotId.setString(ReadIdentifier());
 192         sal_uInt32 n;
 193         if( !rBase.FindId( xAttr->aSlotId.getString(), &n ) )
 194             throw SvParseException( rInStm, "no value for identifier <" + xAttr->aSlotId.getString() + "> " );
 195         xAttr->aSlotId.SetValue(n);
 196         xStruct->GetAttrList().push_back( xAttr.get() );
 197         if( !ReadIfDelimiter() )
 198             break;
 199         if( rInStm.GetToken().IsChar() && rInStm.GetToken().GetChar() == '}')
 200             break;
 201     }
 202     Read( '}' );
 203     ReadDelimiter();
 204     // announce globally
 205     rBase.GetTypeList().push_back( xStruct.get() );
 206 }
 207
 208 void SvIdlParser::ReadItem()
 209 {
 210     tools::SvRef<SvMetaType> xItem(new SvMetaType() );
 211     xItem->SetItem(true);
 212     xItem->SetRef( ReadKnownType() );
 213     xItem->SetName( ReadIdentifier() );
 214     // announce globally
 215     rBase.GetTypeList().push_back( xItem.get() );
 216 }
 217
 218 void SvIdlParser::ReadEnum()
 219 {
 220     tools::SvRef<SvMetaTypeEnum> xEnum( new SvMetaTypeEnum() );
 221     xEnum->SetType( MetaTypeType::Enum );
 222     xEnum->SetName( ReadIdentifier() );
 223
 224     Read('{');
 225     while( true )
 226     {
 227         ReadEnumValue( *xEnum );
 228         if( !ReadIfDelimiter() )
 229             break;
 230     }
 231     Read( '}' );
 232     // announce globally
 233     rBase.GetTypeList().push_back( xEnum.get() );
 234 }
 235
 236 static std::string_view getCommonSubPrefix(std::string_view rA, std::string_view rB)
 237 {
 238     sal_Int32 nMax = std::min(rA.size(), rB.size());
 239     sal_Int32 nI = 0;
 240     while (nI < nMax)
 241     {
 242         if (rA[nI] != rB[nI])
 243             break;
 244         ++nI;
 245     }
 246     return rA.substr(0, nI);
 247 }
 248
 249 void SvIdlParser::ReadEnumValue( SvMetaTypeEnum& rEnum )
 250 {
 251     tools::SvRef<SvMetaEnumValue> aEnumVal = new SvMetaEnumValue();
 252     aEnumVal->SetName( ReadIdentifier() );
 253     if( rEnum.aEnumValueList.empty() )
 254     {
 255        // the first
 256        rEnum.aPrefix = aEnumVal->GetName();
 257     }
 258     else
 259     {
 260         rEnum.aPrefix = OString(getCommonSubPrefix(rEnum.aPrefix, aEnumVal->GetName()));
 261     }
 262     rEnum.aEnumValueList.push_back( aEnumVal.get() );
 263 }
 264
 265 void SvIdlParser::ReadInterfaceOrShell( SvMetaModule& rModule, MetaTypeType aMetaTypeType )
 266 {
 267     tools::SvRef<SvMetaClass> aClass( new SvMetaClass() );
 268
 269     aClass->SetType( aMetaTypeType );
 270
 271     aClass->SetName( ReadIdentifier() );
 272
 273     if( ReadIf( ':' ) )
 274     {
 275         aClass->aSuperClass = ReadKnownClass();
 276     }
 277     if( ReadIf( '{' ) )
 278     {
 279         sal_uInt32 nBeginPos = 0; // can not happen with Tell
 280         while( nBeginPos != rInStm.Tell() )
 281         {
 282             nBeginPos = rInStm.Tell();
 283             ReadInterfaceOrShellEntry(*aClass);
 284             ReadIfDelimiter();
 285         }
 286         Read( '}' );
 287     }
 288     rModule.aClassList.push_back( aClass.get() );
 289     // announce globally
 290     rBase.GetClassList().push_back( aClass.get() );
 291 }
 292
 293 void SvIdlParser::ReadInterfaceOrShellEntry(SvMetaClass& rClass)
 294 {
 295     if( ReadIf( SvHash_import() ) )
 296     {
 297         SvMetaClass * pClass = ReadKnownClass();
 298         SvClassElement aEle(pClass);
 299         SvToken& rTok = rInStm.GetToken();
 300         if( rTok.IsString() )
 301         {
 302             aEle.SetPrefix( rTok.GetString() );
 303             rInStm.GetToken_Next();
 304         }
 305         rClass.aClassElementList.push_back( aEle );
 306     }
 307     else
 308     {
 309         SvMetaType * pType = rBase.ReadKnownType( rInStm );
 310         tools::SvRef<SvMetaAttribute> xAttr;
 311         bool bOk = false;
 312         if( !pType || pType->IsItem() )
 313         {
 314             xAttr = new SvMetaSlot( pType );
 315             bOk = ReadSlot(static_cast<SvMetaSlot&>(*xAttr));
 316         }
 317         else
 318         {
 319             xAttr = new SvMetaAttribute( pType );
 320             ReadInterfaceOrShellMethod(*xAttr);
 321             bOk = true;
 322         }
 323         if( bOk )
 324             bOk = xAttr->Test( rInStm );
 325         if( bOk )
 326             bOk = rClass.TestAttribute( rBase, rInStm, *xAttr );
 327         if( bOk )
 328         {
 329             if( !xAttr->GetSlotId().IsSet() )
 330                 xAttr->SetSlotId( SvIdentifier(rBase.GetUniqueId()) );
 331             rClass.aAttrList.push_back( xAttr.get() );
 332         }
 333     }
 334 }
 335
 336 bool SvIdlParser::ReadSlot(SvMetaSlot& rSlot)
 337 {
 338     sal_uInt32  nTokPos = rInStm.Tell();
 339     bool        bOk     = true;
 340
 341     SvMetaAttribute * pAttr = rBase.ReadKnownAttr( rInStm, rSlot.GetType() );
 342     if( pAttr )
 343     {
 344         SvMetaSlot * pKnownSlot = dynamic_cast<SvMetaSlot*>( pAttr );
 345         if( !pKnownSlot )
 346             throw SvParseException( rInStm, "attribute " + pAttr->GetName() + " is method or variable but not a slot" );
 347         rSlot.SetRef( pKnownSlot );
 348         rSlot.SetName( pKnownSlot->GetName() );
 349         if( ReadIf( '[' ) )
 350         {
 351             sal_uInt32 nBeginPos = 0; // can not happen with Tell
 352             while( nBeginPos != rInStm.Tell() )
 353             {
 354                 nBeginPos = rInStm.Tell();
 355                 ReadSlotAttribute(rSlot);
 356                 ReadIfDelimiter();
 357             }
 358             Read( ']' );
 359         }
 360     }
 361     else
 362     {
 363         bOk = rSlot.SvMetaAttribute::ReadSvIdl( rBase, rInStm );
 364         SvMetaAttribute *pAttr2 = rBase.FindKnownAttr( rSlot.GetSlotId() );
 365         if( pAttr2 )
 366         {
 367             SvMetaSlot * pKnownSlot = dynamic_cast<SvMetaSlot*>( pAttr2 );
 368             if( !pKnownSlot )
 369                 throw SvParseException( rInStm, "attribute " + pAttr2->GetName() + " is method or variable but not a slot" );
 370             rSlot.SetRef( pKnownSlot );
 371             // names may differ, because explicitly given
 372             if ( pKnownSlot->GetName() != rSlot.GetName() )
 373                 throw SvParseException( rInStm, "Illegal definition!"_ostr );
 374         }
 375     }
 376
 377     if( !bOk )
 378         rInStm.Seek( nTokPos );
 379
 380     return bOk;
 381 }
 382
 383 void SvIdlParser::ReadSlotAttribute( SvMetaSlot& rSlot )
 384 {
 385     ReadIfIdAttribute(rSlot.aGroupId, SvHash_GroupId() );
 386     ReadIfIdAttribute(rSlot.aExecMethod, SvHash_ExecMethod() );
 387     ReadIfIdAttribute(rSlot.aStateMethod, SvHash_StateMethod() );
 388     ReadStringSvIdl( SvHash_DisableFlags(), rInStm, rSlot.aDisableFlags );
 389     ReadIfBoolAttribute(rSlot.aReadOnlyDoc, SvHash_ReadOnlyDoc() );
 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"_ostr);
 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"_ostr);
 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"_ostr);
 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 = std::move(xT);
 433     rAttr.aType->SetType( MetaTypeType::Method );
 434     if (ReadIf(')'))
 435         return;
 436
 437     while (true)
 438     {
 439         tools::SvRef<SvMetaAttribute> xParamAttr( new SvMetaAttribute() );
 440         xParamAttr->aType = ReadKnownType();
 441         xParamAttr->SetName( ReadIdentifier() );
 442         ReadSlotId(xParamAttr->aSlotId);
 443         rAttr.aType->GetAttrList().push_back( xParamAttr.get() );
 444         if (!ReadIfDelimiter())
 445             break;
 446     }
 447     Read(')');
 448 }
 449
 450 void SvIdlParser::ReadSlotId(SvIdentifier& rSlotId)
 451 {
 452     rSlotId.setString( ReadIdentifier() );
 453     sal_uInt32 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"_ostr );
 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: "_ostr);
 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"_ostr);
 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"_ostr);
 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"_ostr);
 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"_ostr, 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"_ostr, 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: */