Build separately from mLib.

[sw-tools] / src / sw.c

/* -*-c-*-
 *
 * $Id: sw.c,v 1.3 1999/09/10 15:27:32 mdw Exp $
 *
 * Main driver code for sw-tools
 *
 * (c) 1999 EBI
 */

/*----- Licensing notice --------------------------------------------------* 
 *
 * This file is part of sw-tools.
 *
 * sw-tools is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * sw-tools 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 General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with sw-tools; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

/*----- Revision history --------------------------------------------------* 
 *
 * $Log: sw.c,v $
 * Revision 1.3  1999/09/10 15:27:32  mdw
 * Include `%'-escape substitution.
 *
 * Revision 1.2  1999/07/16 12:50:43  mdw
 * Replace deprecated `mdwopt' flag name with new version.
 *
 * Revision 1.1.1.1  1999/06/02 16:53:33  mdw
 * Initial import.
 *
 */

/*----- Header files ------------------------------------------------------*/

#include "config.h"

#include <ctype.h>
#include <errno.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <unistd.h>

#include <mLib/alloc.h>
#include <mLib/dstr.h>
#include <mLib/exc.h>
#include <mLib/mdwopt.h>
#include <mLib/quis.h>
#include <mLib/report.h>
#include <mLib/sub.h>

#define CMD_LINK 0
#include "sw.h"
#include "sw_arch.h"
#include "sw_build.h"
#include "sw_info.h"
#include "sw_links.h"
#include "sw_rsh.h"

/*----- Static variables --------------------------------------------------*/

static cmd *cmds = CMD_LINK;

/*----- Global option variables -------------------------------------------*
 *
 * It'd be nicer if these could be parsed by the build commands, but alas
 * this is not to be.  Consider `sw configure --arch=i386-linux
 * --with-diffutils': how is the program to know which options are for it and
 * which are for the remote one?  The `configure' command is important,
 * because it does some hairy stuff under the covers (inserting magical
 * options, and running `../configure'), so I can't just require `sw run
 * configure'.  Requiring the user to always put in a `--' to separate the
 * two lots of options is horrific.  So they get picked up at the main
 * program and stuffed into global variables.
 *
 * On the other hand, there is the advantage that `--output' options can be
 * put in an environment variable here.
 */

const char *opt_output = 0;
const char *opt_arch = 0;
unsigned int opt_flags = optFlag_percent;

/*----- Helpful GNUy message routines -------------------------------------*/

/* --- @version@ --- */

static void version(FILE *fp)
{
  fprintf(fp, "%s v. " VERSION "\n", QUIS);
}

/* --- @usage@ --- */

static void usage(FILE *fp)
{
  fprintf(fp, "Usage: %s [-fbip] [-a arch,...] [-o style] command [args]\n",
	  QUIS);
}

/* --- @help@ --- */

static void help(FILE *fp, int full)
{
  cmd *p;
  version(fp);
  fputc('\n', fp);
  usage(fp);
  fputs("\n\
Performs various handy jobs with multiple-architecture builds.\n\
\n\
There are some options which affect a few of the available commands:\n\
\n\
-a, --arch=ARCH,...	Only build on the named architectures.\n\
-b, --beep		Beep when the build is complete.\n\
-i, --install		Mark architectures as done when build succeeds.\n\
-f, --force		Run build commands on installed architectures.\n\
-p, --percent		Enable `%'-escapes in build command arguments.\n\
-o, --output=STYLE	Display output in a particular style.  Use style\n\
			`help' for a list.\n\
\n", fp);

  if (full) {
    fputs("The various commands provided are:\n\n", fp);
    for (p = cmds; p; p = p->next) {
      fputs(p->help, fp);
      fputc('\n', fp);
    }
    fprintf(fp,
"`%s' is an [mdw] production, brought to you in association with the\n\
European Bioinformatics Institute.\n", QUIS);
  } else {
    fputs("The various commands, in summary:\n\n", fp);
    for (p = cmds; p; p = p->next) {
      size_t sz = strcspn(p->help, "\n\t");
      fwrite(p->help, 1, sz, fp);
      fputc('\n', fp);
    }
    fprintf(fp,
"\nType `%s --help-full' for complete information.  There's a lot of it!\n",
	    QUIS);
  }
}

