KWSys 2015-07-08 (d3ba91e1)

Extract upstream KWSys using the following shell commands.

$ git archive --prefix=upstream-kwsys/ d3ba91e1 | tar x
$ git shortlog --no-merges --abbrev=8 --format='%h %s' 8504e845..d3ba91e1
Brad King (1):
      d3ba91e1 System: Drop Shell_* APIs

2 files changed, 2 insertions, 681 deletions

diff --git a/System.c b/System.c
index 1ee26fa..ccc7e81 100644
--- a/System.c
+++ b/System.c
@@ -20,8 +20,8 @@
 
 #include <stddef.h> /* ptrdiff_t */
 #include <stdlib.h> /* malloc, free */
-#include <string.h> /* strlen */
-#include <ctype.h>  /* isalpha */
+#include <string.h> /* memcpy */
+#include <ctype.h>  /* isspace */
 
 #include <stdio.h>
 
@@ -31,587 +31,6 @@ typedef ptrdiff_t kwsysSystem_ptrdiff_t;
 typedef int kwsysSystem_ptrdiff_t;
 #endif
 
-/*
-
-Notes:
-
-Make variable replacements open a can of worms.  Sometimes they should
-be quoted and sometimes not.  Sometimes their replacement values are
-already quoted.
-
-VS variables cause problems.  In order to pass the referenced value
-with spaces the reference must be quoted.  If the variable value ends
-in a backslash then it will escape the ending quote!  In order to make
-the ending backslash appear we need this:
-
-  "$(InputDir)\"
-
-However if there is not a trailing backslash then this will put a
-quote in the value so we need:
-
-  "$(InputDir)"
-
-Make variable references are platform specific so we should probably
-just NOT quote them and let the listfile author deal with it.
-
-*/
-
-/*
-TODO: For windows echo:
-
-To display a pipe (|) or redirection character (< or >) when using the
-echo command, use a caret character immediately before the pipe or
-redirection character (for example, ^>, ^<, or ^| ). If you need to
-use the caret character itself (^), use two in a row (^^).
-*/
-
-/*--------------------------------------------------------------------------*/
-static int kwsysSystem_Shell__CharIsWhitespace(char c)
-{
-  return ((c == ' ') || (c == '\t'));
-}
-
-/*--------------------------------------------------------------------------*/
-static int kwsysSystem_Shell__CharNeedsQuotesOnUnix(char c)
-{
-  return ((c == '\'') || (c == '`') || (c == ';') || (c == '#') ||
-          (c == '&') || (c == '$') || (c == '(') || (c == ')') ||
-          (c == '~') || (c == '<') || (c == '>') || (c == '|') ||
-          (c == '*') || (c == '^') || (c == '\\'));
-}
-
-/*--------------------------------------------------------------------------*/
-static int kwsysSystem_Shell__CharNeedsQuotesOnWindows(char c)
-{
-  return ((c == '\'') || (c == '#') || (c == '&') ||
-          (c == '<') || (c == '>') || (c == '|') || (c == '^'));
-}
-
-/*--------------------------------------------------------------------------*/
-static int kwsysSystem_Shell__CharNeedsQuotes(char c, int isUnix, int flags)
-{
-  /* On Windows the built-in command shell echo never needs quotes.  */
-  if(!isUnix && (flags & kwsysSystem_Shell_Flag_EchoWindows))
-    {
-    return 0;
-    }
-
-  /* On all platforms quotes are needed to preserve whitespace.  */
-  if(kwsysSystem_Shell__CharIsWhitespace(c))
-    {
-    return 1;
-    }
-
-  if(isUnix)
-    {
-    /* On UNIX several special characters need quotes to preserve them.  */
-    if(kwsysSystem_Shell__CharNeedsQuotesOnUnix(c))
-      {
-      return 1;
-      }
-    }
-  else
-    {
-    /* On Windows several special characters need quotes to preserve them.  */
-    if(kwsysSystem_Shell__CharNeedsQuotesOnWindows(c))
-      {
-      return 1;
-      }
-    }
-  return 0;
-}
-
-/*--------------------------------------------------------------------------*/
-static int kwsysSystem_Shell__CharIsMakeVariableName(char c)
-{
-  return c && (c == '_' || isalpha(((int)c)));
-}
-
-/*--------------------------------------------------------------------------*/
-static const char* kwsysSystem_Shell__SkipMakeVariables(const char* c)
-{
-  while(*c == '$' && *(c+1) == '(')
-    {
-    const char* skip = c+2;
-    while(kwsysSystem_Shell__CharIsMakeVariableName(*skip))
-      {
-      ++skip;
-      }
-    if(*skip == ')')
-      {
-      c = skip+1;
-      }
-    else
-      {
-      break;
-      }
-    }
-  return c;
-}
-
-/*
-Allowing make variable replacements opens a can of worms.  Sometimes
-they should be quoted and sometimes not.  Sometimes their replacement
-values are already quoted or contain escapes.
-
-Some Visual Studio variables cause problems.  In order to pass the
-referenced value with spaces the reference must be quoted.  If the
-variable value ends in a backslash then it will escape the ending
-quote!  In order to make the ending backslash appear we need this:
-
-  "$(InputDir)\"
-
-However if there is not a trailing backslash then this will put a
-quote in the value so we need:
-
-  "$(InputDir)"
-
-This macro decides whether we quote an argument just because it
-contains a make variable reference.  This should be replaced with a
-flag later when we understand applications of this better.
-*/
-#define KWSYS_SYSTEM_SHELL_QUOTE_MAKE_VARIABLES 0
-
-/*--------------------------------------------------------------------------*/
-static int kwsysSystem_Shell__ArgumentNeedsQuotes(const char* in, int isUnix,
-                                                  int flags)
-{
-  /* The empty string needs quotes.  */
-  if(!*in)
-    {
-    return 1;
-    }
-
-  /* Scan the string for characters that require quoting.  */
-  {
-  const char* c;
-  for(c=in; *c; ++c)
-    {
-    /* Look for $(MAKEVAR) syntax if requested.  */
-    if(flags & kwsysSystem_Shell_Flag_AllowMakeVariables)
-      {
-#if KWSYS_SYSTEM_SHELL_QUOTE_MAKE_VARIABLES
-      const char* skip = kwsysSystem_Shell__SkipMakeVariables(c);
-      if(skip != c)
-        {
-        /* We need to quote make variable references to preserve the
-           string with contents substituted in its place.  */
-        return 1;
-        }
-#else
-      /* Skip over the make variable references if any are present.  */
-      c = kwsysSystem_Shell__SkipMakeVariables(c);
-
-      /* Stop if we have reached the end of the string.  */
-      if(!*c)
-        {
-        break;
-        }
-#endif
-      }
-
-    /* Check whether this character needs quotes.  */
-    if(kwsysSystem_Shell__CharNeedsQuotes(*c, isUnix, flags))
-      {
-      return 1;
-      }
-    }
-  }
-
-  /* On Windows some single character arguments need quotes.  */
-  if(!isUnix && *in && !*(in+1))
-    {
-    char c = *in;
-    if((c == '?') || (c == '&') || (c == '^') || (c == '|') || (c == '#'))
-      {
-      return 1;
-      }
-    }
-
-  return 0;
-}
-
-/*--------------------------------------------------------------------------*/
-static int kwsysSystem_Shell__GetArgumentSize(const char* in,
-                                              int isUnix, int flags)
-{
-  /* Start with the length of the original argument, plus one for
-     either a terminating null or a separating space.  */
-  int size = (int)strlen(in) + 1;
-
-  /* String iterator.  */
-  const char* c;
-
-  /* Keep track of how many backslashes have been encountered in a row.  */
-  int windows_backslashes = 0;
-
-  /* Scan the string for characters that require escaping or quoting.  */
-  for(c=in; *c; ++c)
-    {
-    /* Look for $(MAKEVAR) syntax if requested.  */
-    if(flags & kwsysSystem_Shell_Flag_AllowMakeVariables)
-      {
-      /* Skip over the make variable references if any are present.  */
-      c = kwsysSystem_Shell__SkipMakeVariables(c);
-
-      /* Stop if we have reached the end of the string.  */
-      if(!*c)
-        {
-        break;
-        }
-      }
-
-    /* Check whether this character needs escaping for the shell.  */
-    if(isUnix)
-      {
-      /* On Unix a few special characters need escaping even inside a
-         quoted argument.  */
-      if(*c == '\\' || *c == '"' || *c == '`' || *c == '$')
-        {
-        /* This character needs a backslash to escape it.  */
-        ++size;
-        }
-      }
-    else if(flags & kwsysSystem_Shell_Flag_EchoWindows)
-      {
-      /* On Windows the built-in command shell echo never needs escaping.  */
-      }
-    else
-      {
-      /* On Windows only backslashes and double-quotes need escaping.  */
-      if(*c == '\\')
-        {
-        /* Found a backslash.  It may need to be escaped later.  */
-        ++windows_backslashes;
-        }
-      else if(*c == '"')
-        {
-        /* Found a double-quote.  We need to escape it and all
-           immediately preceding backslashes.  */
-        size += windows_backslashes + 1;
-        windows_backslashes = 0;
-        }
-      else
-        {
-        /* Found another character.  This eliminates the possibility
-           that any immediately preceding backslashes will be
-           escaped.  */
-        windows_backslashes = 0;
-        }
-      }
-
-    /* Check whether this character needs escaping for a make tool.  */
-    if(*c == '$')
-      {
-      if(flags & kwsysSystem_Shell_Flag_Make)
-        {
-        /* In Makefiles a dollar is written $$ so we need one extra
-           character.  */
-        ++size;
-        }
-      else if(flags & kwsysSystem_Shell_Flag_VSIDE)
-        {
-        /* In a VS IDE a dollar is written "$" so we need two extra
-           characters.  */
-        size += 2;
-        }
-      }
-    else if(*c == '#')
-      {
-      if((flags & kwsysSystem_Shell_Flag_Make) &&
-         (flags & kwsysSystem_Shell_Flag_WatcomWMake))
-        {
-        /* In Watcom WMake makefiles a pound is written $# so we need
-           one extra character.  */
-        ++size;
-        }
-      }
-    else if(*c == '%')
-      {
-      if((flags & kwsysSystem_Shell_Flag_VSIDE) ||
-         ((flags & kwsysSystem_Shell_Flag_Make) &&
-          ((flags & kwsysSystem_Shell_Flag_MinGWMake) ||
-           (flags & kwsysSystem_Shell_Flag_NMake))))
-        {
-        /* In the VS IDE, NMake, or MinGW make a percent is written %%
-           so we need one extra characters.  */
-        size += 1;
-        }
-      }
-    else if(*c == ';')
-      {
-      if(flags & kwsysSystem_Shell_Flag_VSIDE)
-        {
-        /* In a VS IDE a semicolon is written ";" so we need two extra
-           characters.  */
-        size += 2;
-        }
-      }
-    }
-
-  /* Check whether the argument needs surrounding quotes.  */
-  if(kwsysSystem_Shell__ArgumentNeedsQuotes(in, isUnix, flags))
-    {
-    /* Surrounding quotes are needed.  Allocate space for them.  */
-    if((flags & kwsysSystem_Shell_Flag_WatcomQuote) && (isUnix))
-      {
-        size += 2;
-      }
-    size += 2;
-
-    /* We must escape all ending backslashes when quoting on windows.  */
-    size += windows_backslashes;
-    }
-
-  return size;
-}
-
-/*--------------------------------------------------------------------------*/
-static char* kwsysSystem_Shell__GetArgument(const char* in, char* out,
-                                            int isUnix, int flags)
-{
-  /* String iterator.  */
-  const char* c;
-
-  /* Keep track of how many backslashes have been encountered in a row.  */
-  int windows_backslashes = 0;
-
-  /* Whether the argument must be quoted.  */
-  int needQuotes = kwsysSystem_Shell__ArgumentNeedsQuotes(in, isUnix, flags);
-  if(needQuotes)
-    {
-    /* Add the opening quote for this argument.  */
-    if(flags & kwsysSystem_Shell_Flag_WatcomQuote)
-      {
-      if(isUnix)
-        {
-        *out++ = '"';
-        }
-      *out++ = '\'';
-      }
-    else
-      {
-      *out++ = '"';
-      }
-    }
-
-  /* Scan the string for characters that require escaping or quoting.  */
-  for(c=in; *c; ++c)
-    {
-    /* Look for $(MAKEVAR) syntax if requested.  */
-    if(flags & kwsysSystem_Shell_Flag_AllowMakeVariables)
-      {
-      const char* skip = kwsysSystem_Shell__SkipMakeVariables(c);
-      if(skip != c)
-        {
-        /* Copy to the end of the make variable references.  */
-        while(c != skip)
-          {
-          *out++ = *c++;
-          }
-
-        /* The make variable reference eliminates any escaping needed
-           for preceding backslashes.  */
-        windows_backslashes = 0;
-
-        /* Stop if we have reached the end of the string.  */
-        if(!*c)
-          {
-          break;
-          }
-        }
-      }
-
-    /* Check whether this character needs escaping for the shell.  */
-    if(isUnix)
-      {
-      /* On Unix a few special characters need escaping even inside a
-         quoted argument.  */
-      if(*c == '\\' || *c == '"' || *c == '`' || *c == '$')
-        {
-        /* This character needs a backslash to escape it.  */
-        *out++ = '\\';
-        }
-      }
-    else if(flags & kwsysSystem_Shell_Flag_EchoWindows)
-      {
-      /* On Windows the built-in command shell echo never needs escaping.  */
-      }
-    else
-      {
-      /* On Windows only backslashes and double-quotes need escaping.  */
-      if(*c == '\\')
-        {
-        /* Found a backslash.  It may need to be escaped later.  */
-        ++windows_backslashes;
-        }
-      else if(*c == '"')
-        {
-        /* Found a double-quote.  Escape all immediately preceding
-           backslashes.  */
-        while(windows_backslashes > 0)
-          {
-          --windows_backslashes;
-          *out++ = '\\';
-          }
-
-        /* Add the backslash to escape the double-quote.  */
-        *out++ = '\\';
-        }
-      else
-        {
-        /* We encountered a normal character.  This eliminates any
-           escaping needed for preceding backslashes.  */
-        windows_backslashes = 0;
-        }
-      }
-
-    /* Check whether this character needs escaping for a make tool.  */
-    if(*c == '$')
-      {
-      if(flags & kwsysSystem_Shell_Flag_Make)
-        {
-        /* In Makefiles a dollar is written $$.  The make tool will
-           replace it with just $ before passing it to the shell.  */
-        *out++ = '$';
-        *out++ = '$';
-        }
-      else if(flags & kwsysSystem_Shell_Flag_VSIDE)
-        {
-        /* In a VS IDE a dollar is written "$".  If this is written in
-           an un-quoted argument it starts a quoted segment, inserts
-           the $ and ends the segment.  If it is written in a quoted
-           argument it ends quoting, inserts the $ and restarts
-           quoting.  Either way the $ is isolated from surrounding
-           text to avoid looking like a variable reference.  */
-        *out++ = '"';
-        *out++ = '$';
-        *out++ = '"';
-        }
-      else
-        {
-        /* Otherwise a dollar is written just $. */
-        *out++ = '$';
-        }
-      }
-    else if(*c == '#')
-      {
-      if((flags & kwsysSystem_Shell_Flag_Make) &&
-         (flags & kwsysSystem_Shell_Flag_WatcomWMake))
-        {
-        /* In Watcom WMake makefiles a pound is written $#.  The make
-           tool will replace it with just # before passing it to the
-           shell.  */
-        *out++ = '$';
-        *out++ = '#';
-        }
-      else
-        {
-        /* Otherwise a pound is written just #. */
-        *out++ = '#';
-        }
-      }
-    else if(*c == '%')
-      {
-      if((flags & kwsysSystem_Shell_Flag_VSIDE) ||
-         ((flags & kwsysSystem_Shell_Flag_Make) &&
-          ((flags & kwsysSystem_Shell_Flag_MinGWMake) ||
-           (flags & kwsysSystem_Shell_Flag_NMake))))
-        {
-        /* In the VS IDE, NMake, or MinGW make a percent is written %%.  */
-        *out++ = '%';
-        *out++ = '%';
-        }
-      else
-        {
-        /* Otherwise a percent is written just %. */
-        *out++ = '%';
-        }
-      }
-    else if(*c == ';')
-      {
-      if(flags & kwsysSystem_Shell_Flag_VSIDE)
-        {
-        /* In a VS IDE a semicolon is written ";".  If this is written
-           in an un-quoted argument it starts a quoted segment,
-           inserts the ; and ends the segment.  If it is written in a
-           quoted argument it ends quoting, inserts the ; and restarts
-           quoting.  Either way the ; is isolated.  */
-        *out++ = '"';
-        *out++ = ';';
-        *out++ = '"';
-        }
-      else
-        {
-        /* Otherwise a semicolon is written just ;. */
-        *out++ = ';';
-        }
-      }
-    else
-      {
-      /* Store this character.  */
-      *out++ = *c;
-      }
-    }
-
-  if(needQuotes)
-    {
-    /* Add enough backslashes to escape any trailing ones.  */
-    while(windows_backslashes > 0)
-      {
-      --windows_backslashes;
-      *out++ = '\\';
-      }
-
-    /* Add the closing quote for this argument.  */
-    if(flags & kwsysSystem_Shell_Flag_WatcomQuote)
-      {
-      *out++ = '\'';
-      if(isUnix)
-        {
-        *out++ = '"';
-        }
-      }
-    else
-      {
-      *out++ = '"';
-      }
-    }
-
-  /* Store a terminating null without incrementing.  */
-  *out = 0;
-
-  return out;
-}
-
-/*--------------------------------------------------------------------------*/
-char* kwsysSystem_Shell_GetArgumentForWindows(const char* in,
-                                              char* out,
-                                              int flags)
-{
-  return kwsysSystem_Shell__GetArgument(in, out, 0, flags);
-}
-
-/*--------------------------------------------------------------------------*/
-char* kwsysSystem_Shell_GetArgumentForUnix(const char* in,
-                                           char* out,
-                                           int flags)
-{
-  return kwsysSystem_Shell__GetArgument(in, out, 1, flags);
-}
-
-/*--------------------------------------------------------------------------*/
-int kwsysSystem_Shell_GetArgumentSizeForWindows(const char* in, int flags)
-{
-  return kwsysSystem_Shell__GetArgumentSize(in, 0, flags);
-}
-
-/*--------------------------------------------------------------------------*/
-int kwsysSystem_Shell_GetArgumentSizeForUnix(const char* in, int flags)
-{
-  return kwsysSystem_Shell__GetArgumentSize(in, 1, flags);
-}
-
 /*--------------------------------------------------------------------------*/
 static int kwsysSystem__AppendByte(char* local,
                                    char** begin, char** end,
diff --git a/System.h.in b/System.h.in
index f21bf0d..3f3d3f4 100644
--- a/System.h.in
+++ b/System.h.in
@@ -24,28 +24,6 @@
 #endif
 #if !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
 # define kwsysSystem_Parse_CommandForUnix             kwsys_ns(System_Parse_CommandForUnix)
-# define kwsysSystem_Shell_GetArgumentForWindows      kwsys_ns(System_Shell_GetArgumentForWindows)
-# define kwsysSystem_Shell_GetArgumentForUnix         kwsys_ns(System_Shell_GetArgumentForUnix)
-# define kwsysSystem_Shell_GetArgumentSizeForWindows  kwsys_ns(System_Shell_GetArgumentSizeForWindows)
-# define kwsysSystem_Shell_GetArgumentSizeForUnix     kwsys_ns(System_Shell_GetArgumentSizeForUnix)
-# define kwsysSystem_Shell_Flag_e                     kwsys_ns(System_Shell_Flag_e)
-# define kwsysSystem_Shell_Flag_Make                  kwsys_ns(System_Shell_Flag_Make)
-# define kwsysSystem_Shell_Flag_VSIDE                 kwsys_ns(System_Shell_Flag_VSIDE)
-# define kwsysSystem_Shell_Flag_EchoWindows           kwsys_ns(System_Shell_Flag_EchoWindows)
-# define kwsysSystem_Shell_Flag_WatcomWMake           kwsys_ns(System_Shell_Flag_WatcomWMake)
-# define kwsysSystem_Shell_Flag_MinGWMake             kwsys_ns(System_Shell_Flag_MinGWMake)
-# define kwsysSystem_Shell_Flag_NMake                 kwsys_ns(System_Shell_Flag_NMake)
-# define kwsysSystem_Shell_Flag_AllowMakeVariables    kwsys_ns(System_Shell_Flag_AllowMakeVariables)
-# define kwsysSystem_Shell_Flag_WatcomQuote           kwsys_ns(System_Shell_Flag_WatcomQuote)
-#endif
-
-#ifdef __VMS
-#define @KWSYS_NAMESPACE@System_Shell_GetArgumentForUnix \
-   @KWSYS_NAMESPACE@System_Shell_UnixGA
-#define @KWSYS_NAMESPACE@System_Shell_GetArgumentSizeForUnix \
-   @KWSYS_NAMESPACE@System_Shell_UnixGAS
-#define @KWSYS_NAMESPACE@System_Shell_GetArgumentForWindows \
-   @KWSYS_NAMESPACE@System_Shell_WindowsGA
 #endif
 
 #if defined(__cplusplus)
@@ -54,69 +32,6 @@ extern "C"
 #endif
 
 /**
- * Transform the given command line argument for use in a Windows or
- * Unix shell.  Returns a pointer to the end of the command line
- * argument in the provided output buffer.  Flags may be passed to
- * modify the generated quoting and escape sequences to work under
- * alternative environments.
- */
-kwsysEXPORT char* kwsysSystem_Shell_GetArgumentForWindows(const char* in,
-                                                          char* out,
-                                                          int flags);
-kwsysEXPORT char* kwsysSystem_Shell_GetArgumentForUnix(const char* in,
-                                                       char* out,
-                                                       int flags);
-
-/**
- * Compute the size of the buffer required to store the output from
- * kwsysSystem_Shell_GetArgumentForWindows or
- * kwsysSystem_Shell_GetArgumentForUnix.  The flags passed must be
- * identical between the two calls.
- */
-kwsysEXPORT int kwsysSystem_Shell_GetArgumentSizeForWindows(const char* in,
-                                                            int flags);
-kwsysEXPORT int kwsysSystem_Shell_GetArgumentSizeForUnix(const char* in,
-                                                         int flags);
-
-/**
- * Flags to pass to kwsysSystem_Shell_GetArgumentForWindows or
- * kwsysSystem_Shell_GetArgumentForUnix.  These modify the generated
- * quoting and escape sequences to work under alternative
- * environments.
- */
-enum kwsysSystem_Shell_Flag_e
-{
-  /** The target shell is in a makefile.  */
-  kwsysSystem_Shell_Flag_Make               = (1<<0),
-
-  /** The target shell is in a VS project file.  Do not use with
-      Shell_Flag_Make.  */
-  kwsysSystem_Shell_Flag_VSIDE              = (1<<1),
-
-  /** In a windows shell the argument is being passed to "echo".  */
-  kwsysSystem_Shell_Flag_EchoWindows        = (1<<2),
-
-  /** The target shell is in a Watcom WMake makefile.  */
-  kwsysSystem_Shell_Flag_WatcomWMake        = (1<<3),
-
-  /** The target shell is in a MinGW Make makefile.  */
-  kwsysSystem_Shell_Flag_MinGWMake          = (1<<4),
-
-  /** The target shell is in a NMake makefile.  */
-  kwsysSystem_Shell_Flag_NMake              = (1<<5),
-
-  /** Make variable reference syntax $(MAKEVAR) should not be escaped
-      to allow a build tool to replace it.  Replacement values
-      containing spaces, quotes, backslashes, or other
-      non-alphanumeric characters that have significance to some makes
-      or shells produce undefined behavior.  */
-  kwsysSystem_Shell_Flag_AllowMakeVariables = (1<<6),
-
-  /** The target shell quoting uses extra single Quotes for Watcom tools.  */
-  kwsysSystem_Shell_Flag_WatcomQuote        = (1<<7)
-};
-
-/**
  * Parse a unix-style command line string into separate arguments.
  *
  * On success, returns a pointer to an array of pointers to individual
@@ -148,19 +63,6 @@ kwsysEXPORT char** kwsysSystem_Parse_CommandForUnix(const char* command,
 # undef kwsysEXPORT
 # if !defined(KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
 #  undef kwsysSystem_Parse_CommandForUnix
-#  undef kwsysSystem_Shell_GetArgumentForWindows
-#  undef kwsysSystem_Shell_GetArgumentForUnix
-#  undef kwsysSystem_Shell_GetArgumentSizeForWindows
-#  undef kwsysSystem_Shell_GetArgumentSizeForUnix
-#  undef kwsysSystem_Shell_Flag_e
-#  undef kwsysSystem_Shell_Flag_Make
-#  undef kwsysSystem_Shell_Flag_VSIDE
-#  undef kwsysSystem_Shell_Flag_EchoWindows
-#  undef kwsysSystem_Shell_Flag_WatcomWMake
-#  undef kwsysSystem_Shell_Flag_MinGWMake
-#  undef kwsysSystem_Shell_Flag_NMake
-#  undef kwsysSystem_Shell_Flag_AllowMakeVariables
-#  undef kwsysSystem_Shell_Flag_WatcomQuote
 # endif
 #endif