cleanup and unify source layout

2 files changed, 393 insertions, 448 deletions

diff --git a/libopie2/opiecore/oprocess.cpp b/libopie2/opiecore/oprocess.cpp
index fb51bf9..f1a5f3b 100644
--- a/libopie2/opiecore/oprocess.cpp
+++ b/libopie2/opiecore/oprocess.cpp
@@ -1,970 +1,915 @@
 /*
- 
-   $Id$
- 
-   This file is part of the KDE libraries
-   Copyright (C) 1997 Christian Czezatke (e9025461@student.tuwien.ac.at)
- 
-   This library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Library General Public
-   License as published by the Free Software Foundation; either
-   version 2 of the License, or (at your option) any later version.
- 
-   This library is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Library General Public License for more details.
- 
-   You should have received a copy of the GNU Library General Public License
-   along with this library; see the file COPYING.LIB.  If not, write to
-   the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.
- 
+                            This file is part of the Opie Project
+                            Copyright (C) 2002-2004 Holger Freyther <zecke@handhelds.org>
+                            and The Opie Team <opie-devel@handhelds.org>
+             =.             Based on KProcess (C) 1997 Christian Czezatke (e9025461@student.tuwien.ac.at)
+           .=l.
+          .>+-=
+_;:,     .>    :=|.         This program is free software; you can
+.> <`_,   >  .   <=          redistribute it and/or  modify it under
+:`=1 )Y*s>-.--   :           the terms of the GNU Library General Public
+.="- .-=="i,     .._         License as published by the Free Software
+- .   .-<_>     .<>         Foundation; either version 2 of the License,
+    ._= =}       :          or (at your option) any later version.
+   .%`+i>       _;_.
+   .i_,=:_.      -<s.       This program is distributed in the hope that
+    +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
+   : ..    .:,     . . .    without even the implied warranty of
+   =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
+ _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
+..}^=.=       =       ;      Library General Public License for more
+++=   -.     .`     .:       details.
+:     =  ...= . :.=-
+-.   .:....=;==+<;          You should have received a copy of the GNU
+ -_. . .   )=.  =           Library General Public License along with
+   --        :-=`           this library; see the file COPYING.LIB.
+                            If not, write to the Free Software Foundation,
+                            Inc., 59 Temple Place - Suite 330,
+                            Boston, MA 02111-1307, USA.
 */
 
-
-//
-//  KPROCESS -- A class for handling child processes in KDE without
-//  having to take care of Un*x specific implementation details
-//
-//  version 0.3.1, Jan 8th 1998
-//
-//  (C) Christian Czezatke
-//  e9025461@student.tuwien.ac.at
-//
-// Changes:
-//
-// March 2nd, 1998: Changed parameter list for KShellProcess:
-//   Arguments are now placed in a single string so that
-//   <shell> -c <commandstring> is passed to the shell
-//   to make the use of "operator<<" consistent with KProcess
-//
-//
-//  Ported by Holger Freyther
-//   <zekce> Harlekin: oprocess and say it was ported to Qt by the Opie developers an Qt 2
-
-
-
-#include "oprocess.h"
-#define _MAY_INCLUDE_KPROCESSCONTROLLER_
 #include "oprocctrl.h"
 
-//#include <config.h>
+/* OPIE */
+#include <opie2/oprocess.h>
+
+/* QT */
 
+#include <qapplication.h>
 #include <qfile.h>
-#include <qsocketnotifier.h>
+#include <qmap.h>
 #include <qregexp.h>
+#include <qsocketnotifier.h>
 
-#include <sys/time.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <sys/socket.h>
-
+/* STD */
 #include <errno.h>
 #include <fcntl.h>
+#include <pwd.h>
 #include <stdlib.h>
 #include <signal.h>
 #include <stdio.h>
 #include <string.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/socket.h>
 #include <unistd.h>
 #ifdef HAVE_SYS_SELECT_H
 #include <sys/select.h>
 #endif
 #ifdef HAVE_INITGROUPS
 #include <grp.h>
 #endif
-#include <pwd.h>
-
-#include <qapplication.h>
-#include <qmap.h>
-//#include <kdebug.h>
-
-/////////////////////////////
-// public member functions //
-/////////////////////////////
 
 class OProcessPrivate
 {
 public:
-    OProcessPrivate() : useShell(false) { }
+    OProcessPrivate() : useShell( false )
+    { }
 
     bool useShell;
-    QMap<QString,QString> env;
+    QMap<QString, QString> env;
     QString wd;
     QCString shell;
 };
 
 
-OProcess::OProcess(QObject *parent, const char *name)
-        : QObject(parent, name)
+OProcess::OProcess( QObject *parent, const char *name )
+        : QObject( parent, name )
 {
     init ( );
 }
 
-OProcess::OProcess(const QString &arg0, QObject *parent, const char *name)
-        : QObject(parent, name)
+OProcess::OProcess( const QString &arg0, QObject *parent, const char *name )
+        : QObject( parent, name )
 {
     init ( );
     *this << arg0;
 }
 
-OProcess::OProcess(const QStringList &args, QObject *parent, const char *name)
-        : QObject(parent, name)
+OProcess::OProcess( const QStringList &args, QObject *parent, const char *name )
+        : QObject( parent, name )
 {
     init ( );
     *this << args;
 }
 
 void OProcess::init ( )
 {
     run_mode = NotifyOnExit;
     runs = false;
     pid_ = 0;
     status = 0;
     keepPrivs = false;
     innot = 0;
     outnot = 0;
     errnot = 0;
     communication = NoCommunication;
     input_data = 0;
     input_sent = 0;
     input_total = 0;
     d = 0;
 
-    if (0 == OProcessController::theOProcessController)
+    if ( 0 == OProcessController::theOProcessController )
     {
-        (void) new OProcessController();
-        CHECK_PTR(OProcessController::theOProcessController);
+        ( void ) new OProcessController();
+        CHECK_PTR( OProcessController::theOProcessController );
     }
 
-    OProcessController::theOProcessController->addOProcess(this);
-    out[0] = out[1] = -1;
-    in[0] = in[1] = -1;
-    err[0] = err[1] = -1;
+    OProcessController::theOProcessController->addOProcess( this );
+    out[ 0 ] = out[ 1 ] = -1;
+    in[ 0 ] = in[ 1 ] = -1;
+    err[ 0 ] = err[ 1 ] = -1;
 }
 
-void
-OProcess::setEnvironment(const QString &name, const QString &value)
+void OProcess::setEnvironment( const QString &name, const QString &value )
 {
-    if (!d)
+    if ( !d )
         d = new OProcessPrivate;
-    d->env.insert(name, value);
+    d->env.insert( name, value );
 }
 
-void
-OProcess::setWorkingDirectory(const QString &dir)
+void OProcess::setWorkingDirectory( const QString &dir )
 {
-    if (!d)
+    if ( !d )
         d = new OProcessPrivate;
     d->wd = dir;
 }
 
-void
-OProcess::setupEnvironment()
+void OProcess::setupEnvironment()
 {
-    if (d)
+    if ( d )
     {
-        QMap<QString,QString>::Iterator it;
-        for(it = d->env.begin(); it != d->env.end(); ++it)
-            setenv(QFile::encodeName(it.key()).data(),
-                   QFile::encodeName(it.data()).data(), 1);
-        if (!d->wd.isEmpty())
-            chdir(QFile::encodeName(d->wd).data());
+        QMap<QString, QString>::Iterator it;
+        for ( it = d->env.begin(); it != d->env.end(); ++it )
+            setenv( QFile::encodeName( it.key() ).data(),
+                    QFile::encodeName( it.data() ).data(), 1 );
+        if ( !d->wd.isEmpty() )
+            chdir( QFile::encodeName( d->wd ).data() );
     }
 }
 
