ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/util/rad.c
(Generate patch)

Comparing ray/src/util/rad.c (file contents):
Revision 2.50 by greg, Fri Jan 5 14:43:03 1996 UTC vs.
Revision 2.67 by greg, Thu Jul 3 18:03:58 2003 UTC

# Line 1 | Line 1
1 – /* Copyright (c) 1995 Regents of the University of California */
2 –
1   #ifndef lint
2 < static char SCCSid[] = "$SunId$ LBL";
2 > static const char       RCSid[] = "$Id$";
3   #endif
6 –
4   /*
5   * Executive program for oconv, rpict and pfilt
6   */
7  
8   #include "standard.h"
9 +
10 + #include <ctype.h>
11 +
12 + #include "platform.h"
13 + #include "view.h"
14   #include "paths.h"
15   #include "vars.h"
14 – #include <ctype.h>
15 – #include <sys/types.h>
16  
17 <                                /* variables */
18 < #define OBJECT          0               /* object files */
19 < #define SCENE           1               /* scene files */
20 < #define MATERIAL        2               /* material files */
21 < #define ILLUM           3               /* mkillum input files */
22 < #define MKILLUM         4               /* mkillum options */
23 < #define RENDER          5               /* rendering options */
24 < #define OCONV           6               /* oconv options */
25 < #define PFILT           7               /* pfilt options */
26 < #define VIEW            8               /* view(s) for picture(s) */
27 < #define ZONE            9               /* simulation zone */
28 < #define QUALITY         10              /* desired rendering quality */
29 < #define OCTREE          11              /* octree file name */
30 < #define PICTURE         12              /* picture file root name */
31 < #define AMBFILE         13              /* ambient file name */
32 < #define OPTFILE         14              /* rendering options file */
33 < #define EXPOSURE        15              /* picture exposure setting */
34 < #define RESOLUTION      16              /* maximum picture resolution */
35 < #define UP              17              /* view up (X, Y or Z) */
36 < #define INDIRECT        18              /* indirection in lighting */
37 < #define DETAIL          19              /* level of scene detail */
38 < #define PENUMBRAS       20              /* shadow penumbras are desired */
39 < #define VARIABILITY     21              /* level of light variability */
40 < #define REPORT          22              /* report frequency and errfile */
41 < #define RAWFILE         23              /* raw picture file root name */
17 >                                /* variables (alphabetical by name) */
18 > #define AMBFILE         0               /* ambient file name */
19 > #define DETAIL          1               /* level of scene detail */
20 > #define EXPOSURE        2               /* picture exposure setting */
21 > #define EYESEP          3               /* interocular distance */
22 > #define ILLUM           4               /* mkillum input files */
23 > #define INDIRECT        5               /* indirection in lighting */
24 > #define MATERIAL        6               /* material files */
25 > #define MKILLUM         7               /* mkillum options */
26 > #define OBJECT          8               /* object files */
27 > #define OCONV           9               /* oconv options */
28 > #define OCTREE          10              /* octree file name */
29 > #define OPTFILE         11              /* rendering options file */
30 > #define PENUMBRAS       12              /* shadow penumbras are desired */
31 > #define PFILT           13              /* pfilt options */
32 > #define PICTURE         14              /* picture file root name */
33 > #define QUALITY         15              /* desired rendering quality */
34 > #define RAWFILE         16              /* raw picture file root name */
35 > #define RENDER          17              /* rendering options */
36 > #define REPORT          18              /* report frequency and errfile */
37 > #define RESOLUTION      19              /* maximum picture resolution */
38 > #define SCENE           20              /* scene files */
39 > #define UP              21              /* view up (X, Y or Z) */
40 > #define VARIABILITY     22              /* level of light variability */
41 > #define VIEWS           23              /* view(s) for picture(s) */
42   #define ZFILE           24              /* distance file root name */
43 + #define ZONE            25              /* simulation zone */
44                                  /* total number of variables */
45 < int NVARS = 25;
45 > int NVARS = 26;
46  
47   VARIABLE        vv[] = {                /* variable-value pairs */
48 <        {"objects",     3,      0,      NULL,   catvalues},
49 <        {"scene",       3,      0,      NULL,   catvalues},
50 <        {"materials",   3,      0,      NULL,   catvalues},
48 >        {"AMBFILE",     3,      0,      NULL,   onevalue},
49 >        {"DETAIL",      3,      0,      NULL,   qualvalue},
50 >        {"EXPOSURE",    3,      0,      NULL,   fltvalue},
51 >        {"EYESEP",      3,      0,      NULL,   fltvalue},
52          {"illum",       3,      0,      NULL,   catvalues},
53 +        {"INDIRECT",    3,      0,      NULL,   intvalue},
54 +        {"materials",   3,      0,      NULL,   catvalues},
55          {"mkillum",     3,      0,      NULL,   catvalues},
56 <        {"render",      3,      0,      NULL,   catvalues},
56 >        {"objects",     3,      0,      NULL,   catvalues},
57          {"oconv",       3,      0,      NULL,   catvalues},
54 –        {"pfilt",       2,      0,      NULL,   catvalues},
55 –        {"view",        2,      0,      NULL,   NULL},
56 –        {"ZONE",        2,      0,      NULL,   onevalue},
57 –        {"QUALITY",     3,      0,      NULL,   qualvalue},
58          {"OCTREE",      3,      0,      NULL,   onevalue},
59 –        {"PICTURE",     3,      0,      NULL,   onevalue},
60 –        {"AMBFILE",     3,      0,      NULL,   onevalue},
59          {"OPTFILE",     3,      0,      NULL,   onevalue},
60 <        {"EXPOSURE",    3,      0,      NULL,   fltvalue},
60 >        {"PENUMBRAS",   3,      0,      NULL,   boolvalue},
61 >        {"pfilt",       2,      0,      NULL,   catvalues},
62 >        {"PICTURE",     3,      0,      NULL,   onevalue},
63 >        {"QUALITY",     3,      0,      NULL,   qualvalue},
64 >        {"RAWFILE",     3,      0,      NULL,   onevalue},
65 >        {"render",      3,      0,      NULL,   catvalues},
66 >        {"REPORT",      3,      0,      NULL,   onevalue},
67          {"RESOLUTION",  3,      0,      NULL,   onevalue},
68 +        {"scene",       3,      0,      NULL,   catvalues},
69          {"UP",          2,      0,      NULL,   onevalue},
65 –        {"INDIRECT",    3,      0,      NULL,   intvalue},
66 –        {"DETAIL",      3,      0,      NULL,   qualvalue},
67 –        {"PENUMBRAS",   3,      0,      NULL,   boolvalue},
70          {"VARIABILITY", 3,      0,      NULL,   qualvalue},
71 <        {"REPORT",      3,      0,      NULL,   onevalue},
70 <        {"RAWFILE",     3,      0,      NULL,   onevalue},
71 >        {"view",        2,      0,      NULL,   NULL},
72          {"ZFILE",       2,      0,      NULL,   onevalue},
73 +        {"ZONE",        2,      0,      NULL,   onevalue},
74   };
75  
76                                  /* overture calculation file */
77 < #ifdef NIX
78 < char    overfile[] = "overture.unf";
77 > #ifdef NULL_DEVICE
78 > char    overfile[] = NULL_DEVICE;
79   #else
80 < char    overfile[] = "/dev/null";
80 > char    overfile[] = "overture.unf";
81   #endif
82  
83 < extern time_t   fdate(), time();
83 > extern time_t   time();
84  
85   time_t  scenedate;              /* date of latest scene or object file */
86   time_t  octreedate;             /* date of octree */
# Line 94 | Line 96 | int    nowarn = 0;             /* no warnings */
96   int     explicate = 0;          /* explicate variables */
97   int     silent = 0;             /* do work silently */
98   int     touchonly = 0;          /* touch files only */
99 < int     noaction = 0;           /* don't do anything */
99 > int     nprocs = 1;             /* maximum executing processes */
100   int     sayview = 0;            /* print view out */
101   char    *rvdevice = NULL;       /* rview output device */
102   char    *viewselect = NULL;     /* specific view only */
103  
104   int     overture = 0;           /* overture calculation needed */
105  
106 + int     children_running = 0;   /* set negative in children */
107 +
108   char    *progname;              /* global argv[0] */
109   char    *rifname;               /* global rad input file name */
110  
111 < char    radname[MAXPATH];       /* root Radiance file name */
111 > char    radname[PATH_MAX];      /* root Radiance file name */
112  
113 + #define inchild()       (children_running < 0)
114  
115 +
116   main(argc, argv)
117   int     argc;
118   char    *argv[];
# Line 123 | Line 129 | char   *argv[];
129                          silent++;
130                          break;
131                  case 'n':
132 <                        noaction++;
132 >                        nprocs = 0;
133                          break;
134 +                case 'N':
135 +                        nprocs = atoi(argv[++i]);
136 +                        if (nprocs < 0)
137 +                                nprocs = 0;
138 +                        break;
139                  case 't':
140                          touchonly++;
141                          break;
# Line 149 | Line 160 | char   *argv[];
160          if (i >= argc)
161                  goto userr;
162          rifname = argv[i];
163 +                                /* check command-line options */
164 +        if (nprocs > 1 & viewselect != NULL)
165 +                nprocs = 1;
166                                  /* assign Radiance root file name */
167          rootname(radname, rifname);
168                                  /* load variable values */
169          loadvars(rifname);
170                                  /* get any additional assignments */
171          for (i++; i < argc; i++)
172 <                setvariable(argv[i]);
172 >                if (setvariable(argv[i], matchvar) < 0) {
173 >                        fprintf(stderr, "%s: unknown variable: %s\n",
174 >                                        progname, argv[i]);
175 >                        quit(1);
176 >                }
177                                  /* check assignments */
178          checkvalues();
179                                  /* check files and dates */
# Line 176 | Line 194 | char   *argv[];
194                  rview(ropts, popts);
195          else
196                  rpict(ropts, popts);
197 <        exit(0);
197 >        quit(0);
198   userr:
199          fprintf(stderr,
200 < "Usage: %s [-s][-n][-t][-e][-V][-v view][-o dev] rfile [VAR=value ..]\n",
200 > "Usage: %s [-w][-s][-n|-N npr][-t][-e][-V][-v view][-o dev] rfile [VAR=value ..]\n",
201                          progname);
202 <        exit(1);
202 >        quit(1);
203   }
204  
205  
# Line 204 | Line 222 | time_t
222   checklast(fnames)                       /* check files and find most recent */
223   register char   *fnames;
224   {
225 <        char    thisfile[MAXPATH];
225 >        char    thisfile[PATH_MAX];
226          time_t  thisdate, lastdate = 0;
209 –        register char   *cp;
227  
228          if (fnames == NULL)
229                  return(0);
230 <        while (*fnames) {
231 <                while (isspace(*fnames)) fnames++;
232 <                cp = thisfile;
233 <                while (*fnames && !isspace(*fnames))
217 <                        *cp++ = *fnames++;
218 <                *cp = '\0';
230 >        while ((fnames = nextword(thisfile, PATH_MAX, fnames)) != NULL) {
231 >                if (thisfile[0] == '!' ||
232 >                                (thisfile[0] == '\\' && thisfile[1] == '!'))
233 >                        continue;
234                  if (!(thisdate = fdate(thisfile)))
235                          syserr(thisfile);
236                  if (thisdate > lastdate)
# Line 230 | Line 245 | newfname(orig, pred)           /* create modified file name */
245   char    *orig;
246   int     pred;
247   {
233 –        extern char     *rindex();
248          register char   *cp;
249          register int    n;
250          int     suffix;
# Line 260 | Line 274 | checkfiles()                   /* check for existence and modified tim
274                          syserr(progname);
275                  sprintf(vval(OCTREE), "%s.oct", radname);
276                  vdef(OCTREE)++;
277 +        } else if (vval(OCTREE)[0] == '!') {
278 +                fprintf(stderr, "%s: illegal '%s' specification\n",
279 +                                progname, vnam(OCTREE));
280 +                quit(1);
281          }
282          octreedate = fdate(vval(OCTREE));
283          if (vdef(ILLUM)) {              /* illum requires secondary octrees */
# Line 276 | Line 294 | checkfiles()                   /* check for existence and modified tim
294          if (!octreedate & !scenedate & !illumdate) {
295                  fprintf(stderr, "%s: need '%s' or '%s' or '%s'\n", progname,
296                                  vnam(OCTREE), vnam(SCENE), vnam(ILLUM));
297 <                exit(1);
297 >                quit(1);
298          }
299          matdate = checklast(vval(MATERIAL));
300   }      
# Line 293 | Line 311 | double org[3], *sizp;
311          register int    i;
312  
313          if (osiz <= FTINY)
314 <                if (noaction && fdate(oct1name) <
314 >                if (!nprocs && fdate(oct1name) <
315                                  (scenedate>illumdate?scenedate:illumdate)) {
316                                                          /* run getbbox */
317                          sprintf(buf, "getbbox -w -h %s",
# Line 306 | Line 324 | double org[3], *sizp;
324                                  fprintf(stderr,
325                          "%s: error reading bounding box from getbbox\n",
326                                                  progname);
327 <                                exit(1);
327 >                                quit(1);
328                          }
329                          for (i = 0; i < 3; i++)
330                                  if (max[i] - min[i] > osiz)
# Line 324 | Line 342 | double org[3], *sizp;
342                                  fprintf(stderr,
343                          "%s: error reading bounding cube from getinfo\n",
344                                                  progname);
345 <                                exit(1);
345 >                                quit(1);
346                          }
347                          pclose(fp);
348                  }
# Line 334 | Line 352 | double org[3], *sizp;
352  
353   setdefaults()                   /* set default values for unassigned var's */
354   {
355 <        double  org[3], size;
355 >        double  org[3], lim[3], size;
356          char    buf[128];
357  
358          if (!vdef(ZONE)) {
# Line 344 | Line 362 | setdefaults()                  /* set default values for unassigned v
362                  vval(ZONE) = savqstr(buf);
363                  vdef(ZONE)++;
364          }
365 +        if (!vdef(EYESEP)) {
366 +                if (sscanf(vval(ZONE), "%*s %lf %lf %lf %lf %lf %lf",
367 +                                &org[0], &lim[0], &org[1], &lim[1],
368 +                                &org[2], &lim[2]) != 6)
369 +                        badvalue(ZONE);
370 +                sprintf(buf, "%f",
371 +                        0.01*(lim[0]-org[0]+lim[1]-org[1]+lim[2]-org[2]));
372 +                vval(EYESEP) = savqstr(buf);
373 +                vdef(EYESEP)++;
374 +        }
375          if (!vdef(INDIRECT)) {
376                  vval(INDIRECT) = "0";
377                  vdef(INDIRECT)++;
# Line 360 | Line 388 | setdefaults()                  /* set default values for unassigned v
388                  vval(PICTURE) = radname;
389                  vdef(PICTURE)++;
390          }
391 <        if (!vdef(VIEW)) {
392 <                vval(VIEW) = "X";
393 <                vdef(VIEW)++;
391 >        if (!vdef(VIEWS)) {
392 >                vval(VIEWS) = "X";
393 >                vdef(VIEWS)++;
394          }
395          if (!vdef(DETAIL)) {
396                  vval(DETAIL) = "M";
# Line 382 | Line 410 | setdefaults()                  /* set default values for unassigned v
410   oconv()                         /* run oconv and mkillum if necessary */
411   {
412          static char     illumtmp[] = "ilXXXXXX";
413 <        char    combuf[1024], ocopts[64], mkopts[64];
413 >        char    combuf[PATH_MAX], ocopts[64], mkopts[64];
414  
415          oconvopts(ocopts);              /* get options */
416          if (octreedate < scenedate) {   /* check date on original octree */
# Line 402 | Line 430 | oconv()                                /* run oconv and mkillum if necessary */
430                                  "%s: error generating octree\n\t%s removed\n",
431                                                  progname, vval(OCTREE));
432                                  unlink(vval(OCTREE));
433 <                                exit(1);
433 >                                quit(1);
434                          }
435                  }
436                  octreedate = time((time_t *)NULL);
# Line 433 | Line 461 | oconv()                                /* run oconv and mkillum if necessary */
461                                  "%s: error generating octree\n\t%s removed\n",
462                                                  progname, oct0name);
463                                  unlink(oct0name);
464 <                                exit(1);
464 >                                quit(1);
465                          }
466                  }
467                  oct0date = time((time_t *)NULL);
# Line 453 | Line 481 | oconv()                                /* run oconv and mkillum if necessary */
481                          fprintf(stderr, "%s: error running mkillum\n",
482                                          progname);
483                          unlink(illumtmp);
484 <                        exit(1);
484 >                        quit(1);
485                  }
486                                                  /* make octree1 (frozen) */
487                  if (octreedate)
# Line 471 | Line 499 | oconv()                                /* run oconv and mkillum if necessary */
499                                          progname, oct1name);
500                          unlink(oct1name);
501                          unlink(illumtmp);
502 <                        exit(1);
502 >                        quit(1);
503                  }
504                  rmfile(illumtmp);
505          }
# Line 807 | Line 835 | char   *ro;
835                          syserr(vval(OPTFILE));
836                  sprintf(ro, " @%s", vval(OPTFILE));
837          }
838 < #ifdef MSDOS
838 > #ifdef _WIN32
839          else if (n > 50) {
840                  setenv("ROPT", ro+1);
841                  strcpy(ro, " $ROPT");
# Line 826 | Line 854 | register char  *po;
854          }
855          switch (vscale(QUALITY)) {
856          case MEDIUM:
857 <                po = addarg(po, "-r 1");
857 >                po = addarg(po, "-r .6");
858                  break;
859          case HIGH:
860                  po = addarg(po, "-m .25");
# Line 963 | Line 991 | register char  *vs;
991          if (cp == viewopts)             /* append any additional options */
992                  vs++;           /* skip prefixed space if unneeded */
993          strcpy(cp, vs);
994 < #ifdef MSDOS
994 > #ifdef _WIN32
995          if (strlen(viewopts) > 40) {
996                  setenv("VIEW", viewopts);
997                  return("$VIEW");
# Line 995 | Line 1023 | char   *vn;            /* returned view name */
1023                  }
1024                                                  /* view number? */
1025                  if (isint(viewselect))
1026 <                        return(specview(nvalue(vv+VIEW, atoi(viewselect)-1)));
1026 >                        return(specview(nvalue(VIEWS, atoi(viewselect)-1)));
1027                                                  /* check list */
1028 <                while ((mv = nvalue(vv+VIEW, n++)) != NULL)
1028 >                while ((mv = nvalue(VIEWS, n++)) != NULL)
1029                          if (matchword(viewselect, mv))
1030                                  return(specview(mv));
1031                  return(specview(viewselect));   /* standard view? */
1032          }
1033 <        mv = nvalue(vv+VIEW, n);                /* use view n */
1033 >        mv = nvalue(VIEWS, n);          /* use view n */
1034          if (vn != NULL & mv != NULL) {
1035                  register char   *mv2 = mv;
1036                  if (*mv2 != '-')
# Line 1014 | Line 1042 | char   *vn;            /* returned view name */
1042   }
1043  
1044  
1045 < printview(vopts)                        /* print out selected view */
1045 > int
1046 > myprintview(vopts, fp)                  /* print out selected view */
1047   register char   *vopts;
1048 + FILE    *fp;
1049   {
1050 <        extern char     *atos(), *getenv();
1051 <        char    buf[256];
1022 <        FILE    *fp;
1050 >        VIEW    vwr;
1051 >        char    buf[128];
1052          register char   *cp;
1053 <
1053 > again:
1054          if (vopts == NULL)
1055                  return(-1);
1056 <        fputs("VIEW=", stdout);
1057 <        do {
1058 <                if (matchword(vopts, "-vf")) {          /* expand view file */
1059 <                        vopts = sskip(vopts);
1060 <                        if (!*atos(buf, sizeof(buf), vopts))
1032 <                                return(-1);
1033 <                        if ((fp = fopen(buf, "r")) == NULL)
1034 <                                return(-1);
1035 <                        for (buf[sizeof(buf)-2] = '\n';
1036 <                                        fgets(buf, sizeof(buf), fp) != NULL &&
1037 <                                                buf[0] != '\n';
1038 <                                        buf[sizeof(buf)-2] = '\n') {
1039 <                                if (buf[sizeof(buf)-2] != '\n') {
1040 <                                        ungetc(buf[sizeof(buf)-2], fp);
1041 <                                        buf[sizeof(buf)-2] = '\0';
1042 <                                }
1043 <                                if (matchword(buf, "VIEW=") ||
1044 <                                                matchword(buf, "rview")) {
1045 <                                        for (cp = sskip(buf); *cp && *cp != '\n'; cp++)
1046 <                                                putchar(*cp);
1047 <                                }
1048 <                        }
1049 <                        fclose(fp);
1050 <                        vopts = sskip(vopts);
1051 <                } else {
1052 <                        while (isspace(*vopts))
1053 <                                vopts++;
1054 <                        putchar(' ');
1055 < #ifdef MSDOS
1056 <                        if (*vopts == '$') {            /* expand env. var. */
1057 <                                if (!*atos(buf, sizeof(buf), vopts+1))
1058 <                                        return(-1);
1059 <                                if ((cp = getenv(buf)) == NULL)
1060 <                                        return(-1);
1061 <                                fputs(cp, stdout);
1062 <                                vopts = sskip(vopts);
1063 <                        } else
1056 > #ifdef _WIN32
1057 >        if (vopts[0] == '$') {
1058 >                vopts = getenv(vopts+1);
1059 >                goto again;
1060 >        }
1061   #endif
1062 <                                while (*vopts && !isspace(*vopts))
1063 <                                        putchar(*vopts++);
1064 <                }
1065 <        } while (*vopts++);
1066 <        putchar('\n');
1062 >        copystruct(&vwr, &stdview);
1063 >        sscanview(&vwr, cp=vopts);              /* set initial options */
1064 >        while ((cp = strstr(cp, "-vf ")) != NULL &&
1065 >                        *atos(buf, sizeof(buf), cp += 4)) {
1066 >                viewfile(buf, &vwr, NULL);      /* load -vf file */
1067 >                sscanview(&vwr, cp);            /* reset tail */
1068 >        }
1069 >        fputs(VIEWSTR, fp);
1070 >        fprintview(&vwr, fp);                   /* print full spec. */
1071 >        fputc('\n', fp);
1072          return(0);
1073   }
1074  
# Line 1075 | Line 1077 | rview(opts, po)                                /* run rview with first view */
1077   char    *opts, *po;
1078   {
1079          char    *vw;
1080 <        char    combuf[512];
1080 >        char    combuf[PATH_MAX];
1081                                          /* build command */
1082          if (touchonly || (vw = getview(0, NULL)) == NULL)
1083                  return;
1084          if (sayview)
1085 <                printview(vw);
1085 >                myprintview(vw, stdout);
1086          sprintf(combuf, "rview %s%s%s -R %s ", vw, po, opts, rifname);
1087          if (rvdevice != NULL)
1088                  sprintf(combuf+strlen(combuf), "-o %s ", rvdevice);
# Line 1089 | Line 1091 | char   *opts, *po;
1091          strcat(combuf, oct1name);
1092          if (runcom(combuf)) {           /* run it */
1093                  fprintf(stderr, "%s: error running rview\n", progname);
1094 <                exit(1);
1094 >                quit(1);
1095          }
1096   }
1097  
# Line 1097 | Line 1099 | char   *opts, *po;
1099   rpict(opts, po)                         /* run rpict and pfilt for each view */
1100   char    *opts, *po;
1101   {
1102 <        char    combuf[1024];
1103 <        char    rawfile[MAXPATH], picfile[MAXPATH];
1104 <        char    zopt[MAXPATH+4], rep[MAXPATH+16], res[32];
1102 >        char    combuf[PATH_MAX];
1103 >        char    rawfile[PATH_MAX], picfile[PATH_MAX];
1104 >        char    zopt[PATH_MAX+4], rep[PATH_MAX+16], res[32];
1105 >        char    rppopt[128], *pfile = NULL;
1106          char    pfopts[128];
1107          char    vs[32], *vw;
1108          int     vn, mult;
1109 +        FILE    *fp;
1110          time_t  rfdt, pfdt;
1111                                          /* get pfilt options */
1112          pfiltopts(pfopts);
# Line 1144 | Line 1148 | char   *opts, *po;
1148                  else
1149                          badvalue(REPORT);
1150          }
1151 <                                        /* do each view */
1152 <        vn = 0;
1151 >                                        /* set up parallel rendering */
1152 >        if (nprocs > 1 & !vdef(ZFILE)) {
1153 >                strcpy(rppopt, "-S 1 -PP pfXXXXXX");
1154 >                pfile = rppopt+9;
1155 >                if (mktemp(pfile) == NULL)
1156 >                        pfile = NULL;
1157 >        }
1158 >        vn = 0;                                 /* do each view */
1159          while ((vw = getview(vn++, vs)) != NULL) {
1160                  if (sayview)
1161 <                        printview(vw);
1161 >                        myprintview(vw, stdout);
1162                  if (!vs[0])
1163                          sprintf(vs, "%d", vn);
1164                  sprintf(picfile, "%s_%s.pic", vval(PICTURE), vs);
# Line 1172 | Line 1182 | char   *opts, *po;
1182                                  touch(picfile);
1183                          continue;
1184                  }
1185 +                if (next_process()) {           /* parallel running? */
1186 +                        if (pfile != NULL)
1187 +                                sleep(20);
1188 +                        continue;
1189 +                }
1190 +                /* XXX Remember to call finish_process() */
1191                                                  /* build rpict command */
1192 <                if (rfdt >= oct1date)           /* recover */
1192 >                if (rfdt >= oct1date) {         /* recover */
1193                          sprintf(combuf, "rpict%s%s%s%s -ro %s %s",
1194                                  rep, po, opts, zopt, rawfile, oct1name);
1195 <                else {
1195 >                        if (runcom(combuf))     /* run rpict */
1196 >                                goto rperror;
1197 >                } else {
1198                          if (overture) {         /* run overture calculation */
1199                                  sprintf(combuf,
1200                                  "rpict%s %s%s -x 64 -y 64 -ps 1 %s > %s",
# Line 1186 | Line 1204 | char   *opts, *po;
1204                                          fprintf(stderr,
1205                                          "%s: error in overture for view %s\n",
1206                                                  progname, vs);
1207 <                                        exit(1);
1207 >                                        quit(1);
1208                                  }
1209 < #ifdef NIX
1209 > #ifndef NULL_DEVICE
1210                                  rmfile(overfile);
1211   #endif
1212                          }
1213                          sprintf(combuf, "rpict%s %s %s%s%s%s %s > %s",
1214 <                                        rep, vw, res, po, opts, zopt,
1215 <                                        oct1name, rawfile);
1214 >                                        rep, vw, res, po, opts,
1215 >                                        zopt, oct1name, rawfile);
1216 >                        if (pfile != NULL && inchild()) {
1217 >                                                /* rpict persistent mode */
1218 >                                if (!silent)
1219 >                                        printf("\t%s\n", combuf);
1220 >                                sprintf(combuf, "rpict%s %s %s%s%s %s > %s",
1221 >                                                rep, rppopt, res, po, opts,
1222 >                                                oct1name, rawfile);
1223 >                                fflush(stdout);
1224 >                                fp = popen(combuf, "w");
1225 >                                if (fp == NULL)
1226 >                                        goto rperror;
1227 >                                myprintview(vw, fp);
1228 >                                if (pclose(fp))
1229 >                                        goto rperror;
1230 >                        } else {                /* rpict normal mode */
1231 >                                if (runcom(combuf))
1232 >                                        goto rperror;
1233 >                        }
1234                  }
1199 –                if (runcom(combuf)) {           /* run rpict */
1200 –                        fprintf(stderr, "%s: error rendering view %s\n",
1201 –                                        progname, vs);
1202 –                        exit(1);
1203 –                }
1235                  if (!vdef(RAWFILE) || strcmp(vval(RAWFILE),vval(PICTURE))) {
1236                                                  /* build pfilt command */
1237                          if (mult > 1)
# Line 1209 | Line 1240 | char   *opts, *po;
1240                          else
1241                                  sprintf(combuf, "pfilt%s %s > %s", pfopts,
1242                                                  rawfile, picfile);
1243 <                        if (runcom(combuf)) {           /* run pfilt */
1243 >                        if (runcom(combuf)) {   /* run pfilt */
1244                                  fprintf(stderr,
1245                                  "%s: error filtering view %s\n\t%s removed\n",
1246                                                  progname, vs, picfile);
1247                                  unlink(picfile);
1248 <                                exit(1);
1248 >                                quit(1);
1249                          }
1250                  }
1251                                                  /* remove/rename raw file */
# Line 1223 | Line 1254 | char   *opts, *po;
1254                          mvfile(rawfile, combuf);
1255                  } else
1256                          rmfile(rawfile);
1257 +                finish_process();               /* leave if child */
1258          }
1259 +        wait_process(1);                /* wait for children to finish */
1260 +        if (pfile != NULL) {            /* clean up rpict persistent mode */
1261 +                int     pid;
1262 +                fp = fopen(pfile, "r");
1263 +                if (fp != NULL) {
1264 +                        if (fscanf(fp, "%*s %d", &pid) != 1 ||
1265 +                                        kill(pid, 1) == -1)
1266 +                                unlink(pfile);
1267 +                        fclose(fp);
1268 +                }
1269 +        }
1270 +        return;
1271 + rperror:
1272 +        fprintf(stderr, "%s: error rendering view %s\n", progname, vs);
1273 +        quit(1);
1274   }
1275  
1276  
# Line 1232 | Line 1279 | char   *fn;
1279   {
1280          if (!silent)
1281                  printf("\ttouch %s\n", fn);
1282 <        if (noaction)
1282 >        if (!nprocs)
1283                  return(0);
1284   #ifdef notused
1285          if (access(fn, F_OK) == -1)             /* create it */
# Line 1248 | Line 1295 | char   *cs;
1295   {
1296          if (!silent)            /* echo it */
1297                  printf("\t%s\n", cs);
1298 <        if (noaction)
1298 >        if (!nprocs)
1299                  return(0);
1300          fflush(stdout);         /* flush output and pass to shell */
1301          return(system(cs));
# Line 1259 | Line 1306 | rmfile(fn)                     /* remove a file */
1306   char    *fn;
1307   {
1308          if (!silent)
1309 < #ifdef MSDOS
1309 > #ifdef _WIN32
1310                  printf("\tdel %s\n", fn);
1311   #else
1312                  printf("\trm -f %s\n", fn);
1313   #endif
1314 <        if (noaction)
1314 >        if (!nprocs)
1315                  return(0);
1316          return(unlink(fn));
1317   }
# Line 1274 | Line 1321 | mvfile(fold, fnew)             /* move a file */
1321   char    *fold, *fnew;
1322   {
1323          if (!silent)
1324 < #ifdef MSDOS
1324 > #ifdef _WIN32
1325                  printf("\trename %s %s\n", fold, fnew);
1326   #else
1327                  printf("\tmv %s %s\n", fold, fnew);
1328   #endif
1329 <        if (noaction)
1329 >        if (!nprocs)
1330                  return(0);
1331          return(rename(fold, fnew));
1332   }
1333  
1334  
1335 < #ifdef MSDOS
1335 > #ifdef RHAS_FORK_EXEC
1336 > int
1337 > next_process()                  /* fork the next process (max. nprocs) */
1338 > {
1339 >        int     child_pid;
1340 >
1341 >        if (nprocs <= 1)
1342 >                return(0);              /* it's us or no one */
1343 >        if (inchild()) {
1344 >                fprintf(stderr, "%s: internal error 1 in spawn_process()\n",
1345 >                                progname);
1346 >                quit(1);
1347 >        }
1348 >        if (children_running >= nprocs)
1349 >                wait_process(0);        /* wait for someone to finish */
1350 >        fflush(stdout);
1351 >        child_pid = fork();             /* split process */
1352 >        if (child_pid == 0) {           /* we're the child */
1353 >                children_running = -1;
1354 >                return(0);
1355 >        }
1356 >        if (child_pid > 0) {            /* we're the parent */
1357 >                ++children_running;
1358 >                return(1);
1359 >        }
1360 >        fprintf(stderr, "%s: warning -- fork() failed\n", progname);
1361 >        return(0);
1362 > }
1363 >
1364 > wait_process(all)                       /* wait for process(es) to finish */
1365 > int     all;
1366 > {
1367 >        int     ourstatus = 0;
1368 >        int     pid, status;
1369 >
1370 >        if (all)
1371 >                all = children_running;
1372 >        else if (children_running > 0)
1373 >                all = 1;
1374 >        while (all-- > 0) {
1375 >                pid = wait(&status);
1376 >                if (pid < 0)
1377 >                        syserr(progname);
1378 >                status = status>>8 & 0xff;
1379 >                --children_running;
1380 >                if (status != 0) {      /* child's problem is our problem */
1381 >                        if (ourstatus == 0 & children_running > 0)
1382 >                                fprintf(stderr, "%s: waiting for remaining processes\n",
1383 >                                                progname);
1384 >                        ourstatus = status;
1385 >                        all = children_running;
1386 >                }
1387 >        }
1388 >        if (ourstatus != 0)
1389 >                quit(ourstatus);        /* bad status from child */
1390 > }
1391 > #else   /* ! RHAS_FORK_EXEC */
1392 > int
1393 > next_process()
1394 > {
1395 >        return(0);                      /* cannot start new process */
1396 > }
1397 > wait_process(all)
1398 > int     all;
1399 > {
1400 >        (void)all;                      /* no one to wait for */
1401 > }
1402 > #endif  /* ! RHAS_FORK_EXEC */
1403 >
1404 > finish_process()                        /* exit a child process */
1405 > {
1406 >        if (!inchild())
1407 >                return;                 /* in parent -- noop */
1408 >        exit(0);
1409 > }
1410 >
1411 > #ifdef _WIN32
1412   setenv(vname, value)            /* set an environment variable */
1413   char    *vname, *value;
1414   {
# Line 1297 | Line 1420 | char   *vname, *value;
1420          sprintf(evp, "%s=%s", vname, value);
1421          if (putenv(evp) != 0) {
1422                  fprintf(stderr, "%s: out of environment space\n", progname);
1423 <                exit(1);
1423 >                quit(1);
1424          }
1425          if (!silent)
1426                  printf("set %s\n", evp);
# Line 1310 | Line 1433 | int    vc;
1433   {
1434          fprintf(stderr, "%s: bad value for variable '%s'\n",
1435                          progname, vnam(vc));
1436 <        exit(1);
1436 >        quit(1);
1437   }
1438  
1439  
# Line 1318 | Line 1441 | syserr(s)                      /* report a system error and exit */
1441   char    *s;
1442   {
1443          perror(s);
1444 <        exit(1);
1444 >        quit(1);
1445 > }
1446 >
1447 >
1448 > void
1449 > quit(ec)                        /* exit program */
1450 > int     ec;
1451 > {
1452 >        exit(ec);
1453   }

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines