Initial revision

1 files changed, 654 insertions, 0 deletions

diff --git a/library/qprocess.cpp b/library/qprocess.cpp
new file mode 100644
index 0000000..618c0e0
--- a/dev/null
+++ b/library/qprocess.cpp
@@ -0,0 +1,654 @@
+/****************************************************************************
+** $Id$
+**
+** 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
+
+
+/*!
+  \class QProcess qprocess.h
+
+  \brief The QProcess class is used to start external programs and to
+  communicate with them.
+
+  This is a temporary class. This will be replaced by Qt 3's QProcess class.
+*/
+
+/*!
+  \enum QProcess::Communication
+
+  This enum type defines the communication channels connected to the
+  process.
+
+  \value Stdin  Data can be written to the process's standard input.
+
+  \value Stdout  Data can be read from the process's standard output.
+
+  \value Stderr  Data can be read from the process's standard error.
+
+  \value DupStderr  Duplicates standard error to standard output for new
+  processes; i.e.  everything that the process writes to standard error, is
+  reported by QProcess on standard output instead. This is especially useful if
+  your application requires that the output on standard output and standard
+  error is read in the same order as the process output it. Please note that
+  this is a binary flag, so if you want to activate this together with standard
+  input, output and error redirection (the default), you have to specify
+  \c{Stdin|Stdout|Stderr|DupStderr} for the setCommunication() call.
+
+  \sa setCommunication() communication()
+*/
+
+/*!
+  Constructs a QProcess object. The \a parent and \a name parameters are passed
+  to the QObject constructor.
+
+  \sa setArguments() addArgument() start()
+*/
+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();
+}
+
+/*!
+  Constructs a QProcess with \a arg0 as the command to be executed. The
+  \a parent and \a name parameters are passed to the QObject constructor.
+
+  The process is not started. You must call start() or launch()
+  to start the process.
+
+  \sa setArguments() addArgument() start()
+*/
+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 );
+}
+
+/*!
+  Constructs a QProcess with \a args as the arguments of the process. The first
+  element in the list is the command to be executed. The other elements in the
+  list are the arguments to this command. The \a parent and \a name
+  parameters are passed to the QObject constructor.
+
+  The process is not started. You must call start() or launch()
+  to start the process.
+
+  \sa setArguments() addArgument() start()
+*/
+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 );
+}
+
+
+/*!
+  Returns the list of arguments that are set for the process. Arguments can be
+  specified with the constructor or with the functions setArguments() and
+  addArgument().
+
+  \sa setArguments() addArgument()
+*/
+QStringList QProcess::arguments() const
+{
+    return _arguments;
+}
+
+/*!
+  Clears the list of arguments that are set for the process.
+
+  \sa setArguments() addArgument()
+*/
+void QProcess::clearArguments()
+{
+    _arguments.clear();
+}
+
+/*!
+  Sets \a args as the arguments for the process. The first element in the list
+  is the command to be executed. The other elements in the list are the
+  arguments to the command. Any previous arguments are deleted.
+
+  \sa arguments() addArgument()
+*/
+void QProcess::setArguments( const QStringList& args )
+{
+    _arguments = args;
+}
+
+/*!
+  Adds \a arg to the end of the list of arguments.
+
+  The first element in the list of arguments is the command to be
+  executed; the following elements are the arguments to the command.
+
+  \sa arguments() setArguments()
+*/
+void QProcess::addArgument( const QString& arg )
+{
+    _arguments.append( arg );
+}
+
+#ifndef QT_NO_DIR
+/*!
+  Returns the working directory that was set with
+  setWorkingDirectory(), or the current directory if none has been
+  set.
+
+  \sa setWorkingDirectory() QDir::current()
+*/
+QDir QProcess::workingDirectory() const
+{
+    return workingDir;
+}
+
+/*!
+  Sets \a dir as the working directory for a process. This does not affect
+  running processes; only processes that are started afterwards are affected.
+
+  Setting the working directory is especially useful for processes that try to
+  access files with relative filenames.
+
+  \sa workingDirectory() start()
+*/
+void QProcess::setWorkingDirectory( const QDir& dir )
+{
+    workingDir = dir;
+}
+#endif //QT_NO_DIR
+
+/*!
+  Returns the communication required with the process.
+
+  \sa setCommunication()
+*/
+int QProcess::communication() const
+{
+    return comms;
+}
+
+/*!
+  Sets \a commFlags as the communication required with the process.
+
+  \a commFlags is a bitwise OR between the flags defined in \c Communication.
+
+  The default is \c{Stdin|Stdout|Stderr}.
+
+  \sa communication()
+*/
+void QProcess::setCommunication( int commFlags )
+{
+    comms = commFlags;
+}
+
+/*!
+  Returns TRUE if the process has exited normally; otherwise returns
+  FALSE. This implies that this function returns FALSE if the process
+  is still running.
+
+  \sa isRunning() exitStatus() processExited()
+*/
+bool QProcess::normalExit() const
+{
+    // isRunning() has the side effect that it determines the exit status!
+    if ( isRunning() )
+	return FALSE;
+    else
+	return exitNormal;
+}
+
+/*!
+  Returns the exit status of the process or 0 if the process is still
+  running. This function returns immediately and does not wait until
+  the process is finished.
+
+  If normalExit() is FALSE (e.g. if the program was killed or
+  crashed), this function returns 0, so you should check the return
+  value of normalExit() before relying on this value.
+
+  \sa normalExit() processExited()
+*/
+int QProcess::exitStatus() const
+{
+    // isRunning() has the side effect that it determines the exit status!
+    if ( isRunning() )
+	return 0;
+    else
+	return exitStat;
+}
+
+
+/*!
+  Reads the data that the process has written to standard output. When
+  new data is written to standard output, the class emits the signal
+  readyReadStdout().
+
+  If there is no data to read, this function returns a QByteArray of
+  size 0: it does not wait until there is something to read.
+
+  \sa readyReadStdout() readLineStdout() readStderr() writeToStdin()
+*/
+QByteArray QProcess::readStdout()
+{
+    if ( readStdoutCalled ) {
+	return QByteArray();
+    }
+    readStdoutCalled = TRUE;
+
+    QByteArray buf = bufStdout()->copy();
+    consumeBufStdout( -1 ); // consume everything
+
+    readStdoutCalled = FALSE;
+    return buf;
+}
+
+/*!
+  Reads the data that the process has written to standard error. When
+  new data is written to standard error, the class emits the signal
+  readyReadStderr().
+
+  If there is no data to read, this function returns a QByteArray of
+  size 0: it does not wait until there is something to read.
+
+  \sa readyReadStderr() readLineStderr() readStdout() writeToStdin()
+*/
+QByteArray QProcess::readStderr()
+{
+    if ( readStderrCalled ) {
+	return QByteArray();
+    }
+    readStderrCalled = TRUE;
+
+    QByteArray buf = bufStderr()->copy();
+    consumeBufStderr( -1 ); // consume everything
+
+    readStderrCalled = FALSE;
+    return buf;
+}
+
+/*!
+  Returns TRUE if it's possible to read an entire line of text from
+  standard output at this time; otherwise returns FALSE.
+
+  \sa readLineStdout() canReadLineStderr()
+*/
+bool QProcess::canReadLineStdout() const
+{
+    QProcess *that = (QProcess*)this;
+    return that->scanNewline( TRUE, 0 );
+}
+
+/*!
+  Returns TRUE if it's possible to read an entire line of text from
+  standard error at this time; otherwise returns FALSE.
+
+  \sa readLineStderr() canReadLineStdout()
+*/
+bool QProcess::canReadLineStderr() const
+{
+    QProcess *that = (QProcess*)this;
+    return that->scanNewline( FALSE, 0 );
+}
+
+/*!
+  Reads a line of text from standard output, excluding any trailing newline or
+  carriage return characters, and returns it. Returns QString::null if
+  canReadLineStdout() returns FALSE.
+
+  \sa canReadLineStdout() readyReadStdout() readStdout() readLineStderr()
+*/
+QString QProcess::readLineStdout()
+{
+    QByteArray a;
+    QString s;
+    if ( scanNewline( TRUE, &a ) ) {
+	if ( a.isEmpty() )
+	    s = "";
+	else
+	    s = QString( a );
+    }
+    return s;
+}
+
+/*!
+  Reads a line of text from standard error, excluding any trailing newline or
+  carriage return characters and returns it. Returns QString::null if
+  canReadLineStderr() returns FALSE.
+
+  \sa canReadLineStderr() readyReadStderr() readStderr() readLineStdout()
+*/
+QString QProcess::readLineStderr()
+{
+    QByteArray a;
+    QString s;
+    if ( scanNewline( FALSE, &a ) ) {
+	if ( a.isEmpty() )
+	    s = "";
+	else
+	    s = QString( a );
+    }
+    return s;
+}
+
+/*!
+  This private function scans for any occurrence of \n or \r\n in the
+  buffer \e buf. It stores the text in the byte array \a store if it is
+  non-null.
+*/
+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;
+}
+
+/*!
+  \fn void QProcess::launchFinished()
+
+  This signal is emitted when the process was started with launch().
+  If the start was successful, this signal is emitted after all the
+  data has been written to standard input. If the start failed, then
+  this signal is emitted immediately.
+
+  \sa launch() QObject::deleteLater()
+*/
+
+/*!
+  Runs the process and writes the data \a buf to the process's standard input.
+  If all the data is written to standard input, standard input is
+  closed. The command is searched for in the path for executable programs;
+  you can also use an absolute path in the command itself.
+
+  If \a env is null, then the process is started with the same environment as
+  the starting process. If \a env is non-null, then the values in the
+  stringlist are interpreted as environment setttings of the form \c
+  {key=value} and the process is started with these environment settings. For
+  convenience, there is a small exception to this rule under Unix: if \a env
+  does not contain any settings for the environment variable \c
+  LD_LIBRARY_PATH, then this variable is inherited from the starting process.
+
+  Returns TRUE if the process could be started; otherwise returns FALSE.
+
+  Note that you should not use the slots writeToStdin() and closeStdin() on
+  processes started with launch(), since the result is not well-defined. If you
+  need these slots, use start() instead.
+
+  The process may or may not read the \a buf data sent to its standard
+  input.
+
+  You can call this function even when a process that was started with
+  this instance is still running. Be aware that if you do this the
+  standard input of the process that was launched first will be
+  closed, with any pending data being deleted, and the process will be
+  left to run out of your control. Similarly, if the process could not
+  be started the standard input will be closed and the pending data
+  deleted. (On operating systems that have zombie processes, Qt will
+  also wait() on the old process.)
+
+  The object emits the signal launchFinished() when this function
+  call is finished. If the start was successful, this signal is
+  emitted after all the data has been written to standard input. If
+  the start failed, then this signal is emitted immediately.
+
+  \sa start() launchFinished();
+*/
+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;
+    }
+}
+
+/*! \overload
+
+  The data \a buf is written to standard input with writeToStdin()
+  using the QString::local8Bit() representation of the strings.
+*/
+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;
+    }
+}
+
+/*!
+  This private slot is used by the launch() functions to close standard input.
+*/
+void QProcess::closeStdinLaunch()
+{
+    disconnect( this, SIGNAL(wroteToStdin()),
+	    this, SLOT(closeStdinLaunch()) );
+    closeStdin();
+    emit launchFinished();
+}
+
+
+/*!
+  \fn void QProcess::readyReadStdout()
+
+  This signal is emitted when the process has written data to standard output.
+  You can read the data with readStdout().
+
+  Note that this signal is only emitted when there is new data and not
+  when there is old, but unread data. In the slot connected to this signal, you
+  should always read everything that is available at that moment to make sure
+  that you don't lose any data.
+
+  \sa readStdout() readLineStdout() readyReadStderr()
+*/
+/*!
+  \fn void QProcess::readyReadStderr()
+
+  This signal is emitted when the process has written data to standard error.
+  You can read the data with readStderr().
+
+  Note that this signal is only emitted when there is new data and not
+  when there is old, but unread data. In the slot connected to this signal, you
+  should always read everything that is available at that moment to make sure
+  that you don't lose any data.
+
+  \sa readStderr() readLineStderr() readyReadStdout()
+*/
+/*!
+  \fn void QProcess::processExited()
+
+  This signal is emitted when the process has exited.
+
+  \sa isRunning() normalExit() exitStatus() start() launch()
+*/
+/*!
+  \fn void QProcess::wroteToStdin()
+
+  This signal is emitted if the data sent to standard input (via
+  writeToStdin()) was actually written to the process. This does not
+  imply that the process really read the data, since this class only detects
+  when it was able to write the data to the operating system. But it is now
+  safe to close standard input without losing pending data.
+
+  \sa writeToStdin() closeStdin()
+*/
+
+
+/*! \overload
+
+  The string \a buf is handled as text using
+  the QString::local8Bit() representation.
+*/
+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.
+ */
+/*!  \reimp
+*/
+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;
+    }
+}
+
+/*!  \reimp
+*/
+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