Qtopia library API Documentation
	Overview Class Hierarchy Classes Classes (annotated) Members Source Files Todo

qprocess.cpp

/****************************************************************************
** $Id: qprocess.cpp,v 1.1.1.1 2002/01/25 22:14:56 kergoth Exp $
**
** Implementation of QProcess class
**
** Created : 20000905
**
** Copyright (C) 1992-2000 Trolltech AS.  All rights reserved.
**
** This file is part of the kernel module of the Qt GUI Toolkit.
**
** This file may be distributed under the terms of the Q Public License
** as defined by Trolltech AS of Norway and appearing in the file
** LICENSE.QPL included in the packaging of this file.
**
** 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.
**
** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
** licenses may use this file in accordance with the Qt Commercial License
** Agreement provided with the Software.
**
** 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/pricing.html or email sales@trolltech.com for
**   information about Qt Commercial License Agreements.
** See http://www.trolltech.com/qpl/ for QPL licensing information.
** 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)
    qDebug( "QProcess::connectNotify(): signal %s has been connected", signal );
#endif
    if ( !ioRedirection )
    if ( qstrcmp( signal, SIGNAL(readyReadStdout()) )==0 ||
        qstrcmp( signal, SIGNAL(readyReadStderr()) )==0
       ) {
#if defined(QT_QPROCESS_DEBUG)
        qDebug( "QProcess::connectNotify(): set ioRedirection to TRUE" );
#endif
        setIoRedirection( TRUE );
        return;
    }
    if ( !notifyOnExit && qstrcmp( signal, SIGNAL(processExited()) )==0 ) {
#if defined(QT_QPROCESS_DEBUG)
    qDebug( "QProcess::connectNotify(): set notifyOnExit to TRUE" );
#endif
    setNotifyOnExit( TRUE );
    return;
    }
    if ( !wroteToStdinConnected && qstrcmp( signal, SIGNAL(wroteToStdin()) )==0 ) {
#if defined(QT_QPROCESS_DEBUG)
    qDebug( "QProcess::connectNotify(): set wroteToStdinConnected to TRUE" );
#endif
    setWroteStdinConnected( TRUE );
    return;
    }
}

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

#endif // QT_NO_PROCESS

This file is part of the documentation for OPIE Version 1.5.5.

Documentation copyright © 1997-2003 the KDE developers. 2003 OPIE developers
Generated on Tue Feb 10 20:24:08 2004 by doxygen 1.3.5 written by Dimitri van Heesch, © 1997-2001