home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / gnustuff / minix / libsrc~1.z / libsrc~1 / exec.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-12-28  |  2.4 KB  |  106 lines
  1. #define __SRC__
  2. #include "lib.h"
  3.  
  4. extern char **environ;            /* environment pointer */
  5.  
  6. #define    PTRSIZE    sizeof(char *)
  7.  
  8. PUBLIC int execl(name, arg0)
  9. _CONST char *name;
  10. _CONST char *arg0;
  11. {
  12.   return execve(name, &arg0, environ);
  13. }
  14.  
  15. PUBLIC int execle(name, argv)
  16. _CONST char *name, *argv;
  17. {
  18.   char **p;
  19.   p = (char **) &argv;
  20.   while (*p++) /* null statement */ ;
  21.   return execve(name, &argv, (char **)*p);
  22. }
  23.  
  24. PUBLIC int execv(name, argv)
  25. _CONST char *name, *argv[];
  26. {
  27.   return execve(name, argv, environ);
  28. }
  29.  
  30.  
  31. PUBLIC int execve(name, argv, envp)
  32. _CONST char *name;        /* pointer to name of file to be executed */
  33. _CONST char *argv[];        /* pointer to argument array */
  34. char *envp[];        /* pointer to environment */
  35. {
  36.   char stack[MAX_ISTACK_BYTES];
  37.   char **argorg, **envorg, *hp, **ap;
  38.   _CONST char *p;
  39.   int i, nargs, nenvps, stackbytes, offset;
  40.   extern errno;
  41.  
  42.   /* Count the argument pointers and environment pointers. */
  43.   nargs = 0;
  44.   nenvps = 0;
  45.   argorg = (char **)argv;
  46.   envorg = envp;
  47.   while (*argorg++ != NIL_PTR) nargs++;
  48.   while (*envorg++ != NIL_PTR) nenvps++;
  49.  
  50.   /* Prepare to set up the initial stack. */
  51.   hp = &stack[(nargs + nenvps + 3) * PTRSIZE];
  52.   if (hp + nargs + nenvps >= &stack[MAX_ISTACK_BYTES]) {
  53.     errno = E2BIG;
  54.     return(-1);
  55.   }
  56.   ap = (char **) stack;
  57.   *ap++ = (char *) nargs;
  58.  
  59.   /* Prepare the argument pointers and strings. */
  60.   for (i = 0; i < nargs; i++) {
  61.     offset = hp - stack;
  62.     *ap++ = (char *) offset;
  63.     p = *argv++;
  64.     while (*p) {
  65.         *hp++ = *p++;
  66.         if (hp >= &stack[MAX_ISTACK_BYTES]) {
  67.             errno = E2BIG;
  68.             return(-1);
  69.         }
  70.     }
  71.     *hp++ = (char) 0;
  72.   }
  73.   *ap++ = NIL_PTR;
  74.  
  75.   /* Prepare the environment pointers and strings. */
  76.   for (i = 0; i < nenvps; i++) {
  77.     offset = hp - stack;
  78.     *ap++ = (char *) offset;
  79.     p = *envp++;
  80.     while (*p) {
  81.         *hp++ = *p++;
  82.         if (hp >= &stack[MAX_ISTACK_BYTES]) {
  83.             errno = E2BIG;
  84.             return(-1);
  85.         }
  86.     }
  87.     *hp++ = (char) 0;
  88.   }
  89.   *ap++ = NIL_PTR;
  90.   stackbytes = ( ( (int)(hp - stack) + PTRSIZE - 1)/PTRSIZE) * PTRSIZE;
  91.   return callm1(MM_PROC_NR, EXEC, len(name), stackbytes, 0,name, stack,NIL_PTR);
  92. }
  93.  
  94.  
  95. PUBLIC int execn(name)
  96. _CONST char *name;            /* pointer to file to be exec'd */
  97. {
  98. /* Special version used when there are no args and no environment.  This call
  99.  * is principally used by INIT, to avoid having to allocate MAX_ISTACK_BYTES.
  100.  */
  101.  
  102.   static char stack[3 * PTRSIZE];
  103.  
  104.   return callm1(MM_PROC_NR, EXEC, len(name), (int)sizeof(stack), 0, name, stack, NIL_PTR);
  105. }
  106.