Subversion Repositories DevTools

/*

 * This replace for the standard WATCOM supplied argv processing

 * function __Init_Argv.

 *

 *  Handles $<env-name>... expands into the named environment variabe

 *                         accepts $(<env-name>) or ${<env-name>} to

 *                         allow for trailing characters which would

 *                         normally be a part of the name. The value

 *                         of <env-name> is substituted into the string.

 *

 *  Handles @cmd-file-name read arguments.. any number per line, any

 *                         number of lines from <cmd-file-name>.. lines

 *                         read from the file get glob'd too!

 *

 *

 *  Handles "" strings     $<env-name> still expanded but results

 *                         in a single argument.

 *

 *  Handles '' strings     nothing inside expanded & results in a

 *                         single argument.

 *

 *  Handles `` expansion   where the command inside the backquotes

 *                         gets executed and its output substituted

 *                         in place of the string.

 *

 *  Handles unix like wildcards.. including [] character sets and

 *  {} type alternations.

 *

 */

#include <stdio.h>

#include <strings.h>

#include <ctype.h>

#include <sys/stat.h>

#include <sys/types.h>

#include <fcntl.h>

#include <dirent.h>

#include <malloc.h>

#include "glob.h"         /* filename globbing */

/*

 * Increments for growing various arrays.

 */

#define ARGV_GROW_SIZE 100

#define ARG_GROW_SIZE  2000

/*

 * The following are part of the Watcom runtime

 */

extern char **___Argv;		/* the eventual argv */

extern int  ___Argc;		/* the eventual argc */

extern char *_LpPgmName;	/* the program name */

extern char *_LpCmdLine;	/* the raw cmdline */

extern char **environ;		/* the environment strings */

/*

 * How big the array pointed to by __Argv really is.

 */

static int argv_allocated = 0;

/*

 * Non-zero if any wildcards were seen processing the arguments.

 */

static int wildcards_seen = 0;

/*

 * Hmmm, should be in a header someplace... maybe... perhaps.

 */

extern FILE *popen();

extern void pclose();

/*

 * Internal functions.

 */

static void glob_cmd_line(char *);

static void glob_env(int);

static void expand(char*, char*, int, int);

static char **exec_prog(char*m, int);

static char **read_cmd_file(char*);

static int  whitespace_p(char *s, int quote);

static char *xgetenv(char *);

static void add_arg(char*);

static glob_t *wildcard_expand(char*, int);

/*

 * Flag given to expand().

 */

#define ENV_ARG     1

#define CMDLINE_ARG 0

/*

 * True if `c' is a space, tab.

 */

#define WS_P(c) ((c) == ' ' || (c) == '\t')

/*

 * True if `c' is a CR or LF.

 */

#define NL_P(c) ((c) == '\r' || (c) == '\n')

/*

 * True if `c' is special to filename expansion.

 */

#define SPECIAL(c) ((c) == '*' || (c) == '?' || (c) == '[' || (c) == '{')

/******************************************************************************

 *

 * Primary entry point. By linking in this code we simply replace the standard

 * WATCOM supplied version of command line handling: the function __Init_Argv.

 *

 *****************************************************************************/

void __Init_Argv(void)

{

  int  nenv_args = 0;

  char *tmp;

  extern void __setenvp(void);	/* A WATCOM thing which sets up environ */

  __setenvp();                  /* found by grovelling                  */

#ifdef TEST

    printf("_LpCmdLine: %x\n", _LpCmdLine);

    printf("_LpPgmName: %x\n", _LpPgmName);

    printf("_LpCmdLine: \"%s\"\n", _LpCmdLine);

    printf("_LpPgmName: \"%s\"\n", _LpPgmName);

#endif

  ___Argc = 0;

  strlwr(_LpPgmName);

  for (tmp = _LpPgmName; *tmp; tmp++)

    {

      if (*tmp == '\\')

	*tmp = '/';

    }

  add_arg(_LpPgmName);

  if ((tmp = xgetenv("_argc")) != 0)

    {

#ifdef TEST

      printf("getenv(_argc): %x, \"%s\"\n", tmp, tmp);

#endif

      nenv_args = atoi(tmp);

    }

  /*

   *  Stuff from the environment goes first.

   */

  if (nenv_args)

    {

      glob_env(nenv_args);

    }

  /*

   * Tack anything from the command line on the end of the

   * argument array.

   */

  glob_cmd_line(_LpCmdLine);

  ___Argv[___Argc] = 0;

  if (wildcards_seen && ___Argc == 1)

    {

      printf("No match.\n");

      exit(1);

    }

#ifdef TEST

  printf("final argc: %d\n", ___Argc);

#endif

}

