WebSVN – DevTools – Diff – /core_devl/trunk/UTILS/SH/ARGV.C

 #define ARG_GROW_SIZE  2000
 /*
  * The following are part of the Watcom runtime
  */
-extern char **___Argv;		/* the eventual argv */
+extern char **___Argv;          /* the eventual argv */
-extern int  ___Argc;		/* the eventual argc */
+extern int  ___Argc;            /* the eventual argc */
-extern char *_LpPgmName;	/* the program name */
+extern char *_LpPgmName;        /* the program name */
-extern char *_LpCmdLine;	/* the raw cmdline */
+extern char *_LpCmdLine;        /* the raw cmdline */
-extern char **environ;		/* the environment strings */
+extern char **environ;          /* the environment strings */
 /*
  * How big the array pointed to by __Argv really is.
  */
 static int argv_allocated = 0;
 void __Init_Argv(void)
+{
   int  nenv_args = 0;
   char *tmp;
-  extern void __setenvp(void);	/* A WATCOM thing which sets up environ */
+  extern void __setenvp(void);  /* A WATCOM thing which sets up environ */
   __setenvp();                  /* found by grovelling                  */
 #ifdef TEST
     printf("_LpCmdLine: %x\n", _LpCmdLine);
   strlwr(_LpPgmName);
   for (tmp = _LpPgmName; *tmp; tmp++)
+    {
       if (*tmp == '\\')
-	*tmp = '/';
+        *tmp = '/';
+    }
   add_arg(_LpPgmName);
   if ((tmp = xgetenv("_argc")) != 0)
+    {
   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",
+          fprintf(stderr, "glob_env: BAD environment: _argc: %d, no _argv%d\n",
-		  nargs, i);
+                  nargs, i);
-	  exit(42);
+          exit(42);
-	}
+        }
       expand(0, arg, ENV_ARG, 0);
+    }
+}
 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 */
+  char *argv[64];       /* can't get more than this on a DOS command line */
   int  i;
   while (*l)
+    {
       /*
       /*
        * Find the end of the argument.
        */
       for (;*l; l++)
-	{
+        {
-	  if (*l == '\'' || *l == '\"' || *l == '\`')
+          if (*l == '\'' || *l == '\"' || *l == '`')
-	    {
+            {
-	      int quote_char = *l++;
+              int quote_char = *l++;
-	      do
+              do
-		{
+                {
-		  if (!*l)
+                  if (!*l)
-		    {
+                    {
-		      fprintf(stderr, "Unmatched %c.\n", quote_char);
+                      fprintf(stderr, "Unmatched %c.\n", quote_char);
-		      exit(42);
+                      exit(42);
-		    }
+                    }
-		} while (*l++ != quote_char);
+                } while (*l++ != quote_char);
-	    }
+            }
-	  if (*l == ' ' || *l == '\t')
+          if (*l == ' ' || *l == '\t')
-	    {
+            {
-	      *l++ = '\0';
+              *l++ = '\0';
-	      break;
+              break;
-	    }
+            }
-	}
+        }
+    }
   for (i = 0; i < argc; i++)
+    {
       expand(0, argv[i], CMDLINE_ARG, 0);
   char *bufp = buf;
   int   in_quote = 0;
 #ifdef TEST
   printf("expand(prefix: \"%s\", arg: \"%s\")\n",
-	  prefix?prefix:"(nil)", arg);
+          prefix?prefix:"(nil)", arg);
 #endif
