CMakeLua/Source/kwsys/System.c

   1 /*=========================================================================
   2
   3   Program:   KWSys - Kitware System Library
   4   Module:    $RCSfile: System.c,v $
   5
   6   Copyright (c) Kitware, Inc., Insight Consortium.  All rights reserved.
   7   See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
   8
   9      This software is distributed WITHOUT ANY WARRANTY; without even
  10      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  11      PURPOSE.  See the above copyright notices for more information.
  12
  13 =========================================================================*/
  14 #include "kwsysPrivate.h"
  15 #include KWSYS_HEADER(System.h)
  16
  17 /* Work-around CMake dependency scanning limitation.  This must
  18    duplicate the above list of headers.  */
  19 #if 0
  20 # include "System.h.in"
  21 #endif
  22
  23 #include <string.h> /* strlen */
  24 #include <ctype.h>  /* isalpha */
  25
  26 #include <stdio.h>
  27
  28 /*
  29
  30 Notes:
  31
  32 Make variable replacements open a can of worms.  Sometimes they should
  33 be quoted and sometimes not.  Sometimes their replacement values are
  34 already quoted.
  35
  36 VS variables cause problems.  In order to pass the referenced value
  37 with spaces the reference must be quoted.  If the variable value ends
  38 in a backslash then it will escape the ending quote!  In order to make
  39 the ending backslash appear we need this:
  40
  41   "$(InputDir)\"
  42
  43 However if there is not a trailing backslash then this will put a
  44 quote in the value so we need:
  45
  46   "$(InputDir)"
  47
  48 Make variable references are platform specific so we should probably
  49 just NOT quote them and let the listfile author deal with it.
  50
  51 */
  52
  53 /*
  54 TODO: For windows echo:
  55
  56 To display a pipe (|) or redirection character (< or >) when using the
  57 echo command, use a caret character immediately before the pipe or
  58 redirection character (for example, ^>, ^<, or ^| ). If you need to
  59 use the caret character itself (^), use two in a row (^^).
  60 */
  61
  62 /*--------------------------------------------------------------------------*/
  63 static int kwsysSystem_Shell__CharIsWhitespace(char c)
  64 {
  65   return ((c == ' ') || (c == '\t'));
  66 }
  67
  68 /*--------------------------------------------------------------------------*/
  69 static int kwsysSystem_Shell__CharNeedsQuotesOnUnix(char c)
  70 {
  71   return ((c == '\'') || (c == '`') || (c == ';') || (c == '#') ||
  72           (c == '&') || (c == '$') || (c == '(') || (c == ')') ||
  73           (c == '~') || (c == '<') || (c == '>') || (c == '|') ||
  74           (c == '*') || (c == '^') || (c == '\\'));
  75 }
  76
  77 /*--------------------------------------------------------------------------*/
  78 static int kwsysSystem_Shell__CharNeedsQuotes(char c, int isUnix, int flags)
  79 {
  80   /* On Windows the built-in command shell echo never needs quotes.  */
  81   if(!isUnix && (flags & kwsysSystem_Shell_Flag_EchoWindows))
  82     {
  83     return 0;
  84     }
  85
  86   /* On all platforms quotes are needed to preserve whitespace.  */
  87   if(kwsysSystem_Shell__CharIsWhitespace(c))
  88     {
  89     return 1;
  90     }
  91
  92   if(isUnix)
  93     {
  94     /* On UNIX several special characters need quotes to preserve them.  */
  95     if(kwsysSystem_Shell__CharNeedsQuotesOnUnix(c))
  96       {
  97       return 1;
  98       }
  99     }
 100   else
 101     {
 102     /* On Windows single-quotes must be escaped in some make
 103        environments, such as in mingw32-make.  */
 104     if(flags & kwsysSystem_Shell_Flag_Make)
 105       {
 106       if(c == '\'')
 107         {
 108         return 1;
 109         }
 110       }
 111     }
 112   return 0;
 113 }
 114
 115 /*--------------------------------------------------------------------------*/
 116 static int kwsysSystem_Shell__CharIsMakeVariableName(char c)
 117 {
 118   return c && (c == '_' || isalpha(((int)c)));
 119 }
 120
 121 /*--------------------------------------------------------------------------*/
 122 static const char* kwsysSystem_Shell__SkipMakeVariables(const char* c)
 123 {
 124   while(*c == '$' && *(c+1) == '(')
 125     {
 126     const char* skip = c+2;
 127     while(kwsysSystem_Shell__CharIsMakeVariableName(*skip))
 128       {
 129       ++skip;
 130       }
 131     if(*skip == ')')
 132       {
 133       c = skip+1;
 134       }
 135     else
 136       {
 137       break;
 138       }
 139     }
 140   return c;
 141 }
 142
 143 /*
 144 Allowing make variable replacements opens a can of worms.  Sometimes
 145 they should be quoted and sometimes not.  Sometimes their replacement
 146 values are already quoted or contain escapes.
 147
 148 Some Visual Studio variables cause problems.  In order to pass the
 149 referenced value with spaces the reference must be quoted.  If the
 150 variable value ends in a backslash then it will escape the ending
 151 quote!  In order to make the ending backslash appear we need this:
 152
 153   "$(InputDir)\"
 154
 155 However if there is not a trailing backslash then this will put a
 156 quote in the value so we need:
 157
 158   "$(InputDir)"
 159
 160 This macro decides whether we quote an argument just because it
 161 contains a make variable reference.  This should be replaced with a
 162 flag later when we understand applications of this better.
 163 */
 164 #define KWSYS_SYSTEM_SHELL_QUOTE_MAKE_VARIABLES 0
 165
 166 /*--------------------------------------------------------------------------*/
 167 static int kwsysSystem_Shell__ArgumentNeedsQuotes(const char* in, int isUnix,
 168                                                   int flags)
 169 {
 170   /* Scan the string for characters that require quoting.  */
 171   {
 172   const char* c;
 173   for(c=in; *c; ++c)
 174     {
 175     /* Look for $(MAKEVAR) syntax if requested.  */
 176     if(flags & kwsysSystem_Shell_Flag_AllowMakeVariables)
 177       {
 178 #if KWSYS_SYSTEM_SHELL_QUOTE_MAKE_VARIABLES
 179       const char* skip = kwsysSystem_Shell__SkipMakeVariables(c);
 180       if(skip != c)
 181         {
 182         /* We need to quote make variable references to preserve the
 183            string with contents substituted in its place.  */
 184         return 1;
 185         }
 186 #else
 187       /* Skip over the make variable references if any are present.  */
 188       c = kwsysSystem_Shell__SkipMakeVariables(c);
 189
 190       /* Stop if we have reached the end of the string.  */
 191       if(!*c)
 192         {
 193         break;
 194         }
 195 #endif
 196       }
 197
 198     /* Check whether this character needs quotes.  */
 199     if(kwsysSystem_Shell__CharNeedsQuotes(*c, isUnix, flags))
 200       {
 201       return 1;
 202       }
 203     }
 204   }
 205
 206   /* On Windows some single character arguments need quotes.  */
 207   if(!isUnix && *in && !*(in+1))
 208     {
 209     char c = *in;
 210     if((c == '?') || (c == '&') || (c == '^') || (c == '|') || (c == '#'))
 211       {
 212       return 1;
 213       }
 214     }
 215
 216   return 0;
 217 }
 218
 219 /*--------------------------------------------------------------------------*/
 220 static int kwsysSystem_Shell__GetArgumentSize(const char* in,
 221                                               int isUnix, int flags)
 222 {
 223   /* Start with the length of the original argument, plus one for
 224      either a terminating null or a separating space.  */
 225   int size = (int)strlen(in) + 1;
 226
 227   /* String iterator.  */
 228   const char* c;
 229
 230   /* Keep track of how many backslashes have been encountered in a row.  */
 231   int windows_backslashes = 0;
 232
 233   /* Scan the string for characters that require escaping or quoting.  */
 234   for(c=in; *c; ++c)
 235     {
 236     /* Look for $(MAKEVAR) syntax if requested.  */
 237     if(flags & kwsysSystem_Shell_Flag_AllowMakeVariables)
 238       {
 239       /* Skip over the make variable references if any are present.  */
 240       c = kwsysSystem_Shell__SkipMakeVariables(c);
 241
 242       /* Stop if we have reached the end of the string.  */
 243       if(!*c)
 244         {
 245         break;
 246         }
 247       }
 248
 249     /* Check whether this character needs escaping for the shell.  */
 250     if(isUnix)
 251       {
 252       /* On Unix a few special characters need escaping even inside a
 253          quoted argument.  */
 254       if(*c == '\\' || *c == '"' || *c == '`' || *c == '$')
 255         {
 256         /* This character needs a backslash to escape it.  */
 257         ++size;
 258         }
 259       }
 260     else if(flags & kwsysSystem_Shell_Flag_EchoWindows)
 261       {
 262       /* On Windows the built-in command shell echo never needs escaping.  */
 263       }
 264     else
 265       {
 266       /* On Windows only backslashes and double-quotes need escaping.  */
 267       if(*c == '\\')
 268         {
 269         /* Found a backslash.  It may need to be escaped later.  */
 270         ++windows_backslashes;
 271         }
 272       else if(*c == '"')
 273         {
 274         /* Found a double-quote.  We need to escape it and all
 275            immediately preceding backslashes.  */
 276         size += windows_backslashes + 1;
 277         windows_backslashes = 0;
 278         }
 279       else
 280         {
 281         /* Found another character.  This eliminates the possibility
 282            that any immediately preceding backslashes will be
 283            escaped.  */
 284         windows_backslashes = 0;
 285         }
 286       }
 287
 288     /* Check whether this character needs escaping for a make tool.  */
 289     if(*c == '$')
 290       {
 291       if(flags & kwsysSystem_Shell_Flag_Make)
 292         {
 293         /* In Makefiles a dollar is written $$ so we need one extra
 294            character.  */
 295         ++size;
 296         }
 297       else if(flags & kwsysSystem_Shell_Flag_VSIDE)
 298         {
 299         /* In a VS IDE a dollar is written "$" so we need two extra
 300            characters.  */
 301         size += 2;
 302         }
 303       }
 304     else if(*c == '#')
 305       {
 306       if((flags & kwsysSystem_Shell_Flag_Make) &&
 307          (flags & kwsysSystem_Shell_Flag_WatcomWMake))
 308         {
 309         /* In Watcom WMake makefiles a pound is written $# so we need
 310            one extra character.  */
 311         ++size;
 312         }
 313       }
 314     else if(*c == '%')
 315       {
 316       if((flags & kwsysSystem_Shell_Flag_VSIDE) ||
 317          ((flags & kwsysSystem_Shell_Flag_Make) &&
 318           ((flags & kwsysSystem_Shell_Flag_MinGWMake) ||
 319            (flags & kwsysSystem_Shell_Flag_NMake))))
 320         {
 321         /* In the VS IDE, NMake, or MinGW make a percent is written %%
 322            so we need one extra characters.  */
 323         size += 1;
 324         }
 325       }
 326     else if(*c == ';')
 327       {
 328       if(flags & kwsysSystem_Shell_Flag_VSIDE)
 329         {
 330         /* In a VS IDE a semicolon is written ";" so we need two extra
 331            characters.  */
 332         size += 2;
 333         }
 334       }
 335     }
 336
 337   /* Check whether the argument needs surrounding quotes.  */
 338   if(kwsysSystem_Shell__ArgumentNeedsQuotes(in, isUnix, flags))
 339     {
 340     /* Surrounding quotes are needed.  Allocate space for them.  */
 341     size += 2;
 342
 343     /* We must escape all ending backslashes when quoting on windows.  */
 344     size += windows_backslashes;
 345     }
 346
 347   return size;
 348 }
 349
 350 /*--------------------------------------------------------------------------*/
 351 static char* kwsysSystem_Shell__GetArgument(const char* in, char* out,
 352                                             int isUnix, int flags)
 353 {
 354   /* String iterator.  */
 355   const char* c;
 356
 357   /* Keep track of how many backslashes have been encountered in a row.  */
 358   int windows_backslashes = 0;
 359
 360   /* Whether the argument must be quoted.  */
 361   int needQuotes = kwsysSystem_Shell__ArgumentNeedsQuotes(in, isUnix, flags);
 362   if(needQuotes)
 363     {
 364     /* Add the opening quote for this argument.  */
 365     *out++ = '"';
 366     }
 367
 368   /* Scan the string for characters that require escaping or quoting.  */
 369   for(c=in; *c; ++c)
 370     {
 371     /* Look for $(MAKEVAR) syntax if requested.  */
 372     if(flags & kwsysSystem_Shell_Flag_AllowMakeVariables)
 373       {
 374       const char* skip = kwsysSystem_Shell__SkipMakeVariables(c);
 375       if(skip != c)
 376         {
 377         /* Copy to the end of the make variable references.  */
 378         while(c != skip)
 379           {
 380           *out++ = *c++;
 381           }
 382
 383         /* Stop if we have reached the end of the string.  */
 384         if(!*c)
 385           {
 386           break;
 387           }
 388         }
 389       }
 390
 391     /* Check whether this character needs escaping for the shell.  */
 392     if(isUnix)
 393       {
 394       /* On Unix a few special characters need escaping even inside a
 395          quoted argument.  */
 396       if(*c == '\\' || *c == '"' || *c == '`' || *c == '$')
 397         {
 398         /* This character needs a backslash to escape it.  */
 399         *out++ = '\\';
 400         }
 401       }
 402     else if(flags & kwsysSystem_Shell_Flag_EchoWindows)
 403       {
 404       /* On Windows the built-in command shell echo never needs escaping.  */
 405       }
 406     else
 407       {
 408       /* On Windows only backslashes and double-quotes need escaping.  */
 409       if(*c == '\\')
 410         {
 411         /* Found a backslash.  It may need to be escaped later.  */
 412         ++windows_backslashes;
 413         }
 414       else if(*c == '"')
 415         {
 416         /* Found a double-quote.  Escape all immediately preceding
 417            backslashes.  */
 418         while(windows_backslashes > 0)
 419           {
 420           --windows_backslashes;
 421           *out++ = '\\';
 422           }
 423
 424         /* Add the backslash to escape the double-quote.  */
 425         *out++ = '\\';
 426         }
 427       else
 428         {
 429         /* We encountered a normal character.  This eliminates any
 430            escaping needed for preceding backslashes.  */
 431         windows_backslashes = 0;
 432         }
 433       }
 434
 435     /* Check whether this character needs escaping for a make tool.  */
 436     if(*c == '$')
 437       {
 438       if(flags & kwsysSystem_Shell_Flag_Make)
 439         {
 440         /* In Makefiles a dollar is written $$.  The make tool will
 441            replace it with just $ before passing it to the shell.  */
 442         *out++ = '$';
 443         *out++ = '$';
 444         }
 445       else if(flags & kwsysSystem_Shell_Flag_VSIDE)
 446         {
 447         /* In a VS IDE a dollar is written "$".  If this is written in
 448            an un-quoted argument it starts a quoted segment, inserts
 449            the $ and ends the segment.  If it is written in a quoted
 450            argument it ends quoting, inserts the $ and restarts
 451            quoting.  Either way the $ is isolated from surrounding
 452            text to avoid looking like a variable reference.  */
 453         *out++ = '"';
 454         *out++ = '$';
 455         *out++ = '"';
 456         }
 457       else
 458         {
 459         /* Otherwise a dollar is written just $. */
 460         *out++ = '$';
 461         }
 462       }
 463     else if(*c == '#')
 464       {
 465       if((flags & kwsysSystem_Shell_Flag_Make) &&
 466          (flags & kwsysSystem_Shell_Flag_WatcomWMake))
 467         {
 468         /* In Watcom WMake makefiles a pound is written $#.  The make
 469            tool will replace it with just # before passing it to the
 470            shell.  */
 471         *out++ = '$';
 472         *out++ = '#';
 473         }
 474       else
 475         {
 476         /* Otherwise a pound is written just #. */
 477         *out++ = '#';
 478         }
 479       }
 480     else if(*c == '%')
 481       {
 482       if((flags & kwsysSystem_Shell_Flag_VSIDE) ||
 483          ((flags & kwsysSystem_Shell_Flag_Make) &&
 484           ((flags & kwsysSystem_Shell_Flag_MinGWMake) ||
 485            (flags & kwsysSystem_Shell_Flag_NMake))))
 486         {
 487         /* In the VS IDE, NMake, or MinGW make a percent is written %%.  */
 488         *out++ = '%';
 489         *out++ = '%';
 490         }
 491       else
 492         {
 493         /* Otherwise a percent is written just %. */
 494         *out++ = '%';
 495         }
 496       }
 497     else if(*c == ';')
 498       {
 499       if(flags & kwsysSystem_Shell_Flag_VSIDE)
 500         {
 501         /* In a VS IDE a semicolon is written ";".  If this is written
 502            in an un-quoted argument it starts a quoted segment,
 503            inserts the ; and ends the segment.  If it is written in a
 504            quoted argument it ends quoting, inserts the ; and restarts
 505            quoting.  Either way the ; is isolated.  */
 506         *out++ = '"';
 507         *out++ = ';';
 508         *out++ = '"';
 509         }
 510       else
 511         {
 512         /* Otherwise a semicolon is written just ;. */
 513         *out++ = ';';
 514         }
 515       }
 516     else
 517       {
 518       /* Store this character.  */
 519       *out++ = *c;
 520       }
 521     }
 522
 523   if(needQuotes)
 524     {
 525     /* Add enough backslashes to escape any trailing ones.  */
 526     while(windows_backslashes > 0)
 527       {
 528       --windows_backslashes;
 529       *out++ = '\\';
 530       }
 531
 532     /* Add the closing quote for this argument.  */
 533     *out++ = '"';
 534     }
 535
 536   /* Store a terminating null without incrementing.  */
 537   *out = 0;
 538
 539   return out;
 540 }
 541
 542 /*--------------------------------------------------------------------------*/
 543 char* kwsysSystem_Shell_GetArgumentForWindows(const char* in,
 544                                               char* out,
 545                                               int flags)
 546 {
 547   return kwsysSystem_Shell__GetArgument(in, out, 0, flags);
 548 }
 549
 550 /*--------------------------------------------------------------------------*/
 551 char* kwsysSystem_Shell_GetArgumentForUnix(const char* in,
 552                                            char* out,
 553                                            int flags)
 554 {
 555   return kwsysSystem_Shell__GetArgument(in, out, 1, flags);
 556 }
 557
 558 /*--------------------------------------------------------------------------*/
 559 int kwsysSystem_Shell_GetArgumentSizeForWindows(const char* in, int flags)
 560 {
 561   return kwsysSystem_Shell__GetArgumentSize(in, 0, flags);
 562 }
 563
 564 /*--------------------------------------------------------------------------*/
 565 int kwsysSystem_Shell_GetArgumentSizeForUnix(const char* in, int flags)
 566 {
 567   return kwsysSystem_Shell__GetArgumentSize(in, 1, flags);
 568 }