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