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