-void
-OProcess::setRunPrivileged(bool keepPrivileges)
+void OProcess::setRunPrivileged( bool keepPrivileges )
 {
     keepPrivs = keepPrivileges;
 }
 
-bool
-OProcess::runPrivileged() const
+bool OProcess::runPrivileged() const
 {
     return keepPrivs;
 }
 
-
 OProcess::~OProcess()
 {
     // destroying the OProcess instance sends a SIGKILL to the
     // child process (if it is running) after removing it from the
     // list of valid processes (if the process is not started as
     // "DontCare")
 
-    OProcessController::theOProcessController->removeOProcess(this);
+    OProcessController::theOProcessController->removeOProcess( this );
     // this must happen before we kill the child
     // TODO: block the signal while removing the current process from the process list
 
-    if (runs && (run_mode != DontCare))
-        kill(SIGKILL);
+    if ( runs && ( run_mode != DontCare ) )
+        kill( SIGKILL );
 
     // Clean up open fd's and socket notifiers.
     closeStdin();
     closeStdout();
     closeStderr();
 
     // TODO: restore SIGCHLD and SIGPIPE handler if this is the last OProcess
     delete d;
 }
 
 void OProcess::detach()
 {
-    OProcessController::theOProcessController->removeOProcess(this);
+    OProcessController::theOProcessController->removeOProcess( this );
 
     runs = false;
     pid_ = 0;
 
     // Clean up open fd's and socket notifiers.
     closeStdin();
     closeStdout();
     closeStderr();
 }
 
-bool OProcess::setExecutable(const QString& proc)
+bool OProcess::setExecutable( const QString& proc )
 {
-    if (runs) return false;
+    if ( runs )
+        return false;
 
-    if (proc.isEmpty())  return false;
+    if ( proc.isEmpty() )
+        return false;
 
-    if (!arguments.isEmpty())
-        arguments.remove(arguments.begin());
-    arguments.prepend(QFile::encodeName(proc));
+    if ( !arguments.isEmpty() )
+        arguments.remove( arguments.begin() );
+    arguments.prepend( QFile::encodeName( proc ) );
 
     return true;
 }
 
-OProcess &OProcess::operator<<(const QStringList& args)
+OProcess &OProcess::operator<<( const QStringList& args )
 {
     QStringList::ConstIterator it = args.begin();
     for ( ; it != args.end() ; ++it )
-        arguments.append(QFile::encodeName(*it));
+        arguments.append( QFile::encodeName( *it ) );
     return *this;
 }
 
-OProcess &OProcess::operator<<(const QCString& arg)
+OProcess &OProcess::operator<<( const QCString& arg )
 {
-    return operator<< (arg.data());
+    return operator<< ( arg.data() );
 }
 
-OProcess &OProcess::operator<<(const char* arg)
+OProcess &OProcess::operator<<( const char* arg )
 {
-    arguments.append(arg);
+    arguments.append( arg );
     return *this;
 }
 
-OProcess &OProcess::operator<<(const QString& arg)
+OProcess &OProcess::operator<<( const QString& arg )
 {
-    arguments.append(QFile::encodeName(arg));
+    arguments.append( QFile::encodeName( arg ) );
     return *this;
 }
 
 void OProcess::clearArguments()
 {
     arguments.clear();
 }
 
-bool OProcess::start(RunMode runmode, Communication comm)
+bool OProcess::start( RunMode runmode, Communication comm )
 {
     uint i;
     uint n = arguments.count();
     char **arglist;
 
-    if (runs || (0 == n))
+    if ( runs || ( 0 == n ) )
     {
         return false;  // cannot start a process that is already running
         // or if no executable has been assigned
     }
     run_mode = runmode;
     status = 0;
 
     QCString shellCmd;
-    if (d && d->useShell)
+    if ( d && d->useShell )
     {
-        if (d->shell.isEmpty())
+        if ( d->shell.isEmpty() )
         {
             qWarning( "Could not find a valid shell" );
             return false;
         }
 
-        arglist = static_cast<char **>(malloc( (4)*sizeof(char *)));
-        for (i=0; i < n; i++)
+        arglist = static_cast<char **>( malloc( ( 4 ) * sizeof( char * ) ) );
+        for ( i = 0; i < n; i++ )
         {
-            shellCmd += arguments[i];
+            shellCmd += arguments[ i ];
             shellCmd += " "; // CC: to separate the arguments
         }
 
-        arglist[0] = d->shell.data();
-        arglist[1] = (char *) "-c";
-        arglist[2] = shellCmd.data();
-        arglist[3] = 0;
+        arglist[ 0 ] = d->shell.data();
+        arglist[ 1 ] = ( char * ) "-c";
+        arglist[ 2 ] = shellCmd.data();
+        arglist[ 3 ] = 0;
     }
     else
     {
-        arglist = static_cast<char **>(malloc( (n+1)*sizeof(char *)));
-        for (i=0; i < n; i++)
-            arglist[i] = arguments[i].data();
-        arglist[n]= 0;
+        arglist = static_cast<char **>( malloc( ( n + 1 ) * sizeof( char * ) ) );
+        for ( i = 0; i < n; i++ )
+            arglist[ i ] = arguments[ i ].data();
+        arglist[ n ] = 0;
     }
 
-    if (!setupCommunication(comm))
-        qWarning( "Could not setup Communication!");
+    if ( !setupCommunication( comm ) )
+        qWarning( "Could not setup Communication!" );
 
     // We do this in the parent because if we do it in the child process
     // gdb gets confused when the application runs from gdb.
     uid_t uid = getuid();
     gid_t gid = getgid();
 #ifdef HAVE_INITGROUPS
-    struct passwd *pw = getpwuid(uid);
+
+    struct passwd *pw = getpwuid( uid );
 #endif
 
-    int fd[2];
-    if (0 > pipe(fd))
+    int fd[ 2 ];
+    if ( 0 > pipe( fd ) )
     {
-        fd[0] = fd[1] = 0; // Pipe failed.. continue
+        fd[ 0 ] = fd[ 1 ] = 0; // Pipe failed.. continue
     }
 
     runs = true;
 
     QApplication::flushX();
 
     // WABA: Note that we use fork() and not vfork() because
     // vfork() has unclear semantics and is not standardized.
     pid_ = fork();
 
-    if (0 == pid_)
+    if ( 0 == pid_ )
     {
-        if (fd[0])
-            close(fd[0]);
-        if (!runPrivileged())
+        if ( fd[ 0 ] )
+            close( fd[ 0 ] );
+        if ( !runPrivileged() )
         {
-            setgid(gid);
+            setgid( gid );
 #if defined( HAVE_INITGROUPS)
-            if(pw)
-                initgroups(pw->pw_name, pw->pw_gid);
+
+            if ( pw )
+                initgroups( pw->pw_name, pw->pw_gid );
 #endif
-            setuid(uid);
+
+            setuid( uid );
         }
         // The child process
-        if(!commSetupDoneC())
+        if ( !commSetupDoneC() )
             qWarning( "Could not finish comm setup in child!" );
 
         setupEnvironment();
 
         // Matthias
-        if (run_mode == DontCare)
-            setpgid(0,0);
+        if ( run_mode == DontCare )
+            setpgid( 0, 0 );
         // restore default SIGPIPE handler (Harri)
         struct sigaction act;
-        sigemptyset(&(act.sa_mask));
-        sigaddset(&(act.sa_mask), SIGPIPE);
+        sigemptyset( &( act.sa_mask ) );
+        sigaddset( &( act.sa_mask ), SIGPIPE );
         act.sa_handler = SIG_DFL;
         act.sa_flags = 0;
-        sigaction(SIGPIPE, &act, 0L);
+        sigaction( SIGPIPE, &act, 0L );
 
         // We set the close on exec flag.
         // Closing of fd[1] indicates that the execvp succeeded!
-        if (fd[1])
-            fcntl(fd[1], F_SETFD, FD_CLOEXEC);
-        execvp(arglist[0], arglist);
+        if ( fd[ 1 ] )
+            fcntl( fd[ 1 ], F_SETFD, FD_CLOEXEC );
+        execvp( arglist[ 0 ], arglist );
         char resultByte = 1;
-        if (fd[1])
-            write(fd[1], &resultByte, 1);
-        _exit(-1);
+        if ( fd[ 1 ] )
+            write( fd[ 1 ], &resultByte, 1 );
+        _exit( -1 );
     }
-    else if (-1 == pid_)
+    else if ( -1 == pid_ )
     {
         // forking failed
 
         runs = false;
-        free(arglist);
+        free( arglist );
         return false;
     }
     else
     {
-        if (fd[1])
-            close(fd[1]);
+        if ( fd[ 1 ] )
+            close( fd[ 1 ] );
         // the parent continues here
 
         // Discard any data for stdin that might still be there
         input_data = 0;
 
         // Check whether client could be started.
-        if (fd[0]) for(;;)
+        if ( fd[ 0 ] )
+            for ( ;; )
             {
                 char resultByte;
-                int n = ::read(fd[0], &resultByte, 1);
-                if (n == 1)
+                int n = ::read( fd[ 0 ], &resultByte, 1 );
+                if ( n == 1 )
                 {
                     // Error
                     runs = false;
-                    close(fd[0]);
-                    free(arglist);
+                    close( fd[ 0 ] );
+                    free( arglist );
                     pid_ = 0;
                     return false;
                 }
-                if (n == -1)
+                if ( n == -1 )
                 {
-                    if ((errno == ECHILD) || (errno == EINTR))
+                    if ( ( errno == ECHILD ) || ( errno == EINTR ) )
                         continue; // Ignore
                 }
                 break; // success
             }
-        if (fd[0])
-            close(fd[0]);
+        if ( fd[ 0 ] )
+            close( fd[ 0 ] );
 
-        if (!commSetupDoneP())  // finish communication socket setup for the parent
+        if ( !commSetupDoneP() )   // finish communication socket setup for the parent
             qWarning( "Could not finish comm setup in parent!" );
 
-        if (run_mode == Block)
+        if ( run_mode == Block )
         {
             commClose();
 
             // The SIGCHLD handler of the process controller will catch
             // the exit and set the status
-            while(runs)
+            while ( runs )
             {
                 OProcessController::theOProcessController->
-                slotDoHousekeeping(0);
+                slotDoHousekeeping( 0 );
             }
             runs = FALSE;
-            emit processExited(this);
+            emit processExited( this );
         }
     }
-    free(arglist);
+    free( arglist );
     return true;
 }
 
 
 
