// does execl() in a fork returning control to a terminal immediately.

#include <stdio.h> // stderr
#include <stdlib.h> // EXIT_FAILURE
#include <unistd.h> // fork(), execl(), _exit()
#include <sys/types.h> // pid_t
#include "usage.str"
#include <string.h>
#include <malloc.h>
#include <errno.h>
#include "version.h"

struct
{
  char warn;
}flg;

int usage(int err);
int unparse_args(char* cmdline, int limit, int argc, char** argv);
int print_version(int err);
// if error, returns argc of option to list in error display
int parse_options(int argc, char** argv);


int main(int argc, char** argv)
{
  int err = 0;
  
  // help and version switches
  if(argc == 1)
    return usage(0);
  
  if(argc == 2)
  {
    if(strcmp(argv[1], "--help") == 0)
      return usage(0);
    if(strcmp(argv[1], "-v") == 0)
      return print_version(0);
  }
  
  err = parse_options(argc, argv);
  if(err) 
  {
    printf("Unknown launch option '%s'\n", argv[err]);
  }
  
  // reassemble commandline
  char args[1024];
  err = unparse_args(args, 1000, argc, argv);
  if(err)
  {
    if(err == ENOMEM)
      fprintf(stderr, "Out of memory or args list too long\n");
    else if (err == E2BIG)
      fprintf(stderr, "Argument list too long\n");
    return 1;
  }
  
  // if -q suppress all feedback from the app
  if(!flg.warn)
  {
    fclose(stdout);
    fclose(stderr);
    strcat(args, " > /dev/null 2>&1");
  }
  
  // do the fork and execute the commandline
  pid_t pid;
  
  pid = fork ();
  if (pid == 0)
  {
    
    
    // command path, command name, arg1, arg2, ...
    execl ("/bin/sh", "sh", "-c", args, NULL);
    
    // _exit(code) for threads and forks.
    _exit (EXIT_FAILURE);
  }
  else if (pid < 0)
    return -1;
  else
    return 0;
}


int usage(int err)
{
  if(err)
    fprintf(stderr, "%s", usage_str);
  else
    fprintf(stdout, "%s", usage_str);
  return err;
}

// returns 0 on success, or one of the following
// #define ENOMEM    12  /* Out of memory */
// #define E2BIG    7  /* Argument list too long */
// defined in /usr/include/asm-generic/errno-base.h

int unparse_args(char* cmdline, int limit, int argc, char** argv)
{
  cmdline[0] = 0;
  if(argc < 2)
    return 0;
  
  char* buf = (char*) malloc(limit+256);
  if(!buf)
    return errno = ENOMEM;
  
  char* p = buf;
  char* stopat = buf+limit -1;
  int len;
  
  // point to args list
  argc --;
  argv ++;
  
  // skip option switches
  if(flg.warn)
  {
    argc --;
    argv ++;
  }
  
  //////////////////////////////////////
  // recreate command and commandline
  //////////////////////////////////////
  
  for(int i = 0; i < argc; i++)
  {
    p += sprintf(p, "%s ", argv[i]);
    if(p >= stopat)
    {
      free(buf);
      return errno = E2BIG;
    }
  }
  p[-1] = 0; // terminate
  memcpy(cmdline, buf, p-buf);
  free(buf);
  return 0;
}

int print_version(int err)
{
  printf("Launch version %s\n", VERSION);
  return err;
}

int parse_options(int argc, char** argv)
{
  // if no options, return
  if(argv[1][0] != '-')
    return 0;
  
  // init opts
    flg.warn = 0; // default
    
    // check args (only 1 so far)
    int arg = 1;
    
    // assume error each iteration
    int err = 1;
    
    // check and break if match
    if(strcmp(argv[arg], "-a") == 0)    
    { 
      flg.warn = 1;
      err = 0;
    }
    
    // return argN where error occurred or 0
    if(err) 
      return arg;
    else 
      return 0;
}

#!/bin/sh
cd `dirname "$0"`
printf "" >.msg
txt2str usage.txt usage_str usage.str 2>>.msg
echo 'done.' >> .msg
kdialog --msgbox "$(<.msg)"
rm -f .msg

