home *** CD-ROM | disk | FTP | other *** search
/ Shareware 1 2 the Maxx / sw_1.zip / sw_1 / PROGRAM / SETARGV.ZIP / SETARGV.C
C/C++ Source or Header  |  1992-01-02  |  5KB  |  166 lines
  1. /* setargv -- setup argv with wild card expansion                           */
  2. /* copyright 1987  Michael M Rubenstein                                     */
  3.  
  4. /* This program may be freely distributed provided no fee is assessed.      */
  5.  
  6. /* This file implements wild card expansion in argv for Turbo C 1.5.        */
  7. /* Strings of characters in either quotes (") or appostrophes (') on the    */
  8. /* command line are considered a single argument.  However, backslash       */
  9. /* escapes are not implemented.  A quote may be included in an argument     */
  10. /* which is enclosed in appostrophes and an appostrophe may be included     */
  11. /* in an argument enclosed in quotes.  Either may be included as an         */
  12. /* in an argument starting with any other character.                        */
  13.  
  14. /* Any argument which is not enclosed in quotes or appostrophes, does not   */
  15. /* begin with a hyphen (-), and which contains an asterisk (*) or question  */
  16. /* mark (?) will be expanded.  It is NOT an error for an argument to have a */
  17. /* null expansion (no matching files).  Only ordinary files (not            */
  18. /* directories or hidden or system files) will be included in the           */
  19. /* expansion.                                                               */
  20.  
  21. /* To use this function, simply compile it with the appropriate memory      */
  22. /* model and include in the link.  This can be accomplished very simply     */
  23. /* in the integrated environment by simply including this file in the       */
  24. /* project file.  In the command line version, simply include this file     */
  25. /* (or a precompiled .OBJ version) on the command line.                     */
  26.  
  27. #include <ctype.h>
  28. #include <dir.h>
  29. #include <dos.h>
  30. #include <process.h>
  31.  
  32. #define FALSE           0
  33. #define TRUE            1
  34.  
  35. void                    putarg(unsigned char far *, unsigned char far *);
  36.  
  37. extern int              _argc;
  38. extern char             **_argv;
  39. extern unsigned         _psp;
  40. extern unsigned         _envseg;
  41. extern unsigned         _envLng;
  42. extern unsigned char    _osmajor;
  43. extern void             _abort();
  44. extern char             *sbrk(int);
  45.  
  46. void _setargv()
  47. {
  48.   unsigned char         far *cmdtail;
  49.   unsigned char         *firstarg;
  50.   unsigned char         far *cmdarg;
  51.   int                   wild;
  52.   int                   c;
  53.   unsigned char         buffer[129];
  54.   unsigned char         *p, *q;
  55.   unsigned char         *lastdir;
  56.   char                  **wargv;
  57.   int                   i;
  58.   struct ffblk          ffb;
  59.  
  60.   cmdtail = MK_FP(_psp, 0x81);
  61.   cmdtail[cmdtail[-1]] = '\0';      /* make sure null at end */
  62.   firstarg = (unsigned char *) sbrk(0);
  63.   _argc = 1;
  64.  
  65.   while (*cmdtail != '\0')
  66.   {
  67.     /* skip white space */
  68.     while (isascii(*cmdtail) && isspace(*cmdtail))
  69.       ++cmdtail;
  70.  
  71.     /* done with command loop if end of command tail */
  72.     if (*cmdtail == '\0')
  73.       break;
  74.  
  75.     /* if quoted string, just save the argument */
  76.     if ((c = *cmdtail) == '"' || c == '\'')
  77.     {
  78.       cmdarg = ++cmdtail;
  79.       while (*cmdtail != c && *cmdtail != '\0')
  80.         ++cmdtail;
  81.       putarg(cmdarg, cmdtail);
  82.       if (*cmdtail != '\0')
  83.         ++cmdtail;
  84.       continue;
  85.     }
  86.  
  87.     /* find word */
  88.     cmdarg = cmdtail;
  89.     wild = FALSE;
  90.     p = lastdir = buffer;
  91.     while ((c = *cmdtail) != '\0'
  92.         && (!isascii(c) || !isspace(c)))
  93.     {
  94.       /* wild is TRUE if word contains * or ? */
  95.       wild |= (c == '*' || c == '?');
  96.       if (c == '/') c = '\\';
  97.       *(p++) = c;
  98.  
  99.       /* lastdir points to the first character of the base file name */
  100.       if (c == '\\' || c == ':')
  101.         lastdir = p;
  102.       ++cmdtail;
  103.     }
  104.     *p = '\0';
  105.  
  106.     if (wild && *cmdarg != '-')
  107.       for (c = findfirst((char *) buffer, &ffb, 0);
  108.            c == 0;
  109.            c = findnext(&ffb))
  110.       {
  111.         /* use lower case for wild card expanded names (my prejudice) */
  112.         for (p = lastdir, q = (unsigned char *) ffb.ff_name; *q != '\0';)
  113.              *(p++) = tolower(*(q++));
  114.           ;
  115.         putarg(buffer, p);
  116.       }
  117.     else
  118.       putarg(cmdarg, cmdtail);
  119.   }
  120.  
  121.   /* allocate argv */
  122.   if ((wargv = (char **) sbrk(sizeof(char *) * (_argc + 1))) == (char **) -1)
  123.     abort();
  124.   _argv = wargv;
  125.  
  126.   /* store program name */
  127.   if (_osmajor < 3)
  128.     *(wargv++) = "C";
  129.   else
  130.   {
  131.       cmdtail = cmdarg = MK_FP(_envseg, _envLng + 2);
  132. #   if defined(__TINY__) || defined(__SMALL__) || defined(__MEDIUM__)
  133.       *(wargv++) = sbrk(0);
  134.       while (*cmdtail != '\0')
  135.         ++cmdtail;
  136.       putarg(cmdarg, cmdtail);
  137.       --_argc;
  138. #   else
  139.       *(wargv++) = (char *) cmdarg;
  140. #   endif
  141.   }
  142.  
  143.   /* store arguments */
  144.   for (i = _argc; --i;)
  145.   {
  146.     *(wargv++) = (char *) firstarg;
  147.     while(*++firstarg != '\0')
  148.       ;
  149.     ++firstarg;
  150.   }
  151.   *wargv = (char *) 0;
  152. }
  153.  
  154. static void putarg(from, to)
  155.   unsigned char         far *from, far *to;
  156. {
  157.   char                  *p;
  158.  
  159.   if ((p = sbrk(to - from + 1)) == (char *) -1)
  160.     abort();
  161.   while (from < to)
  162.    *(p++) = *(from++);
  163.   *p = '\0';
  164.   ++_argc;
  165. }
  166.