-bool OProcess::kill(int signo)
+bool OProcess::kill( int signo )
 {
-    bool rv=false;
+    bool rv = false;
 
-    if (0 != pid_)
-        rv= (-1 != ::kill(pid_, signo));
+    if ( 0 != pid_ )
+        rv = ( -1 != ::kill( pid_, signo ) );
     // probably store errno somewhere...
     return rv;
 }
 
-
-
 bool OProcess::isRunning() const
 {
     return runs;
 }
 
-
-
 pid_t OProcess::pid() const
 {
     return pid_;
 }
 
-
-
 bool OProcess::normalExit() const
 {
     int _status = status;
-    return (pid_ != 0) && (!runs) && (WIFEXITED((_status)));
+    return ( pid_ != 0 ) && ( !runs ) && ( WIFEXITED( ( _status ) ) );
 }
 
-
-
 int OProcess::exitStatus() const
 {
     int _status = status;
-    return WEXITSTATUS((_status));
+    return WEXITSTATUS( ( _status ) );
 }
 
-
-
-bool OProcess::writeStdin(const char *buffer, int buflen)
+bool OProcess::writeStdin( const char *buffer, int buflen )
 {
     bool rv;
 
     // if there is still data pending, writing new data
     // to stdout is not allowed (since it could also confuse
     // kprocess...
-    if (0 != input_data)
+    if ( 0 != input_data )
         return false;
 
-    if (runs && (communication & Stdin))
+    if ( runs && ( communication & Stdin ) )
     {
         input_data = buffer;
         input_sent = 0;
         input_total = buflen;
-        slotSendData(0);
-        innot->setEnabled(true);
+        slotSendData( 0 );
+        innot->setEnabled( true );
         rv = true;
     }
     else
         rv = false;
     return rv;
 }
 
 void OProcess::flushStdin ( )
 {
-    if ( !input_data || ( input_sent == input_total ))
-        return;
+    if ( !input_data || ( input_sent == input_total ) )
+        return ;
 
     int d1, d2;
 
     do
     {
         d1 = input_total - input_sent;
         slotSendData ( 0 );
         d2 = input_total - input_sent;
     }
     while ( d2 <= d1 );
 }
 
 void OProcess::suspend()
 {
-    if ((communication & Stdout) && outnot)
-        outnot->setEnabled(false);
+    if ( ( communication & Stdout ) && outnot )
+        outnot->setEnabled( false );
 }
 
 void OProcess::resume()
 {
-    if ((communication & Stdout) && outnot)
-        outnot->setEnabled(true);
+    if ( ( communication & Stdout ) && outnot )
+        outnot->setEnabled( true );
 }
 
 bool OProcess::closeStdin()
 {
     bool rv;
 
-    if (communication & Stdin)
+    if ( communication & Stdin )
     {
-        communication = (Communication) (communication & ~Stdin);
+        communication = ( Communication ) ( communication & ~Stdin );
         delete innot;
         innot = 0;
-        close(in[1]);
+        close( in[ 1 ] );
         rv = true;
     }
     else
         rv = false;
     return rv;
 }
 
 bool OProcess::closeStdout()
 {
     bool rv;
 
-    if (communication & Stdout)
+    if ( communication & Stdout )
     {
-        communication = (Communication) (communication & ~Stdout);
+        communication = ( Communication ) ( communication & ~Stdout );
         delete outnot;
         outnot = 0;
-        close(out[0]);
+        close( out[ 0 ] );
         rv = true;
     }
     else
         rv = false;
     return rv;
 }
 
 bool OProcess::closeStderr()
 {
     bool rv;
 
-    if (communication & Stderr)
+    if ( communication & Stderr )
     {
-        communication = static_cast<Communication>(communication & ~Stderr);
+        communication = static_cast<Communication>( communication & ~Stderr );
         delete errnot;
         errnot = 0;
-        close(err[0]);
+        close( err[ 0 ] );
         rv = true;
     }
     else
         rv = false;
     return rv;
 }
 
-
-/////////////////////////////
-// protected slots         //
-/////////////////////////////
-
-
-
-void OProcess::slotChildOutput(int fdno)
+void OProcess::slotChildOutput( int fdno )
 {
-    if (!childOutput(fdno))
+    if ( !childOutput( fdno ) )
         closeStdout();
 }
 
-
-void OProcess::slotChildError(int fdno)
+void OProcess::slotChildError( int fdno )
 {
-    if (!childError(fdno))
+    if ( !childError( fdno ) )
         closeStderr();
 }
 
-
-void OProcess::slotSendData(int)
+void OProcess::slotSendData( int )
 {
-    if (input_sent == input_total)
+    if ( input_sent == input_total )
     {
-        innot->setEnabled(false);
+        innot->setEnabled( false );
         input_data = 0;
-        emit wroteStdin(this);
+        emit wroteStdin( this );
     }
     else
-        input_sent += ::write(in[1], input_data+input_sent, input_total-input_sent);
+        input_sent += ::write( in[ 1 ], input_data + input_sent, input_total - input_sent );
 }
 