-#define CHECK_BUF_END(l)					\
+#define CHECK_BUF_END(l)                                        \
-  {								\
+  {                                                             \
-    int offset = bufp - buf;    				\
+    int offset = bufp - buf;                                    \
-    while ((offset + (l)) >= buf_len)				\
+    while ((offset + (l)) >= buf_len)                           \
-      {								\
+      {                                                         \
-	buf = (char*)realloc(buf, buf_len += ARG_GROW_SIZE);	\
+        buf = (char*)realloc(buf, buf_len += ARG_GROW_SIZE);    \
-      }				        			\
+      }                                                         \
-    bufp = buf + offset;                			\
+    bufp = buf + offset;                                        \
+  }
   if (!buf)
+    {
       fprintf(stderr, "expand: Out of memory\n");
    * do stuff..
    */
   for (;*arg; arg++)
+    {
       switch (*arg)
-	{
+        {
-	case '\'':
+        case '\'':
-	  {
+          {
-	    in_quote = !in_quote;
+            in_quote = !in_quote;
-	    arg;
+            arg;
-	    break;
+            break;
-	  }
+          }
-	case '\"':
+        case '\"':
-	  {
+          {
-	    if (!in_quote)
+            if (!in_quote)
-	      {
+              {
-		in_string = !in_string;
+                in_string = !in_string;
-		arg;
+                arg;
-	      }
+              }
-	    else
+            else
-	      goto copy_it;
+              goto copy_it;
-	    break;
+            break;
-	  }
+          }
-	case '\`':
+        case '`':
-	  {
+          {
-	    if (!in_quote)
+            if (!in_quote)
-	      {
+              {
-		char *start = ++arg;
+                char *start = ++arg;
-		char **lines;
+                char **lines;
-		for (arg++; *arg != '\`'; arg++);
+                for (arg++; *arg != '`'; arg++);
-		CHECK_BUF_END(arg - start);
+                CHECK_BUF_END(arg - start);
-		strncpy(bufp, start, arg - start);
+                strncpy(bufp, start, arg - start);
-		*(bufp + (arg - start)) = '\0';
+                *(bufp + (arg - start)) = '\0';
-		lines =  exec_prog(bufp, in_string);
+                lines =  exec_prog(bufp, in_string);
-		*bufp = '\0';
+                *bufp = '\0';
-		if (lines)
+                if (lines)
-		  {
+                  {
-		    for (;*lines; lines++)
+                    for (;*lines; lines++)
-		      {
+                      {
-			if (lines[1])
+                        if (lines[1])
-			  {
+                          {
-			    /* more arguments after this one. */
+                            /* more arguments after this one. */
-			    expand((bufp == buf)?0:buf, *lines, 0, in_string);
+                            expand((bufp == buf)?0:buf, *lines, 0, in_string);
-			    bufp = buf;
+                            bufp = buf;
-			  }
+                          }
-			else
+                        else
-			  {
+                          {
-			    char *new_arg;
+                            char *new_arg;
-			    /* last argument.. tack the rest of arg onto it. */
+                            /* last argument.. tack the rest of arg onto it. */
-			    new_arg = (char*)malloc(strlen(*lines) +
+                            new_arg = (char*)malloc(strlen(*lines) +
-						    strlen(arg + 1) + 1);
+                                                    strlen(arg + 1) + 1);
-			    if (!new_arg)
+                            if (!new_arg)
-			      {
+                              {
-				fprintf(stderr, "expand: Out of memory\n");
+                                fprintf(stderr, "expand: Out of memory\n");
-			      }
+                              }
-			    strcpy(new_arg, *lines);
+                            strcpy(new_arg, *lines);
-			    strcat(new_arg, arg + 1);
+                            strcat(new_arg, arg + 1);
-			    expand((bufp == buf)?0:buf, new_arg, 0, in_string);
+                            expand((bufp == buf)?0:buf, new_arg, 0, in_string);
-			    free(new_arg);
+                            free(new_arg);
-			  }
+                          }
-		      }
+                      }
-		  }
+                  }
-		return;
+                return;
-	      }
+              }
-	    else
+            else
-	      goto copy_it;
+              goto copy_it;
-	    break;
+            break;
-	  }
+          }
-	case '$':
+        case '$':
-	  {
+          {
-	    if (!in_quote)
+            if (!in_quote)
-	      {
+              {
-		char *start  = ++arg;
+                char *start  = ++arg;
-		int  bracket = 0;
+                int  bracket = 0;
-		char var_name[200];
+                char var_name[200];
-		char *new_arg;
+                char *new_arg;
-		char *var_val;
+                char *var_val;
-		if (*start == '(')
+                if (*start == '(')
-		  {
+                  {
-		    bracket = ')';
+                    bracket = ')';
-		    start++;
+                    start++;
-		  }
+                  }
-		else
+                else
-		  if (*start == '{')
+                  if (*start == '{')
-		    {
+                    {
-		      bracket = '}';
+                      bracket = '}';
-		      start++;
+                      start++;
-		    }
+                    }
-		if (bracket)
+                if (bracket)
-		  {
+                  {
-		    while (*arg && *arg != bracket)
+                    while (*arg && *arg != bracket)
-		      arg++;
+                      arg++;
-		    if (!*arg)
+                    if (!*arg)
-		      {
+                      {
-			fprintf(stderr, "Missing %c.\n", bracket);
+                        fprintf(stderr, "Missing %c.\n", bracket);
-			exit(42);
+                        exit(42);
-		      }
+                      }
-		    strncpy(var_name, start, arg - start);
+                    strncpy(var_name, start, arg - start);
-		    var_name[arg-start] = '\0';
+                    var_name[arg-start] = '\0';
-		    arg++;
+                    arg++;
-		  }
+                  }
-		else
+                else
-		  {
+                  {
-		    while (*arg && (isalnum(*arg) || *arg == '_'))
+                    while (*arg && (isalnum(*arg) || *arg == '_'))
-		      arg++;
+                      arg++;
-		    strncpy(var_name, start, arg - start);
+                    strncpy(var_name, start, arg - start);
-		    var_name[arg-start] = '\0';
+                    var_name[arg-start] = '\0';
-		  }
+                  }
-		if (var_val = xgetenv(var_name))
+                if (var_val = xgetenv(var_name))
-		  {
+                  {
-		    new_arg = (char *)malloc(strlen(arg) +
+                    new_arg = (char *)malloc(strlen(arg) +
-					     strlen(var_val) + 1);
+                                             strlen(var_val) + 1);
-		    if (!new_arg)
+                    if (!new_arg)
-		      {
+                      {
-			fprintf(stderr, "expand: Out of memory (expanding var)\n");
+                        fprintf(stderr, "expand: Out of memory (expanding var)\n");
-			exit(42);
+                        exit(42);
-		      }
+                      }
-		    strcpy(new_arg, var_val);
+                    strcpy(new_arg, var_val);
-		    strcat(new_arg, arg);
+                    strcat(new_arg, arg);
-		    *bufp = '\0';
+                    *bufp = '\0';
-		    expand((bufp == buf)?0:buf, new_arg, 0, in_string);
+                    expand((bufp == buf)?0:buf, new_arg, 0, in_string);
-		    free(new_arg);
+                    free(new_arg);
-		  }
+                  }
-		else
+                else
-		  {
+                  {
-		    fprintf(stderr, "Undefined variable: %s\n", var_name);
+                    fprintf(stderr, "Undefined variable: %s\n", var_name);
-		    exit(42);
+                    exit(42);
-		  }
+                  }
-		return;
+                return;
-	      }
+              }
-	    else
+            else
-	      goto copy_it;
+              goto copy_it;
-	    break;
+            break;
-	  }
+          }
-	default:
+        default:
-	  {
+          {
-	  copy_it:
+          copy_it:
-	    if (SPECIAL(*arg) && (in_quote || in_string))
+            if (SPECIAL(*arg) && (in_quote || in_string))
-	      {
+              {
-		CHECK_BUF_END(1);
+                CHECK_BUF_END(1);
-		*bufp++ = '\\';
+                *bufp++ = '\\';
-	      }
+              }
-	    CHECK_BUF_END(1);
+            CHECK_BUF_END(1);
-	    *bufp++ = *arg;
+            *bufp++ = *arg;
-	    break;
+            break;
-	  }
+          }
-	}
+        }
+    }
   CHECK_BUF_END(1);
   *bufp = '\0';
    */
   if (*buf == '@')
+    {
       char **lines = read_cmd_file(buf + 1);
       while (lines && *lines)
-	{
+        {
-	  expand(0, *lines++, 0, 0);
+          expand(0, *lines++, 0, 0);
-	}
+        }
       free(buf);
       return;
+    }
   /*
    * only get wildcarded if they don't contain any spaces.
    */
   if (*buf)
+    {
       if (from_env && (strchr(buf, ' ') || strchr(buf, '\t')))
-	add_arg(buf);
+        add_arg(buf);
       else
-	{
+        {
-	  glob_t *gb = wildcard_expand(buf, 1);
+          glob_t *gb = wildcard_expand(buf, 1);
-	  int    i;
+          int    i;
-	  if (gb)
+          if (gb)
-	    {
+            {
-	      for (i = 0; i < gb->nused; i++)
+              for (i = 0; i < gb->nused; i++)
-		add_arg(gb->paths[i]);
+                add_arg(gb->paths[i]);
-	      arg_free_glob_t(gb);
+              arg_free_glob_t(gb);
-	    }
+            }
-	  else
+          else
-	    add_arg(buf); /* no wildcards in `buf' so just add it */
+            add_arg(buf); /* no wildcards in `buf' so just add it */
-	}
+        }
+    }
   free(buf);
+}
   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_allocated = ARGV_GROW_SIZE;
-	  ___Argv = (char**)malloc(argv_allocated * sizeof(char*));
+          ___Argv = (char**)malloc(argv_allocated * sizeof(char*));
-	}
+        }
       else
