root/branches/tango/hcf/process.d

/**
 * Helpful process functions
 * 
 * Authors:
 *  Gregor Richards
 * 
 * License:
 *  Copyright (c) 2006, 2007  Gregor Richards
 *  
 *  Permission is hereby granted, free of charge, to any person obtaining a
 *  copy of this software and associated documentation files (the "Software"),
 *  to deal in the Software without restriction, including without limitation
 *  the rights to use, copy, modify, merge, publish, distribute, sublicense,
 *  and/or sell copies of the Software, and to permit persons to whom the
 *  Software is furnished to do so, subject to the following conditions:
 *  
 *  The above copyright notice and this permission notice shall be included in
 *  all copies or substantial portions of the Software.
 *  
 *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 *  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 *  DEALINGS IN THE SOFTWARE.
 */

module hcf.process;

import tango.io.File;
import tango.io.FilePath;
import tango.io.Stdout;

import tango.text.Util;

import tango.stdc.stdlib;
import tango.stdc.stringz;

private {
    version (Windows) {
        import bcd.windows.windows;
    } else {
        extern (C) int dup2(int, int);
        extern (C) int fork();
        extern (C) int pipe(int[2]);
        extern (C) int read(int, void*, size_t);
        extern (C) int write(int, void*, size_t);
        extern (C) int close(int);
        extern (C) size_t waitpid(size_t, int*, int);
    }
}

/** system with char[] */
int system(char[] cmd)
{
    return tango.stdc.stdlib.system(toUtf8z(cmd));
}

/** system + guarantee success */
void systemOrDie(char[] cmd)
{
    int res;
    Stdout.flush(); Stderr.flush();
    res = system(cmd);
    if (res)  // CyberShadow 2007.02.22: Display a message before exiting
    {
        int p = locate(cmd, ' ');
        if(p!=-1) cmd=cmd[0..p];
        Stdout("Command ")(" returned with code ")(res)(", aborting.").newline;
        exit(1);
    }
}

/** system + output */
int sayAndSystem(char[] cmd)
{
    Stdout("+ ")(cmd).newline;
    Stdout.flush(); Stderr.flush();
    return system(cmd);
}

/** systemOrDie + output */
void saySystemDie(char[] cmd)
{
    Stdout("+ ")(cmd).newline;
    systemOrDie(cmd);
}

/** system + use a response file */
int systemResponse(char[] cmd, char[] rflag, char[] rfile, bool deleteRFile)
{
    int ret;
    char[][] elems = split(cmd, " ");
    
    /* the output is elems past 1 joined with \n */
    char[] resp = join(elems[1..$], "\n");
    (new File(rfile)).write(resp);
    
    Stdout.flush(); Stderr.flush();
    ret = system(elems[0] ~ " " ~ rflag ~ rfile);
    
    if (deleteRFile) (new FilePath(rfile)).remove();
    
    return ret;
}

/** systemResponse + guarantee success */
void systemROrDie(char[] cmd, char[] rflag, char[] rfile, bool deleteRFile)
{
    int res;
    res = systemResponse(cmd, rflag, rfile, deleteRFile);
    if (res)  // CyberShadow 2007.02.22: Display a message before exiting
    {
        int p = locate(cmd, ' ');
        if(p!=-1) cmd=cmd[0..p];
        Stdout("Command ")(cmd)(" returned with code ")(res)(", aborting.").newline;
        exit(1);
    }
}

/** systemResponse + output */
int sayAndSystemR(char[] cmd, char[] rflag, char[] rfile, bool deleteRFile)
{
    Stdout("+ ")(cmd).newline;
    return systemResponse(cmd, rflag, rfile, deleteRFile);
}

/** systemROrDie + output */
void saySystemRDie(char[] cmd, char[] rflag, char[] rfile, bool deleteRFile)
{
    Stdout("+ ")(cmd).newline;
    systemROrDie(cmd, rflag, rfile, deleteRFile);
}