/******************************************************************************

 *

 * Loop through the environment grabbing arguments from it.

 *

 *****************************************************************************/

static void glob_env(int nargs)

{

  int i;

  char *arg;

  char env_name[80];

  if (nargs > 999999)

    {

      fprintf(stderr, "glob_env: too many arguments (>= 1000000)\n");

      exit(42);

    }

  for (i = 1; i < nargs; i++)

    {

      sprintf(env_name, "_argv%d", i);

      if ((arg = xgetenv(env_name)) == 0)

	{

	  fprintf(stderr, "glob_env: BAD environment: _argc: %d, no _argv%d\n",

		  nargs, i);

	  exit(42);

	}

      expand(0, arg, ENV_ARG, 0);

    }

}

/******************************************************************************

 *

 * Find each distinct argument on the command line, taking note

 * of quotes etc. then expand & add each argument to the final

 * argument vector. Leaves the quote characters intact (for now).

 *

 *****************************************************************************/

static void glob_cmd_line(const char *cmd_line)

{

  char *l   = strdup(cmd_line);

  char argc = 0;

  char *argv[64];	/* can't get more than this on a DOS command line */

  int  i;

  while (*l)

    {

      /*

       * Find the start of the argument.

       */

      while (*l == ' ' || *l == '\t') l++;

      argv[argc++] = l;

      /*

       * Find the end of the argument.

       */

      for (;*l; l++)

	{

	  if (*l == '\'' || *l == '\"' || *l == '\`')

	    {

	      int quote_char = *l++;

	      do

		{

		  if (!*l)

		    {

		      fprintf(stderr, "Unmatched %c.\n", quote_char);

		      exit(42);

		    }

		} while (*l++ != quote_char);

	    }

	  if (*l == ' ' || *l == '\t')

	    {

	      *l++ = '\0';

	      break;

	    }

	}

    }

  for (i = 0; i < argc; i++)

    {

      expand(0, argv[i], CMDLINE_ARG, 0);

    }

}

/******************************************************************************

 *

 * Process an argument...

 *

 * If PREFIX is non-zero then it contains a partial argument

 * which has already been processed... it is simply copied into

 * the output buffer. This is used when handling variables and

 * backquoting.. backquoting particularly crappy because it

 * turns a single argument into many.

 *

 *****************************************************************************/

static void expand(char *prefix, char *arg, int from_env, int in_string)