-	{
+        {
-	  argv_allocated += ARGV_GROW_SIZE;
+          argv_allocated += ARGV_GROW_SIZE;
-	  ___Argv = (char**)realloc(___Argv, argv_allocated * sizeof(char*));
+          ___Argv = (char**)localRealloc(___Argv, argv_allocated * sizeof(char*));
-	}
+        }
+    }
   if (!___Argv)
+    {
       fprintf(stderr, "add_arg: Out of memory.\n");
       char *mess;
       wildcards_seen++;
       if ((gb = (glob_t *) malloc(sizeof(glob_t))) == 0)
-	{
+        {
-	  fprintf(stderr, "argv: Out of memory.\n");
+          fprintf(stderr, "argv: Out of memory.\n");
-	  exit(42);
+          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)
+          if (no_match_ok)
-	    status = 0;
+            status = 0;
-	  else
+          else
-	    mess = "No match\n";
+            mess = "No match\n";
-	}
+        }
       else
       if (status == E_NOMEMORY)
-	mess = "glob: out of memory\n";
+        mess = "glob: out of memory\n";
       else
       if (status == E_IMPOSSIBLE)
-	mess = "glob: can't handle wildcard drive names\n";
+        mess = "glob: can't handle wildcard drive names\n";
       else
       if (status == E_NODIR)