/* usage.txt converted with txt2cstr */
const char* usage_str =
"\n"
"Usage launch [opt] <command> [parameters]\n"
"\n"
"Launch just returns control to the terminal immediately after \n"
"starting an app.  Useful for launching one or more other \n"
"applications while retaining ability to use the terminal.\n"
"\n"
"Options for launch must preceed the command and it's arguments.\n"
"\n"
"Recognized optiions are:\n"
"  --help          this display\n"
"  -v              version\n"
"  -a              allow feedback from the launched app.\n"
"\n"
;

Usage launch [opt] <command> [parameters]

Launch just returns control to the terminal immediately after 
starting an app.  Useful for launching one or more other 
applications while retaining ability to use the terminal.

Options for launch must preceed the command and it's arguments.

Recognized optiions are:
--help          this display
-v              version
-a              allow feedback from the launched app.

// initial version
// #define VERSION "1.0"

// changed switch to -w to allow warnings to display.  Defaults to
// supress warnings and other feedback from launched applications.
// #define VERSION "1.1"

// Added these notes in the version header.
// #define VERSION "1.2"

// Can't just close stdout or kde will spin out.  Trying redirect
// to /dev/null for kde and also closing stdin and stderr to -1
// for normal user.
// #define VERSION "1.3"

// Changing switch to -a for 'allow' error and warnings instead
// of -w, which might be useful for a windows style /w(ait) 
// if anyone uses this for a 'start' clone.
// #define VERSION "1.4"

// Release .1 corrects a misspelling in this file.
#define VERSION "1.4.1"

// rewrote in C/C++ to give more control over how strings are interpreted
#define VERSION "2.0"

/* usage_str.txt converted with txt2cstr */
const char* usage_str =
    "\n"
    "Usage: tofile <command> [args]\n"
    "\n"
    "  Sends output of command and args to a file and opens it\n"
    "  in an editor named 'edit', expected to be found in the\n"
    "  user's current PATH.\n"
    "\n"
    "  The following switches may replace <command>\n"
    "\n"
    "    --help            print this message\n"
    "    -v | --version    print version info\n"
    "\n"
    ;

// tofile - sends commandline results to file and opens in an editor

#include <stdio.h>
#include <string.h>
#include <stdlib.h> // getenv()
#include "usage.str"
#include "version.h"

#define streq(a, b) (strcmp(a, b) == 0)

void dbg(){}

int do_pipe(const char* filename, char* cmdline);
int usage(int err);
int print_version(int err);

int main(int argc, char** argv)
{
  dbg();
  
  int err = 0;
  
  char cmdline[256];
  char* p = cmdline;
  
  char filename[256];
  sprintf(filename, "%s/tofile.tmp", getenv("HOME"));
  // usage notes
  if(argc < 2)
    return usage(1);
  
  if(streq(argv[1], "--help"))
     return usage(0);
  
  if(streq(argv[1], "-v") || streq(argv[1], "--version"))
    return print_version(0);

  if(argc > 16)
  {
    fprintf(stderr, "Too many args. Did you use a splat in an unquoted args list?\n");
    return 1;
  }
  
  // reassemble commandline
  for(int i = 1; i < argc; i++)
    p += sprintf(p, "%s ", argv[i]);
  
  p[-1] = 0;
  
  // pipe the commandline to ~/tofile.tmp
  err = do_pipe(filename, cmdline);
  if(err)
  {
    fprintf(stderr, "\n  Error reading piped command\n\n");
    return 1;
  }
  
  // try some other editors with the output file.  I prefer 'edit'. -rs
  sprintf(cmdline, "edit %s/tofile.tmp", getenv("HOME"));
  return system(cmdline);
}


int usage(int errcode)
{
  printf("%s", usage_str);
  return errcode;
}

int do_pipe(const char* filename, char* cmdline)
{
  int nbytes;
  char buf[4096];
  FILE* outfile = fopen(filename, "wb");
  if(!outfile)
    return 1;
  
  FILE* infile = popen(cmdline, "r");
  if(!infile)
    return 1;
  
  while(!feof(infile))
  {
    *buf = 0;
    nbytes = fread(buf, 1, 4096, infile);
    fwrite(buf, 1, nbytes, outfile);
  }
  fflush(outfile);
  fclose(infile);
  fclose(outfile);
  return 0;
}

int print_version(int errcode)
{
  printf("%s\n", VERSION);
  return errcode;
}

tofile grep "a" "~/bin/*"

tofile cat --help