-
-
-//////////////////////////////
-// private member functions //
-//////////////////////////////
-
-
-
-void OProcess::processHasExited(int state)
+void OProcess::processHasExited( int state )
 {
-    if (runs)
+    if ( runs )
     {
         runs = false;
         status = state;
 
         commClose(); // cleanup communication sockets
 
         // also emit a signal if the process was run Blocking
-        if (DontCare != run_mode)
+        if ( DontCare != run_mode )
         {
-            emit processExited(this);
+            emit processExited( this );
         }
     }
 }
 
-
-
-int OProcess::childOutput(int fdno)
+int OProcess::childOutput( int fdno )
 {
-    if (communication & NoRead)
+    if ( communication & NoRead )
     {
         int len = -1;
-        emit receivedStdout(fdno, len);
+        emit receivedStdout( fdno, len );
         errno = 0; // Make sure errno doesn't read "EAGAIN"
         return len;
     }
     else
     {
-        char buffer[1024];
+        char buffer[ 1024 ];
         int len;
 
-        len = ::read(fdno, buffer, 1024);
+        len = ::read( fdno, buffer, 1024 );
 
-        if ( 0 < len)
+        if ( 0 < len )
         {
-            emit receivedStdout(this, buffer, len);
+            emit receivedStdout( this, buffer, len );
         }
         return len;
     }
 }
 
-
-
-int OProcess::childError(int fdno)
+int OProcess::childError( int fdno )
 {
-    char buffer[1024];
+    char buffer[ 1024 ];
     int len;
 
-    len = ::read(fdno, buffer, 1024);
+    len = ::read( fdno, buffer, 1024 );
 
-    if ( 0 < len)
-        emit receivedStderr(this, buffer, len);
+    if ( 0 < len )
+        emit receivedStderr( this, buffer, len );
     return len;
 }
 
-
-
-int OProcess::setupCommunication(Communication comm)
+int OProcess::setupCommunication( Communication comm )
 {
     int ok;
 
     communication = comm;
 
     ok = 1;
-    if (comm & Stdin)
-        ok &= socketpair(AF_UNIX, SOCK_STREAM, 0, in) >= 0;
+    if ( comm & Stdin )
+        ok &= socketpair( AF_UNIX, SOCK_STREAM, 0, in ) >= 0;
 
-    if (comm & Stdout)
-        ok &= socketpair(AF_UNIX, SOCK_STREAM, 0, out) >= 0;
+    if ( comm & Stdout )
+        ok &= socketpair( AF_UNIX, SOCK_STREAM, 0, out ) >= 0;
 
-    if (comm & Stderr)
-        ok &= socketpair(AF_UNIX, SOCK_STREAM, 0, err) >= 0;
+    if ( comm & Stderr )
+        ok &= socketpair( AF_UNIX, SOCK_STREAM, 0, err ) >= 0;
 
     return ok;
 }
 
-
-
 int OProcess::commSetupDoneP()
 {
     int ok = 1;
 
-    if (communication != NoCommunication)
+    if ( communication != NoCommunication )
     {
-        if (communication & Stdin)
-            close(in[0]);
-        if (communication & Stdout)
-            close(out[1]);
-        if (communication & Stderr)
-            close(err[1]);
+        if ( communication & Stdin )
+            close( in[ 0 ] );
+        if ( communication & Stdout )
+            close( out[ 1 ] );
+        if ( communication & Stderr )
+            close( err[ 1 ] );
 
         // Don't create socket notifiers and set the sockets non-blocking if
         // blocking is requested.
-        if (run_mode == Block) return ok;
+        if ( run_mode == Block )
+            return ok;
 
-        if (communication & Stdin)
+        if ( communication & Stdin )
         {
             //        ok &= (-1 != fcntl(in[1], F_SETFL, O_NONBLOCK));
-            innot =  new QSocketNotifier(in[1], QSocketNotifier::Write, this);
-            CHECK_PTR(innot);
-            innot->setEnabled(false); // will be enabled when data has to be sent
-            QObject::connect(innot, SIGNAL(activated(int)),
-                             this, SLOT(slotSendData(int)));
+            innot = new QSocketNotifier( in[ 1 ], QSocketNotifier::Write, this );
+            CHECK_PTR( innot );
+            innot->setEnabled( false ); // will be enabled when data has to be sent
+            QObject::connect( innot, SIGNAL( activated( int ) ),
+                              this, SLOT( slotSendData( int ) ) );
         }
 
-        if (communication & Stdout)
+        if ( communication & Stdout )
         {
             //        ok &= (-1 != fcntl(out[0], F_SETFL, O_NONBLOCK));
-            outnot = new QSocketNotifier(out[0], QSocketNotifier::Read, this);
-            CHECK_PTR(outnot);
-            QObject::connect(outnot, SIGNAL(activated(int)),
-                             this, SLOT(slotChildOutput(int)));
-            if (communication & NoRead)
+            outnot = new QSocketNotifier( out[ 0 ], QSocketNotifier::Read, this );
+            CHECK_PTR( outnot );
+            QObject::connect( outnot, SIGNAL( activated( int ) ),
+                              this, SLOT( slotChildOutput( int ) ) );
+            if ( communication & NoRead )
                 suspend();
         }
 
-        if (communication & Stderr)
+        if ( communication & Stderr )
         {
             //        ok &= (-1 != fcntl(err[0], F_SETFL, O_NONBLOCK));
-            errnot = new QSocketNotifier(err[0], QSocketNotifier::Read, this );
-            CHECK_PTR(errnot);
-            QObject::connect(errnot, SIGNAL(activated(int)),
-                             this, SLOT(slotChildError(int)));
+            errnot = new QSocketNotifier( err[ 0 ], QSocketNotifier::Read, this );
+            CHECK_PTR( errnot );
+            QObject::connect( errnot, SIGNAL( activated( int ) ),
+                              this, SLOT( slotChildError( int ) ) );
         }
     }
     return ok;
 }
 
-
-
 int OProcess::commSetupDoneC()
 {
     int ok = 1;
     struct linger so;
-    memset(&so, 0, sizeof(so));
+    memset( &so, 0, sizeof( so ) );
 
-    if (communication & Stdin)
-        close(in[1]);
-    if (communication & Stdout)
-        close(out[0]);
-    if (communication & Stderr)
-        close(err[0]);
+    if ( communication & Stdin )
+        close( in[ 1 ] );
+    if ( communication & Stdout )
+        close( out[ 0 ] );
+    if ( communication & Stderr )
+        close( err[ 0 ] );
 
-    if (communication & Stdin)
-        ok &= dup2(in[0],  STDIN_FILENO) != -1;
+    if ( communication & Stdin )
+        ok &= dup2( in[ 0 ], STDIN_FILENO ) != -1;
     else
     {
         int null_fd = open( "/dev/null", O_RDONLY );
         ok &= dup2( null_fd, STDIN_FILENO ) != -1;
         close( null_fd );
     }
-    if (communication & Stdout)
+    if ( communication & Stdout )
     {
-        ok &= dup2(out[1], STDOUT_FILENO) != -1;
-        ok &= !setsockopt(out[1], SOL_SOCKET, SO_LINGER, (char*)&so, sizeof(so));
+        ok &= dup2( out[ 1 ], STDOUT_FILENO ) != -1;
+        ok &= !setsockopt( out[ 1 ], SOL_SOCKET, SO_LINGER, ( char* ) & so, sizeof( so ) );
     }
     else
     {
         int null_fd = open( "/dev/null", O_WRONLY );
         ok &= dup2( null_fd, STDOUT_FILENO ) != -1;
         close( null_fd );
     }
-    if (communication & Stderr)
+    if ( communication & Stderr )
     {
-        ok &= dup2(err[1], STDERR_FILENO) != -1;
-        ok &= !setsockopt(err[1], SOL_SOCKET, SO_LINGER, reinterpret_cast<char *>(&so), sizeof(so));
+        ok &= dup2( err[ 1 ], STDERR_FILENO ) != -1;
+        ok &= !setsockopt( err[ 1 ], SOL_SOCKET, SO_LINGER, reinterpret_cast<char *>( &so ), sizeof( so ) );
     }
     else
     {
         int null_fd = open( "/dev/null", O_WRONLY );
         ok &= dup2( null_fd, STDERR_FILENO ) != -1;
         close( null_fd );
     }
     return ok;
 }
 