-	mess = "glob: failed opening directory\n";
+        mess = "glob: failed opening directory\n";
       if (status)
-	{
+        {
-	  fprintf(stderr, mess);
+          fprintf(stderr, mess);
-	  exit(42);
+          exit(42);
-	}
+        }
+    }
   return gb;
+}
    */
   while ((ch = fgetc(fp)) != EOF)
+    {
       if (l >= (buf + buf_len - 1))
-	{
+        {
-	  int offset = l - buf;
+          int offset = l - buf;
-	  buf = (char*)realloc(buf, buf_len += ARG_GROW_SIZE);
+          buf = (char*)realloc(buf, buf_len += ARG_GROW_SIZE);
-	  l = buf + offset;
+          l = buf + offset;
-	}
+        }
       *l++ = ch;
+    }
   *l++ = '\0';
   pclose(fp);
+    {
       /*
        * Kill leading whitespace.
        */
       while ( NL_P(*l) || (!in_string && WS_P(*l)))
-	l++;
+        l++;
       if (*l)
-	{
+        {
-	  argv[argc++] = l;
+          argv[argc++] = l;
-	  /*
+          /*
-	   * Skip to next whitespace or end of string.
+           * Skip to next whitespace or end of string.
-	   */
+           */
-	  while (*l && !(NL_P(*l) || (!in_string && WS_P(*l))))
+          while (*l && !(NL_P(*l) || (!in_string && WS_P(*l))))
-	    l++;
+            l++;
-	  /*
+          /*
-	   * Only terminate if not at end of input.
+           * Only terminate if not at end of input.
-	   */
+           */
-	  if (*l)
+          if (*l)
-	    *l++ = '\0';
+            *l++ = '\0';
-	}
+        }
+    }
   /*
    * Fix up the size of the returned array.
    */
-  argv = realloc(argv, sizeof(char *) * (argc + 1));
+  argv = localRealloc(argv, sizeof(char *) * (argc + 1));
   argv[argc] = 0;
   return argv;
+}
+    {
 #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 ((buf = (char*)malloc(statb.st_size + 1)) != 0)
-	    {
+            {
-	      if (statb.st_size == read(ifile, buf, statb.st_size))
+              if (statb.st_size == read(ifile, buf, statb.st_size))
-		{
+                {
-		  buf[statb.st_size] = '\0';
+                  buf[statb.st_size] = '\0';
-		  close(ifile);
+                  close(ifile);
-		}
+                }
-	      else
+              else
-		{
+                {
-		  fprintf(stderr, "read_cmd_file: read failed, size: %d\n",
+                  fprintf(stderr, "read_cmd_file: read failed, size: %d\n",
-			  statb.st_size);
+                          statb.st_size);
-		  exit(42);
+                  exit(42);
-		}
+                }
-	    }
+            }
-	  else
+          else
-	    {
+            {
-	      fprintf(stderr, "read_cmd_file: Out of memory\n");
+              fprintf(stderr, "read_cmd_file: Out of memory\n");
-	      _exit(42);
+              _exit(42);
-	    }
+            }
-	}
+        }
       else
-	{
+        {
-	  perror("read_cmd_file");
+          perror("read_cmd_file");
-	  exit(42);
+          exit(42);
-	}
+        }
+    }
   else
+    {
       fprintf(stderr, "read_cmd_file: r: %d\n", r);
       perror("read_cmd_file: stat failed");
       char *start = 0;
       /*
        * Find the start of the argument.
        */
       while (NL_P(*l) || WS_P(*l))
-	l++;
+        l++;
       if (*l)
-	start = l;
+        start = l;
       /*
        * Find the end of the argument.
        */
       for (;*l;l++)
-	{
+        {
-	  if (*l == '\'' || *l == '\"' || *l == '\`')
+          if (*l == '\'' || *l == '\"' || *l == '`')
-	    {
+            {
-	      int quote_char = *l++;
+              int quote_char = *l++;
-	      do
+              do
-		{
+                {
-		  if (!*l)
+                  if (!*l)
-		    {
+                    {
-		      fprintf(stderr, "Unmatched %c. (reading %s)\n",
+                      fprintf(stderr, "Unmatched %c. (reading %s)\n",
-			      quote_char, fname);
+                              quote_char, fname);
-		      exit(42);
+                      exit(42);
-		    }
+                    }
-		} while (*l++ != quote_char);
+                } while (*l++ != quote_char);
-	    }
+            }
-	  if (NL_P(*l) || WS_P(*l))
+          if (NL_P(*l) || WS_P(*l))
-	    {
+            {
-	      *l++ = '\0';
+              *l++ = '\0';
-	      break;
+              break;
-	    }
+            }
-	}
+        }
       if (start)
-	argv[argc++] = start;
+        argv[argc++] = start;
+    }
-  argv = realloc(argv, sizeof(char *) * (argc + 1));
+  argv = localRealloc(argv, sizeof(char *) * (argc + 1));
   argv[argc] = 0;
   return argv;
+}
   while (envp && *envp)
+    {
       char *endp = (*envp) + var_len;
       if (!strncmp(var_name, *envp, var_len))
-	{
+        {
-	  if (*endp == '=')
+          if (*endp == '=')
-	    {
+            {
 #ifdef TEST
-	      printf("%s\n", endp+1);
+              printf("%s\n", endp+1);
 #endif
-	      return endp + 1;
+              return endp + 1;
-	    }
+            }
-	}
+        }
       envp++;
+    }
 #ifdef TEST
   printf("(nil)\n");
 #endif

Subversion Repositories DevTools

(root)/core_devl/trunk/UTILS/SH/ARGV.C – Rev 227 → 5659