basic/source/runtime/iosys.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 <string.h>
  21 #include <vcl/svapp.hxx>
  22 #include <vcl/weld.hxx>
  23 #include <vcl/window.hxx>
  24 #include <osl/file.hxx>
  25
  26 #include <runtime.hxx>
  27
  28 #include <rtl/strbuf.hxx>
  29 #include <sal/log.hxx>
  30
  31 #include <comphelper/processfactory.hxx>
  32 #include <comphelper/string.hxx>
  33
  34 #include <com/sun/star/uno/Sequence.hxx>
  35 #include <com/sun/star/ucb/SimpleFileAccess.hpp>
  36 #include <com/sun/star/ucb/UniversalContentBroker.hpp>
  37 #include <com/sun/star/io/XInputStream.hpp>
  38 #include <com/sun/star/io/XOutputStream.hpp>
  39 #include <com/sun/star/io/XStream.hpp>
  40 #include <com/sun/star/io/XSeekable.hpp>
  41
  42 using namespace com::sun::star::uno;
  43 using namespace com::sun::star::lang;
  44 using namespace com::sun::star::ucb;
  45 using namespace com::sun::star::io;
  46 using namespace com::sun::star::bridge;
  47
  48 #include <iosys.hxx>
  49
  50 namespace {
  51
  52 class SbiInputDialog : public weld::GenericDialogController
  53 {
  54     std::unique_ptr<weld::Entry> m_xInput;
  55     std::unique_ptr<weld::Button> m_xOk;
  56     std::unique_ptr<weld::Button> m_xCancel;
  57     std::unique_ptr<weld::Label> m_xPromptText;
  58     OUString m_aText;
  59     DECL_LINK(Ok, weld::Button&, void);
  60     DECL_LINK(Cancel, weld::Button&, void);
  61 public:
  62     SbiInputDialog(weld::Window*, const OUString&);
  63     const OUString& GetInput() const { return m_aText; }
  64 };
  65
  66 }
  67
  68 SbiInputDialog::SbiInputDialog(weld::Window* pParent, const OUString& rPrompt)
  69     : GenericDialogController(pParent, "svt/ui/inputbox.ui", "InputBox")
  70     , m_xInput(m_xBuilder->weld_entry("entry"))
  71     , m_xOk(m_xBuilder->weld_button("ok"))
  72     , m_xCancel(m_xBuilder->weld_button("cancel"))
  73     , m_xPromptText(m_xBuilder->weld_label("prompt"))
  74 {
  75     m_xDialog->set_title(rPrompt);
  76     m_xPromptText->set_label(rPrompt);
  77     m_xOk->connect_clicked( LINK( this, SbiInputDialog, Ok ) );
  78     m_xCancel->connect_clicked( LINK( this, SbiInputDialog, Cancel ) );
  79 }
  80
  81 IMPL_LINK_NOARG( SbiInputDialog, Ok, weld::Button&, void )
  82 {
  83     m_aText = m_xInput->get_text();
  84     m_xDialog->response(RET_OK);
  85 }
  86
  87 IMPL_LINK_NOARG( SbiInputDialog, Cancel, weld::Button&, void )
  88 {
  89     m_xDialog->response(RET_CANCEL);
  90 }
  91
  92 SbiStream::SbiStream()
  93     : nExpandOnWriteTo(0)
  94     , nLine(0)
  95     , nLen(0)
  96     , nMode(SbiStreamFlags::NONE)
  97     , nError(0)
  98 {
  99 }
 100
 101 SbiStream::~SbiStream()
 102 {
 103 }
 104
 105 // map an SvStream-error to StarBASIC-code
 106
 107 void SbiStream::MapError()
 108 {
 109     if( !pStrm )
 110         return;
 111
 112     ErrCode nEC = pStrm->GetError();
 113     if (nEC == ERRCODE_NONE)
 114         nError = ERRCODE_NONE;
 115     else if (nEC == SVSTREAM_FILE_NOT_FOUND)
 116         nError = ERRCODE_BASIC_FILE_NOT_FOUND;
 117     else if (nEC ==SVSTREAM_PATH_NOT_FOUND)
 118         nError = ERRCODE_BASIC_PATH_NOT_FOUND;
 119     else if (nEC ==SVSTREAM_TOO_MANY_OPEN_FILES)
 120         nError = ERRCODE_BASIC_TOO_MANY_FILES;
 121     else if (nEC ==SVSTREAM_ACCESS_DENIED)
 122         nError = ERRCODE_BASIC_ACCESS_DENIED;
 123     else if (nEC ==SVSTREAM_INVALID_PARAMETER)
 124         nError = ERRCODE_BASIC_BAD_ARGUMENT;
 125     else if (nEC ==SVSTREAM_OUTOFMEMORY)
 126         nError = ERRCODE_BASIC_NO_MEMORY;
 127     else
 128         nError = ERRCODE_BASIC_IO_ERROR;
 129 }
 130
 131 // Returns sal_True if UNO is available, otherwise the old file
 132 // system implementation has to be used
 133 // #89378 New semantic: Don't just ask for UNO but for UCB
 134 bool hasUno()
 135 {
 136     static bool bNeedInit = true;
 137     static bool bRetVal = true;
 138
 139     if( bNeedInit )
 140     {
 141         bNeedInit = false;
 142         Reference< XComponentContext > xContext = comphelper::getProcessComponentContext();
 143         if( !xContext.is() )
 144         {
 145             // No service manager at all
 146             bRetVal = false;
 147         }
 148         else
 149         {
 150             Reference< XUniversalContentBroker > xManager = UniversalContentBroker::create(xContext);
 151
 152             if ( !( xManager->queryContentProvider( "file:///" ).is() ) )
 153             {
 154                 // No UCB
 155                 bRetVal = false;
 156             }
 157         }
 158     }
 159     return bRetVal;
 160 }
 161
 162 namespace {
 163
 164 class OslStream : public SvStream
 165 {
 166     osl::File maFile;
 167
 168 public:
 169                         OslStream( const OUString& rName, StreamMode nStrmMode );
 170                        virtual ~OslStream() override;
 171     virtual std::size_t GetData(void* pData, std::size_t nSize) override;
 172     virtual std::size_t PutData(const void* pData, std::size_t nSize) override;
 173     virtual sal_uInt64 SeekPos( sal_uInt64 nPos ) override;
 174     virtual void        FlushData() override;
 175     virtual void        SetSize( sal_uInt64 nSize) override;
 176 };
 177
 178 }
 179
 180 OslStream::OslStream( const OUString& rName, StreamMode nStrmMode )
 181     : maFile( rName )
 182 {
 183     sal_uInt32 nFlags;
 184
 185     if( (nStrmMode & (StreamMode::READ | StreamMode::WRITE)) == (StreamMode::READ | StreamMode::WRITE) )
 186     {
 187         nFlags = osl_File_OpenFlag_Read | osl_File_OpenFlag_Write;
 188     }
 189     else if( nStrmMode & StreamMode::WRITE )
 190     {
 191         nFlags = osl_File_OpenFlag_Write;
 192     }
 193     else //if( nStrmMode & StreamMode::READ )
 194     {
 195         nFlags = osl_File_OpenFlag_Read;
 196     }
 197
 198     osl::FileBase::RC nRet = maFile.open( nFlags );
 199     if( nRet == osl::FileBase::E_NOENT && nFlags != osl_File_OpenFlag_Read )
 200     {
 201         nFlags |= osl_File_OpenFlag_Create;
 202         nRet = maFile.open( nFlags );
 203     }
 204
 205     if( nRet != osl::FileBase::E_None )
 206     {
 207         SetError( ERRCODE_IO_GENERAL );
 208     }
 209 }
 210
 211
 212 OslStream::~OslStream()
 213 {
 214     maFile.close();
 215 }
 216
 217 std::size_t OslStream::GetData(void* pData, std::size_t nSize)
 218 {
 219     sal_uInt64 nBytesRead = nSize;
 220     maFile.read( pData, nBytesRead, nBytesRead );
 221     return nBytesRead;
 222 }
 223
 224 std::size_t OslStream::PutData(const void* pData, std::size_t nSize)
 225 {
 226     sal_uInt64 nBytesWritten;
 227     maFile.write( pData, nSize, nBytesWritten );
 228     return nBytesWritten;
 229 }
 230
 231 sal_uInt64 OslStream::SeekPos( sal_uInt64 nPos )
 232 {
 233     ::osl::FileBase::RC rc = ::osl::FileBase::E_None;
 234     // check if a truncated STREAM_SEEK_TO_END was passed
 235     assert(nPos != SAL_MAX_UINT32);
 236     if( nPos == STREAM_SEEK_TO_END )
 237     {
 238         rc = maFile.setPos( osl_Pos_End, 0 );
 239     }
 240     else
 241     {
 242         rc = maFile.setPos( osl_Pos_Absolut, nPos );
 243     }
 244     OSL_VERIFY(rc == ::osl::FileBase::E_None);
 245     sal_uInt64 nRealPos(0);
 246     rc = maFile.getPos( nRealPos );
 247     OSL_VERIFY(rc == ::osl::FileBase::E_None);
 248     return nRealPos;
 249 }
 250
 251 void OslStream::FlushData()
 252 {
 253 }
 254
 255 void OslStream::SetSize( sal_uInt64 nSize )
 256 {
 257     maFile.setSize( nSize );
 258 }
 259
 260 namespace {
 261
 262 class UCBStream : public SvStream
 263 {
 264     Reference< XInputStream >   xIS;
 265     Reference< XStream >        xS;
 266     Reference< XSeekable >      xSeek;
 267 public:
 268     explicit UCBStream( Reference< XInputStream > const & xIS );
 269     explicit UCBStream( Reference< XStream > const & xS );
 270                        virtual ~UCBStream() override;
 271     virtual std::size_t GetData( void* pData, std::size_t nSize ) override;
 272     virtual std::size_t PutData( const void* pData, std::size_t nSize ) override;
 273     virtual sal_uInt64 SeekPos( sal_uInt64 nPos ) override;
 274     virtual void        FlushData() override;
 275     virtual void        SetSize( sal_uInt64 nSize ) override;
 276 };
 277
 278 }
 279
 280 UCBStream::UCBStream( Reference< XInputStream > const & rStm )
 281     : xIS( rStm )
 282     , xSeek( rStm, UNO_QUERY )
 283 {
 284 }
 285
 286 UCBStream::UCBStream( Reference< XStream > const & rStm )
 287     : xS( rStm )
 288     , xSeek( rStm, UNO_QUERY )
 289 {
 290 }
 291
 292
 293 UCBStream::~UCBStream()
 294 {
 295     try
 296     {
 297         if( xIS.is() )
 298         {
 299             xIS->closeInput();
 300         }
 301         else if( xS.is() )
 302         {
 303             Reference< XInputStream > xIS_ = xS->getInputStream();
 304             if( xIS_.is() )
 305             {
 306                 xIS_->closeInput();
 307             }
 308         }
 309     }
 310     catch(const Exception & )
 311     {
 312         SetError( ERRCODE_IO_GENERAL );
 313     }
 314 }
 315
 316 std::size_t UCBStream::GetData(void* pData, std::size_t nSize)
 317 {
 318     try
 319     {
 320         Reference< XInputStream > xISFromS;
 321         if( xIS.is() )
 322         {
 323             Sequence<sal_Int8> aData;
 324             nSize = xIS->readBytes( aData, nSize );
 325             memcpy( pData, aData.getConstArray(), nSize );
 326             return nSize;
 327         }
 328         else if( xS.is() && (xISFromS = xS->getInputStream()).is() )
 329         {
 330             Sequence<sal_Int8> aData;
 331             nSize = xISFromS->readBytes( aData, nSize );
 332             memcpy(pData, aData.getConstArray(), nSize );
 333             return nSize;
 334         }
 335         else
 336         {
 337             SetError( ERRCODE_IO_GENERAL );
 338         }
 339     }
 340     catch(const Exception & )
 341     {
 342         SetError( ERRCODE_IO_GENERAL );
 343     }
 344     return 0;
 345 }
 346
 347 std::size_t UCBStream::PutData(const void* pData, std::size_t nSize)
 348 {
 349     try
 350     {
 351         Reference< XOutputStream > xOSFromS;
 352         if( xS.is() && (xOSFromS = xS->getOutputStream()).is() )
 353         {
 354             Sequence<sal_Int8> aData( static_cast<const sal_Int8 *>(pData), nSize );
 355             xOSFromS->writeBytes( aData );
 356             return nSize;
 357         }
 358         else
 359         {
 360             SetError( ERRCODE_IO_GENERAL );
 361         }
 362     }
 363     catch(const Exception & )
 364     {
 365         SetError( ERRCODE_IO_GENERAL );
 366     }
 367     return 0;
 368 }
 369
 370 sal_uInt64 UCBStream::SeekPos( sal_uInt64 nPos )
 371 {
 372     try
 373     {
 374         if( xSeek.is() )
 375         {
 376             sal_uInt64 nLen = static_cast<sal_uInt64>( xSeek->getLength() );
 377             if( nPos > nLen )
 378             {
 379                 nPos = nLen;
 380             }
 381             xSeek->seek( nPos );
 382             return nPos;
 383         }
 384         else
 385         {
 386             SetError( ERRCODE_IO_GENERAL );
 387         }
 388     }
 389     catch(const Exception & )
 390     {
 391         SetError( ERRCODE_IO_GENERAL );
 392     }
 393     return 0;
 394 }
 395
 396 void UCBStream::FlushData()
 397 {
 398     try
 399     {
 400         Reference< XOutputStream > xOSFromS;
 401         if( xS.is() && (xOSFromS = xS->getOutputStream()).is() )
 402         {
 403             xOSFromS->flush();
 404         }
 405         else
 406         {
 407             SetError( ERRCODE_IO_GENERAL );
 408         }
 409     }
 410     catch(const Exception & )
 411     {
 412         SetError( ERRCODE_IO_GENERAL );
 413     }
 414 }
 415
 416 void    UCBStream::SetSize( sal_uInt64 )
 417 {
 418     SAL_WARN("basic", "UCBStream::SetSize not allowed to call from basic" );
 419     SetError( ERRCODE_IO_GENERAL );
 420 }
 421
 422
 423 ErrCode const & SbiStream::Open
 424 ( const OString& rName, StreamMode nStrmMode, SbiStreamFlags nFlags, short nL )
 425 {
 426     nMode   = nFlags;
 427     nLen    = nL;
 428     nLine   = 0;
 429     nExpandOnWriteTo = 0;
 430     if( ( nStrmMode & ( StreamMode::READ|StreamMode::WRITE ) ) == StreamMode::READ )
 431     {
 432         nStrmMode |= StreamMode::NOCREATE;
 433     }
 434     OUString aStr(OStringToOUString(rName, osl_getThreadTextEncoding()));
 435     OUString aNameStr = getFullPath( aStr );
 436
 437     if( hasUno() )
 438     {
 439         Reference< XSimpleFileAccess3 > xSFI( SimpleFileAccess::create( comphelper::getProcessComponentContext() ) );
 440         try
 441         {
 442
 443         // #??? For write access delete file if it already exists (not for appending)
 444         if( (nStrmMode & StreamMode::WRITE) && !IsAppend() && !IsBinary() && !IsRandom() &&
 445             xSFI->exists( aNameStr ) && !xSFI->isFolder( aNameStr ) )
 446         {
 447             xSFI->kill( aNameStr );
 448         }
 449
 450         if( (nStrmMode & (StreamMode::READ | StreamMode::WRITE)) == (StreamMode::READ | StreamMode::WRITE) )
 451         {
 452             Reference< XStream > xIS = xSFI->openFileReadWrite( aNameStr );
 453             pStrm.reset( new UCBStream( xIS ) );
 454         }
 455         else if( nStrmMode & StreamMode::WRITE )
 456         {
 457             Reference< XStream > xIS = xSFI->openFileReadWrite( aNameStr );
 458             pStrm.reset( new UCBStream( xIS ) );
 459         }
 460         else //if( nStrmMode & StreamMode::READ )
 461         {
 462             Reference< XInputStream > xIS = xSFI->openFileRead( aNameStr );
 463             pStrm.reset( new UCBStream( xIS ) );
 464         }
 465
 466         }
 467         catch(const Exception & )
 468         {
 469             nError = ERRCODE_IO_GENERAL;
 470         }
 471     }
 472
 473     if( !pStrm )
 474     {
 475         pStrm.reset( new OslStream( aNameStr, nStrmMode ) );
 476     }
 477     if( IsAppend() )
 478     {
 479         pStrm->Seek( STREAM_SEEK_TO_END );
 480     }
 481     MapError();
 482     if( nError )
 483     {
 484         pStrm.reset();
 485     }
 486     return nError;
 487 }
 488
 489 ErrCode const & SbiStream::Close()
 490 {
 491     if( pStrm )
 492     {
 493         MapError();
 494         pStrm.reset();
 495     }
 496     return nError;
 497 }
 498
 499 ErrCode SbiStream::Read(OString& rBuf, sal_uInt16 n, bool bForceReadingPerByte)
 500 {
 501     nExpandOnWriteTo = 0;
 502     if( !bForceReadingPerByte && IsText() )
 503     {
 504         pStrm->ReadLine(rBuf);
 505         nLine++;
 506     }
 507     else
 508     {
 509         if( !n )
 510         {
 511             n = nLen;
 512         }
 513         if( !n )
 514         {
 515             return nError = ERRCODE_BASIC_BAD_RECORD_LENGTH;
 516         }
 517         OStringBuffer aBuffer(read_uInt8s_ToOString(*pStrm, n));
 518         //Pad it out with ' ' to the requested length on short read
 519         sal_Int32 nRequested = sal::static_int_cast<sal_Int32>(n);
 520         comphelper::string::padToLength(aBuffer, nRequested, ' ');
 521         rBuf = aBuffer.makeStringAndClear();
 522     }
 523     MapError();
 524     if( !nError && pStrm->eof() )
 525     {
 526         nError = ERRCODE_BASIC_READ_PAST_EOF;
 527     }
 528     return nError;
 529 }
 530
 531 ErrCode const & SbiStream::Read( char& ch )
 532 {
 533     nExpandOnWriteTo = 0;
 534     if (aLine.isEmpty())
 535     {
 536         Read( aLine );
 537         aLine += OString('\n');
 538     }
 539     ch = aLine[0];
 540     aLine = aLine.copy(1);
 541     return nError;
 542 }
 543
 544 void SbiStream::ExpandFile()
 545 {
 546     if ( !nExpandOnWriteTo )
 547         return;
 548
 549     sal_uInt64 nCur = pStrm->Seek(STREAM_SEEK_TO_END);
 550     if( nCur < nExpandOnWriteTo )
 551     {
 552         sal_uInt64 nDiff = nExpandOnWriteTo - nCur;
 553         while( nDiff-- )
 554         {
 555             pStrm->WriteChar( 0 );
 556         }
 557     }
 558     else
 559     {
 560         pStrm->Seek( nExpandOnWriteTo );
 561     }
 562     nExpandOnWriteTo = 0;
 563 }
 564
 565 namespace
 566 {
 567     void WriteLines(SvStream &rStream, const OString& rStr)
 568     {
 569         OString aStr(convertLineEnd(rStr, rStream.GetLineDelimiter()) );
 570         write_uInt8s_FromOString(rStream, aStr);
 571         endl( rStream );
 572     }
 573 }
 574
 575 ErrCode SbiStream::Write( const OString& rBuf )
 576 {
 577     ExpandFile();
 578     if( IsAppend() )
 579     {
 580         pStrm->Seek( STREAM_SEEK_TO_END );
 581     }
 582     if( IsText() )
 583     {
 584         aLine += rBuf;
 585         // Get it out, if the end is an LF, but strip CRLF before,
 586         // because the SvStream adds a CRLF!
 587         sal_Int32 nLineLen = aLine.getLength();
 588         if (nLineLen && aLine[--nLineLen] == 0x0A)
 589         {
 590             aLine = aLine.copy(0, nLineLen);
 591             if (nLineLen && aLine[--nLineLen] == 0x0D)
 592             {
 593                 aLine = aLine.copy(0, nLineLen);
 594             }
 595             WriteLines(*pStrm, aLine);
 596             aLine.clear();
 597         }
 598     }
 599     else
 600     {
 601         if( !nLen )
 602         {
 603             return nError = ERRCODE_BASIC_BAD_RECORD_LENGTH;
 604         }
 605         pStrm->WriteBytes(rBuf.getStr(), nLen);
 606         MapError();
 607     }
 608     return nError;
 609 }
 610
 611
 612 SbiIoSystem::SbiIoSystem()
 613 {
 614     for(SbiStream* & i : pChan)
 615     {
 616         i = nullptr;
 617     }
 618     nChan  = 0;
 619     nError = ERRCODE_NONE;
 620 }
 621
 622 SbiIoSystem::~SbiIoSystem() COVERITY_NOEXCEPT_FALSE
 623 {
 624     Shutdown();
 625 }
 626
 627 ErrCode SbiIoSystem::GetError()
 628 {
 629     ErrCode n = nError;
 630     nError = ERRCODE_NONE;
 631     return n;
 632 }
 633
 634 void SbiIoSystem::Open(short nCh, const OString& rName, StreamMode nMode, SbiStreamFlags nFlags, short nLen)
 635 {
 636     nError = ERRCODE_NONE;
 637     if( nCh >= CHANNELS || !nCh )
 638     {
 639         nError = ERRCODE_BASIC_BAD_CHANNEL;
 640     }
 641     else if( pChan[ nCh ] )
 642     {
 643         nError = ERRCODE_BASIC_FILE_ALREADY_OPEN;
 644     }
 645     else
 646     {
 647        pChan[ nCh ] = new SbiStream;
 648        nError = pChan[ nCh ]->Open( rName, nMode, nFlags, nLen );
 649        if( nError )
 650        {
 651             delete pChan[ nCh ];
 652             pChan[ nCh ] = nullptr;
 653        }
 654     }
 655     nChan = 0;
 656 }
 657
 658
 659 void SbiIoSystem::Close()
 660 {
 661     if( !nChan )
 662     {
 663         nError = ERRCODE_BASIC_BAD_CHANNEL;
 664     }
 665     else if( !pChan[ nChan ] )
 666     {
 667         nError = ERRCODE_BASIC_BAD_CHANNEL;
 668     }
 669     else
 670     {
 671         nError = pChan[ nChan ]->Close();
 672         delete pChan[ nChan ];
 673         pChan[ nChan ] = nullptr;
 674     }
 675     nChan = 0;
 676 }
 677
 678
 679 void SbiIoSystem::Shutdown()
 680 {
 681     for( short i = 1; i < CHANNELS; i++ )
 682     {
 683         if( pChan[ i ] )
 684         {
 685             ErrCode n = pChan[ i ]->Close();
 686             delete pChan[ i ];
 687             pChan[ i ] = nullptr;
 688             if( n && !nError )
 689             {
 690                 nError = n;
 691             }
 692         }
 693     }
 694     nChan = 0;
 695     // anything left to PRINT?
 696     if( !aOut.isEmpty() )
 697     {
 698         vcl::Window* pParent = Application::GetDefDialogParent();
 699         std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(pParent ? pParent->GetFrameWeld() : nullptr, VclMessageType::Warning,
 700             VclButtonsType::Ok, aOut));
 701         xBox->run();
 702     }
 703     aOut.clear();
 704 }
 705
 706
 707 void SbiIoSystem::Read(OString& rBuf)
 708 {
 709     if( !nChan )
 710     {
 711         ReadCon( rBuf );
 712     }
 713     else if( !pChan[ nChan ] )
 714     {
 715         nError = ERRCODE_BASIC_BAD_CHANNEL;
 716     }
 717     else
 718     {
 719         nError = pChan[ nChan ]->Read( rBuf );
 720     }
 721 }
 722
 723 char SbiIoSystem::Read()
 724 {
 725     char ch = ' ';
 726     if( !nChan )
 727     {
 728         if( aIn.isEmpty() )
 729         {
 730             ReadCon( aIn );
 731             aIn += OString('\n');
 732         }
 733         ch = aIn[0];
 734         aIn = aIn.copy(1);
 735     }
 736     else if( !pChan[ nChan ] )
 737     {
 738         nError = ERRCODE_BASIC_BAD_CHANNEL;
 739     }
 740     else
 741     {
 742         nError = pChan[ nChan ]->Read( ch );
 743     }
 744     return ch;
 745 }
 746
 747 void SbiIoSystem::Write(const OUString& rBuf)
 748 {
 749     if( !nChan )
 750     {
 751         WriteCon( rBuf );
 752     }
 753     else if( !pChan[ nChan ] )
 754     {
 755         nError = ERRCODE_BASIC_BAD_CHANNEL;
 756     }
 757     else
 758     {
 759         nError = pChan[ nChan ]->Write( OUStringToOString(rBuf, osl_getThreadTextEncoding()) );
 760     }
 761 }
 762
 763 // nChannel == 0..CHANNELS-1
 764
 765 SbiStream* SbiIoSystem::GetStream( short nChannel ) const
 766 {
 767     SbiStream* pRet = nullptr;
 768     if( nChannel >= 0 && nChannel < CHANNELS )
 769     {
 770         pRet = pChan[ nChannel ];
 771     }
 772     return pRet;
 773 }
 774
 775 void SbiIoSystem::CloseAll()
 776 {
 777     for( short i = 1; i < CHANNELS; i++ )
 778     {
 779         if( pChan[ i ] )
 780         {
 781             ErrCode n = pChan[ i ]->Close();
 782             delete pChan[ i ];
 783             pChan[ i ] = nullptr;
 784             if( n && !nError )
 785             {
 786                 nError = n;
 787             }
 788         }
 789     }
 790 }
 791
 792 void SbiIoSystem::ReadCon(OString& rIn)
 793 {
 794     OUString aPromptStr(OStringToOUString(aPrompt, osl_getThreadTextEncoding()));
 795     SbiInputDialog aDlg(nullptr, aPromptStr);
 796     if (aDlg.run() == RET_OK)
 797     {
 798         rIn = OUStringToOString(aDlg.GetInput(), osl_getThreadTextEncoding());
 799     }
 800     else
 801     {
 802         nError = ERRCODE_BASIC_USER_ABORT;
 803     }
 804     aPrompt.clear();
 805 }
 806
 807 // output of a MessageBox, if there's a CR in the console-buffer
 808
 809 void SbiIoSystem::WriteCon(const OUString& rText)
 810 {
 811     aOut += rText;
 812     sal_Int32 n1 = aOut.indexOf('\n');
 813     sal_Int32 n2 = aOut.indexOf('\r');
 814     if( n1 == -1 && n2 == -1 )
 815         return;
 816
 817     if( n1 == -1 )
 818     {
 819         n1 = n2;
 820     }
 821     else if( n2 == -1 )
 822     {
 823         n2 = n1;
 824     }
 825     if( n1 > n2 )
 826     {
 827         n1 = n2;
 828     }
 829     OUString s(aOut.copy(0, n1));
 830     aOut = aOut.copy(n1);
 831     while ( !aOut.isEmpty() && (aOut[0] == '\n' || aOut[0] == '\r') )
 832     {
 833         aOut = aOut.copy(1);
 834     }
 835     {
 836         SolarMutexGuard aSolarGuard;
 837
 838         vcl::Window* pParent = Application::GetDefDialogParent();
 839         std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(pParent ? pParent->GetFrameWeld() : nullptr, VclMessageType::Warning,
 840             VclButtonsType::OkCancel, s));
 841         xBox->set_default_response(RET_OK);
 842         if (!xBox->run())
 843         {
 844             nError = ERRCODE_BASIC_USER_ABORT;
 845         }
 846     }
 847 }
 848
 849 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */