src/rt/rtmain.c

#ifndef lint
static const char       RCSid[] = "$Id: rtmain.c,v 2.29 2019/04/18 23:58:22 greg Exp $";
#endif
/*
 *  rtmain.c - main for rtrace per-ray calculation program
 */

#include "copyright.h"

#include  <signal.h>

#include  "platform.h"
#include  "rtprocess.h" /* getpid() */
#include  "resolu.h"
#include  "ray.h"
#include  "source.h"
#include  "ambient.h"
#include  "random.h"
#include  "paths.h"
#include  "pmapray.h"

extern char     *progname;              /* global argv[0] */

extern char     *shm_boundary;          /* boundary of shared memory */

                                        /* persistent processes define */
#ifdef  F_SETLKW
#define  PERSIST        1               /* normal persist */
#define  PARALLEL       2               /* parallel persist */
#define  PCHILD         3               /* child of normal persist */
#endif

char  *sigerr[NSIG];                    /* signal error messages */
char  *errfile = NULL;                  /* error output file */

int  nproc = 1;                         /* number of processes */

extern char  *formstr();                /* string from format */
int  inform = 'a';                      /* input format */
int  outform = 'a';                     /* output format */
char  *outvals = "v";                   /* output specification */

int  hresolu = 0;                       /* horizontal (scan) size */
int  vresolu = 0;                       /* vertical resolution */

int  imm_irrad = 0;                     /* compute immediate irradiance? */
int  lim_dist = 0;                      /* limit distance? */

#ifndef MAXMODLIST
#define MAXMODLIST      1024            /* maximum modifiers we'll track */
#endif

extern void  (*addobjnotify[])();       /* object notification calls */
extern void  tranotify(OBJECT obj);

char  *tralist[MAXMODLIST];             /* list of modifers to trace (or no) */
int  traincl = -1;                      /* include == 1, exclude == 0 */

static int  loadflags = ~IO_FILES;      /* what to load from octree */

static void onsig(int  signo);
static void sigdie(int  signo, char  *msg);
static void printdefaults(void);


int
main(int  argc, char  *argv[])
{
#define  check(ol,al)           if (argv[i][ol] || \
                                badarg(argc-i-1,argv+i+1,al)) \
                                goto badopt
