qprocess.cpp

Go to the documentation of this file.

/**********************************************************************
** Copyright (C) 2000-2002 Trolltech AS.  All rights reserved.
**
** This file is part of the Qtopia Environment.
**
** This file may be distributed and/or modified under the terms of the
** GNU General Public License version 2 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
** See http://www.trolltech.com/gpl/ for GPL licensing information.
**
** Contact info@trolltech.com if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/

#include <stdio.h>
#include <stdlib.h>

#include "qprocess.h"

#ifndef QT_NO_PROCESS

#include "qapplication.h"


//#define QT_QPROCESS_DEBUG


QProcess::QProcess( QObject *parent, const char *name )
    : QObject( parent, name ), ioRedirection( FALSE ), notifyOnExit( FALSE ),
    wroteToStdinConnected( FALSE ),
    readStdoutCalled( FALSE ), readStderrCalled( FALSE ),
    comms( Stdin|Stdout|Stderr )
{
    init();
}

QProcess::QProcess( const QString& arg0, QObject *parent, const char *name )
    : QObject( parent, name ), ioRedirection( FALSE ), notifyOnExit( FALSE ),
    wroteToStdinConnected( FALSE ),
    readStdoutCalled( FALSE ), readStderrCalled( FALSE ),
    comms( Stdin|Stdout|Stderr )
{
    init();
    addArgument( arg0 );
}

QProcess::QProcess( const QStringList& args, QObject *parent, const char *name )
    : QObject( parent, name ), ioRedirection( FALSE ), notifyOnExit( FALSE ),
    wroteToStdinConnected( FALSE ),
    readStdoutCalled( FALSE ), readStderrCalled( FALSE ),
    comms( Stdin|Stdout|Stderr )
{
    init();
    setArguments( args );
}


QStringList QProcess::arguments() const
{
    return _arguments;
}

void QProcess::clearArguments()
{
    _arguments.clear();
}

void QProcess::setArguments( const QStringList& args )
{
    _arguments = args;
}

void QProcess::addArgument( const QString& arg )
{
    _arguments.append( arg );
}

#ifndef QT_NO_DIR

QDir QProcess::workingDirectory() const
{
    return workingDir;
}

void QProcess::setWorkingDirectory( const QDir& dir )
{
    workingDir = dir;
}
#endif //QT_NO_DIR

int QProcess::communication() const
{
    return comms;
}

void QProcess::setCommunication( int commFlags )
{
    comms = commFlags;
}

bool QProcess::normalExit() const
{
    // isRunning() has the side effect that it determines the exit status!
    if ( isRunning() )
        return FALSE;
    else
        return exitNormal;
}

int QProcess::exitStatus() const
{
    // isRunning() has the side effect that it determines the exit status!
    if ( isRunning() )
        return 0;
    else
        return exitStat;
}


QByteArray QProcess::readStdout()
{
    if ( readStdoutCalled ) {
        return QByteArray();
    }
    readStdoutCalled = TRUE;

    QByteArray buf = bufStdout()->copy();
    consumeBufStdout( -1 ); // consume everything

    readStdoutCalled = FALSE;
    return buf;
}

QByteArray QProcess::readStderr()
{
    if ( readStderrCalled ) {
        return QByteArray();
    }
    readStderrCalled = TRUE;

    QByteArray buf = bufStderr()->copy();
    consumeBufStderr( -1 ); // consume everything

    readStderrCalled = FALSE;
    return buf;
}

bool QProcess::canReadLineStdout() const
{
    QProcess *that = (QProcess*)this;
    return that->scanNewline( TRUE, 0 );
}

bool QProcess::canReadLineStderr() const
{
    QProcess *that = (QProcess*)this;
    return that->scanNewline( FALSE, 0 );
}

QString QProcess::readLineStdout()
{
    QByteArray a;
    QString s;
    if ( scanNewline( TRUE, &a ) ) {
        if ( a.isEmpty() )
            s = "";
        else
            s = QString( a );
    }
    return s;
}

QString QProcess::readLineStderr()
{
    QByteArray a;
    QString s;
    if ( scanNewline( FALSE, &a ) ) {
        if ( a.isEmpty() )
            s = "";
        else
            s = QString( a );
    }
    return s;
}

bool QProcess::scanNewline( bool stdOut, QByteArray *store )
{
    QByteArray *buf;
    if ( stdOut )
        buf = bufStdout();
    else
        buf = bufStderr();
    uint n = buf->size();
    uint i;
    for ( i=0; i<n; i++ ) {
        if ( buf->at(i) == '\n' ) {
            break;
        }
    }
    if ( i >= n )
        return FALSE;

    if ( store ) {
        uint lineLength = i;
        if ( lineLength>0 && buf->at(lineLength-1) == '\r' )
            lineLength--; // (if there are two \r, let one stay)
        store->resize( lineLength );
        memcpy( store->data(), buf->data(), lineLength );
        if ( stdOut )
            consumeBufStdout( i+1 );
        else
            consumeBufStderr( i+1 );
    }
    return TRUE;
}

bool QProcess::launch( const QByteArray& buf, QStringList *env )
{
    if ( start( env ) ) {
        if ( !buf.isEmpty() ) {
            connect( this, SIGNAL(wroteToStdin()),
                    this, SLOT(closeStdinLaunch()) );
            writeToStdin( buf );
        } else {
            closeStdin();
            emit launchFinished();
        }
        return TRUE;
    } else {
        emit launchFinished();
        return FALSE;
    }
}

bool QProcess::launch( const QString& buf, QStringList *env )
{
    if ( start( env ) ) {
        if ( !buf.isEmpty() ) {
            connect( this, SIGNAL(wroteToStdin()),
                    this, SLOT(closeStdinLaunch()) );
            writeToStdin( buf );
        } else {
            closeStdin();
            emit launchFinished();
        }
        return TRUE;
    } else {
        emit launchFinished();
        return FALSE;
    }
}

void QProcess::closeStdinLaunch()
{
    disconnect( this, SIGNAL(wroteToStdin()),
            this, SLOT(closeStdinLaunch()) );
    closeStdin();
    emit launchFinished();
}


void QProcess::writeToStdin( const QString& buf )
{
    QByteArray tmp = buf.local8Bit();
    tmp.resize( buf.length() );
    writeToStdin( tmp );
}


/*
 * Under Windows the implementation is not so nice: it is not that easy to
 * detect when one of the signals should be emitted; therefore there are some
 * timers that query the information.
 * To keep it a little efficient, use the timers only when they are needed.
 * They are needed, if you are interested in the signals. So use
 * connectNotify() and disconnectNotify() to keep track of your interest.
 */