/*----- Main code ---------------------------------------------------------*/

/* --- @main@ --- *
 *
 * Arguments:	@int argc@ = number of command line arguments
 *		@char *argv[]@ = array of command line strings
 *
 * Returns:	Zero on success, nonzero on failure.
 *
 * Use:		Main program.  Parses some trivial arguments out, and
 *		dispatches control to one of the subprogram handlers.
 */

int main(int argc, char *argv[])
{
  unsigned f = 0;

  enum {
    f_bogus = 1
  };

  /* --- Initialize the support library --- */

  ego(argv[0]);
  sub_init();

  /* --- Parse command line flags --- */

  for (;;) {
    static struct option opt[] = {

      /* --- Standard GNUy help options --- */

      { "help",		0,		0,	'h' },
      { "help-full",	0,		0,	'H' },
      { "version", 	0,		0,	'v' },
      { "usage",	0,		0,	'u' },

      /* --- Build options --- *
       *
       */

      { "arch",		OPTF_ARGREQ,	0,	'a' },
      { "force",	0,		0,	'f' },
      { "install",	0,		0,	'i' },
      { "output",	OPTF_ARGREQ,	0,	'o' },
      { "beep",		OPTF_NEGATE,	0,	'b' },
      { "percent",	OPTF_NEGATE,	0,	'p' },
      { "escape",	OPTF_NEGATE,	0,	'p' },

      /* --- Internal-use-only magical options --- *
       *
       * You get what you deserve if you use this.
       */

      { "me",		OPTF_ARGREQ,	0,	'=' },
      { "remote",	OPTF_ARGREQ,	0,	'!' },

      /* --- Termination marker --- */

      { 0,		0,		0,	0 }
    };
    int i = mdwopt(argc, argv, "+hHvu a:b+p+fio:", opt, 0, 0,
		   OPTF_ENVVAR | OPTF_NEGATION);
    if (i < 0)
      break;

    switch (i) {

      /* --- GNUy help --- */

      case 'h':
	help(stdout, 0);
	exit(0);
      case 'H':
	help(stdout, 1);
	exit(0);
      case 'v':
	version(stdout);
	exit(0);
      case 'u':
	usage(stdout);
	exit(0);

      /* --- Build options --- */

      case 'a':
	opt_arch = optarg;
	break;
      case 'f':
	opt_flags |= optFlag_force;
	break;
      case 'b':
	opt_flags |= optFlag_beep;
	break;
      case 'b' | OPTF_NEGATED:
	opt_flags &= ~optFlag_beep;
	break;
      case 'p':
	opt_flags |= optFlag_percent;
	break;
      case 'p' | OPTF_NEGATED:
	opt_flags &= ~optFlag_percent;
	break;
      case 'i':
	opt_flags |= optFlag_install;
	break;
      case 'o':
	opt_output = optarg;
	break;

      /* --- Magical options for internal use --- */

      case '=':
	ego(optarg);
	break;
      case '!':
	swrsh_remote(optarg);
	_exit(1);

      /* --- The user screwed up --- */

      default:
	f |= f_bogus;
	break;
    }
  }

  if (f & f_bogus || argc == optind) {
    usage(stderr);
    exit(1);
  }

  /* --- Pick up the operation name --- */

  argc -= optind;
  argv += optind;
  optind = 0;

  {
    cmd *p, *chosen = 0;
    const char *which = argv[0];
    size_t sz = strlen(which);

    for (p = cmds; p; p = p->next) {
      if (strncmp(which, p->name, sz) == 0) {
	if (p->name[sz] == 0) {
	  chosen = p;
	  break;
	} else if (chosen)
	  die(1, "ambiguous command name `%s'", which);
	chosen = p;
      }
    }

    if (!chosen)
      die(1, "unknown command name `%s'", which);
    signal(SIGPIPE, SIG_IGN);
    TRY
      return (chosen->cmd(argc, argv));
    CATCH switch (exc_type) {
      case EXC_NOMEM:
	die(1, "not enough memory");
      default:
	RETHROW;
    } END_TRY;
  }
  return (127);
}

/*----- That's all, folks -------------------------------------------------*/