#define  check_bool(olen,var)           switch (argv[i][olen]) { \
                                case '\0': var = !var; break; \
                                case 'y': case 'Y': case 't': case 'T': \
                                case '+': case '1': var = 1; break; \
                                case 'n': case 'N': case 'f': case 'F': \
                                case '-': case '0': var = 0; break; \
                                default: goto badopt; }
        extern char  *octname;
        int  persist = 0;
        char  *octnm = NULL;
        char  **tralp = NULL;
        int  duped1 = -1;
        int  rval;
        int  i;
                                        /* global program name */
        progname = argv[0] = fixargv0(argv[0]);
                                        /* add trace notify function */
        for (i = 0; addobjnotify[i] != NULL; i++)
                ;
        addobjnotify[i] = tranotify;
                                        /* option city */
        for (i = 1; i < argc; i++) {
                                                /* expand arguments */
                while ((rval = expandarg(&argc, &argv, i)) > 0)
                        ;
                if (rval < 0) {
                        sprintf(errmsg, "cannot expand '%s'", argv[i]);
                        error(SYSTEM, errmsg);
                }
                if (argv[i] == NULL || argv[i][0] != '-')
                        break;                  /* break from options */
                if (!strcmp(argv[i], "-version")) {
                        puts(VersionID);
                        quit(0);
                }
                if (!strcmp(argv[i], "-defaults") ||
                                !strcmp(argv[i], "-help")) {
                        printdefaults();
                        quit(0);
                }
                rval = getrenderopt(argc-i, argv+i);
                if (rval >= 0) {
                        i += rval;
                        continue;
                }
                switch (argv[i][1]) {
                case 'n':                               /* number of cores */
                        check(2,"i");
                        nproc = atoi(argv[++i]);
                        if (nproc <= 0)
                                error(USER, "bad number of processes");
                        break;
                case 'x':                               /* x resolution */
                        check(2,"i");
                        hresolu = atoi(argv[++i]);
                        break;
                case 'y':                               /* y resolution */
                        check(2,"i");
                        vresolu = atoi(argv[++i]);
                        break;
                case 'w':                               /* warnings */
                        rval = erract[WARNING].pf != NULL;
                        check_bool(2,rval);
                        if (rval) erract[WARNING].pf = wputs;
                        else erract[WARNING].pf = NULL;
                        break;
                case 'e':                               /* error file */
                        check(2,"s");
                        errfile = argv[++i];
                        break;
                case 'l':                               /* limit distance */
                        if (argv[i][2] != 'd')
                                goto badopt;
                        check_bool(3,lim_dist);
                        break;
                case 'I':                               /* immed. irradiance */
                        check_bool(2,imm_irrad);
                        break;
                case 'f':                               /* format i/o */
                        switch (argv[i][2]) {
                        case 'a':                               /* ascii */
                        case 'f':                               /* float */
                        case 'd':                               /* double */
                                inform = argv[i][2];
                                break;
                        default:
                                goto badopt;
                        }
                        switch (argv[i][3]) {
                        case '\0':
                                outform = inform;
                                break;
                        case 'a':                               /* ascii */
                        case 'f':                               /* float */
                        case 'd':                               /* double */
                        case 'c':                               /* color */
                                check(4,"");
                                outform = argv[i][3];
                                break;
                        default:
                                goto badopt;
                        }
                        break;
                case 'o':                               /* output */
                        outvals = argv[i]+2;
                        break;
                case 'h':                               /* header output */
                        rval = loadflags & IO_INFO;
                        check_bool(2,rval);
                        loadflags = rval ? loadflags | IO_INFO :
                                        loadflags & ~IO_INFO;
                        break;
                case 't':                               /* trace */
                        switch (argv[i][2]) {
                        case 'i':                               /* include */
                        case 'I':
                                check(3,"s");
                                if (traincl != 1) {
                                        traincl = 1;
                                        tralp = tralist;
                                }
                                if (argv[i][2] == 'I') {        /* file */
                                        rval = wordfile(tralp, MAXMODLIST-(tralp-tralist),
                                        getpath(argv[++i],getrlibpath(),R_OK));
                                        if (rval < 0) {
                                                sprintf(errmsg,
                                "cannot open trace include file \"%s\"",
                                                                argv[i]);
                                                error(SYSTEM, errmsg);
                                        }
                                        tralp += rval;
                                } else {
                                        *tralp++ = argv[++i];
                                        *tralp = NULL;
                                }
                                break;
                        case 'e':                               /* exclude */
                        case 'E':
                                check(3,"s");
                                if (traincl != 0) {
                                        traincl = 0;
                                        tralp = tralist;
                                }
                                if (argv[i][2] == 'E') {        /* file */
                                        rval = wordfile(tralp, MAXMODLIST-(tralp-tralist),
                                        getpath(argv[++i],getrlibpath(),R_OK));
                                        if (rval < 0) {
                                                sprintf(errmsg,
                                "cannot open trace exclude file \"%s\"",
                                                                argv[i]);
                                                error(SYSTEM, errmsg);
                                        }
                                        tralp += rval;
                                } else {
                                        *tralp++ = argv[++i];
                                        *tralp = NULL;
                                }
                                break;
                        default:
                                goto badopt;
                        }
                        break;
#ifdef  PERSIST
                case 'P':                               /* persist file */
                        if (argv[i][2] == 'P') {
                                check(3,"s");
                                persist = PARALLEL;
                        } else {
                                check(2,"s");
                                persist = PERSIST;
                        }
                        persistfile(argv[++i]);
                        break;
#endif
                default:
                        goto badopt;
                }
        }
        if (nproc > 1) {
                if (persist)
                        error(USER, "multiprocessing incompatible with persist file");
                if (!vresolu && hresolu > 0 && hresolu < nproc)
                        error(WARNING, "number of cores should not exceed horizontal resolution");
                if (trace != NULL)
                        error(WARNING, "multiprocessing does not work properly with trace mode");
        }
                                        /* initialize object types */
        initotypes();
                                        /* initialize urand */
        if (rand_samp) {
                srandom((long)time(0));
                initurand(0);
        } else {
                srandom(0L);
                initurand(2048);
        }
                                        /* set up signal handling */
        sigdie(SIGINT, "Interrupt");
#ifdef SIGHUP
        sigdie(SIGHUP, "Hangup");
#endif
        sigdie(SIGTERM, "Terminate");
#ifdef SIGPIPE
        sigdie(SIGPIPE, "Broken pipe");
#endif
#ifdef SIGALRM
        sigdie(SIGALRM, "Alarm clock");
#endif
#ifdef  SIGXCPU
        sigdie(SIGXCPU, "CPU limit exceeded");
        sigdie(SIGXFSZ, "File size exceeded");
#endif
                                        /* open error file */
        if (errfile != NULL) {
                if (freopen(errfile, "a", stderr) == NULL)
                        quit(2);
                fprintf(stderr, "**************\n*** PID %5d: ",
                                getpid());
                printargs(argc, argv, stderr);
                putc('\n', stderr);
                fflush(stderr);
        }
#ifdef  NICE
        nice(NICE);                     /* lower priority */
#endif
                                        /* get octree */
        if (i == argc)
                octnm = NULL;
        else if (i == argc-1)
                octnm = argv[i];
        else
                goto badopt;
        if (octnm == NULL)
                error(USER, "missing octree argument");
                                        /* set up output */
#ifdef  PERSIST
        if (persist) {
                duped1 = dup(fileno(stdout));   /* don't lose our output */
                openheader();
        }
#endif
        if (outform != 'a')
                SET_FILE_BINARY(stdout);
        readoct(octname = octnm, loadflags, &thescene, NULL);
        nsceneobjs = nobjects;

        if (loadflags & IO_INFO) {      /* print header */
                printargs(i, argv, stdout);
                printf("SOFTWARE= %s\n", VersionID);
                fputnow(stdout);
                if ((outform == 'f') | (outform == 'd'))
                        fputendian(stdout);
                fputformat(formstr(outform), stdout);
                putchar('\n');
        }
        
        ray_init_pmap();     /* PMAP: set up & load photon maps */
        
        marksources();                  /* find and mark sources */

        setambient();                   /* initialize ambient calculation */
        
#ifdef  PERSIST
        if (persist) {
                fflush(stdout);
                                                /* reconnect stdout */
                dup2(duped1, fileno(stdout));
                close(duped1);
                if (persist == PARALLEL) {      /* multiprocessing */
                        preload_objs();         /* preload scene */
                        shm_boundary = (char *)malloc(16);
                        strcpy(shm_boundary, "SHM_BOUNDARY");
                        while ((rval=fork()) == 0) {    /* keep on forkin' */
                                pflock(1);
                                pfhold();
                                ambsync();              /* load new values */
                        }
                        if (rval < 0)
                                error(SYSTEM, "cannot fork child for persist function");
                        pfdetach();             /* parent will run then exit */
                }
        }
runagain:
        if (persist)
                dupheader();                    /* send header to stdout */
#endif
                                        /* trace rays */
        rtrace(NULL, nproc);
                                        /* flush ambient file */
        ambsync();
#ifdef  PERSIST
        if (persist == PERSIST) {       /* first run-through */
                if ((rval=fork()) == 0) {       /* child loops until killed */
                        pflock(1);
                        persist = PCHILD;
                } else {                        /* original process exits */
                        if (rval < 0)
                                error(SYSTEM, "cannot fork child for persist function");
                        pfdetach();             /* parent exits */
                }
        }
        if (persist == PCHILD) {        /* wait for a signal then go again */
                pfhold();
                raynum = nrays = 0;             /* reinitialize */
                goto runagain;
        }
#endif

        ray_done_pmap();           /* PMAP: free photon maps */
        
        quit(0);

badopt:
        sprintf(errmsg, "command line error at '%s'", argv[i]);
        error(USER, errmsg);
        return 1; /* pro forma return */

#undef  check
#undef  check_bool
}


void
wputs(                          /* warning output function */
        char    *s
)
{
        int  lasterrno = errno;
        eputs(s);
        errno = lasterrno;
}


void
eputs(                          /* put string to stderr */
        register char  *s
)
{
        static int  midline = 0;

        if (!*s)
                return;
        if (!midline++) {
                fputs(progname, stderr);
                fputs(": ", stderr);
        }
        fputs(s, stderr);
        if (s[strlen(s)-1] == '\n') {
                fflush(stderr);
                midline = 0;
        }
}