{

  int  prefix_len = (prefix)?strlen(prefix):0;

  int  buf_len = prefix_len + ARG_GROW_SIZE;

  char *buf = (char*)malloc(buf_len);

  char *bufp = buf;

  int   in_quote = 0;

#ifdef TEST

  printf("expand(prefix: \"%s\", arg: \"%s\")\n",

	  prefix?prefix:"(nil)", arg);

#endif

#define CHECK_BUF_END(l)					\

  {								\

    int offset = bufp - buf;    				\

    while ((offset + (l)) >= buf_len)				\

      {								\

	buf = (char*)realloc(buf, buf_len += ARG_GROW_SIZE);	\

      }				        			\

    bufp = buf + offset;                			\

  }

  if (!buf)

    {

      fprintf(stderr, "expand: Out of memory\n");

      exit(42);

    }

  if (prefix)

    {

      strcpy(buf, prefix);

      bufp += prefix_len;

    }

  /*

   * do stuff..

   */

  for (;*arg; arg++)

    {

      switch (*arg)

	{

	case '\'':

	  {

	    in_quote = !in_quote;

	    arg;

	    break;

	  }

	case '\"':

	  {

	    if (!in_quote)

	      {

		in_string = !in_string;

		arg;

	      }

	    else

	      goto copy_it;

	    break;

	  }

	case '\`':

	  {

	    if (!in_quote)

	      {

		char *start = ++arg;

		char **lines;

		for (arg++; *arg != '\`'; arg++);

		CHECK_BUF_END(arg - start);

		strncpy(bufp, start, arg - start);

		*(bufp + (arg - start)) = '\0';

		lines =  exec_prog(bufp, in_string);

		*bufp = '\0';

		if (lines)

		  {

		    for (;*lines; lines++)

		      {

			if (lines[1])

			  {

			    /* more arguments after this one. */

			    expand((bufp == buf)?0:buf, *lines, 0, in_string);

			    bufp = buf;

			  }

			else

			  {

			    char *new_arg;

			    /* last argument.. tack the rest of arg onto it. */

			    new_arg = (char*)malloc(strlen(*lines) +

						    strlen(arg + 1) + 1);

			    if (!new_arg)

			      {

				fprintf(stderr, "expand: Out of memory\n");

			      }

			    strcpy(new_arg, *lines);

			    strcat(new_arg, arg + 1);

			    expand((bufp == buf)?0:buf, new_arg, 0, in_string);

			    free(new_arg);

			  }

		      }

		  }

		return;

	      }

	    else

	      goto copy_it;

	    break;

	  }

	case '$':

	  {

	    if (!in_quote)

	      {

		char *start  = ++arg;

		int  bracket = 0;

		char var_name[200];

		char *new_arg;

		char *var_val;

		if (*start == '(')

		  {

		    bracket = ')';

		    start++;

		  }

		else

		  if (*start == '{')

		    {

		      bracket = '}';

		      start++;

		    }

		if (bracket)

		  {

		    while (*arg && *arg != bracket)

		      arg++;

		    if (!*arg)

		      {

			fprintf(stderr, "Missing %c.\n", bracket);

			exit(42);

		      }

		    strncpy(var_name, start, arg - start);

		    var_name[arg-start] = '\0';

		    arg++;

		  }

		else

		  {

		    while (*arg && (isalnum(*arg) || *arg == '_'))

		      arg++;

		    strncpy(var_name, start, arg - start);

		    var_name[arg-start] = '\0';

		  }

		if (var_val = xgetenv(var_name))

		  {

		    new_arg = (char *)malloc(strlen(arg) +

					     strlen(var_val) + 1);

		    if (!new_arg)

		      {

			fprintf(stderr, "expand: Out of memory (expanding var)\n");

			exit(42);

		      }

		    strcpy(new_arg, var_val);

		    strcat(new_arg, arg);

		    *bufp = '\0';

		    expand((bufp == buf)?0:buf, new_arg, 0, in_string);

		    free(new_arg);

		  }

		else

		  {

		    fprintf(stderr, "Undefined variable: %s\n", var_name);

		    exit(42);

		  }

		return;

	      }

	    else

	      goto copy_it;

	    break;

	  }

	default:

	  {

	  copy_it:

	    if (SPECIAL(*arg) && (in_quote || in_string))

	      {

		CHECK_BUF_END(1);

		*bufp++ = '\\';

	      }

	    CHECK_BUF_END(1);

	    *bufp++ = *arg;

	    break;

	  }

	}

    }

  CHECK_BUF_END(1);

  *bufp = '\0';

  /*

   * Check for a reference to a command file..

   */

  if (*buf == '@')

    {

      char **lines = read_cmd_file(buf + 1);

      while (lines && *lines)

	{

	  expand(0, *lines++, 0, 0);

	}

      free(buf);

      return;

    }

  /*

   * wildcard expand the argument... arguments from the environment

   * only get wildcarded if they don't contain any spaces.

   */

  if (*buf)

    {

      if (from_env && (strchr(buf, ' ') || strchr(buf, '\t')))

	add_arg(buf);

      else

	{

	  glob_t *gb = wildcard_expand(buf, 1);

	  int    i;

	  if (gb)

	    {

	      for (i = 0; i < gb->nused; i++)

		add_arg(gb->paths[i]);

	      arg_free_glob_t(gb);

	    }

	  else

	    add_arg(buf); /* no wildcards in `buf' so just add it */

	}

    }

  free(buf);

}

