/*
 * 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**)localRealloc(___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 = localRealloc(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 = localRealloc(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;
}