    /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
    /*
     * This file is part of the LibreOffice project.
     *
     * This Source Code Form is subject to the terms of the Mozilla Public
     * License, v. 2.0. If a copy of the MPL was not distributed with this
     * file, You can obtain one at http://mozilla.org/MPL/2.0/.
     *
     * This file incorporates work covered by the following license notice:
     *
     *   Licensed to the Apache Software Foundation (ASF) under one or more
     *   contributor license agreements. See the NOTICE file distributed
     *   with this work for additional information regarding copyright
     *   ownership. The ASF licenses this file to you under the Apache
     *   License, Version 2.0 (the "License"); you may not use this file
     *   except in compliance with the License. You may obtain a copy of
     *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
     */

    #include <string.h>
    #include <vcl/svapp.hxx>
    #include <vcl/weld.hxx>
    #include <osl/file.hxx>
    #include <tools/urlobj.hxx>

    #include <runtime.hxx>

    #include <rtl/byteseq.hxx>
    #include <rtl/textenc.h>
    #include <rtl/strbuf.hxx>
    #include <rtl/ustrbuf.hxx>
    #include <sal/log.hxx>

    #include <comphelper/processfactory.hxx>
    #include <comphelper/string.hxx>

    #include <com/sun/star/bridge/BridgeFactory.hpp>
    #include <com/sun/star/bridge/XBridge.hpp>
    #include <com/sun/star/uno/Sequence.hxx>
    #include <com/sun/star/lang/XMultiServiceFactory.hpp>
    #include <com/sun/star/ucb/SimpleFileAccess.hpp>
    #include <com/sun/star/ucb/UniversalContentBroker.hpp>
    #include <com/sun/star/ucb/XContentProvider.hpp>
    #include <com/sun/star/ucb/XContentProviderManager.hpp>
    #include <com/sun/star/io/XInputStream.hpp>
    #include <com/sun/star/io/XOutputStream.hpp>
    #include <com/sun/star/io/XStream.hpp>
    #include <com/sun/star/io/XSeekable.hpp>

    using namespace com::sun::star::uno;
    using namespace com::sun::star::lang;
    using namespace com::sun::star::ucb;
    using namespace com::sun::star::io;
    using namespace com::sun::star::bridge;

    #include <iosys.hxx>
    #include <sbintern.hxx>

    class SbiInputDialog : public weld::GenericDialogController
    {
        std::unique_ptr<weld::Entry> m_xInput;
        std::unique_ptr<weld::Button> m_xOk;
        std::unique_ptr<weld::Button> m_xCancel;
        std::unique_ptr<weld::Label> m_xPromptText;
        OUString m_aText;
        DECL_LINK(Ok, weld::Button&, void);
        DECL_LINK(Cancel, weld::Button&, void);
    public:
        SbiInputDialog(weld::Window*, const OUString&);
        const OUString& GetInput() { return m_aText; }
    };

    SbiInputDialog::SbiInputDialog(weld::Window* pParent, const OUString& rPrompt)
        : GenericDialogController(pParent, "svt/ui/inputbox.ui", "InputBox")
        , m_xInput(m_xBuilder->weld_entry("entry"))
        , m_xOk(m_xBuilder->weld_button("ok"))
        , m_xCancel(m_xBuilder->weld_button("cancel"))
        , m_xPromptText(m_xBuilder->weld_label("prompt"))
    {
        m_xDialog->set_title(rPrompt);
        m_xPromptText->set_label(rPrompt);
        m_xOk->connect_clicked( LINK( this, SbiInputDialog, Ok ) );
        m_xCancel->connect_clicked( LINK( this, SbiInputDialog, Cancel ) );
    }

    IMPL_LINK_NOARG( SbiInputDialog, Ok, weld::Button&, void )
    {
        m_aText = m_xInput->get_text();
        m_xDialog->response(RET_OK);
    }

    IMPL_LINK_NOARG( SbiInputDialog, Cancel, weld::Button&, void )
    {
        m_xDialog->response(RET_CANCEL);
    }

    SbiStream::SbiStream()
        : nExpandOnWriteTo(0)
        , nLine(0)
        , nLen(0)
        , nMode(SbiStreamFlags::NONE)
        , nError(0)
    {
    }

    SbiStream::~SbiStream()
    {
    }

    // map an SvStream-error to StarBASIC-code

    void SbiStream::MapError()
    {
        if( pStrm )
        {
            ErrCode nEC = pStrm->GetError();
            if (nEC == ERRCODE_NONE)
                nError = ERRCODE_NONE;
            else if (nEC == SVSTREAM_FILE_NOT_FOUND)
                nError = ERRCODE_BASIC_FILE_NOT_FOUND;
            else if (nEC ==SVSTREAM_PATH_NOT_FOUND)
                nError = ERRCODE_BASIC_PATH_NOT_FOUND;
            else if (nEC ==SVSTREAM_TOO_MANY_OPEN_FILES)
                nError = ERRCODE_BASIC_TOO_MANY_FILES;
            else if (nEC ==SVSTREAM_ACCESS_DENIED)
                nError = ERRCODE_BASIC_ACCESS_DENIED;
            else if (nEC ==SVSTREAM_INVALID_PARAMETER)
                nError = ERRCODE_BASIC_BAD_ARGUMENT;
            else if (nEC ==SVSTREAM_OUTOFMEMORY)
                nError = ERRCODE_BASIC_NO_MEMORY;
            else
                nError = ERRCODE_BASIC_IO_ERROR;
        }
    }

    // Returns sal_True if UNO is available, otherwise the old file
    // system implementation has to be used
    // #89378 New semantic: Don't just ask for UNO but for UCB
    bool hasUno()
    {
        static bool bNeedInit = true;
        static bool bRetVal = true;

        if( bNeedInit )
        {
            bNeedInit = false;
            Reference< XComponentContext > xContext = comphelper::getProcessComponentContext();
            if( !xContext.is() )
            {
                // No service manager at all
                bRetVal = false;
            }
            else
            {
                Reference< XUniversalContentBroker > xManager = UniversalContentBroker::create(xContext);

                if ( !( xManager->queryContentProvider( "file:///" ).is() ) )
                {
                    // No UCB
                    bRetVal = false;
                }
            }
        }
        return bRetVal;
    }

    class OslStream : public SvStream
    {
        osl::File maFile;

    public:
                            OslStream( const OUString& rName, StreamMode nStrmMode );
                           virtual ~OslStream() override;
        virtual std::size_t GetData(void* pData, std::size_t nSize) override;
        virtual std::size_t PutData(const void* pData, std::size_t nSize) override;
        virtual sal_uInt64 SeekPos( sal_uInt64 nPos ) override;
        virtual void        FlushData() override;
        virtual void        SetSize( sal_uInt64 nSize) override;
    };

    OslStream::OslStream( const OUString& rName, StreamMode nStrmMode )
        : maFile( rName )
    {
        sal_uInt32 nFlags;

        if( (nStrmMode & (StreamMode::READ | StreamMode::WRITE)) == (StreamMode::READ | StreamMode::WRITE) )
        {
            nFlags = osl_File_OpenFlag_Read | osl_File_OpenFlag_Write;
        }
        else if( nStrmMode & StreamMode::WRITE )
        {
            nFlags = osl_File_OpenFlag_Write;
        }
        else //if( nStrmMode & StreamMode::READ )
        {
            nFlags = osl_File_OpenFlag_Read;
        }

        osl::FileBase::RC nRet = maFile.open( nFlags );
        if( nRet == osl::FileBase::E_NOENT && nFlags != osl_File_OpenFlag_Read )
        {
            nFlags |= osl_File_OpenFlag_Create;
            nRet = maFile.open( nFlags );
        }

        if( nRet != osl::FileBase::E_None )
        {
            SetError( ERRCODE_IO_GENERAL );
        }
    }

    OslStream::~OslStream()
    {
        maFile.close();
    }

    std::size_t OslStream::GetData(void* pData, std::size_t nSize)
    {
        sal_uInt64 nBytesRead = nSize;
        maFile.read( pData, nBytesRead, nBytesRead );
        return nBytesRead;
    }

    std::size_t OslStream::PutData(const void* pData, std::size_t nSize)
    {
        sal_uInt64 nBytesWritten;
        maFile.write( pData, nSize, nBytesWritten );
        return nBytesWritten;
    }

    sal_uInt64 OslStream::SeekPos( sal_uInt64 nPos )
    {
        ::osl::FileBase::RC rc = ::osl::FileBase::E_None;
        // check if a truncated STREAM_SEEK_TO_END was passed
        assert(nPos != SAL_MAX_UINT32);
        if( nPos == STREAM_SEEK_TO_END )
        {
            rc = maFile.setPos( osl_Pos_End, 0 );
        }
        else
        {
            rc = maFile.setPos( osl_Pos_Absolut, nPos );
        }
        OSL_VERIFY(rc == ::osl::FileBase::E_None);
        sal_uInt64 nRealPos(0);
        maFile.getPos( nRealPos );
        return nRealPos;
    }

    void OslStream::FlushData()
    {
    }

    void OslStream::SetSize( sal_uInt64 nSize )
    {
        maFile.setSize( nSize );
    }

    class UCBStream : public SvStream
    {
        Reference< XInputStream >   xIS;
        Reference< XStream >        xS;
        Reference< XSeekable >      xSeek;
    public:
        explicit UCBStream( Reference< XInputStream > const & xIS );
        explicit UCBStream( Reference< XStream > const & xS );
                           virtual ~UCBStream() override;
        virtual std::size_t GetData( void* pData, std::size_t nSize ) override;
        virtual std::size_t PutData( const void* pData, std::size_t nSize ) override;
        virtual sal_uInt64 SeekPos( sal_uInt64 nPos ) override;
        virtual void        FlushData() override;
        virtual void        SetSize( sal_uInt64 nSize ) override;
    };

    UCBStream::UCBStream( Reference< XInputStream > const & rStm )
        : xIS( rStm )
        , xSeek( rStm, UNO_QUERY )
    {
    }

    UCBStream::UCBStream( Reference< XStream > const & rStm )
        : xS( rStm )
        , xSeek( rStm, UNO_QUERY )
    {
    }

    UCBStream::~UCBStream()
    {
        try
        {
            if( xIS.is() )
            {
                xIS->closeInput();
            }
            else if( xS.is() )
            {
                Reference< XInputStream > xIS_ = xS->getInputStream();
                if( xIS_.is() )
                {
                    xIS_->closeInput();
                }
            }
        }
        catch(const Exception & )
        {
            SetError( ERRCODE_IO_GENERAL );
        }
    }

    std::size_t UCBStream::GetData(void* pData, std::size_t nSize)
    {
        try
        {
            Reference< XInputStream > xISFromS;
            if( xIS.is() )
            {
                Sequence<sal_Int8> aData;
                nSize = xIS->readBytes( aData, nSize );
                memcpy( pData, aData.getConstArray(), nSize );
                return nSize;
            }
            else if( xS.is() && (xISFromS = xS->getInputStream()).is() )
            {
                Sequence<sal_Int8> aData;
                nSize = xISFromS->readBytes( aData, nSize );
                memcpy(pData, aData.getConstArray(), nSize );
                return nSize;
            }
            else
            {
                SetError( ERRCODE_IO_GENERAL );
            }
        }
        catch(const Exception & )
        {
            SetError( ERRCODE_IO_GENERAL );
        }
        return 0;
    }

    std::size_t UCBStream::PutData(const void* pData, std::size_t nSize)
    {
        try
        {
            Reference< XOutputStream > xOSFromS;
            if( xS.is() && (xOSFromS = xS->getOutputStream()).is() )
            {
                Sequence<sal_Int8> aData( static_cast<const sal_Int8 *>(pData), nSize );
                xOSFromS->writeBytes( aData );
                return nSize;
            }
            else
            {
                SetError( ERRCODE_IO_GENERAL );
            }
        }
        catch(const Exception & )
        {
            SetError( ERRCODE_IO_GENERAL );
        }
        return 0;
    }

    sal_uInt64 UCBStream::SeekPos( sal_uInt64 nPos )
    {
        try
        {
            if( xSeek.is() )
            {
                sal_uInt64 nLen = static_cast<sal_uInt64>( xSeek->getLength() );
                if( nPos > nLen )
                {
                    nPos = nLen;
                }
                xSeek->seek( nPos );
                return nPos;
            }
            else
            {
                SetError( ERRCODE_IO_GENERAL );
            }
        }
        catch(const Exception & )
        {
            SetError( ERRCODE_IO_GENERAL );
        }
        return 0;
    }

    void UCBStream::FlushData()
    {
        try
        {
            Reference< XOutputStream > xOSFromS;
            if( xS.is() && (xOSFromS = xS->getOutputStream()).is() )
            {
                xOSFromS->flush();
            }
            else
            {
                SetError( ERRCODE_IO_GENERAL );
            }
        }
        catch(const Exception & )
        {
            SetError( ERRCODE_IO_GENERAL );
        }
    }

    void    UCBStream::SetSize( sal_uInt64 )
    {
        SAL_WARN("basic", "UCBStream::SetSize not allowed to call from basic" );
        SetError( ERRCODE_IO_GENERAL );
    }

    ErrCode const & SbiStream::Open
    ( const OString& rName, StreamMode nStrmMode, SbiStreamFlags nFlags, short nL )
    {
        nMode   = nFlags;
        nLen    = nL;
        nLine   = 0;
        nExpandOnWriteTo = 0;
        if( ( nStrmMode & ( StreamMode::READ|StreamMode::WRITE ) ) == StreamMode::READ )
        {
            nStrmMode |= StreamMode::NOCREATE;
        }
        OUString aStr(OStringToOUString(rName, osl_getThreadTextEncoding()));
        OUString aNameStr = getFullPath( aStr );

        if( hasUno() )
        {
            Reference< XSimpleFileAccess3 > xSFI( SimpleFileAccess::create( comphelper::getProcessComponentContext() ) );
            try
            {

            // #??? For write access delete file if it already exists (not for appending)
            if( (nStrmMode & StreamMode::WRITE) && !IsAppend() && !IsBinary() && !IsRandom() &&
                xSFI->exists( aNameStr ) && !xSFI->isFolder( aNameStr ) )
            {
                xSFI->kill( aNameStr );
            }

            if( (nStrmMode & (StreamMode::READ | StreamMode::WRITE)) == (StreamMode::READ | StreamMode::WRITE) )
            {
                Reference< XStream > xIS = xSFI->openFileReadWrite( aNameStr );
                pStrm.reset( new UCBStream( xIS ) );
            }
            else if( nStrmMode & StreamMode::WRITE )
            {
                Reference< XStream > xIS = xSFI->openFileReadWrite( aNameStr );
                pStrm.reset( new UCBStream( xIS ) );
            }
            else //if( nStrmMode & StreamMode::READ )
            {
                Reference< XInputStream > xIS = xSFI->openFileRead( aNameStr );
                pStrm.reset( new UCBStream( xIS ) );
            }

            }
            catch(const Exception & )
            {
                nError = ERRCODE_IO_GENERAL;
            }
        }

        if( !pStrm )
        {
            pStrm.reset( new OslStream( aNameStr, nStrmMode ) );
        }
        if( IsAppend() )
        {
            pStrm->Seek( STREAM_SEEK_TO_END );
        }
        MapError();
        if( nError )
        {
            pStrm.reset();
        }
        return nError;
    }

    ErrCode const & SbiStream::Close()
    {
        if( pStrm )
        {
            MapError();
            pStrm.reset();
        }
        return nError;
    }

    ErrCode SbiStream::Read(OString& rBuf, sal_uInt16 n, bool bForceReadingPerByte)
    {
        nExpandOnWriteTo = 0;
        if( !bForceReadingPerByte && IsText() )
        {
            pStrm->ReadLine(rBuf);
            nLine++;
        }
        else
        {
            if( !n )
            {
                n = nLen;
            }
            if( !n )
            {
                return nError = ERRCODE_BASIC_BAD_RECORD_LENGTH;
            }
            OStringBuffer aBuffer(read_uInt8s_ToOString(*pStrm, n));
            //Pad it out with ' ' to the requested length on short read
            sal_Int32 nRequested = sal::static_int_cast<sal_Int32>(n);
            comphelper::string::padToLength(aBuffer, nRequested, ' ');
            rBuf = aBuffer.makeStringAndClear();
        }
        MapError();
        if( !nError && pStrm->eof() )
        {
            nError = ERRCODE_BASIC_READ_PAST_EOF;
        }
        return nError;
    }

    ErrCode const & SbiStream::Read( char& ch )
    {
        nExpandOnWriteTo = 0;
        if (aLine.isEmpty())
        {
            Read( aLine );
            aLine = aLine + OString('\n');
        }
        ch = aLine[0];
        aLine = aLine.copy(1);
        return nError;
    }

    void SbiStream::ExpandFile()
    {
        if ( nExpandOnWriteTo )
        {
            sal_uInt64 nCur = pStrm->Seek(STREAM_SEEK_TO_END);
            if( nCur < nExpandOnWriteTo )
            {
                sal_uInt64 nDiff = nExpandOnWriteTo - nCur;
                while( nDiff-- )
                {
                    pStrm->WriteChar( 0 );
                }
            }
            else
            {
                pStrm->Seek( nExpandOnWriteTo );
            }
            nExpandOnWriteTo = 0;
        }
    }

    namespace
    {
        void WriteLines(SvStream &rStream, const OString& rStr)
        {
            OString aStr(convertLineEnd(rStr, rStream.GetLineDelimiter()) );
            write_uInt8s_FromOString(rStream, aStr);
            endl( rStream );
        }
    }

    ErrCode SbiStream::Write( const OString& rBuf )
    {
        ExpandFile();
        if( IsAppend() )
        {
            pStrm->Seek( STREAM_SEEK_TO_END );
        }
        if( IsText() )
        {
            aLine = aLine + rBuf;
            // Get it out, if the end is an LF, but strip CRLF before,
            // because the SvStream adds a CRLF!
            sal_Int32 nLineLen = aLine.getLength();
            if (nLineLen && aLine[--nLineLen] == 0x0A)
            {
                aLine = aLine.copy(0, nLineLen);
                if (nLineLen && aLine[--nLineLen] == 0x0D)
                {
                    aLine = aLine.copy(0, nLineLen);
                }
                WriteLines(*pStrm, aLine);
                aLine.clear();
            }
        }
        else
        {
            if( !nLen )
            {
                return nError = ERRCODE_BASIC_BAD_RECORD_LENGTH;
            }
            pStrm->WriteBytes(rBuf.getStr(), nLen);
            MapError();
        }
        return nError;
    }

    SbiIoSystem::SbiIoSystem()
    {
        for(SbiStream* & i : pChan)
        {
            i = nullptr;
        }
        nChan  = 0;
        nError = ERRCODE_NONE;
    }

    SbiIoSystem::~SbiIoSystem() COVERITY_NOEXCEPT_FALSE
    {
        Shutdown();
    }

    ErrCode SbiIoSystem::GetError()
    {
        ErrCode n = nError;
        nError = ERRCODE_NONE;
        return n;
    }

    void SbiIoSystem::Open(short nCh, const OString& rName, StreamMode nMode, SbiStreamFlags nFlags, short nLen)
    {
        nError = ERRCODE_NONE;
        if( nCh >= CHANNELS || !nCh )
        {
            nError = ERRCODE_BASIC_BAD_CHANNEL;
        }
        else if( pChan[ nCh ] )
        {
            nError = ERRCODE_BASIC_FILE_ALREADY_OPEN;
        }
        else
        {
           pChan[ nCh ] = new SbiStream;
           nError = pChan[ nCh ]->Open( rName, nMode, nFlags, nLen );
           if( nError )
           {
                delete pChan[ nCh ];
                pChan[ nCh ] = nullptr;
           }
        }
        nChan = 0;
    }

    void SbiIoSystem::Close()
    {
        if( !nChan )
        {
            nError = ERRCODE_BASIC_BAD_CHANNEL;
        }
        else if( !pChan[ nChan ] )
        {
            nError = ERRCODE_BASIC_BAD_CHANNEL;
        }
        else
        {
            nError = pChan[ nChan ]->Close();
            delete pChan[ nChan ];
            pChan[ nChan ] = nullptr;
        }
        nChan = 0;
    }

    void SbiIoSystem::Shutdown()
    {
        for( short i = 1; i < CHANNELS; i++ )
        {
            if( pChan[ i ] )
            {
                ErrCode n = pChan[ i ]->Close();
                delete pChan[ i ];
                pChan[ i ] = nullptr;
                if( n && !nError )
                {
                    nError = n;
                }
            }
        }
        nChan = 0;
        // anything left to PRINT?
        if( !aOut.isEmpty() )
        {
            vcl::Window* pParent = Application::GetDefDialogParent();
            std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(pParent ? pParent->GetFrameWeld() : nullptr, VclMessageType::Warning,
                VclButtonsType::Ok, aOut));
            xBox->run();
        }
        aOut.clear();
    }

    void SbiIoSystem::Read(OString& rBuf)
    {
        if( !nChan )
        {
            ReadCon( rBuf );
        }
        else if( !pChan[ nChan ] )
        {
            nError = ERRCODE_BASIC_BAD_CHANNEL;
        }
        else
        {
            nError = pChan[ nChan ]->Read( rBuf );
        }
    }

    char SbiIoSystem::Read()
    {
        char ch = ' ';
        if( !nChan )
        {
            if( aIn.isEmpty() )
            {
                ReadCon( aIn );
                aIn = aIn + OString('\n');
            }
            ch = aIn[0];
            aIn = aIn.copy(1);
        }
        else if( !pChan[ nChan ] )
        {
            nError = ERRCODE_BASIC_BAD_CHANNEL;
        }
        else
        {
            nError = pChan[ nChan ]->Read( ch );
        }
        return ch;
    }

    void SbiIoSystem::Write(const OUString& rBuf)
    {
        if( !nChan )
        {
            WriteCon( rBuf );
        }
        else if( !pChan[ nChan ] )
        {
            nError = ERRCODE_BASIC_BAD_CHANNEL;
        }
        else
        {
            nError = pChan[ nChan ]->Write( OUStringToOString(rBuf, osl_getThreadTextEncoding()) );
        }
    }

    // nChannel == 0..CHANNELS-1

    SbiStream* SbiIoSystem::GetStream( short nChannel ) const
    {
        SbiStream* pRet = nullptr;
        if( nChannel >= 0 && nChannel < CHANNELS )
        {
            pRet = pChan[ nChannel ];
        }
        return pRet;
    }

    void SbiIoSystem::CloseAll()
    {
        for( short i = 1; i < CHANNELS; i++ )
        {
            if( pChan[ i ] )
            {
                ErrCode n = pChan[ i ]->Close();
                delete pChan[ i ];
                pChan[ i ] = nullptr;
                if( n && !nError )
                {
                    nError = n;
                }
            }
        }
    }

    void SbiIoSystem::ReadCon(OString& rIn)
    {
        OUString aPromptStr(OStringToOUString(aPrompt, osl_getThreadTextEncoding()));
        SbiInputDialog aDlg(nullptr, aPromptStr);
        if (aDlg.run() == RET_OK)
        {
            rIn = OUStringToOString(aDlg.GetInput(), osl_getThreadTextEncoding());
        }
        else
        {
            nError = ERRCODE_BASIC_USER_ABORT;
        }
        aPrompt.clear();
    }

    // output of a MessageBox, if there's a CR in the console-buffer

    void SbiIoSystem::WriteCon(const OUString& rText)
    {
        aOut += rText;
        sal_Int32 n1 = aOut.indexOf('\n');
        sal_Int32 n2 = aOut.indexOf('\r');
        if( n1 != -1 || n2 != -1 )
        {
            if( n1 == -1 )
            {
                n1 = n2;
            }
            else if( n2 == -1 )
            {
                n2 = n1;
            }
            if( n1 > n2 )
            {
                n1 = n2;
            }
            OUString s(aOut.copy(0, n1));
            aOut = aOut.copy(n1);
            while ( !aOut.isEmpty() && (aOut[0] == '\n' || aOut[0] == '\r') )
            {
                aOut = aOut.copy(1);
            }
            {
                SolarMutexGuard aSolarGuard;

                vcl::Window* pParent = Application::GetDefDialogParent();
                std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(pParent ? pParent->GetFrameWeld() : nullptr, VclMessageType::Warning,
                    VclButtonsType::OkCancel, s));
                xBox->set_default_response(RET_OK);
                if (!xBox->run())
                {
                    nError = ERRCODE_BASIC_USER_ABORT;
                }
            }
        }
    }

    /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

↑ V730 Not all members of a class are initialized inside the constructor. Consider inspecting: pChan.