/******************************************************************************

 *

 * Add an argument to ___Argv.. expanding Argv if required.

 *

 *****************************************************************************/

static void add_arg(char *arg)

{

  char *str = strdup(arg);

#ifdef TEST

  printf("add_arg: \"%s\"\n", arg);

#endif

  if (!str)

    {

      fprintf(stderr, "add_arg: Out of memory.\n");

      exit(42);

    }

  if (___Argc >= argv_allocated)

    {

      if (!argv_allocated)

	{

	  argv_allocated = ARGV_GROW_SIZE;

	  ___Argv = (char**)malloc(argv_allocated * sizeof(char*));

	}

      else

	{

	  argv_allocated += ARGV_GROW_SIZE;

	  ___Argv = (char**)realloc(___Argv, argv_allocated * sizeof(char*));

	}

    }

  if (!___Argv)

    {

      fprintf(stderr, "add_arg: Out of memory.\n");

      exit(42);

    }

  ___Argv[___Argc++] = str;

}

/*****************************************************************************

 *

 * Do the work of expanding the wild card characters in a string.

 *

 *****************************************************************************/

static glob_t *wildcard_expand(char *s, int no_match_ok)

{

  glob_t *gb = 0;

#ifdef TEST

  printf("wildcard_expand: \"%s\"\n", s);

#endif

  if (wildcard_p(s, 0))

    {

      int status;

      char *mess;

      wildcards_seen++;

      if ((gb = (glob_t *) malloc(sizeof(glob_t))) == 0)

	{

	  fprintf(stderr, "argv: Out of memory.\n");

	  exit(42);

	}

      gb->nused = 0;

      gb->paths = 0;

      gb->nallocated = 0;

      status = arg_glob(s, GLOB_FLAGS, gb);

#ifdef TEST

      printf("globbing finds %d names\n", gb->nused);

#endif

      if (status == E_NOMATCH)

	{

	  if (no_match_ok)

	    status = 0;

	  else

	    mess = "No match\n";

	}

      else

      if (status == E_NOMEMORY)

	mess = "glob: out of memory\n";

      else

      if (status == E_IMPOSSIBLE)

	mess = "glob: can't handle wildcard drive names\n";

      else

      if (status == E_NODIR)

	mess = "glob: failed opening directory\n";

      if (status)

	{

	  fprintf(stderr, mess);

	  exit(42);

	}

    }

  return gb;

}

/******************************************************************************

 *

 * Exec a subprogram and returns it's output as an array of strings.

 * If in_string is non-zero only newlines separate fields.

 *

 *****************************************************************************/

static char **exec_prog(char *cmd_line, int in_string)

{

  int   buf_len   = ARG_GROW_SIZE;

  char *buf       = malloc(ARG_GROW_SIZE); /* the input line buffer */

  char *l         = buf;

  int    argc     = 0;

  char **argv     = 0;

  FILE  *fp;

  int    ch;

#ifdef TEST

  printf("exec_prog(\"%s\")\n", cmd_line);

#endif

  if ((fp = popen(cmd_line, "r")) == 0)

    {

      fprintf(stderr, "exec of subcommand failed...\n");

      perror("argv-handler");

      exit(42);

    }

  /*

   * Suck in all the output of the exec'd program.

   */

  while ((ch = fgetc(fp)) != EOF)

    {

      if (l >= (buf + buf_len - 1))

	{

	  int offset = l - buf;

	  buf = (char*)realloc(buf, buf_len += ARG_GROW_SIZE);

	  l = buf + offset;

	}

      *l++ = ch;

    }

  *l++ = '\0';

  pclose(fp);

#ifdef TEST

  printf("Output from exec'd prog: |%s|\n", buf);

#endif

  /*

   * Parse it into fields... straight up guess the sizeof argv as

   * half the length of the buffer (ie, every second character a

   * space).

   */

  if (0 == (argv = malloc(((l - buf) / 2) * sizeof(char *))))

    {

      fprintf(stderr, "Out of memory executing backquote.\n");

      exit(42);

    }

  for (l = buf; *l;)

    {

      /*

       * Kill leading whitespace.

       */

      while ( NL_P(*l) || (!in_string && WS_P(*l)))

	l++;

      if (*l)

	{

	  argv[argc++] = l;

	  /*

	   * Skip to next whitespace or end of string.

	   */

	  while (*l && !(NL_P(*l) || (!in_string && WS_P(*l))))

	    l++;

	  /*

	   * Only terminate if not at end of input.

	   */

	  if (*l)

	    *l++ = '\0';

	}

    }

  /*

   * Fix up the size of the returned array.

   */

  argv = realloc(argv, sizeof(char *) * (argc + 1));

  argv[argc] = 0;

  return argv;

}

