sdcc/src/SDCCsystem.c

   1 /*-------------------------------------------------------------------------
   2   SDCCsystem - SDCC system & pipe functions
   3
   4              Written By - Sandeep Dutta . sandeep.dutta@usa.net (1999)
   5
   6    This program is free software; you can redistribute it and/or modify it
   7    under the terms of the GNU General Public License as published by the
   8    Free Software Foundation; either version 2, or (at your option) any
   9    later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  19
  20    In other words, you are welcome to use, share and improve this program.
  21    You are forbidden to forbid anyone else to use, share and improve
  22    what you give them.   Help stamp out software-hoarding!
  23 -------------------------------------------------------------------------*/
  24
  25 #ifdef _WIN32
  26 /* avoid DATADIR definition clash :-( */
  27 #undef DATADIR
  28 #include <windows.h>
  29 #undef TRUE
  30 #undef FALSE
  31 #include <stdio.h>
  32 #include <io.h>
  33 #include <fcntl.h>
  34 #else
  35 #include <unistd.h>
  36 #endif
  37 #include <string.h>
  38 #include <ctype.h>
  39 #include "SDCCglobl.h"
  40 #include "SDCCutil.h"
  41 #include "dbuf_string.h"
  42 #include "SDCCsystem.h"
  43 #include "newalloc.h"
  44
  45
  46 set *binPathSet = NULL; /* set of binary paths */
  47
  48
  49 /*!
  50  * get command and arguments from command line
  51  */
  52
  53 static void
  54 split_command (const char *cmd_line, char **command, char **params)
  55 {
  56   const char *p, *cmd_start;
  57   char delim;
  58   char *str;
  59   unsigned len;
  60
  61   /* skip leading spaces */
  62   for (p = cmd_line; isspace (*p); p++)
  63     ;
  64
  65   /* get command */
  66   switch (*p)
  67     {
  68     case '\'':
  69     case '"':
  70       delim = *p;
  71       cmd_start = ++p;
  72       break;
  73
  74     default:
  75       delim = ' ';
  76       cmd_start = p;
  77     }
  78
  79   if (delim == ' ')
  80     {
  81       while (*p != '\0' && !isspace (*p))
  82         p++;
  83     }
  84   else
  85     {
  86       while (*p != '\0' && *p != delim)
  87         p++;
  88     }
  89
  90   if (command != NULL)
  91     {
  92       len = p - cmd_start;
  93       str = Safe_alloc (len + 1);
  94       strncpy (str, cmd_start, len);
  95       str[len] = '\0';
  96       *command = str;
  97     }
  98
  99   p++;
 100
 101   /* skip spaces before parameters */
 102   while (isspace (*p))
 103     p++;
 104
 105   /* get parameters */
 106   if (params != NULL)
 107     *params = Safe_strdup (p);
 108 }
 109
 110
 111 /*!
 112  * find the command:
 113  * 1) if the command is specified by path, try it
 114  * 2) try to find the command in predefined path's
 115  * 3) trust on $PATH
 116  */
 117
 118 #ifdef _WIN32
 119 /* WIN32 version */
 120
 121 static bool
 122 file_exists (const char* path)
 123 {
 124   DWORD attr = GetFileAttributes (path);
 125   return     attr != INVALID_FILE_ATTRIBUTES
 126           && 0 == (attr & FILE_ATTRIBUTE_DIRECTORY);
 127 }
 128
 129 /*
 130  * cmd.exe via _popen doesn't accept something like this:
 131  * "program" "argument"
 132  * It has to be:
 133  * ""program with possible spaces" "argument with spaces""
 134  * or
 135  * ""program with possible spaces" argument_without_spaces"
 136  * (note: the first and last " are also needed).
 137  * The arguments at this point already contain double quotes,
 138  * if necessary, so the following code formats the line as:
 139  * ""program"  arguments".
 140  */
 141
 142 #define EXE_EXT ".exe"
 143
 144 /*!
 145  * merge command and parameters to command line
 146  */
 147
 148 static const char *
 149 merge_command (const char *command, const char *params)
 150 {
 151   struct dbuf_s dbuf;
 152
 153   /* allocate extra space for '""', '"' ' and ""\0" */
 154   dbuf_init (&dbuf, strlen (command) + strlen (params) + 6);
 155
 156   dbuf_append_str (&dbuf, "\"\"");
 157   dbuf_append_str (&dbuf, command);
 158   dbuf_append_str (&dbuf, "\" ");
 159   dbuf_append_str (&dbuf, params);
 160   dbuf_append_str (&dbuf, "\"");
 161
 162   return dbuf_detach_c_str (&dbuf);
 163 }
 164
 165
 166 /*!
 167  * check if path/command exist by converting it to short file name
 168  * if it exists, compose with args and return it
 169  */
 170
 171 static const char *
 172 compose_command_line (const char *path, const char *command, const char *args)
 173 {
 174   bool cmd_exists;
 175   struct dbuf_s cmdPath;
 176
 177   dbuf_init (&cmdPath, PATH_MAX);
 178
 179   if (path != NULL)
 180     dbuf_makePath (&cmdPath, path, command);
 181   else
 182     dbuf_append_str (&cmdPath, command);
 183
 184   /* Does cmdPath or cmdPath.exe exist? */
 185   cmd_exists = file_exists (dbuf_c_str (&cmdPath));
 186   if (!cmd_exists)
 187     {
 188       dbuf_append_str (&cmdPath, EXE_EXT);
 189       cmd_exists = file_exists (dbuf_c_str (&cmdPath));
 190     }
 191   if (cmd_exists)
 192     {
 193       /* compose the command line */
 194       return merge_command (dbuf_c_str (&cmdPath), args);
 195     }
 196   else
 197     {
 198       /* path/command not found */
 199       return NULL;
 200     }
 201 }
 202
 203
 204 static const char *
 205 get_path (const char *cmd)
 206 {
 207   const char *cmdLine;
 208   char *command;
 209   char *args;
 210   char *path;
 211
 212   /* get the command */
 213   split_command (cmd, &command, &args);
 214
 215   if (NULL == (cmdLine = compose_command_line(NULL, command, args)))
 216     {
 217       /* not an absolute path: try to find the command in predefined binary paths */
 218       if (NULL != (path = (char *)setFirstItem (binPathSet)))
 219         {
 220           while (NULL == (cmdLine  = compose_command_line (path, command, args)) &&
 221             NULL != (path = (char *)setNextItem (binPathSet)))
 222             ;
 223         }
 224
 225       if (NULL == cmdLine)
 226         {
 227           /* didn't found the command in predefined binary paths: try with PATH */
 228           char *envPath;
 229
 230           if (NULL != (envPath = getenv("PATH")))
 231             {
 232               /* make a local copy; strtok() will modify it */
 233               envPath = Safe_strdup (envPath);
 234
 235               if (NULL != (path = strtok (envPath, ";")))
 236                 {
 237                   while (NULL == (cmdLine = compose_command_line (path, command, args)) &&
 238                     NULL != (path = strtok (NULL, ";")))
 239                     ;
 240                 }
 241
 242               Safe_free (envPath);
 243           }
 244     }
 245
 246     /* didn't found it; probably this won't help neither :-( */
 247     if (NULL == cmdLine)
 248       cmdLine = merge_command (command, args);
 249   }
 250
 251   Safe_free(command);
 252   Safe_free(args);
 253
 254   return cmdLine;
 255 }
 256
 257 #else
 258 /* *nix version */
 259
 260 /*!
 261  * merge command and parameters to command line
 262  */
 263
 264 static const char *
 265 merge_command (const char *command, const char *params)
 266 {
 267   struct dbuf_s dbuf;
 268   char *s = shell_escape (command);
 269
 270   /* allocate extra space for ' ' and '\0' */
 271   dbuf_init (&dbuf, strlen (command) + strlen (params) + 2);
 272
 273   dbuf_append_str (&dbuf, s);
 274   dbuf_append (&dbuf, " ", 1);
 275   dbuf_append_str (&dbuf, params);
 276
 277   return dbuf_detach_c_str (&dbuf);
 278 }
 279
 280
 281 /*!
 282  * check if the path is relative or absolute (if contains the dir separator)
 283  */
 284
 285 static int
 286 has_path (const char *path)
 287 {
 288   return dbuf_splitPath (path, NULL, NULL);
 289 }
 290
 291
 292 static const char *
 293 get_path (const char *cmd)
 294 {
 295   const char *cmdLine = NULL;
 296   char *command;
 297   char *args;
 298   char *path;
 299
 300   /* get the command */
 301   split_command (cmd, &command, &args);
 302
 303   if (!has_path (command))
 304     {
 305       /* try to find the command in predefined binary paths */
 306       if (NULL != (path = (char *)setFirstItem (binPathSet)))
 307         {
 308           do
 309             {
 310               struct dbuf_s dbuf;
 311               const char *cmdPath;
 312
 313               dbuf_init (&dbuf, PATH_MAX);
 314               dbuf_makePath (&dbuf, path, command);
 315               cmdPath = dbuf_detach (&dbuf);
 316
 317               /* Try if cmdPath */
 318               if (0 == access (cmdPath, X_OK))
 319                 {
 320                   /* compose the command line */
 321                   cmdLine = merge_command (cmdPath, args);
 322                   break;
 323                 }
 324             } while (NULL != (path = (char *)setNextItem (binPathSet)));
 325         }
 326       if (NULL == cmdLine)
 327         cmdLine = merge_command (command, args);
 328
 329       Safe_free (command);
 330       Safe_free (args);
 331
 332       return cmdLine;
 333     }
 334   else
 335     {
 336       /*
 337        * the command is defined with absolute path:
 338        * just return it
 339        */
 340       Safe_free (command);
 341       Safe_free (args);
 342
 343       return Safe_strdup (cmd);
 344     }
 345 }
 346 #endif
 347
 348
 349 /*!
 350  * call an external program with arguments
 351  */
 352
 353 int
 354 sdcc_system (const char *cmd)
 355 {
 356   int e;
 357   const char *cmdLine = get_path (cmd);
 358
 359   assert (NULL != cmdLine);
 360
 361   if (options.verboseExec)
 362     printf ("+ %s\n", cmdLine);
 363
 364   e = system (cmdLine);
 365
 366   if (options.verboseExec && e)
 367     printf ("+ %s returned errorcode %d\n", cmdLine, e);
 368
 369   dbuf_free (cmdLine);
 370
 371   return e;
 372 }
 373
 374
 375 /*!
 376  * pipe an external program with arguments
 377  */
 378
 379 #ifdef _WIN32
 380 #define sdcc_popen_read(cmd)  _popen ((cmd), "rt")
 381 int
 382 sdcc_pclose (FILE *fp)
 383 {
 384   return _pclose (fp);
 385 }
 386 #else
 387 #define sdcc_popen_read(cmd)  popen ((cmd), "r")
 388 int
 389 sdcc_pclose (FILE *fp)
 390 {
 391   return pclose (fp);
 392 }
 393 #endif
 394
 395 FILE *
 396 sdcc_popen (const char *cmd)
 397 {
 398   FILE *fp;
 399   const char *cmdLine = get_path (cmd);
 400
 401   assert (NULL != cmdLine);
 402
 403   if (options.verboseExec)
 404     {
 405       printf ("+ %s\n", cmdLine);
 406     }
 407
 408   fp = sdcc_popen_read (cmdLine);
 409   dbuf_free (cmdLine);
 410
 411   return fp;
 412 }