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