[BACK]Return to function.c CVS log [TXT][DIR] Up to [local] / src / usr.bin / find

Diff for /src/usr.bin/find/function.c between version 1.53 and 1.54

version 1.53, 2023/03/08 04:43:10 version 1.54, 2023/04/01 05:27:44
Line 123 
Line 123 
 {  {
         long long value;          long long value;
         char *endchar, *str;    /* Pointer to character ending conversion. */          char *endchar, *str;    /* Pointer to character ending conversion. */
   
         /* Determine comparison from leading + or -. */          /* Determine comparison from leading + or -. */
         str = vp;          str = vp;
         switch (*str) {          switch (*str) {
Line 139 
Line 139 
                 plan->flags = F_EQUAL;                  plan->flags = F_EQUAL;
                 break;                  break;
         }          }
   
         /*          /*
          * Convert the string with strtoll().  Note, if strtoll() returns           * Convert the string with strtoll().  Note, if strtoll() returns
          * zero and endchar points to the beginning of the string we know           * zero and endchar points to the beginning of the string we know
Line 206 
Line 206 
         COMPARE((now - entry->fts_statp->st_atime +          COMPARE((now - entry->fts_statp->st_atime +
             SECSPERDAY - 1) / SECSPERDAY, plan->sec_data);              SECSPERDAY - 1) / SECSPERDAY, plan->sec_data);
 }  }
   
 PLAN *  PLAN *
 c_atime(char *arg, char ***ignored, int unused)  c_atime(char *arg, char ***ignored, int unused)
 {  {
Line 261 
Line 261 
         COMPARE((now - entry->fts_statp->st_ctime +          COMPARE((now - entry->fts_statp->st_ctime +
             SECSPERDAY - 1) / SECSPERDAY, plan->sec_data);              SECSPERDAY - 1) / SECSPERDAY, plan->sec_data);
 }  }
   
 PLAN *  PLAN *
 c_ctime(char *arg, char ***ignored, int unused)  c_ctime(char *arg, char ***ignored, int unused)
 {  {
Line 287 
Line 287 
 {  {
         return (1);          return (1);
 }  }
   
 PLAN *  PLAN *
 c_depth(char *ignore, char ***ignored, int unused)  c_depth(char *ignore, char ***ignored, int unused)
 {  {
Line 352 
Line 352 
   
         return (palloc(N_DELETE, f_delete));          return (palloc(N_DELETE, f_delete));
 }  }
   
 /*  /*
  * -empty functions --   * -empty functions --
  *   *
Line 491 
Line 491 
         plan->ep_bxp[plan->ep_narg] = NULL;          plan->ep_bxp[plan->ep_narg] = NULL;
   
         /* Don't mix output of command with find output. */          /* Don't mix output of command with find output. */
         fflush(stdout);          fflush(stdout);
         fflush(stderr);          fflush(stderr);
   
         switch (pid = vfork()) {          switch (pid = vfork()) {
         case -1:          case -1:
Line 528 
Line 528 
         if (rval)          if (rval)
                 plan->ep_rval = rval;                  plan->ep_rval = rval;
 }  }
   
 /*  /*
  * c_exec --   * c_exec --
  *      build three parallel arrays, one with pointers to the strings passed   *      build three parallel arrays, one with pointers to the strings passed
Line 552 
Line 552 
                 errx(1, "%s: cannot open \".\"", isok ? "-ok" : "-exec");                  errx(1, "%s: cannot open \".\"", isok ? "-ok" : "-exec");
   
         isoutput = 1;          isoutput = 1;
   
         new = palloc(N_EXEC, f_exec);          new = palloc(N_EXEC, f_exec);
         if (isok)          if (isok)
                 new->flags |= F_NEEDOK;                  new->flags |= F_NEEDOK;
Line 621 
Line 621 
                      argv < ap;                       argv < ap;
                      ++argv, ++cnt) {                       ++argv, ++cnt) {
                         c += strlen(*argv) + 1;                          c += strlen(*argv) + 1;
                         new->e_argv[cnt] = *argv;                          new->e_argv[cnt] = *argv;
                 }                  }
                 if (arg_max < 4 * 1024 + c)                  if (arg_max < 4 * 1024 + c)
                         errx(1, "-exec: no space left to run child command");                          errx(1, "-exec: no space left to run child command");
                 bufsize = arg_max - 4 * 1024 - c;                  bufsize = arg_max - 4 * 1024 - c;
Line 655 
Line 655 
                         }                          }
                 }                  }
                 new->e_orig[cnt] = NULL;                  new->e_orig[cnt] = NULL;
         }          }
   
         new->e_argv[cnt] = NULL;          new->e_argv[cnt] = NULL;
         *argvp = argv + 1;          *argvp = argv + 1;
         return (new);          return (new);
 }  }
   
 /*  /*
  * -execdir utility [arg ... ] ; functions --   * -execdir utility [arg ... ] ; functions --
  *   *
Line 726 
Line 726 
         pid = waitpid(pid, &status, 0);          pid = waitpid(pid, &status, 0);
         return (pid != -1 && WIFEXITED(status) && !WEXITSTATUS(status));          return (pid != -1 && WIFEXITED(status) && !WEXITSTATUS(status));
 }  }
   
 /*  /*
  * c_execdir --   * c_execdir --
  *      build three parallel arrays, one with pointers to the strings passed   *      build three parallel arrays, one with pointers to the strings passed
Line 743 
Line 743 
   
         ftsoptions &= ~FTS_NOSTAT;          ftsoptions &= ~FTS_NOSTAT;
         isoutput = 1;          isoutput = 1;
   
         new = palloc(N_EXECDIR, f_execdir);          new = palloc(N_EXECDIR, f_execdir);
   
         for (ap = argv = *argvp;; ++ap) {          for (ap = argv = *argvp;; ++ap) {
Line 822 
Line 822 
         new->fl_mask = flags | notflags;          new->fl_mask = flags | notflags;
         return (new);          return (new);
 }  }
   
 /*  /*
  * -follow functions --   * -follow functions --
  *   *
Line 837 
Line 837 
   
         return (palloc(N_FOLLOW, f_always_true));          return (palloc(N_FOLLOW, f_always_true));
 }  }
   
 /*  /*
  * -fstype functions --   * -fstype functions --
  *   *
Line 871 
Line 871 
                         p[0] = '.';                          p[0] = '.';
                         save[1] = p[1];                          save[1] = p[1];
                         p[1] = '\0';                          p[1] = '\0';
   
                 } else                  } else
                         p = NULL;                          p = NULL;
   
                 if (statfs(entry->fts_accpath, &sb))                  if (statfs(entry->fts_accpath, &sb))
Line 894 
Line 894 
         }          }
         switch (plan->flags) {          switch (plan->flags) {
         case F_MTFLAG:          case F_MTFLAG:
                 return (val & plan->mt_data);                  return (val & plan->mt_data);
         case F_MTTYPE:          case F_MTTYPE:
                 return (strncmp(fstype, plan->c_data, MFSNAMELEN) == 0);                  return (strncmp(fstype, plan->c_data, MFSNAMELEN) == 0);
         default:          default:
                 abort();                  abort();
         }          }
 }  }
   
 PLAN *  PLAN *
 c_fstype(char *arg, char ***ignored, int unused)  c_fstype(char *arg, char ***ignored, int unused)
 {  {
         PLAN *new;          PLAN *new;
   
         ftsoptions &= ~FTS_NOSTAT;          ftsoptions &= ~FTS_NOSTAT;
   
         new = palloc(N_FSTYPE, f_fstype);          new = palloc(N_FSTYPE, f_fstype);
         switch (*arg) {          switch (*arg) {
         case 'l':          case 'l':
Line 931 
Line 931 
         new->c_data = arg;          new->c_data = arg;
         return (new);          return (new);
 }  }
   
 /*  /*
  * -group gname functions --   * -group gname functions --
  *   *
Line 944 
Line 944 
 {  {
         return (entry->fts_statp->st_gid == plan->g_data);          return (entry->fts_statp->st_gid == plan->g_data);
 }  }
   
 PLAN *  PLAN *
 c_group(char *gname, char ***ignored, int unused)  c_group(char *gname, char ***ignored, int unused)
 {  {
         PLAN *new;          PLAN *new;
         gid_t gid;          gid_t gid;
   
         ftsoptions &= ~FTS_NOSTAT;          ftsoptions &= ~FTS_NOSTAT;
   
         if (gid_from_group(gname, &gid) == -1) {          if (gid_from_group(gname, &gid) == -1) {
Line 960 
Line 960 
                 if (errstr)                  if (errstr)
                         errx(1, "-group: %s: no such group", gname);                          errx(1, "-group: %s: no such group", gname);
         }          }
   
         new = palloc(N_GROUP, f_group);          new = palloc(N_GROUP, f_group);
         new->g_data = gid;          new->g_data = gid;
         return (new);          return (new);
Line 976 
Line 976 
 {  {
         COMPARE(entry->fts_statp->st_ino, plan->i_data);          COMPARE(entry->fts_statp->st_ino, plan->i_data);
 }  }
   
 PLAN *  PLAN *
 c_inum(char *arg, char ***ignored, int unused)  c_inum(char *arg, char ***ignored, int unused)
 {  {
         long long inum;          long long inum;
         PLAN *new;          PLAN *new;
   
         ftsoptions &= ~FTS_NOSTAT;          ftsoptions &= ~FTS_NOSTAT;
   
         new = palloc(N_INUM, f_inum);          new = palloc(N_INUM, f_inum);
         inum = find_parsenum(new, "-inum", arg, NULL);          inum = find_parsenum(new, "-inum", arg, NULL);
         if (inum != (ino_t)inum)          if (inum != (ino_t)inum)
Line 992 
Line 992 
         new->i_data = inum;          new->i_data = inum;
         return (new);          return (new);
 }  }
   
 /*  /*
  * -links n functions --   * -links n functions --
  *   *
Line 1003 
Line 1003 
 {  {
         COMPARE(entry->fts_statp->st_nlink, plan->l_data);          COMPARE(entry->fts_statp->st_nlink, plan->l_data);
 }  }
   
 PLAN *  PLAN *
 c_links(char *arg, char ***ignored, int unused)  c_links(char *arg, char ***ignored, int unused)
 {  {
         PLAN *new;          PLAN *new;
         long long nlink;          long long nlink;
   
         ftsoptions &= ~FTS_NOSTAT;          ftsoptions &= ~FTS_NOSTAT;
   
         new = palloc(N_LINKS, f_links);          new = palloc(N_LINKS, f_links);
         nlink = find_parsenum(new, "-links", arg, NULL);          nlink = find_parsenum(new, "-links", arg, NULL);
         if (nlink != (nlink_t)nlink)          if (nlink != (nlink_t)nlink)
Line 1019 
Line 1019 
         new->l_data = nlink;          new->l_data = nlink;
         return (new);          return (new);
 }  }
   
 /*  /*
  * -ls functions --   * -ls functions --
  *   *
Line 1031 
Line 1031 
         printlong(entry->fts_path, entry->fts_accpath, entry->fts_statp);          printlong(entry->fts_path, entry->fts_accpath, entry->fts_statp);
         return (1);          return (1);
 }  }
   
 PLAN *  PLAN *
 c_ls(char *ignore, char ***ignored, int unused)  c_ls(char *ignore, char ***ignored, int unused)
 {  {
         ftsoptions &= ~FTS_NOSTAT;          ftsoptions &= ~FTS_NOSTAT;
         isoutput = 1;          isoutput = 1;
   
         return (palloc(N_LS, f_ls));          return (palloc(N_LS, f_ls));
 }  }
   
Line 1108 
Line 1108 
         COMPARE((now - entry->fts_statp->st_mtime + SECSPERDAY - 1) /          COMPARE((now - entry->fts_statp->st_mtime + SECSPERDAY - 1) /
             SECSPERDAY, plan->sec_data);              SECSPERDAY, plan->sec_data);
 }  }
   
 PLAN *  PLAN *
 c_mtime(char *arg, char ***ignored, int unused)  c_mtime(char *arg, char ***ignored, int unused)
 {  {
Line 1161 
Line 1161 
 {  {
         return (!fnmatch(plan->c_data, entry->fts_name, 0));          return (!fnmatch(plan->c_data, entry->fts_name, 0));
 }  }
   
 PLAN *  PLAN *
 c_name(char *pattern, char ***ignored, int unused)  c_name(char *pattern, char ***ignored, int unused)
 {  {
Line 1176 
Line 1176 
  * -iname functions --   * -iname functions --
  *   *
  *      Similar to -name, but does case insensitive matching   *      Similar to -name, but does case insensitive matching
  *   *
  */   */
 int  int
 f_iname(PLAN *plan, FTSENT *entry)  f_iname(PLAN *plan, FTSENT *entry)
 {  {
         return (!fnmatch(plan->c_data, entry->fts_name, FNM_CASEFOLD));          return (!fnmatch(plan->c_data, entry->fts_name, FNM_CASEFOLD));
 }  }
   
 PLAN *  PLAN *
 c_iname(char *pattern, char ***ignored, int unused)  c_iname(char *pattern, char ***ignored, int unused)
 {  {
Line 1193 
Line 1193 
         new->c_data = pattern;          new->c_data = pattern;
         return (new);          return (new);
 }  }
   
 /*  /*
  * -newer file functions --   * -newer file functions --
  *   *
Line 1209 
Line 1209 
             (entry->fts_statp->st_mtimespec.tv_sec == plan->t_data.tv_sec &&              (entry->fts_statp->st_mtimespec.tv_sec == plan->t_data.tv_sec &&
             entry->fts_statp->st_mtimespec.tv_nsec > plan->t_data.tv_nsec));              entry->fts_statp->st_mtimespec.tv_nsec > plan->t_data.tv_nsec));
 }  }
   
 PLAN *  PLAN *
 c_newer(char *filename, char ***ignored, int unused)  c_newer(char *filename, char ***ignored, int unused)
 {  {
         PLAN *new;          PLAN *new;
         struct stat sb;          struct stat sb;
   
         ftsoptions &= ~FTS_NOSTAT;          ftsoptions &= ~FTS_NOSTAT;
   
         if (stat(filename, &sb))          if (stat(filename, &sb))
Line 1224 
Line 1224 
         memcpy(&new->t_data, &sb.st_mtimespec, sizeof(struct timespec));          memcpy(&new->t_data, &sb.st_mtimespec, sizeof(struct timespec));
         return (new);          return (new);
 }  }
   
 /*  /*
  * -anewer file functions --   * -anewer file functions --
  *   *
Line 1240 
Line 1240 
             (entry->fts_statp->st_atimespec.tv_sec == plan->t_data.tv_sec &&              (entry->fts_statp->st_atimespec.tv_sec == plan->t_data.tv_sec &&
             entry->fts_statp->st_atimespec.tv_nsec > plan->t_data.tv_nsec));              entry->fts_statp->st_atimespec.tv_nsec > plan->t_data.tv_nsec));
 }  }
   
 PLAN *  PLAN *
 c_anewer(char *filename, char ***ignored, int unused)  c_anewer(char *filename, char ***ignored, int unused)
 {  {
         PLAN *new;          PLAN *new;
         struct stat sb;          struct stat sb;
   
         ftsoptions &= ~FTS_NOSTAT;          ftsoptions &= ~FTS_NOSTAT;
   
         if (stat(filename, &sb))          if (stat(filename, &sb))
Line 1255 
Line 1255 
         memcpy(&new->t_data, &sb.st_atimespec, sizeof(struct timespec));          memcpy(&new->t_data, &sb.st_atimespec, sizeof(struct timespec));
         return (new);          return (new);
 }  }
   
 /*  /*
  * -cnewer file functions --   * -cnewer file functions --
  *   *
Line 1271 
Line 1271 
             (entry->fts_statp->st_ctimespec.tv_sec == plan->t_data.tv_sec &&              (entry->fts_statp->st_ctimespec.tv_sec == plan->t_data.tv_sec &&
             entry->fts_statp->st_ctimespec.tv_nsec > plan->t_data.tv_nsec));              entry->fts_statp->st_ctimespec.tv_nsec > plan->t_data.tv_nsec));
 }  }
   
 PLAN *  PLAN *
 c_cnewer(char *filename, char ***ignored, int unused)  c_cnewer(char *filename, char ***ignored, int unused)
 {  {
         PLAN *new;          PLAN *new;
         struct stat sb;          struct stat sb;
   
         ftsoptions &= ~FTS_NOSTAT;          ftsoptions &= ~FTS_NOSTAT;
   
         if (stat(filename, &sb))          if (stat(filename, &sb))
Line 1286 
Line 1286 
         memcpy(&new->t_data, &sb.st_ctimespec, sizeof(struct timespec));          memcpy(&new->t_data, &sb.st_ctimespec, sizeof(struct timespec));
         return (new);          return (new);
 }  }
   
 /*  /*
  * -nogroup functions --   * -nogroup functions --
  *   *
Line 1298 
Line 1298 
 {  {
         return (group_from_gid(entry->fts_statp->st_gid, 1) ? 0 : 1);          return (group_from_gid(entry->fts_statp->st_gid, 1) ? 0 : 1);
 }  }
   
 PLAN *  PLAN *
 c_nogroup(char *ignore, char ***ignored, int unused)  c_nogroup(char *ignore, char ***ignored, int unused)
 {  {
Line 1306 
Line 1306 
   
         return (palloc(N_NOGROUP, f_nogroup));          return (palloc(N_NOGROUP, f_nogroup));
 }  }
   
 /*  /*
  * -nouser functions --   * -nouser functions --
  *   *
Line 1318 
Line 1318 
 {  {
         return (user_from_uid(entry->fts_statp->st_uid, 1) ? 0 : 1);          return (user_from_uid(entry->fts_statp->st_uid, 1) ? 0 : 1);
 }  }
   
 PLAN *  PLAN *
 c_nouser(char *ignore, char ***ignored, int unused)  c_nouser(char *ignore, char ***ignored, int unused)
 {  {
Line 1326 
Line 1326 
   
         return (palloc(N_NOUSER, f_nouser));          return (palloc(N_NOUSER, f_nouser));
 }  }
   
 /*  /*
  * -path functions --   * -path functions --
  *   *
Line 1338 
Line 1338 
 {  {
         return (!fnmatch(plan->c_data, entry->fts_path, 0));          return (!fnmatch(plan->c_data, entry->fts_path, 0));
 }  }
   
 PLAN *  PLAN *
 c_path(char *pattern, char ***ignored, int unused)  c_path(char *pattern, char ***ignored, int unused)
 {  {
Line 1348 
Line 1348 
         new->c_data = pattern;          new->c_data = pattern;
         return (new);          return (new);
 }  }
   
 /*  /*
  * -perm functions --   * -perm functions --
  *   *
Line 1369 
Line 1369 
                 return (mode == plan->m_data);                  return (mode == plan->m_data);
         /* NOTREACHED */          /* NOTREACHED */
 }  }
   
 PLAN *  PLAN *
 c_perm(char *perm, char ***ignored, int unused)  c_perm(char *perm, char ***ignored, int unused)
 {  {
Line 1392 
Line 1392 
         free(set);          free(set);
         return (new);          return (new);
 }  }
   
 /*  /*
  * -print functions --   * -print functions --
  *   *
Line 1413 
Line 1413 
         (void)fputc('\0', stdout);          (void)fputc('\0', stdout);
         return(1);          return(1);
 }  }
   
 PLAN *  PLAN *
 c_print(char *ignore, char ***ignored, int unused)  c_print(char *ignore, char ***ignored, int unused)
 {  {
Line 1429 
Line 1429 
   
         return(palloc(N_PRINT0, f_print0));          return(palloc(N_PRINT0, f_print0));
 }  }
   
 /*  /*
  * -prune functions --   * -prune functions --
  *   *
Line 1443 
Line 1443 
                 err(1, "%s", entry->fts_path);                  err(1, "%s", entry->fts_path);
         return (1);          return (1);
 }  }
   
 PLAN *  PLAN *
 c_prune(char *ignore, char ***ignored, int unused)  c_prune(char *ignore, char ***ignored, int unused)
 {  {
         return (palloc(N_PRUNE, f_prune));          return (palloc(N_PRUNE, f_prune));
 }  }
   
 /*  /*
  * -size n[c] functions --   * -size n[c] functions --
  *   *
Line 1469 
Line 1469 
             FIND_SIZE : entry->fts_statp->st_size;              FIND_SIZE : entry->fts_statp->st_size;
         COMPARE(size, plan->o_data);          COMPARE(size, plan->o_data);
 }  }
   
 PLAN *  PLAN *
 c_size(char *arg, char ***ignored, int unused)  c_size(char *arg, char ***ignored, int unused)
 {  {
         PLAN *new;          PLAN *new;
         char endch;          char endch;
   
         ftsoptions &= ~FTS_NOSTAT;          ftsoptions &= ~FTS_NOSTAT;
   
         new = palloc(N_SIZE, f_size);          new = palloc(N_SIZE, f_size);
Line 1485 
Line 1485 
                 divsize = 0;                  divsize = 0;
         return (new);          return (new);
 }  }
   
 /*  /*
  * -type c functions --   * -type c functions --
  *   *
Line 1498 
Line 1498 
 {  {
         return ((entry->fts_statp->st_mode & S_IFMT) == plan->m_data);          return ((entry->fts_statp->st_mode & S_IFMT) == plan->m_data);
 }  }
   
 PLAN *  PLAN *
 c_type(char *typestring, char ***ignored, int unused)  c_type(char *typestring, char ***ignored, int unused)
 {  {
         PLAN *new;          PLAN *new;
         mode_t  mask;          mode_t  mask;
   
         ftsoptions &= ~FTS_NOSTAT;          ftsoptions &= ~FTS_NOSTAT;
   
         switch (typestring[0]) {          switch (typestring[0]) {
Line 1532 
Line 1532 
         default:          default:
                 errx(1, "-type: %s: unknown type", typestring);                  errx(1, "-type: %s: unknown type", typestring);
         }          }
   
         new = palloc(N_TYPE, f_type);          new = palloc(N_TYPE, f_type);
         new->m_data = mask;          new->m_data = mask;
         return (new);          return (new);
 }  }
   
 /*  /*
  * -user uname functions --   * -user uname functions --
  *   *
Line 1550 
Line 1550 
 {  {
         return (entry->fts_statp->st_uid == plan->u_data);          return (entry->fts_statp->st_uid == plan->u_data);
 }  }
   
 PLAN *  PLAN *
 c_user(char *username, char ***ignored, int unused)  c_user(char *username, char ***ignored, int unused)
 {  {
         PLAN *new;          PLAN *new;
         uid_t uid;          uid_t uid;
   
         ftsoptions &= ~FTS_NOSTAT;          ftsoptions &= ~FTS_NOSTAT;
   
         if (uid_from_user(username, &uid) == -1) {          if (uid_from_user(username, &uid) == -1) {
Line 1571 
Line 1571 
         new->u_data = uid;          new->u_data = uid;
         return (new);          return (new);
 }  }
   
 /*  /*
  * -xdev functions --   * -xdev functions --
  *   *
Line 1601 
Line 1601 
             p && (state = (p->eval)(p, entry)); p = p->next);              p && (state = (p->eval)(p, entry)); p = p->next);
         return (state);          return (state);
 }  }
   
 /*  /*
  * N_OPENPAREN and N_CLOSEPAREN nodes are temporary place markers.  They are   * N_OPENPAREN and N_CLOSEPAREN nodes are temporary place markers.  They are
  * eliminated during phase 2 of find_formplan() --- the '(' node is converted   * eliminated during phase 2 of find_formplan() --- the '(' node is converted
Line 1612 
Line 1612 
 {  {
         return (palloc(N_OPENPAREN, (int (*)(PLAN *, FTSENT *))-1));          return (palloc(N_OPENPAREN, (int (*)(PLAN *, FTSENT *))-1));
 }  }
   
 PLAN *  PLAN *
 c_closeparen(char *ignore, char ***ignored, int unused)  c_closeparen(char *ignore, char ***ignored, int unused)
 {  {
         return (palloc(N_CLOSEPAREN, (int (*)(PLAN *, FTSENT *))-1));          return (palloc(N_CLOSEPAREN, (int (*)(PLAN *, FTSENT *))-1));
 }  }
   
 /*  /*
  * ! expression functions --   * ! expression functions --
  *   *
Line 1634 
Line 1634 
             p && (state = (p->eval)(p, entry)); p = p->next);              p && (state = (p->eval)(p, entry)); p = p->next);
         return (!state);          return (!state);
 }  }
   
 PLAN *  PLAN *
 c_not(char *ignore, char ***ignored, int unused)  c_not(char *ignore, char ***ignored, int unused)
 {  {
         return (palloc(N_NOT, f_not));          return (palloc(N_NOT, f_not));
 }  }
   
 /*  /*
  * expression -o expression functions --   * expression -o expression functions --
  *   *
Line 1677 
Line 1677 
  *      and if so, clean it up as appropriate.   *      and if so, clean it up as appropriate.
  *   *
  *      At the moment, only N_EXEC has state. Two kinds: 1)   *      At the moment, only N_EXEC has state. Two kinds: 1)
  *      lists of files to feed to subprocesses 2) State on exit   *      lists of files to feed to subprocesses 2) State on exit
  *      status of past subprocesses.   *      status of past subprocesses.
  */   */
 int  int
Legend:
Removed from v.1.53  
changed lines
  Added in v.1.54