Subversion Repositories DevTools

Rev

Rev 227 | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 227 Rev 5659
Line 48... Line 48...
48
#define ARG_GROW_SIZE  2000
48
#define ARG_GROW_SIZE  2000
49
 
49
 
50
/*
50
/*
51
 * The following are part of the Watcom runtime
51
 * The following are part of the Watcom runtime
52
 */
52
 */
53
extern char **___Argv;		/* the eventual argv */
53
extern char **___Argv;          /* the eventual argv */
54
extern int  ___Argc;		/* the eventual argc */
54
extern int  ___Argc;            /* the eventual argc */
55
extern char *_LpPgmName;	/* the program name */
55
extern char *_LpPgmName;        /* the program name */
56
extern char *_LpCmdLine;	/* the raw cmdline */
56
extern char *_LpCmdLine;        /* the raw cmdline */
57
extern char **environ;		/* the environment strings */
57
extern char **environ;          /* the environment strings */
58
 
58
 
59
/*
59
/*
60
 * How big the array pointed to by __Argv really is.
60
 * How big the array pointed to by __Argv really is.
61
 */
61
 */
62
static int argv_allocated = 0;
62
static int argv_allocated = 0;
Line 117... Line 117...
117
void __Init_Argv(void)
117
void __Init_Argv(void)
118
{
118
{
119
  int  nenv_args = 0;
119
  int  nenv_args = 0;
120
  char *tmp;
120
  char *tmp;
121
 
121
 
122
  extern void __setenvp(void);	/* A WATCOM thing which sets up environ */
122
  extern void __setenvp(void);  /* A WATCOM thing which sets up environ */
123
  __setenvp();                  /* found by grovelling                  */
123
  __setenvp();                  /* found by grovelling                  */
124
 
124
 
125
 
125
 
126
#ifdef TEST
126
#ifdef TEST
127
    printf("_LpCmdLine: %x\n", _LpCmdLine);
127
    printf("_LpCmdLine: %x\n", _LpCmdLine);
Line 133... Line 133...
133
  strlwr(_LpPgmName);
133
  strlwr(_LpPgmName);
134
 
134
 
135
  for (tmp = _LpPgmName; *tmp; tmp++)
135
  for (tmp = _LpPgmName; *tmp; tmp++)
136
    {
136
    {
137
      if (*tmp == '\\')
137
      if (*tmp == '\\')
138
	*tmp = '/';
138
        *tmp = '/';
139
    }
139
    }
140
  add_arg(_LpPgmName);
140
  add_arg(_LpPgmName);
141
 
141
 
142
  if ((tmp = xgetenv("_argc")) != 0)
142
  if ((tmp = xgetenv("_argc")) != 0)
143
    {
143
    {
Line 195... Line 195...
195
 
195
 
196
  for (i = 1; i < nargs; i++)
196
  for (i = 1; i < nargs; i++)
197
    {
197
    {
198
      sprintf(env_name, "_argv%d", i);
198
      sprintf(env_name, "_argv%d", i);
199
      if ((arg = xgetenv(env_name)) == 0)
199
      if ((arg = xgetenv(env_name)) == 0)
200
	{
200
        {
201
	  fprintf(stderr, "glob_env: BAD environment: _argc: %d, no _argv%d\n",
201
          fprintf(stderr, "glob_env: BAD environment: _argc: %d, no _argv%d\n",
202
		  nargs, i);
202
                  nargs, i);
203
	  exit(42);
203
          exit(42);
204
	}
204
        }
205
      expand(0, arg, ENV_ARG, 0);
205
      expand(0, arg, ENV_ARG, 0);
206
    }
206
    }
207
}
207
}
208
 
208
 
209
 
209
 
Line 218... Line 218...
218
 
218
 
219
static void glob_cmd_line(const char *cmd_line)
219
static void glob_cmd_line(const char *cmd_line)
220
{
220
{
221
  char *l   = strdup(cmd_line);
221
  char *l   = strdup(cmd_line);
222
  char argc = 0;
222
  char argc = 0;
223
  char *argv[64];	/* can't get more than this on a DOS command line */
223
  char *argv[64];       /* can't get more than this on a DOS command line */
224
  int  i;
224
  int  i;
225
 
225
 
226
  while (*l)
226
  while (*l)
227
    {
227
    {
228
      /*
228
      /*
Line 234... Line 234...
234
 
234
 
235
      /*
235
      /*
236
       * Find the end of the argument.
236
       * Find the end of the argument.
237
       */
237
       */
238
      for (;*l; l++)
238
      for (;*l; l++)
239
	{
239
        {
240
	  if (*l == '\'' || *l == '\"' || *l == '\`')
240
          if (*l == '\'' || *l == '\"' || *l == '`')
241
	    {
241
            {
242
	      int quote_char = *l++;
242
              int quote_char = *l++;
243
	      
243
              
244
	      do
244
              do
245
		{
245
                {
246
		  if (!*l)
246
                  if (!*l)
247
		    {
247
                    {
248
		      fprintf(stderr, "Unmatched %c.\n", quote_char);
248
                      fprintf(stderr, "Unmatched %c.\n", quote_char);
249
		      exit(42);
249
                      exit(42);
250
		    }
250
                    }
251
		} while (*l++ != quote_char);
251
                } while (*l++ != quote_char);
252
	    }
252
            }
253
 
253
 
254
	  if (*l == ' ' || *l == '\t')
254
          if (*l == ' ' || *l == '\t')
255
	    {
255
            {
256
	      *l++ = '\0';
256
              *l++ = '\0';
257
	      break;
257
              break;
258
	    }
258
            }
259
	}
259
        }
260
    }
260
    }
261
 
261
 
262
  for (i = 0; i < argc; i++)
262
  for (i = 0; i < argc; i++)
263
    {
263
    {
264
      expand(0, argv[i], CMDLINE_ARG, 0);
264
      expand(0, argv[i], CMDLINE_ARG, 0);
Line 287... Line 287...
287
  char *bufp = buf;
287
  char *bufp = buf;
288
  int   in_quote = 0;
288
  int   in_quote = 0;
289
 
289
 
290
#ifdef TEST
290
#ifdef TEST
291
  printf("expand(prefix: \"%s\", arg: \"%s\")\n",
291
  printf("expand(prefix: \"%s\", arg: \"%s\")\n",
292
	  prefix?prefix:"(nil)", arg);
292
          prefix?prefix:"(nil)", arg);
293
#endif
293
#endif
294
 
294
 
295
#define CHECK_BUF_END(l)					\
295
#define CHECK_BUF_END(l)                                        \
296
  {								\
296
  {                                                             \
297
    int offset = bufp - buf;    				\
297
    int offset = bufp - buf;                                    \
298
    while ((offset + (l)) >= buf_len)				\
298
    while ((offset + (l)) >= buf_len)                           \
299
      {								\
299
      {                                                         \
300
	buf = (char*)realloc(buf, buf_len += ARG_GROW_SIZE);	\
300
        buf = (char*)realloc(buf, buf_len += ARG_GROW_SIZE);    \
301
      }				        			\
301
      }                                                         \
302
    bufp = buf + offset;                			\
302
    bufp = buf + offset;                                        \
303
  }
303
  }
304
 
304
 
305
  if (!buf)
305
  if (!buf)
306
    {
306
    {
307
      fprintf(stderr, "expand: Out of memory\n");
307
      fprintf(stderr, "expand: Out of memory\n");
Line 319... Line 319...
319
   * do stuff..
319
   * do stuff..
320
   */
320
   */
321
  for (;*arg; arg++)
321
  for (;*arg; arg++)
322
    {
322
    {
323
      switch (*arg)
323
      switch (*arg)
324
	{
324
        {
325
	case '\'':
325
        case '\'':
326
	  {
326
          {
327
	    in_quote = !in_quote;
327
            in_quote = !in_quote;
328
	    arg;
328
            arg;
329
	    break;
329
            break;
330
	  }
330
          }
331
 
331
 
332
	case '\"':
332
        case '\"':
333
	  {
333
          {
334
	    if (!in_quote)
334
            if (!in_quote)
335
	      {
335
              {
336
		in_string = !in_string;
336
                in_string = !in_string;
337
		arg;
337
                arg;
338
	      }
338
              }
339
	    else
339
            else
340
	      goto copy_it;
340
              goto copy_it;
341
	    break;
341
            break;
342
	  }
342
          }
343
 
343
 
344
	case '\`':
344
        case '`':
345
	  {
345
          {
346
	    if (!in_quote)
346
            if (!in_quote)
347
	      {
347
              {
348
		char *start = ++arg;
348
                char *start = ++arg;
349
		char **lines;
349
                char **lines;
350
 
350
 
351
		for (arg++; *arg != '\`'; arg++);
351
                for (arg++; *arg != '`'; arg++);
352
		CHECK_BUF_END(arg - start);
352
                CHECK_BUF_END(arg - start);
353
		strncpy(bufp, start, arg - start);
353
                strncpy(bufp, start, arg - start);
354
		*(bufp + (arg - start)) = '\0';
354
                *(bufp + (arg - start)) = '\0';
355
		lines =  exec_prog(bufp, in_string);
355
                lines =  exec_prog(bufp, in_string);
356
		*bufp = '\0';
356
                *bufp = '\0';
357
 
357
 
358
		if (lines)
358
                if (lines)
359
		  {
359
                  {
360
		    for (;*lines; lines++)
360
                    for (;*lines; lines++)
361
		      {
361
                      {
362
			if (lines[1])
362
                        if (lines[1])
363
			  {
363
                          {
364
			    /* more arguments after this one. */
364
                            /* more arguments after this one. */
365
			    expand((bufp == buf)?0:buf, *lines, 0, in_string);
365
                            expand((bufp == buf)?0:buf, *lines, 0, in_string);
366
			    bufp = buf;
366
                            bufp = buf;
367
			  }
367
                          }
368
			else
368
                        else
369
			  {
369
                          {
370
			    char *new_arg;
370
                            char *new_arg;
371
			    /* last argument.. tack the rest of arg onto it. */
371
                            /* last argument.. tack the rest of arg onto it. */
372
			    new_arg = (char*)malloc(strlen(*lines) +
372
                            new_arg = (char*)malloc(strlen(*lines) +
373
						    strlen(arg + 1) + 1);
373
                                                    strlen(arg + 1) + 1);
374
			    if (!new_arg)
374
                            if (!new_arg)
375
			      {
375
                              {
376
				fprintf(stderr, "expand: Out of memory\n");
376
                                fprintf(stderr, "expand: Out of memory\n");
377
			      }
377
                              }
378
			    strcpy(new_arg, *lines);
378
                            strcpy(new_arg, *lines);
379
			    strcat(new_arg, arg + 1);
379
                            strcat(new_arg, arg + 1);
380
			    expand((bufp == buf)?0:buf, new_arg, 0, in_string);
380
                            expand((bufp == buf)?0:buf, new_arg, 0, in_string);
381
			    free(new_arg);
381
                            free(new_arg);
382
			  }
382
                          }
383
		      }
383
                      }
384
		  }
384
                  }
385
		return;
385
                return;
386
	      }
386
              }
387
	    else
387
            else
388
	      goto copy_it;
388
              goto copy_it;
389
	    break;
389
            break;
390
	  }
390
          }
391
 
391
 
392
	case '$':
392
        case '$':
393
	  {
393
          {
394
	    if (!in_quote)
394
            if (!in_quote)
395
	      {
395
              {
396
		char *start  = ++arg;
396
                char *start  = ++arg;
397
		int  bracket = 0;
397
                int  bracket = 0;
398
		char var_name[200];
398
                char var_name[200];
399
		char *new_arg;
399
                char *new_arg;
400
		char *var_val;
400
                char *var_val;
401
 
401
 
402
		if (*start == '(')
402
                if (*start == '(')
403
		  {
403
                  {
404
		    bracket = ')';
404
                    bracket = ')';
405
		    start++;
405
                    start++;
406
		  }
406
                  }
407
		else
407
                else
408
		  if (*start == '{')
408
                  if (*start == '{')
409
		    {
409
                    {
410
		      bracket = '}';
410
                      bracket = '}';
411
		      start++;
411
                      start++;
412
		    }
412
                    }
413
 
413
 
414
		if (bracket)
414
                if (bracket)
415
		  {
415
                  {
416
		    while (*arg && *arg != bracket)
416
                    while (*arg && *arg != bracket)
417
		      arg++;
417
                      arg++;
418
		    if (!*arg)
418
                    if (!*arg)
419
		      {
419
                      {
420
			fprintf(stderr, "Missing %c.\n", bracket);
420
                        fprintf(stderr, "Missing %c.\n", bracket);
421
			exit(42);
421
                        exit(42);
422
		      }
422
                      }
423
		    strncpy(var_name, start, arg - start);
423
                    strncpy(var_name, start, arg - start);
424
		    var_name[arg-start] = '\0';
424
                    var_name[arg-start] = '\0';
425
		    arg++;
425
                    arg++;
426
		  }
426
                  }
427
		else
427
                else
428
		  {
428
                  {
429
		    while (*arg && (isalnum(*arg) || *arg == '_'))
429
                    while (*arg && (isalnum(*arg) || *arg == '_'))
430
		      arg++;
430
                      arg++;
431
		    strncpy(var_name, start, arg - start);
431
                    strncpy(var_name, start, arg - start);
432
		    var_name[arg-start] = '\0';
432
                    var_name[arg-start] = '\0';
433
		  }
433
                  }
434
 
434
 
435
		if (var_val = xgetenv(var_name))
435
                if (var_val = xgetenv(var_name))
436
		  {
436
                  {
437
		    new_arg = (char *)malloc(strlen(arg) +
437
                    new_arg = (char *)malloc(strlen(arg) +
438
					     strlen(var_val) + 1);
438
                                             strlen(var_val) + 1);
439
		    if (!new_arg)
439
                    if (!new_arg)
440
		      {
440
                      {
441
			fprintf(stderr, "expand: Out of memory (expanding var)\n");
441
                        fprintf(stderr, "expand: Out of memory (expanding var)\n");
442
			exit(42);
442
                        exit(42);
443
		      }
443
                      }
444
		    strcpy(new_arg, var_val);
444
                    strcpy(new_arg, var_val);
445
		    strcat(new_arg, arg);
445
                    strcat(new_arg, arg);
446
		    *bufp = '\0';
446
                    *bufp = '\0';
447
		    expand((bufp == buf)?0:buf, new_arg, 0, in_string);
447
                    expand((bufp == buf)?0:buf, new_arg, 0, in_string);
448
		    free(new_arg);
448
                    free(new_arg);
449
		  }
449
                  }
450
		else
450
                else
451
		  {
451
                  {
452
		    fprintf(stderr, "Undefined variable: %s\n", var_name);
452
                    fprintf(stderr, "Undefined variable: %s\n", var_name);
453
		    exit(42);
453
                    exit(42);
454
		  }
454
                  }
455
		return;
455
                return;
456
	      }
456
              }
457
	    else
457
            else
458
	      goto copy_it;
458
              goto copy_it;
459
	    break;
459
            break;
460
	  }
460
          }
461
 
461
 
462
	default:
462
        default:
463
	  {
463
          {
464
	  copy_it:
464
          copy_it:
465
	    if (SPECIAL(*arg) && (in_quote || in_string))
465
            if (SPECIAL(*arg) && (in_quote || in_string))
466
	      {
466
              {
467
		CHECK_BUF_END(1);
467
                CHECK_BUF_END(1);
468
		*bufp++ = '\\';
468
                *bufp++ = '\\';
469
	      }
469
              }
470
	    CHECK_BUF_END(1);
470
            CHECK_BUF_END(1);
471
	    *bufp++ = *arg;
471
            *bufp++ = *arg;
472
	    break;
472
            break;
473
	  }
473
          }
474
	}
474
        }
475
    }
475
    }
476
  
476
  
477
  CHECK_BUF_END(1);
477
  CHECK_BUF_END(1);
478
  *bufp = '\0';
478
  *bufp = '\0';
479
 
479
 
Line 482... Line 482...
482
   */
482
   */
483
  if (*buf == '@')
483
  if (*buf == '@')
484
    {
484
    {
485
      char **lines = read_cmd_file(buf + 1);
485
      char **lines = read_cmd_file(buf + 1);
486
      while (lines && *lines)
486
      while (lines && *lines)
487
	{
487
        {
488
	  expand(0, *lines++, 0, 0);
488
          expand(0, *lines++, 0, 0);
489
	}
489
        }
490
      free(buf);
490
      free(buf);
491
      return;
491
      return;
492
    }
492
    }
493
 
493
 
494
  /*
494
  /*
Line 496... Line 496...
496
   * only get wildcarded if they don't contain any spaces.
496
   * only get wildcarded if they don't contain any spaces.
497
   */
497
   */
498
  if (*buf)
498
  if (*buf)
499
    {
499
    {
500
      if (from_env && (strchr(buf, ' ') || strchr(buf, '\t')))
500
      if (from_env && (strchr(buf, ' ') || strchr(buf, '\t')))
501
	add_arg(buf);
501
        add_arg(buf);
502
      else
502
      else
503
	{
503
        {
504
	  glob_t *gb = wildcard_expand(buf, 1);
504
          glob_t *gb = wildcard_expand(buf, 1);
505
	  int    i;
505
          int    i;
506
	  if (gb)
506
          if (gb)
507
	    {
507
            {
508
	      for (i = 0; i < gb->nused; i++)
508
              for (i = 0; i < gb->nused; i++)
509
		add_arg(gb->paths[i]);
509
                add_arg(gb->paths[i]);
510
	      arg_free_glob_t(gb);
510
              arg_free_glob_t(gb);
511
	    }
511
            }
512
	  else
512
          else
513
	    add_arg(buf); /* no wildcards in `buf' so just add it */
513
            add_arg(buf); /* no wildcards in `buf' so just add it */
514
	}
514
        }
515
    }
515
    }
516
 
516
 
517
  free(buf);
517
  free(buf);
518
}
518
}
519
 
519
 
Line 537... Line 537...
537
  if (!str)
537
  if (!str)
538
    {
538
    {
539
      fprintf(stderr, "add_arg: Out of memory.\n");
539
      fprintf(stderr, "add_arg: Out of memory.\n");
540
      exit(42);
540
      exit(42);
541
    }
541
    }
542
	  
542
          
543
  if (___Argc >= argv_allocated)
543
  if (___Argc >= argv_allocated)
544
    {
544
    {
545
      if (!argv_allocated)
545
      if (!argv_allocated)
546
	{
546
        {
547
	  argv_allocated = ARGV_GROW_SIZE;
547
          argv_allocated = ARGV_GROW_SIZE;
548
	  ___Argv = (char**)malloc(argv_allocated * sizeof(char*));
548
          ___Argv = (char**)malloc(argv_allocated * sizeof(char*));
549
	}
549
        }
550
      else
550
      else
551
	{
551
        {
552
	  argv_allocated += ARGV_GROW_SIZE;
552
          argv_allocated += ARGV_GROW_SIZE;
553
	  ___Argv = (char**)realloc(___Argv, argv_allocated * sizeof(char*));
553
          ___Argv = (char**)localRealloc(___Argv, argv_allocated * sizeof(char*));
554
	}
554
        }
555
    }
555
    }
556
 
556
 
557
  if (!___Argv)
557
  if (!___Argv)
558
    {
558
    {
559
      fprintf(stderr, "add_arg: Out of memory.\n");
559
      fprintf(stderr, "add_arg: Out of memory.\n");
Line 583... Line 583...
583
      char *mess;
583
      char *mess;
584
 
584
 
585
      wildcards_seen++;
585
      wildcards_seen++;
586
 
586
 
587
      if ((gb = (glob_t *) malloc(sizeof(glob_t))) == 0)
587
      if ((gb = (glob_t *) malloc(sizeof(glob_t))) == 0)
588
	{
588
        {
589
	  fprintf(stderr, "argv: Out of memory.\n");
589
          fprintf(stderr, "argv: Out of memory.\n");
590
	  exit(42);
590
          exit(42);
591
	}
591
        }
592
      gb->nused = 0;
592
      gb->nused = 0;
593
      gb->paths = 0;
593
      gb->paths = 0;
594
      gb->nallocated = 0;
594
      gb->nallocated = 0;
595
      status = arg_glob(s, GLOB_FLAGS, gb);
595
      status = arg_glob(s, GLOB_FLAGS, gb);
596
 
596
 
597
#ifdef TEST
597
#ifdef TEST
598
      printf("globbing finds %d names\n", gb->nused);
598
      printf("globbing finds %d names\n", gb->nused);
599
#endif
599
#endif
600
 
600
 
601
      if (status == E_NOMATCH)
601
      if (status == E_NOMATCH)
602
	{
602
        {
603
	  if (no_match_ok)
603
          if (no_match_ok)
604
	    status = 0;
604
            status = 0;
605
	  else
605
          else
606
	    mess = "No match\n";
606
            mess = "No match\n";
607
	}
607
        }
608
      else
608
      else
609
      if (status == E_NOMEMORY)
609
      if (status == E_NOMEMORY)
610
	mess = "glob: out of memory\n";
610
        mess = "glob: out of memory\n";
611
      else
611
      else
612
      if (status == E_IMPOSSIBLE)
612
      if (status == E_IMPOSSIBLE)
613
	mess = "glob: can't handle wildcard drive names\n";
613
        mess = "glob: can't handle wildcard drive names\n";
614
      else
614
      else
615
      if (status == E_NODIR)
615
      if (status == E_NODIR)
616
	mess = "glob: failed opening directory\n";
616
        mess = "glob: failed opening directory\n";
617
 
617
 
618
      if (status)
618
      if (status)
619
	{
619
        {
620
	  fprintf(stderr, mess);
620
          fprintf(stderr, mess);
621
	  exit(42);
621
          exit(42);
622
	}
622
        }
623
    }
623
    }
624
  return gb;
624
  return gb;
625
}
625
}
626
 
626
 
627
 
627
 
Line 665... Line 665...
665
   */
665
   */
666
 
666
 
667
  while ((ch = fgetc(fp)) != EOF)
667
  while ((ch = fgetc(fp)) != EOF)
668
    {
668
    {
669
      if (l >= (buf + buf_len - 1))
669
      if (l >= (buf + buf_len - 1))
670
	{
670
        {
671
	  int offset = l - buf;
671
          int offset = l - buf;
672
	  buf = (char*)realloc(buf, buf_len += ARG_GROW_SIZE);
672
          buf = (char*)realloc(buf, buf_len += ARG_GROW_SIZE);
673
	  l = buf + offset;
673
          l = buf + offset;
674
	}
674
        }
675
      *l++ = ch;
675
      *l++ = ch;
676
    }
676
    }
677
  *l++ = '\0';
677
  *l++ = '\0';
678
  pclose(fp);
678
  pclose(fp);
679
 
679
 
Line 696... Line 696...
696
    {
696
    {
697
      /*
697
      /*
698
       * Kill leading whitespace.
698
       * Kill leading whitespace.
699
       */
699
       */
700
      while ( NL_P(*l) || (!in_string && WS_P(*l)))
700
      while ( NL_P(*l) || (!in_string && WS_P(*l)))
701
	l++;
701
        l++;
702
 
702
 
703
      if (*l)
703
      if (*l)
704
	{
704
        {
705
	  argv[argc++] = l;
705
          argv[argc++] = l;
706
 
706
 
707
	  /*
707
          /*
708
	   * Skip to next whitespace or end of string.
708
           * Skip to next whitespace or end of string.
709
	   */
709
           */
710
	  while (*l && !(NL_P(*l) || (!in_string && WS_P(*l))))
710
          while (*l && !(NL_P(*l) || (!in_string && WS_P(*l))))
711
	    l++;
711
            l++;
712
 
712
 
713
	  /*
713
          /*
714
	   * Only terminate if not at end of input.
714
           * Only terminate if not at end of input.
715
	   */
715
           */
716
	  if (*l)
716
          if (*l)
717
	    *l++ = '\0';
717
            *l++ = '\0';
718
	}
718
        }
719
    }
719
    }
720
 
720
 
721
  /*
721
  /*
722
   * Fix up the size of the returned array.
722
   * Fix up the size of the returned array.
723
   */
723
   */
724
  argv = realloc(argv, sizeof(char *) * (argc + 1));
724
  argv = localRealloc(argv, sizeof(char *) * (argc + 1));
725
  argv[argc] = 0;
725
  argv[argc] = 0;
726
 
726
 
727
  return argv;
727
  return argv;
728
}
728
}
729
 
729
 
Line 754... Line 754...
754
    {
754
    {
755
#ifdef TEST
755
#ifdef TEST
756
      printf("read_cmd_file: opens: \"%s\"\n", fname);
756
      printf("read_cmd_file: opens: \"%s\"\n", fname);
757
#endif
757
#endif
758
      if ((ifile = open(fname, O_RDONLY | O_BINARY)) >= 0)
758
      if ((ifile = open(fname, O_RDONLY | O_BINARY)) >= 0)
759
	{
759
        {
760
	  if ((buf = (char*)malloc(statb.st_size + 1)) != 0)
760
          if ((buf = (char*)malloc(statb.st_size + 1)) != 0)
761
	    {
761
            {
762
	      if (statb.st_size == read(ifile, buf, statb.st_size))
762
              if (statb.st_size == read(ifile, buf, statb.st_size))
763
		{
763
                {
764
		  buf[statb.st_size] = '\0';
764
                  buf[statb.st_size] = '\0';
765
		  close(ifile);
765
                  close(ifile);
766
		}
766
                }
767
	      else
767
              else
768
		{
768
                {
769
		  fprintf(stderr, "read_cmd_file: read failed, size: %d\n",
769
                  fprintf(stderr, "read_cmd_file: read failed, size: %d\n",
770
			  statb.st_size);
770
                          statb.st_size);
771
		  exit(42);
771
                  exit(42);
772
		}
772
                }
773
	    }
773
            }
774
	  else
774
          else
775
	    {
775
            {
776
	      fprintf(stderr, "read_cmd_file: Out of memory\n");
776
              fprintf(stderr, "read_cmd_file: Out of memory\n");
777
	      _exit(42);
777
              _exit(42);
778
	    }
778
            }
779
	}
779
        }
780
      else
780
      else
781
	{
781
        {
782
	  perror("read_cmd_file");
782
          perror("read_cmd_file");
783
	  exit(42);
783
          exit(42);
784
	}
784
        }
785
    }
785
    }
786
  else
786
  else
787
    {
787
    {
788
      fprintf(stderr, "read_cmd_file: r: %d\n", r);
788
      fprintf(stderr, "read_cmd_file: r: %d\n", r);
789
      perror("read_cmd_file: stat failed");
789
      perror("read_cmd_file: stat failed");
Line 806... Line 806...
806
      char *start = 0;
806
      char *start = 0;
807
      /*
807
      /*
808
       * Find the start of the argument.
808
       * Find the start of the argument.
809
       */
809
       */
810
      while (NL_P(*l) || WS_P(*l))
810
      while (NL_P(*l) || WS_P(*l))
811
	l++;
811
        l++;
812
 
812
 
813
      if (*l)
813
      if (*l)
814
	start = l;
814
        start = l;
815
 
815
 
816
      /*
816
      /*
817
       * Find the end of the argument.
817
       * Find the end of the argument.
818
       */
818
       */
819
      for (;*l;l++)
819
      for (;*l;l++)
820
	{
820
        {
821
	  if (*l == '\'' || *l == '\"' || *l == '\`')
821
          if (*l == '\'' || *l == '\"' || *l == '`')
822
	    {
822
            {
823
	      int quote_char = *l++;
823
              int quote_char = *l++;
824
	      
824
              
825
	      do
825
              do
826
		{
826
                {
827
		  if (!*l)
827
                  if (!*l)
828
		    {
828
                    {
829
		      fprintf(stderr, "Unmatched %c. (reading %s)\n",
829
                      fprintf(stderr, "Unmatched %c. (reading %s)\n",
830
			      quote_char, fname);
830
                              quote_char, fname);
831
		      exit(42);
831
                      exit(42);
832
		    }
832
                    }
833
		} while (*l++ != quote_char);
833
                } while (*l++ != quote_char);
834
	    }
834
            }
835
 
835
 
836
 
836
 
837
	  if (NL_P(*l) || WS_P(*l))
837
          if (NL_P(*l) || WS_P(*l))
838
	    {
838
            {
839
	      *l++ = '\0';
839
              *l++ = '\0';
840
	      break;
840
              break;
841
	    }
841
            }
842
	}
842
        }
843
      if (start)
843
      if (start)
844
	argv[argc++] = start;
844
        argv[argc++] = start;
845
    }
845
    }
846
 
846
 
847
  argv = realloc(argv, sizeof(char *) * (argc + 1));
847
  argv = localRealloc(argv, sizeof(char *) * (argc + 1));
848
  argv[argc] = 0;
848
  argv[argc] = 0;
849
 
849
 
850
  return argv;
850
  return argv;
851
}
851
}
852
 
852
 
Line 872... Line 872...
872
  while (envp && *envp)
872
  while (envp && *envp)
873
    {
873
    {
874
      char *endp = (*envp) + var_len;
874
      char *endp = (*envp) + var_len;
875
 
875
 
876
      if (!strncmp(var_name, *envp, var_len))
876
      if (!strncmp(var_name, *envp, var_len))
877
	{
877
        {
878
	  if (*endp == '=')
878
          if (*endp == '=')
879
	    {
879
            {
880
#ifdef TEST
880
#ifdef TEST
881
	      printf("%s\n", endp+1);
881
              printf("%s\n", endp+1);
882
#endif
882
#endif
883
	      return endp + 1;
883
              return endp + 1;
884
	    }
884
            }
885
	}
885
        }
886
      envp++;
886
      envp++;
887
    }
887
    }
888
#ifdef TEST
888
#ifdef TEST
889
  printf("(nil)\n");
889
  printf("(nil)\n");
890
#endif
890
#endif