/******************************************************************************

 *

 * Read a command file.. returns a null terminated array of fields..

 *

 *****************************************************************************/

static char **read_cmd_file(char *fname)

{

  struct stat statb;

  int    ifile;

  char  *buf;

  char **argv = 0;

  char  *l;

  int    r;

  int    argc = 0;

#ifdef TEST

  printf("read_cmd_file(%s)\n", fname);

#endif

  if ((r = stat(fname, &statb)) == 0)

    {

#ifdef TEST

      printf("read_cmd_file: opens: \"%s\"\n", fname);

#endif

      if ((ifile = open(fname, O_RDONLY | O_BINARY)) >= 0)

	{

	  if ((buf = (char*)malloc(statb.st_size + 1)) != 0)

	    {

	      if (statb.st_size == read(ifile, buf, statb.st_size))

		{

		  buf[statb.st_size] = '\0';

		  close(ifile);

		}

	      else

		{

		  fprintf(stderr, "read_cmd_file: read failed, size: %d\n",

			  statb.st_size);

		  exit(42);

		}

	    }

	  else

	    {

	      fprintf(stderr, "read_cmd_file: Out of memory\n");

	      _exit(42);

	    }

	}

      else

	{

	  perror("read_cmd_file");

	  exit(42);

	}

    }

  else

    {

      fprintf(stderr, "read_cmd_file: r: %d\n", r);

      perror("read_cmd_file: stat failed");

      exit(42);

    }

  /*

   * Construct the vector of fields... use a straight up guess on the

   * size of argv... then fix it up afterwards.

   */

  if (0 == (argv = (char**)malloc((statb.st_size / 2) * sizeof(char*))))

    {

      fprintf(stderr, "Out of memory reading command file.\n");

      exit(42);

    }

  for (l = buf; *l;)

    {

      char *start = 0;

      /*

       * Find the start of the argument.

       */

      while (NL_P(*l) || WS_P(*l))

	l++;

      if (*l)

	start = l;

      /*

       * Find the end of the argument.

       */

      for (;*l;l++)

	{

	  if (*l == '\'' || *l == '\"' || *l == '\`')

	    {

	      int quote_char = *l++;

	      do

		{

		  if (!*l)

		    {

		      fprintf(stderr, "Unmatched %c. (reading %s)\n",

			      quote_char, fname);

		      exit(42);

		    }

		} while (*l++ != quote_char);

	    }

	  if (NL_P(*l) || WS_P(*l))

	    {

	      *l++ = '\0';

	      break;

	    }

	}

      if (start)

	argv[argc++] = start;

    }

  argv = realloc(argv, sizeof(char *) * (argc + 1));

  argv[argc] = 0;

  return argv;

}

/******************************************************************************

 *

 * A replacement for getenv() which IS case sensitive, the standard

 * WATCOM one is not.

 *

 *****************************************************************************/

static char *xgetenv(char *var_name)

{

  char **envp = environ;

  int  var_len = strlen(var_name);

#ifdef TEST

  printf("envp: %x, getenv(\"%s\") returns ", environ, var_name);

#endif

  while (envp && *envp)

    {

      char *endp = (*envp) + var_len;

      if (!strncmp(var_name, *envp, var_len))

	{

	  if (*endp == '=')

	    {

#ifdef TEST

	      printf("%s\n", endp+1);

#endif

	      return endp + 1;

	    }

	}

      envp++;

    }

#ifdef TEST

  printf("(nil)\n");

#endif

  return 0;

}