void QProcess::connectNotify( const char * signal )
{
#if defined(QT_QPROCESS_DEBUG)
    odebug << "QProcess::connectNotify(): signal " << signal << " has been connected" << oendl; 
#endif
    if ( !ioRedirection )
        if ( qstrcmp( signal, SIGNAL(readyReadStdout()) )==0 ||
                qstrcmp( signal, SIGNAL(readyReadStderr()) )==0
           ) {
#if defined(QT_QPROCESS_DEBUG)
            odebug << "QProcess::connectNotify(): set ioRedirection to TRUE" << oendl; 
#endif
            setIoRedirection( TRUE );
            return;
        }
    if ( !notifyOnExit && qstrcmp( signal, SIGNAL(processExited()) )==0 ) {
#if defined(QT_QPROCESS_DEBUG)
        odebug << "QProcess::connectNotify(): set notifyOnExit to TRUE" << oendl; 
#endif
        setNotifyOnExit( TRUE );
        return;
    }
    if ( !wroteToStdinConnected && qstrcmp( signal, SIGNAL(wroteToStdin()) )==0 ) {
#if defined(QT_QPROCESS_DEBUG)
        odebug << "QProcess::connectNotify(): set wroteToStdinConnected to TRUE" << oendl; 
#endif
        setWroteStdinConnected( TRUE );
        return;
    }
}

void QProcess::disconnectNotify( const char * )
{
    if ( ioRedirection &&
            receivers( SIGNAL(readyReadStdout()) ) ==0 &&
            receivers( SIGNAL(readyReadStderr()) ) ==0
            ) {
#if defined(QT_QPROCESS_DEBUG)
        odebug << "QProcess::disconnectNotify(): set ioRedirection to FALSE" << oendl; 
#endif
        setIoRedirection( FALSE );
    }
    if ( notifyOnExit && receivers( SIGNAL(processExited()) ) == 0 ) {
#if defined(QT_QPROCESS_DEBUG)
        odebug << "QProcess::disconnectNotify(): set notifyOnExit to FALSE" << oendl; 
#endif
        setNotifyOnExit( FALSE );
    }
    if ( wroteToStdinConnected && receivers( SIGNAL(wroteToStdin()) ) == 0 ) {
#if defined(QT_QPROCESS_DEBUG)
        odebug << "QProcess::disconnectNotify(): set wroteToStdinConnected to FALSE" << oendl; 
#endif
        setWroteStdinConnected( FALSE );
    }
}

#endif // QT_NO_PROCESS

---