-
-
 void OProcess::commClose()
 {
-    if (NoCommunication != communication)
+    if ( NoCommunication != communication )
     {
-        bool b_in = (communication & Stdin);
-        bool b_out = (communication & Stdout);
-        bool b_err = (communication & Stderr);
-        if (b_in)
+        bool b_in = ( communication & Stdin );
+        bool b_out = ( communication & Stdout );
+        bool b_err = ( communication & Stderr );
+        if ( b_in )
             delete innot;
 
-        if (b_out || b_err)
+        if ( b_out || b_err )
         {
             // If both channels are being read we need to make sure that one socket buffer
             // doesn't fill up whilst we are waiting for data on the other (causing a deadlock).
             // Hence we need to use select.
 
             // Once one or other of the channels has reached EOF (or given an error) go back
             // to the usual mechanism.
 
             int fds_ready = 1;
             fd_set rfds;
 
             int max_fd = 0;
-            if (b_out)
+            if ( b_out )
             {
-                fcntl(out[0], F_SETFL, O_NONBLOCK);
-                if (out[0] > max_fd)
-                    max_fd = out[0];
+                fcntl( out[ 0 ], F_SETFL, O_NONBLOCK );
+                if ( out[ 0 ] > max_fd )
+                    max_fd = out[ 0 ];
                 delete outnot;
                 outnot = 0;
             }
-            if (b_err)
+            if ( b_err )
             {
-                fcntl(err[0], F_SETFL, O_NONBLOCK);
-                if (err[0] > max_fd)
-                    max_fd = err[0];
+                fcntl( err[ 0 ], F_SETFL, O_NONBLOCK );
+                if ( err[ 0 ] > max_fd )
+                    max_fd = err[ 0 ];
                 delete errnot;
                 errnot = 0;
             }
 
 
-            while (b_out || b_err)
+            while ( b_out || b_err )
             {
                 // * If the process is still running we block until we
                 // receive data. (p_timeout = 0, no timeout)
                 // * If the process has already exited, we only check
                 // the available data, we don't wait for more.
                 // (p_timeout = &timeout, timeout immediately)
                 struct timeval timeout;
                 timeout.tv_sec = 0;
                 timeout.tv_usec = 0;
                 struct timeval *p_timeout = runs ? 0 : &timeout;
 
-                FD_ZERO(&rfds);
-                if (b_out)
-                    FD_SET(out[0], &rfds);
+                FD_ZERO( &rfds );
+                if ( b_out )
+                    FD_SET( out[ 0 ], &rfds );
 
-                if (b_err)
-                    FD_SET(err[0], &rfds);
+                if ( b_err )
+                    FD_SET( err[ 0 ], &rfds );
 
-                fds_ready = select(max_fd+1, &rfds, 0, 0, p_timeout);
-                if (fds_ready <= 0) break;
+                fds_ready = select( max_fd + 1, &rfds, 0, 0, p_timeout );
+                if ( fds_ready <= 0 )
+                    break;
 
-                if (b_out && FD_ISSET(out[0], &rfds))
+                if ( b_out && FD_ISSET( out[ 0 ], &rfds ) )
                 {
                     int ret = 1;
-                    while (ret > 0) ret = childOutput(out[0]);
-                    if ((ret == -1 && errno != EAGAIN) || ret == 0)
+                    while ( ret > 0 )
+                        ret = childOutput( out[ 0 ] );
+                    if ( ( ret == -1 && errno != EAGAIN ) || ret == 0 )
                         b_out = false;
                 }
 
-                if (b_err && FD_ISSET(err[0], &rfds))
+                if ( b_err && FD_ISSET( err[ 0 ], &rfds ) )
                 {
                     int ret = 1;
-                    while (ret > 0) ret = childError(err[0]);
-                    if ((ret == -1 && errno != EAGAIN) || ret == 0)
+                    while ( ret > 0 )
+                        ret = childError( err[ 0 ] );
+                    if ( ( ret == -1 && errno != EAGAIN ) || ret == 0 )
                         b_err = false;
                 }
             }
         }
 
-        if (b_in)
+        if ( b_in )
         {
-            communication = (Communication) (communication & ~Stdin);
-            close(in[1]);
+            communication = ( Communication ) ( communication & ~Stdin );
+            close( in[ 1 ] );
         }
-        if (b_out)
+        if ( b_out )
         {
-            communication = (Communication) (communication & ~Stdout);
-            close(out[0]);
+            communication = ( Communication ) ( communication & ~Stdout );
+            close( out[ 0 ] );
         }
-        if (b_err)
+        if ( b_err )
         {
-            communication = (Communication) (communication & ~Stderr);
-            close(err[0]);
+            communication = ( Communication ) ( communication & ~Stderr );
+            close( err[ 0 ] );
         }
     }
 }
 
-void OProcess::setUseShell(bool useShell, const char *shell)
+void OProcess::setUseShell( bool useShell, const char *shell )
 {
-    if (!d)
+    if ( !d )
         d = new OProcessPrivate;
     d->useShell = useShell;
     d->shell = shell;
-    if (d->shell.isEmpty())
+    if ( d->shell.isEmpty() )
         d->shell = searchShell();
 }
 
-QString OProcess::quote(const QString &arg)
+QString OProcess::quote( const QString &arg )
 {
     QString res = arg;
-    res.replace(QRegExp(QString::fromLatin1("\'")),
-                QString::fromLatin1("'\"'\"'"));
-    res.prepend('\'');
-    res.append('\'');
+    res.replace( QRegExp( QString::fromLatin1( "\'" ) ),
+                 QString::fromLatin1( "'\"'\"'" ) );
+    res.prepend( '\'' );
+    res.append( '\'' );
     return res;
 }
 
 QCString OProcess::searchShell()
 {
-    QCString tmpShell = QCString(getenv("SHELL")).stripWhiteSpace();
-    if (!isExecutable(tmpShell))
+    QCString tmpShell = QCString( getenv( "SHELL" ) ).stripWhiteSpace();
+    if ( !isExecutable( tmpShell ) )
     {
         tmpShell = "/bin/sh";
     }
 
     return tmpShell;
 }
 