static void
onsig(                          /* fatal signal */
        int  signo
)
{
        static int  gotsig = 0;

        if (gotsig++)                   /* two signals and we're gone! */
                _exit(signo);

#ifdef SIGALRM
        alarm(15);                      /* allow 15 seconds to clean up */
        signal(SIGALRM, SIG_DFL);       /* make certain we do die */
#endif
        eputs("signal - ");
        eputs(sigerr[signo]);
        eputs("\n");
        quit(3);
}


static void
sigdie(                 /* set fatal signal */
        int  signo,
        char  *msg
)
{
        if (signal(signo, onsig) == SIG_IGN)
                signal(signo, SIG_IGN);
        sigerr[signo] = msg;
}


static void
printdefaults(void)                     /* print default values to stdout */
{
        register char  *cp;

        if (imm_irrad)
                printf("-I+\t\t\t\t# immediate irradiance on\n");
        printf("-n %-2d\t\t\t\t# number of rendering processes\n", nproc);
        printf("-x %-9d\t\t\t# %s\n", hresolu,
                        vresolu && hresolu ? "x resolution" : "flush interval");
        printf("-y %-9d\t\t\t# y resolution\n", vresolu);
        printf(lim_dist ? "-ld+\t\t\t\t# limit distance on\n" :
                        "-ld-\t\t\t\t# limit distance off\n");
        printf("-h%c\t\t\t\t# %s header\n", loadflags & IO_INFO ? '+' : '-',
                        loadflags & IO_INFO ? "output" : "no");
        printf("-f%c%c\t\t\t\t# format input/output = %s/%s\n",
                        inform, outform, formstr(inform), formstr(outform));
        printf("-o%-9s\t\t\t# output", outvals);
        for (cp = outvals; *cp; cp++)
                switch (*cp) {
                case 't': case 'T': printf(" trace"); break;
                case 'o': printf(" origin"); break;
                case 'd': printf(" direction"); break;
                case 'r': printf(" reflect_contrib"); break;
                case 'R': printf(" reflect_length"); break;
                case 'x': printf(" unreflect_contrib"); break;
                case 'X': printf(" unreflect_length"); break;
                case 'v': printf(" value"); break;
                case 'V': printf(" contribution"); break;
                case 'l': printf(" length"); break;
                case 'L': printf(" first_length"); break;
                case 'p': printf(" point"); break;
                case 'n': printf(" normal"); break;
                case 'N': printf(" unperturbed_normal"); break;
                case 's': printf(" surface"); break;
                case 'w': printf(" weight"); break;
                case 'W': printf(" coefficient"); break;
                case 'm': printf(" modifier"); break;
                case 'M': printf(" material"); break;
                case '-': printf(" stroke"); break;
                }
        putchar('\n');
        printf(erract[WARNING].pf != NULL ?
                        "-w+\t\t\t\t# warning messages on\n" :
                        "-w-\t\t\t\t# warning messages off\n");
        print_rdefaults();
}
Revision:	2.30
Committed:	Wed Aug 14 20:07:20 2019 UTC (4 years, 9 months ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 2.29:	+3 -1 lines
Log Message:	Added BigEndian= line to binary header output
#	User	Rev	Content
1	greg	2.1	#ifndef lint
2	greg	2.30	static const char RCSid[] = "$Id: rtmain.c,v 2.29 2019/04/18 23:58:22 greg Exp $";
3	greg	2.1	#endif
4			/*
5			* rtmain.c - main for rtrace per-ray calculation program
6			*/
7
8	greg	2.2	#include "copyright.h"
9	greg	2.1
10	schorsch	2.4	#include <signal.h>
11
12			#include "platform.h"
13	schorsch	2.7	#include "rtprocess.h" /* getpid() */
14	schorsch	2.9	#include "resolu.h"
15	greg	2.1	#include "ray.h"
16			#include "source.h"
17			#include "ambient.h"
18			#include "random.h"
19			#include "paths.h"
20	greg	2.23	#include "pmapray.h"
21	greg	2.1
22	greg	2.18	extern char progname; / global argv[0] */
23
24			extern char shm_boundary; / boundary of shared memory */
25
26	greg	2.1	/* persistent processes define */
27			#ifdef F_SETLKW
28			#define PERSIST 1 /* normal persist */
29			#define PARALLEL 2 /* parallel persist */
30			#define PCHILD 3 /* child of normal persist */
31			#endif
32
33			char sigerr[NSIG]; / signal error messages */
34			char errfile = NULL; / error output file */
35
36	greg	2.18	int nproc = 1; /* number of processes */
37
38	greg	2.1	extern char formstr(); / string from format */
39	greg	2.18	int inform = 'a'; /* input format */
40			int outform = 'a'; /* output format */
41			char outvals = "v"; / output specification */
42	greg	2.1
43	greg	2.18	int hresolu = 0; /* horizontal (scan) size */
44			int vresolu = 0; /* vertical resolution */
45	greg	2.1
46	greg	2.18	int imm_irrad = 0; /* compute immediate irradiance? */
47			int lim_dist = 0; /* limit distance? */
48
49			#ifndef MAXMODLIST
50			#define MAXMODLIST 1024 /* maximum modifiers we'll track */
51			#endif
52	greg	2.1
53	greg	2.18	extern void (addobjnotify[])(); / object notification calls */
54			extern void tranotify(OBJECT obj);
55
56			char tralist[MAXMODLIST]; / list of modifers to trace (or no) */
57			int traincl = -1; /* include == 1, exclude == 0 */
58	greg	2.1
59	greg	2.10	static int loadflags = ~IO_FILES; /* what to load from octree */
60
61	schorsch	2.9	static void onsig(int signo);
62			static void sigdie(int signo, char *msg);
63			static void printdefaults(void);
64	greg	2.1
65
66			int
67	schorsch	2.9	main(int argc, char *argv[])
68	greg	2.1	{
69			#define check(ol,al) if (argv[i][ol] \|\| \
70			badarg(argc-i-1,argv+i+1,al)) \
71			goto badopt
72	schorsch	2.26	#define check_bool(olen,var) switch (argv[i][olen]) { \
73	greg	2.1	case '\0': var = !var; break; \
74			case 'y': case 'Y': case 't': case 'T': \
75			case '+': case '1': var = 1; break; \
76			case 'n': case 'N': case 'f': case 'F': \
77			case '-': case '0': var = 0; break; \
78			default: goto badopt; }
79	greg	2.25	extern char *octname;
80	greg	2.1	int persist = 0;
81	greg	2.18	char *octnm = NULL;
82	greg	2.22	char **tralp = NULL;
83			int duped1 = -1;
84	greg	2.1	int rval;
85			int i;
86			/* global program name */
87			progname = argv[0] = fixargv0(argv[0]);
88	greg	2.18	/* add trace notify function */
89			for (i = 0; addobjnotify[i] != NULL; i++)
90			;
91			addobjnotify[i] = tranotify;
92	greg	2.1	/* option city */
93			for (i = 1; i < argc; i++) {
94			/* expand arguments */
95			while ((rval = expandarg(&argc, &argv, i)) > 0)
96			;
97			if (rval < 0) {
98			sprintf(errmsg, "cannot expand '%s'", argv[i]);
99			error(SYSTEM, errmsg);
100			}
101			if (argv[i] == NULL \|\| argv[i][0] != '-')
102			break; /* break from options */
103			if (!strcmp(argv[i], "-version")) {
104			puts(VersionID);
105			quit(0);
106			}
107			if (!strcmp(argv[i], "-defaults") \|\|
108			!strcmp(argv[i], "-help")) {
109			printdefaults();
110			quit(0);
111			}
112			rval = getrenderopt(argc-i, argv+i);
113			if (rval >= 0) {
114			i += rval;
115			continue;
116			}
117			switch (argv[i][1]) {
118	greg	2.18	case 'n': /* number of cores */
119			check(2,"i");
120			nproc = atoi(argv[++i]);
121			if (nproc <= 0)
122			error(USER, "bad number of processes");
123			break;
124	greg	2.1	case 'x': /* x resolution */
125			check(2,"i");
126			hresolu = atoi(argv[++i]);
127			break;
128			case 'y': /* y resolution */
129			check(2,"i");
130			vresolu = atoi(argv[++i]);
131			break;
132			case 'w': /* warnings */
133			rval = erract[WARNING].pf != NULL;
134	schorsch	2.26	check_bool(2,rval);
135	greg	2.1	if (rval) erract[WARNING].pf = wputs;
136			else erract[WARNING].pf = NULL;
137			break;
138			case 'e': /* error file */
139			check(2,"s");
140			errfile = argv[++i];
141			break;
142			case 'l': /* limit distance */
143			if (argv[i][2] != 'd')
144			goto badopt;
145	schorsch	2.26	check_bool(3,lim_dist);
146	greg	2.1	break;
147			case 'I': /* immed. irradiance */
148	schorsch	2.26	check_bool(2,imm_irrad);
149	greg	2.1	break;
150			case 'f': /* format i/o */
151			switch (argv[i][2]) {
152			case 'a': /* ascii */
153			case 'f': /* float */
154			case 'd': /* double */
155			inform = argv[i][2];
156			break;
157			default:
158			goto badopt;
159			}
160			switch (argv[i][3]) {
161			case '\0':
162			outform = inform;
163			break;
164			case 'a': /* ascii */
165			case 'f': /* float */
166			case 'd': /* double */
167			case 'c': /* color */
168			check(4,"");
169			outform = argv[i][3];
170			break;
171			default:
172			goto badopt;
173			}
174			break;
175			case 'o': /* output */
176			outvals = argv[i]+2;
177			break;
178			case 'h': /* header output */
179			rval = loadflags & IO_INFO;
180	schorsch	2.26	check_bool(2,rval);
181	greg	2.1	loadflags = rval ? loadflags \| IO_INFO :
182			loadflags & ~IO_INFO;
183			break;
184			case 't': /* trace */
185			switch (argv[i][2]) {
186			case 'i': /* include */
187			case 'I':
188			check(3,"s");
189			if (traincl != 1) {
190			traincl = 1;
191			tralp = tralist;
192			}
193			if (argv[i][2] == 'I') { /* file */
194	greg	2.27	rval = wordfile(tralp, MAXMODLIST-(tralp-tralist),
195	greg	2.3	getpath(argv[++i],getrlibpath(),R_OK));
196	greg	2.1	if (rval < 0) {
197			sprintf(errmsg,
198			"cannot open trace include file \"%s\"",
199			argv[i]);
200			error(SYSTEM, errmsg);
201			}
202			tralp += rval;
203			} else {
204			*tralp++ = argv[++i];
205			*tralp = NULL;
206			}
207			break;
208			case 'e': /* exclude */
209			case 'E':
210			check(3,"s");
211			if (traincl != 0) {
212			traincl = 0;
213			tralp = tralist;
214			}
215			if (argv[i][2] == 'E') { /* file */
216	greg	2.27	rval = wordfile(tralp, MAXMODLIST-(tralp-tralist),
217	greg	2.3	getpath(argv[++i],getrlibpath(),R_OK));
218	greg	2.1	if (rval < 0) {
219			sprintf(errmsg,
220			"cannot open trace exclude file \"%s\"",
221			argv[i]);
222			error(SYSTEM, errmsg);
223			}
224			tralp += rval;
225			} else {
226			*tralp++ = argv[++i];
227			*tralp = NULL;
228			}
229			break;
230			default:
231			goto badopt;
232			}
233			break;
234			#ifdef PERSIST
235			case 'P': /* persist file */
236			if (argv[i][2] == 'P') {
237			check(3,"s");
238			persist = PARALLEL;
239			} else {
240			check(2,"s");
241			persist = PERSIST;
242			}
243			persistfile(argv[++i]);
244			break;
245			#endif
246			default:
247			goto badopt;
248			}
249			}
250	greg	2.18	if (nproc > 1) {
251			if (persist)
252			error(USER, "multiprocessing incompatible with persist file");
253	greg	2.21	if (!vresolu && hresolu > 0 && hresolu < nproc)
254	greg	2.18	error(WARNING, "number of cores should not exceed horizontal resolution");
255			if (trace != NULL)
256			error(WARNING, "multiprocessing does not work properly with trace mode");
257			}
258	greg	2.1	/* initialize object types */
259			initotypes();
260			/* initialize urand */
261	greg	2.14	if (rand_samp) {
262			srandom((long)time(0));
263			initurand(0);
264			} else {
265			srandom(0L);
266			initurand(2048);
267			}
268	greg	2.1	/* set up signal handling */
269			sigdie(SIGINT, "Interrupt");
270	schorsch	2.5	#ifdef SIGHUP
271	greg	2.1	sigdie(SIGHUP, "Hangup");
272	schorsch	2.5	#endif
273	greg	2.1	sigdie(SIGTERM, "Terminate");
274	schorsch	2.5	#ifdef SIGPIPE
275	greg	2.1	sigdie(SIGPIPE, "Broken pipe");
276	schorsch	2.5	#endif
277			#ifdef SIGALRM
278	greg	2.1	sigdie(SIGALRM, "Alarm clock");
279	schorsch	2.5	#endif
280	greg	2.1	#ifdef SIGXCPU
281			sigdie(SIGXCPU, "CPU limit exceeded");
282			sigdie(SIGXFSZ, "File size exceeded");
283			#endif
284			/* open error file */
285			if (errfile != NULL) {
286			if (freopen(errfile, "a", stderr) == NULL)
287			quit(2);
288			fprintf(stderr, "************\n* PID %5d: ",
289			getpid());
290			printargs(argc, argv, stderr);
291			putc('\n', stderr);
292			fflush(stderr);
293			}
294			#ifdef NICE
295			nice(NICE); /* lower priority */
296			#endif
297			/* get octree */
298			if (i == argc)
299	greg	2.18	octnm = NULL;
300	greg	2.1	else if (i == argc-1)
301	greg	2.18	octnm = argv[i];
302	greg	2.1	else
303			goto badopt;
304	greg	2.18	if (octnm == NULL)
305	greg	2.1	error(USER, "missing octree argument");
306			/* set up output */
307			#ifdef PERSIST
308			if (persist) {
309			duped1 = dup(fileno(stdout)); /* don't lose our output */
310			openheader();
311			}
312			#endif
313			if (outform != 'a')
314	schorsch	2.4	SET_FILE_BINARY(stdout);
315	greg	2.24	readoct(octname = octnm, loadflags, &thescene, NULL);
316	greg	2.1	nsceneobjs = nobjects;
317
318			if (loadflags & IO_INFO) { /* print header */
319			printargs(i, argv, stdout);
320			printf("SOFTWARE= %s\n", VersionID);
321			fputnow(stdout);
322	greg	2.30	if ((outform == 'f') \| (outform == 'd'))
323			fputendian(stdout);
324	greg	2.1	fputformat(formstr(outform), stdout);
325			putchar('\n');
326			}
327	greg	2.23
328			ray_init_pmap(); /* PMAP: set up & load photon maps */
329
330	greg	2.1	marksources(); /* find and mark sources */
331
332			setambient(); /* initialize ambient calculation */
333	greg	2.23
334	greg	2.1	#ifdef PERSIST
335			if (persist) {
336			fflush(stdout);
337			/* reconnect stdout */
338			dup2(duped1, fileno(stdout));
339			close(duped1);
340			if (persist == PARALLEL) { /* multiprocessing */
341			preload_objs(); /* preload scene */
342			shm_boundary = (char *)malloc(16);
343			strcpy(shm_boundary, "SHM_BOUNDARY");
344			while ((rval=fork()) == 0) { /* keep on forkin' */
345			pflock(1);
346			pfhold();
347	greg	2.15	ambsync(); /* load new values */
348	greg	2.1	}
349			if (rval < 0)
350			error(SYSTEM, "cannot fork child for persist function");
351	greg	2.15	pfdetach(); /* parent will run then exit */
352	greg	2.1	}
353			}
354			runagain:
355			if (persist)
356			dupheader(); /* send header to stdout */
357			#endif
358			/* trace rays */
359	greg	2.19	rtrace(NULL, nproc);
360	greg	2.1	/* flush ambient file */
361			ambsync();
362			#ifdef PERSIST
363			if (persist == PERSIST) { /* first run-through */
364			if ((rval=fork()) == 0) { /* child loops until killed */
365			pflock(1);
366			persist = PCHILD;
367			} else { /* original process exits */
368			if (rval < 0)
369			error(SYSTEM, "cannot fork child for persist function");
370			pfdetach(); /* parent exits */
371			}
372			}
373			if (persist == PCHILD) { /* wait for a signal then go again */
374			pfhold();
375			raynum = nrays = 0; /* reinitialize */
376			goto runagain;
377			}
378			#endif
379	greg	2.23
380			ray_done_pmap(); /* PMAP: free photon maps */
381
382	greg	2.1	quit(0);
383
384			badopt:
385			sprintf(errmsg, "command line error at '%s'", argv[i]);
386			error(USER, errmsg);
387	schorsch	2.9	return 1; /* pro forma return */
388	greg	2.1
389			#undef check
390	schorsch	2.26	#undef check_bool
391	greg	2.1	}
392
393
394			void
395	schorsch	2.9	wputs( /* warning output function */
396			char *s
397			)
398	greg	2.1	{
399			int lasterrno = errno;
400			eputs(s);
401			errno = lasterrno;
402			}
403
404
405			void
406	schorsch	2.9	eputs( /* put string to stderr */
407			register char *s
408			)
409	greg	2.1	{
410			static int midline = 0;
411
412			if (!*s)
413			return;
414			if (!midline++) {
415			fputs(progname, stderr);
416			fputs(": ", stderr);
417			}
418			fputs(s, stderr);
419			if (s[strlen(s)-1] == '\n') {
420			fflush(stderr);
421			midline = 0;
422			}
423			}
424
425
426	schorsch	2.9	static void
427			onsig( /* fatal signal */
428			int signo
429			)
430	greg	2.1	{
431			static int gotsig = 0;
432
433			if (gotsig++) /* two signals and we're gone! */
434			_exit(signo);
435
436	schorsch	2.5	#ifdef SIGALRM
437	greg	2.1	alarm(15); /* allow 15 seconds to clean up */
438			signal(SIGALRM, SIG_DFL); /* make certain we do die */
439	schorsch	2.5	#endif
440	greg	2.1	eputs("signal - ");
441			eputs(sigerr[signo]);
442			eputs("\n");
443			quit(3);
444			}
445
446
447	schorsch	2.9	static void
448			sigdie( /* set fatal signal */
449			int signo,
450			char *msg
451			)
452	greg	2.1	{
453			if (signal(signo, onsig) == SIG_IGN)
454			signal(signo, SIG_IGN);
455			sigerr[signo] = msg;
456			}
457
458
459	schorsch	2.9	static void
460	schorsch	2.8	printdefaults(void) /* print default values to stdout */
461	greg	2.1	{
462			register char *cp;
463
464			if (imm_irrad)
465			printf("-I+\t\t\t\t# immediate irradiance on\n");
466	greg	2.18	printf("-n %-2d\t\t\t\t# number of rendering processes\n", nproc);
467	greg	2.21	printf("-x %-9d\t\t\t# %s\n", hresolu,
468			vresolu && hresolu ? "x resolution" : "flush interval");
469	greg	2.16	printf("-y %-9d\t\t\t# y resolution\n", vresolu);
470	greg	2.1	printf(lim_dist ? "-ld+\t\t\t\t# limit distance on\n" :
471			"-ld-\t\t\t\t# limit distance off\n");
472	greg	2.10	printf("-h%c\t\t\t\t# %s header\n", loadflags & IO_INFO ? '+' : '-',
473			loadflags & IO_INFO ? "output" : "no");
474	greg	2.1	printf("-f%c%c\t\t\t\t# format input/output = %s/%s\n",
475			inform, outform, formstr(inform), formstr(outform));
476	greg	2.10	printf("-o%-9s\t\t\t# output", outvals);
477	greg	2.1	for (cp = outvals; *cp; cp++)
478			switch (*cp) {
479	greg	2.10	case 't': case 'T': printf(" trace"); break;
480	greg	2.1	case 'o': printf(" origin"); break;
481			case 'd': printf(" direction"); break;
482	greg	2.28	case 'r': printf(" reflect_contrib"); break;
483			case 'R': printf(" reflect_length"); break;
484			case 'x': printf(" unreflect_contrib"); break;
485			case 'X': printf(" unreflect_length"); break;
486	greg	2.1	case 'v': printf(" value"); break;
487	greg	2.13	case 'V': printf(" contribution"); break;
488	greg	2.1	case 'l': printf(" length"); break;
489			case 'L': printf(" first_length"); break;
490			case 'p': printf(" point"); break;
491			case 'n': printf(" normal"); break;
492			case 'N': printf(" unperturbed_normal"); break;
493			case 's': printf(" surface"); break;
494			case 'w': printf(" weight"); break;
495	greg	2.13	case 'W': printf(" coefficient"); break;
496	greg	2.1	case 'm': printf(" modifier"); break;
497	greg	2.10	case 'M': printf(" material"); break;
498			case '-': printf(" stroke"); break;
499	greg	2.1	}
500			putchar('\n');
501			printf(erract[WARNING].pf != NULL ?
502			"-w+\t\t\t\t# warning messages on\n" :
503			"-w-\t\t\t\t# warning messages off\n");
504			print_rdefaults();
505			}