-bool OProcess::isExecutable(const QCString &filename)
+bool OProcess::isExecutable( const QCString &filename )
 {
     struct stat fileinfo;
 
-    if (filename.isEmpty()) return false;
+    if ( filename.isEmpty() )
+        return false;
 
     // CC: we've got a valid filename, now let's see whether we can execute that file
 
-    if (-1 == stat(filename.data(), &fileinfo)) return false;
+    if ( -1 == stat( filename.data(), &fileinfo ) )
+        return false;
     // CC: return false if the file does not exist
 
     // CC: anyway, we cannot execute directories, block/character devices, fifos or sockets
-    if ( (S_ISDIR(fileinfo.st_mode))  ||
-            (S_ISCHR(fileinfo.st_mode))  ||
-            (S_ISBLK(fileinfo.st_mode))  ||
+    if ( ( S_ISDIR( fileinfo.st_mode ) ) ||
+            ( S_ISCHR( fileinfo.st_mode ) ) ||
+            ( S_ISBLK( fileinfo.st_mode ) ) ||
 #ifdef S_ISSOCK
             // CC: SYSVR4 systems don't have that macro
-            (S_ISSOCK(fileinfo.st_mode)) ||
+            ( S_ISSOCK( fileinfo.st_mode ) ) ||
 #endif
-            (S_ISFIFO(fileinfo.st_mode)) ||
-            (S_ISDIR(fileinfo.st_mode)) )
+            ( S_ISFIFO( fileinfo.st_mode ) ) ||
+            ( S_ISDIR( fileinfo.st_mode ) ) )
     {
         return false;
     }
 
     // CC: now check for permission to execute the file
-    if (access(filename.data(), X_OK) != 0) return false;
+    if ( access( filename.data(), X_OK ) != 0 )
+        return false;
 
     // CC: we've passed all the tests...
     return true;
 }
 
-
-
diff --git a/libopie2/opiecore/oprocess.h b/libopie2/opiecore/oprocess.h
index 8dd19b5..352485b 100644
--- a/libopie2/opiecore/oprocess.h
+++ b/libopie2/opiecore/oprocess.h
@@ -1,63 +1,67 @@
-/* This file is part of the KDE libraries
-    Copyright (C) 1997 Christian Czezakte (e9025461@student.tuwien.ac.at)
- 
-    This library is free software; you can redistribute it and/or
-    modify it under the terms of the GNU Library General Public
-    License as published by the Free Software Foundation; either
-    version 2 of the License, or (at your option) any later version.
- 
-    This library is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-    Library General Public License for more details.
- 
-    You should have received a copy of the GNU Library General Public License
-    along with this library; see the file COPYING.LIB.  If not, write to
-    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-    Boston, MA 02111-1307, USA.
+/*
+                            This file is part of the Opie Project
+                            Copyright (C) 2003-2004 Holger Freyther <zecke@handhelds.org>
+                            Copyright (C) The Opie Team <opie-devel@handhelds.org>
+             =.             Based on KProcess (C) 1997 Christian Czezatke (e9025461@student.tuwien.ac.at)
+           .=l.
+          .>+-=
+_;:,     .>    :=|.         This program is free software; you can
+.> <`_,   >  .   <=         redistribute it and/or  modify it under
+:`=1 )Y*s>-.--   :          the terms of the GNU Library General Public
+.="- .-=="i,     .._        License as published by the Free Software
+- .   .-<_>     .<>         Foundation; either version 2 of the License,
+    ._= =}       :          or (at your option) any later version.
+   .%`+i>       _;_.
+   .i_,=:_.      -<s.       This program is distributed in the hope that
+    +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
+   : ..    .:,     . . .    without even the implied warranty of
+   =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
+ _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
+..}^=.=       =       ;     Library General Public License for more
+++=   -.     .`     .:      details.
+:     =  ...= . :.=-
+-.   .:....=;==+<;          You should have received a copy of the GNU
+ -_. . .   )=.  =           Library General Public License along with
+   --        :-=`           this library; see the file COPYING.LIB.
+                            If not, write to the Free Software Foundation,
+                            Inc., 59 Temple Place - Suite 330,
+                            Boston, MA 02111-1307, USA.
 */
-//
-//  KPROCESS -- A class for handling child processes in KDE without
-//  having to take care of Un*x specific implementation details
-//
-//  version 0.3.1, Jan 8th 1998
-//
-//  (C) Christian Czezatke
-//  e9025461@student.tuwien.ac.at
-//  Ported by Holger Freyther to the Open Palmtop Integrated Environment
-//
-
-#ifndef __kprocess_h__
-#define __kprocess_h__
 
+#ifndef OPROCESS_H
+#define OPROCESS_H
+
+/* QT */
+#include <qcstring.h>
+#include <qobject.h>
+#include <qvaluelist.h>
+
+/* STD */
 #include <sys/types.h> // for pid_t
 #include <sys/wait.h>
 #include <signal.h>
 #include <unistd.h>
-#include <qvaluelist.h>
-#include <qcstring.h>
-#include <qobject.h>
 
 class QSocketNotifier;
 class OProcessPrivate;
 
 /**
  * Child process invocation, monitoring and control.
  *
  * @sect General usage and features
  *
  *This class allows a KDE and OPIE application to start child processes without having
  *to worry about UN*X signal handling issues and zombie process reaping.
  *
  *@see KProcIO
  *
  *Basically, this class distinguishes three different ways of running
  *child processes:
  *
  *@li  OProcess::DontCare -- The child process is invoked and both the child
  *process and the parent process continue concurrently.
  *
  *Starting a  DontCare child process means that the application is
  *not interested in any notification to determine whether the
  *child process has already exited or not.
  *
@@ -120,453 +124,453 @@ class OProcessPrivate;
  *@li bool @ref closeStdout();
  *@li -- Closes the child process's stdout.
  *Returns false if you try to close stdout for a process that has been started
  *without a communication channel to stdout.
  *
  *@li bool @ref closeStderr();
  *@li -- Closes the child process's stderr.
  *Returns false if you try to close stderr for a process that has been started
  *without a communication channel to stderr.
  *
  *
  *@sect QT signals:
  *
  *@li void @ref receivedStdout(OProcess  *proc, char  *buffer, int  buflen);
  *@li  void @ref receivedStderr(OProcess  *proc, char  *buffer, int  buflen);
  *@li  -- Indicates that new data has arrived from either the
  *child process's stdout or stderr.
  *
  *@li  void @ref wroteStdin(OProcess  *proc);
  *@li  -- Indicates that all data that has been sent to the child process
  *by a prior call to @ref writeStdin() has actually been transmitted to the
  *client .
  *
  *@author Christian Czezakte e9025461@student.tuwien.ac.at
- *
+ *@author Holger Freyther (Opie Port)
  *
  **/
 class OProcess : public QObject
 {
     Q_OBJECT
 
 public:
 
     /**
      * Modes in which the communication channel can be opened.
      *
      * If communication for more than one channel is required,
      * the values have to be or'ed together, for example to get
      * communication with stdout as well as with stdin, you would
      * specify @p Stdin @p | @p Stdout
      *
      * If @p NoRead is specified in conjunction with @p Stdout,
      * no data is actually read from @p Stdout but only
      * the signal @ref childOutput(int fd) is emitted.
      */
     enum Communication { NoCommunication = 0, Stdin = 1, Stdout = 2, Stderr = 4,
                          AllOutput = 6, All = 7,
                          NoRead };
 
     /**
      * Run-modes for a child process.
      */
     enum RunMode {
         /**
          * The application does not receive notifications from the subprocess when
          * it is finished or aborted.
          */
         DontCare,
         /**
          * The application is notified when the subprocess dies.
          */
         NotifyOnExit,
         /**
          * The application is suspended until the started process is finished.
          */
         Block };
 
     /**
      * Constructor
      */
-    OProcess(QObject *parent = 0, const char *name = 0);
+    OProcess( QObject *parent = 0, const char *name = 0 );
     /**
      * Constructor
      */
-    OProcess(const QString &arg0, QObject *parent = 0, const char *name = 0);
+    OProcess( const QString &arg0, QObject *parent = 0, const char *name = 0 );
     /**
      * Constructor
      */
-    OProcess(const QStringList &args, QObject *parent = 0, const char *name = 0);
+    OProcess( const QStringList &args, QObject *parent = 0, const char *name = 0 );
 
     /**
      *Destructor:
      *
      *  If the process is running when the destructor for this class
      *  is called, the child process is killed with a SIGKILL, but
      *  only if the run mode is not of type @p DontCare.
      *  Processes started as @p DontCare keep running anyway.
     */
     virtual ~OProcess();
 
     /**
      @deprecated
 
            The use of this function is now deprecated. -- Please use the
     "operator<<" instead of "setExecutable".
 
     Sets the executable to be started with this OProcess object.
     Returns false if the process is currently running (in that
     case the executable remains unchanged.)
 
     @see operator<<
 
     */
-    bool setExecutable(const QString& proc);
+    bool setExecutable( const QString& proc );
 
 
     /**
      * Sets the executable and the command line argument list for this process.
      *
      * For example, doing an "ls -l /usr/local/bin" can be achieved by:
      *  <pre>
      *  OProcess p;
      *  ...
      *  p << "ls" << "-l" << "/usr/local/bin"
      *  </pre>
      *
      **/
-    OProcess &operator<<(const QString& arg);
+    OProcess &operator<<( const QString& arg );
     /**
      * Similar to previous method, takes a char *, supposed to be in locale 8 bit already.
      */
-    OProcess &operator<<(const char * arg);
+    OProcess &operator<<( const char * arg );
     /**
      * Similar to previous method, takes a QCString, supposed to be in locale 8 bit already.
      */
-    OProcess &operator<<(const QCString & arg);
+    OProcess &operator<<( const QCString & arg );
 
     /**
      * Sets the executable and the command line argument list for this process,
      * in a single method call, or add a list of arguments.
      **/
-    OProcess &operator<<(const QStringList& args);
+    OProcess &operator<<( const QStringList& args );
 
     /**
      * Clear a command line argument list that has been set by using
      * the "operator<<".
     */
     void clearArguments();
 
     /**
      *  Starts the process.
      *  For a detailed description of the
      *  various run modes and communication semantics, have a look at the
      *  general description of the OProcess class.
      *
      *  The following problems could cause this function to
      *    return false:
      *
      *  @li The process is already running.
      *  @li The command line argument list is empty.
      *  @li The starting of the process failed (could not fork).
      *  @li The executable was not found.
      *
      *  @param comm  Specifies which communication links should be
      *  established to the child process (stdin/stdout/stderr). By default,
      *  no communication takes place and the respective communication
      *  signals will never get emitted.
      *
      *  @return true on success, false on error
      *  (see above for error conditions)
      **/
-    virtual bool start(RunMode  runmode = NotifyOnExit,
-                       Communication comm = NoCommunication);
+    virtual bool start( RunMode runmode = NotifyOnExit,
+                        Communication comm = NoCommunication );
 
     /**
      * Stop the process (by sending it a signal).
      *
      * @param signo	The signal to send. The default is SIGTERM.
      * @return @p true if the signal was delivered successfully.
     */
-    virtual bool kill(int signo = SIGTERM);
+    virtual bool kill( int signo = SIGTERM );
 
     /**
        @return @p true if the process is (still) considered to be running
     */
     bool isRunning() const;
 
     /** Returns the process id of the process.
      *
      * If it is called after
      * the process has exited, it returns the process id of the last
      *  child process that was created by this instance of OProcess.
      *
      *  Calling it before any child process has been started by this
      *  OProcess instance causes pid() to return 0.
      **/
     pid_t pid() const;
 
     /**
      * Suspend processing of data from stdout of the child process.
      */
     void suspend();
 
     /**
      * Resume processing of data from stdout of the child process.
      */
     void resume();
 
     /**
      * @return @p true if the process has already finished and has exited
      *  "voluntarily", ie: it has not been killed by a signal.
      *
      * Note that you should check @ref OProcess::exitStatus() to determine
      * whether the process completed its task successful or not.
      */
     bool normalExit() const;
 
     /**
      * Returns the exit status of the process.
      *
      * Please use
      * @ref OProcess::normalExit() to check whether the process has exited
      * cleanly (i.e., @ref OProcess::normalExit() returns @p true) before calling
      * this function because if the process did not exit normally,
      * it does not have a valid exit status.
     */
-    int  exitStatus() const;
+    int exitStatus() const;
 
 
     /**
      *	 Transmit data to the child process's stdin.
      *
      * OProcess::writeStdin may return false in the following cases:
      *
      *     @li The process is not currently running.
      *
      *     @li Communication to stdin has not been requested in the @ref start() call.
      *
      *     @li Transmission of data to the child process by a previous call to
      * @ref writeStdin() is still in progress.
      *
      * Please note that the data is sent to the client asynchronously,
      * so when this function returns, the data might not have been
      * processed by the child process.
      *
      * If all the data has been sent to the client, the signal
      * @ref wroteStdin() will be emitted.
      *
      * Please note that you must not free "buffer" or call @ref writeStdin()
      * again until either a @ref wroteStdin() signal indicates that the
      * data has been sent or a @ref processHasExited() signal shows that
      * the child process is no longer alive...
      **/
-    bool writeStdin(const char *buffer, int buflen);
+    bool writeStdin( const char *buffer, int buflen );
 
     void flushStdin();
 
     /**
      * This causes the stdin file descriptor of the child process to be
      * closed indicating an "EOF" to the child.
      *
      * @return @p false if no communication to the process's stdin
      *  had been specified in the call to @ref start().
     */
     bool closeStdin();
 
     /**
      * This causes the stdout file descriptor of the child process to be
      * closed.
      *
      * @return @p false if no communication to the process's stdout
      *  had been specified in the call to @ref start().
     */
     bool closeStdout();
 
     /**
      * This causes the stderr file descriptor of the child process to be
      * closed.
      *
      * @return @p false if no communication to the process's stderr
      *  had been specified in the call to @ref start().
     */
     bool closeStderr();
 
     /**
      * Lets you see what your arguments are for debugging.
      */
 
-    const QValueList<QCString> &args() { return arguments; }
+    const QValueList<QCString> &args()
+    {
+        return arguments;
+    }
 
     /**
      * Controls whether the started process should drop any
      * setuid/segid privileges or whether it should keep them
      *
      * The default is @p false : drop privileges
      */
-    void setRunPrivileged(bool keepPrivileges);
+    void setRunPrivileged( bool keepPrivileges );
 
     /**
      * Returns whether the started process will drop any
      * setuid/segid privileges or whether it will keep them
      */
     bool runPrivileged() const;
 
     /**
      * Modifies the environment of the process to be started.
      * This function must be called before starting the process.
      */
-    void setEnvironment(const QString &name, const QString &value);
+    void setEnvironment( const QString &name, const QString &value );
 
     /**
      * Changes the current working directory (CWD) of the process
      * to be started.
      * This function must be called before starting the process.
      */
-    void setWorkingDirectory(const QString &dir);
+    void setWorkingDirectory( const QString &dir );
 
     /**
      * Specify whether to start the command via a shell or directly.
      * The default is to start the command directly.
      * If @p useShell is true @p shell will be used as shell, or
      * if shell is empty, the standard shell is used.
      * @p quote A flag indicating whether to quote the arguments.
      *
      * When using a shell, the caller should make sure that all filenames etc.
      * are properly quoted when passed as argument.
      * @see quote()
      */
-    void setUseShell(bool useShell, const char *shell = 0);
+    void setUseShell( bool useShell, const char *shell = 0 );
 
     /**
      * This function can be used to quote an argument string such that
      * the shell processes it properly. This is e. g. necessary for
      * user-provided file names which may contain spaces or quotes.
      * It also prevents expansion of wild cards and environment variables.
      */
-    static QString quote(const QString &arg);
+    static QString quote( const QString &arg );
 
     /**
      * Detaches OProcess from child process. All communication is closed.
      * No exit notification is emitted any more for the child process.
      * Deleting the OProcess will no longer kill the child process.
      * Note that the current process remains the parent process of the
      * child process.
      */
     void detach();
 
-
-
 signals:
 
     /**
      * Emitted after the process has terminated when
      * the process was run in the @p NotifyOnExit  (==default option to
      * @ref start()) or the @ref Block mode.
      **/
-    void processExited(OProcess *proc);
+    void processExited( OProcess *proc );
 
 
     /**
      * Emitted, when output from the child process has
      * been received on stdout.
      *
      *  To actually get
      * these signals, the respective communication link (stdout/stderr)
      * has to be turned on in @ref start().
      *
      * @param buffer The data received.
      * @param buflen The number of bytes that are available.
      *
      * You should copy the information contained in @p buffer to your private
      * data structures before returning from this slot.
      **/
-    void receivedStdout(OProcess *proc, char *buffer, int buflen);
+    void receivedStdout( OProcess *proc, char *buffer, int buflen );
 
     /**
      * Emitted when output from the child process has
      * been received on stdout.
      *
      * To actually get these signals, the respective communications link
      * (stdout/stderr) has to be turned on in @ref start() and the
      * @p NoRead flag should have been passed.
      *
      * You will need to explicitly call resume() after your call to start()
      * to begin processing data from the child process's stdout.  This is
      * to ensure that this signal is not emitted when no one is connected
      * to it, otherwise this signal will not be emitted.
      *
      * The data still has to be read from file descriptor @p fd.
      **/
-    void receivedStdout(int fd, int &len);
+    void receivedStdout( int fd, int &len );
 
 
     /**
      * Emitted, when output from the child process has
      * been received on stderr.
      * To actually get
      * these signals, the respective communication link (stdout/stderr)
      * has to be turned on in @ref start().
      *
      * @param buffer The data received.
      * @param buflen The number of bytes that are available.
      *
      * You should copy the information contained in @p buffer to your private
      * data structures before returning from this slot.
     */
-    void receivedStderr(OProcess *proc, char *buffer, int buflen);
+    void receivedStderr( OProcess *proc, char *buffer, int buflen );
 
     /**
      * Emitted after all the data that has been
      * specified by a prior call to @ref writeStdin() has actually been
      * written to the child process.
      **/
-    void wroteStdin(OProcess *proc);
-
+    void wroteStdin( OProcess *proc );
 
 protected slots:
 
     /**
      * This slot gets activated when data from the child's stdout arrives.
      * It usually calls "childOutput"
      */
-    void slotChildOutput(int fdno);
+    void slotChildOutput( int fdno );
 
     /**
      * This slot gets activated when data from the child's stderr arrives.
      * It usually calls "childError"
      */
-    void slotChildError(int fdno);
+    void slotChildError( int fdno );
     /*
     Slot functions for capturing stdout and stderr of the child
     */
 
     /**
      * Called when another bulk of data can be sent to the child's
      * stdin. If there is no more data to be sent to stdin currently
      * available, this function must disable the QSocketNotifier "innot".
      */
-    void slotSendData(int dummy);
+    void slotSendData( int dummy );
 
 protected:
 
     /**
      * Sets up the environment according to the data passed via
      * setEnvironment(...)
      */
     void setupEnvironment();
 
     /**
      * The list of the process' command line arguments. The first entry
      * in this list is the executable itself.
      */
     QValueList<QCString> arguments;
     /**
      * How to run the process (Block, NotifyOnExit, DontCare). You should
      *  not modify this data member directly from derived classes.
      */
     RunMode run_mode;
     /**
      * true if the process is currently running. You should not
      * modify this data member directly from derived classes. For
      * reading the value of this data member, please use "isRunning()"
      * since "runs" will probably be made private in later versions
@@ -603,145 +607,141 @@ protected:
     setupCommunication
     -- is called from "start" before "fork"ing.
     commSetupDoneP
     -- completes communication socket setup in the parent
     commSetupDoneC
     -- completes communication setup in the child process
     commClose
     -- frees all allocated communication resources in the parent
     after the process has exited
     */
 
     /**
      * This function is called from "OProcess::start" right before a "fork" takes
      * place. According to
      * the "comm" parameter this function has to initialize the "in", "out" and
      * "err" data member of OProcess.
      *
      * This function should return 0 if setting the needed communication channels
      * was successful.
      *
      * The default implementation is to create UNIX STREAM sockets for the communication,
      * but you could overload this function and establish a TCP/IP communication for
      * network communication, for example.
      */
-    virtual int setupCommunication(Communication comm);
+    virtual int setupCommunication( Communication comm );
 
     /**
      * Called right after a (successful) fork on the parent side. This function
      * will usually do some communications cleanup, like closing the reading end
      * of the "stdin" communication channel.
      *
      * Furthermore, it must also create the QSocketNotifiers "innot", "outnot" and
      * "errnot" and connect their Qt slots to the respective OProcess member functions.
      *
      * For a more detailed explanation, it is best to have a look at the default
      * implementation of "setupCommunication" in kprocess.cpp.
      */
     virtual int commSetupDoneP();
 
     /**
      * Called right after a (successful) fork, but before an "exec" on the child
      * process' side. It usually just closes the unused communication ends of
      * "in", "out" and "err" (like the writing end of the "in" communication
      * channel.
      */
     virtual int commSetupDoneC();
 
 
     /**
      * Immediately called after a process has exited. This function normally
      * calls commClose to close all open communication channels to this
      * process and emits the "processExited" signal (if the process was
      * not running in the "DontCare" mode).
      */
-    virtual void processHasExited(int state);
+    virtual void processHasExited( int state );
 
     /**
      * Should clean up the communication links to the child after it has
      * exited. Should be called from "processHasExited".
      */
     virtual void commClose();
 
 
     /**
      * the socket descriptors for stdin/stdout/stderr.
      */
-    int out[2];
-    int in[2];
-    int err[2];
+    int out[ 2 ];
+    int in[ 2 ];
+    int err[ 2 ];
 
     /**
      * The socket notifiers for the above socket descriptors.
      */
     QSocketNotifier *innot;
     QSocketNotifier *outnot;
     QSocketNotifier *errnot;
 
     /**
      * Lists the communication links that are activated for the child
      * process.  Should not be modified from derived classes.
      */
     Communication communication;
 
     /**
      * Called by "slotChildOutput" this function copies data arriving from the
      * child process's stdout to the respective buffer and emits the signal
      * "@ref receivedStderr".
      */
-    int childOutput(int fdno);
+    int childOutput( int fdno );
 
     /**
      * Called by "slotChildOutput" this function copies data arriving from the
      * child process's stdout to the respective buffer and emits the signal
      * "@ref receivedStderr"
      */
-    int childError(int fdno);
+    int childError( int fdno );
 
     // information about the data that has to be sent to the child:
 
     const char *input_data;  // the buffer holding the data
     int input_sent;    // # of bytes already transmitted
     int input_total;   // total length of input_data
 
     /**
      * @ref OProcessController is a friend of OProcess because it has to have
      * access to various data members.
      */
     friend class OProcessController;
 
-
 private:
     /**
      * Searches for a valid shell.
      * Here is the algorithm used for finding an executable shell:
      *
      *    @li Try the executable pointed to by the "SHELL" environment
      *    variable with white spaces stripped off
      *
      *    @li If your process runs with uid != euid or gid != egid, a shell
      *    not listed in /etc/shells will not used.
      *
      *    @li If no valid shell could be found, "/bin/sh" is used as a last resort.
      */
     QCString searchShell();
 
     /**
      * Used by @ref searchShell in order to find out whether the shell found
      * is actually executable at all.
      */
-    bool isExecutable(const QCString &filename);
+    bool isExecutable( const QCString &filename );
 
     // Disallow assignment and copy-construction
     OProcess( const OProcess& );
     OProcess& operator= ( const OProcess& );
 
 private:
     void init ( );
-
     OProcessPrivate *d;
 };
 
-
-
 #endif