ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/Development/ray/src/cal/rcalc.c

Comparing ray/src/cal/rcalc.c (file contents):
Revision 1.1 by greg, Sat Feb 22 02:07:20 2003 UTC vs.
Revision 1.24 by greg, Sat May 10 01:27:14 2014 UTC

#	Line 1 | Line 1
1		#ifndef lint
2	<	static const char       RCSid[] = "$Id$";
2	>	static const char RCSid[] = "$Id$";
3		#endif
4		/*
5		*  rcalc.c - record calculator program.
#	Line 7 | Line 7 | static const char      RCSid[] = "$Id$";
7		*     9/11/87
8		*/
9
10	–	#include  <stdio.h>
11	–
10		#include  <stdlib.h>
13	–
11		#include  <math.h>
15	–
12		#include  <ctype.h>
13
14	+	#include  "platform.h"
15	+	#include  "rterror.h"
16	+	#include  "rtmisc.h"
17	+	#include  "rtio.h"
18		#include  "calcomp.h"
19
20	–	#ifdef  CPM
21	–	#define  getc           agetc   /* text files only, right? */
22	–	#endif
23	–
20		#define  isnum(c)       (isdigit(c) || (c)=='-' || (c)=='.' \
21		|| (c)=='+' || (c)=='e' || (c)=='E')
22
23		#define  isblnk(c)      (igneol ? isspace(c) : (c)==' '||(c)=='\t')
24
25	<	#define  INBSIZ         4096    /* longest record */
25	>	#define  INBSIZ         16384   /* longest record */
26		#define  MAXCOL         32      /* number of columns recorded */
27
28		/* field type specifications */
#	Line 58 | Line 54 | struct field {                  /* record format struc
54		#define  savqstr(s)     strcpy(emalloc(strlen(s)+1),s)
55		#define  freqstr(s)     efree(s)
56
57	<	extern char  *strcpy(), *emalloc(), *savestr();
58	<	struct strvar  *getsvar();
57	>	static int getinputrec(FILE *fp);
58	>	static void scaninp(void), advinp(void), resetinp(void);
59	>	static void putrec(void), putout(void), nbsynch(void);
60	>	static int getrec(void);
61	>	static void execute(char *file);
62	>	static void initinp(FILE *fp);
63	>	static void svpreset(char *eqn);
64	>	static void readfmt(char *spec, int output);
65	>	static int readfield(char **pp);
66	>	static int getfield(struct field *f);
67	>	static void chanset(int n, double v);
68	>	static void bchanset(int n, double v);
69	>	static struct strvar* getsvar(char *svname);
70	>	static double l_in(char *);
71
72		struct field  *inpfmt = NULL;   /* input record format */
73		struct field  *outfmt = NULL;   /* output record structure */
#	Line 67 | Line 75 | struct strvar  *svhead = NULL;  /* string variables */
75
76		int  blnkeq = 1;                /* blanks compare equal? */
77		int  igneol = 0;                /* ignore end of line? */
78	+	int  passive = 0;               /* passive mode (transmit unmatched input) */
79		char  sepchar = '\t';           /* input/output separator */
80		int  noinput = 0;               /* no input records? */
81	+	int  itype = 'a';               /* input type (a/f/F/d/D) */
82	+	int  nbicols = 0;               /* number of binary input columns */
83	+	int  otype = 'a';               /* output format (a/f/F/d/D) */
84		char  inpbuf[INBSIZ];           /* input buffer */
85		double  colval[MAXCOL];         /* input column values */
86		unsigned long  colflg = 0;      /* column retrieved flags */
#	Line 86 | Line 98 | struct {
98		} ipb;                          /* circular lookahead buffer */
99
100
101	<	main(argc, argv)
102	<	int  argc;
103	<	char  *argv[];
101	>	int
102	>	main(
103	>	int  argc,
104	>	char  *argv[]
105	>	)
106		{
107	+	char  *fpath;
108		int  i;
109
110	<	esupport |= (E_VARIABLE|E_FUNCTION|E_INCHAN|E_OUTCHAN|E_RCONST);
110	>	esupport |= E_VARIABLE|E_FUNCTION|E_INCHAN|E_OUTCHAN|E_RCONST;
111	>	esupport &= ~(E_REDEFW);
112
113		#ifdef  BIGGERLIB
114		biggerlib();
115		#endif
116		varset("PI", ':', 3.14159265358979323846);
117	+	funset("in", 1, '=', &l_in);
118
119		for (i = 1; i < argc && argv[i][0] == '-'; i++)
120		switch (argv[i][1]) {
#	Line 107 | Line 124 | char  *argv[];
124		case 'l':
125		igneol = !igneol;
126		break;
127	+	case 'p':
128	+	passive = !passive;
129	+	break;
130		case 't':
131		sepchar = argv[i][2];
132		break;
#	Line 114 | Line 134 | char  *argv[];
134		svpreset(argv[++i]);
135		break;
136		case 'f':
137	<	fcompile(argv[++i]);
137	>	fpath = getpath(argv[++i], getrlibpath(), 0);
138	>	if (fpath == NULL) {
139	>	eputs(argv[0]);
140	>	eputs(": cannot find file '");
141	>	eputs(argv[i]);
142	>	eputs("'\n");
143	>	quit(1);
144	>	}
145	>	fcompile(fpath);
146		break;
147		case 'e':
148		scompile(argv[++i], NULL, 0);
#	Line 123 | Line 151 | char  *argv[];
151		noinput = 1;
152		break;
153		case 'i':
154	<	readfmt(argv[++i], 0);
154	>	switch (argv[i][2]) {
155	>	case '\0':
156	>	itype = 'a';
157	>	nbicols = 0;
158	>	readfmt(argv[++i], 0);
159	>	break;
160	>	case 'a':
161	>	itype = 'a';
162	>	nbicols = 0;
163	>	break;
164	>	case 'd':
165	>	case 'D':
166	>	itype = argv[i][2];
167	>	if (isdigit(argv[i][3]))
168	>	nbicols = atoi(argv[i]+3);
169	>	else
170	>	nbicols = 1;
171	>	if (nbicols*sizeof(double) > INBSIZ) {
172	>	eputs(argv[0]);
173	>	eputs(": too many input columns\n");
174	>	quit(1);
175	>	}
176	>	break;
177	>	case 'f':
178	>	case 'F':
179	>	itype = argv[i][2];
180	>	if (isdigit(argv[i][3]))
181	>	nbicols = atoi(argv[i]+3);
182	>	else
183	>	nbicols = 1;
184	>	if (nbicols*sizeof(float) > INBSIZ) {
185	>	eputs(argv[0]);
186	>	eputs(": too many input columns\n");
187	>	quit(1);
188	>	}
189	>	break;
190	>	default:
191	>	goto userr;
192	>	}
193		break;
194		case 'o':
195	<	readfmt(argv[++i], 1);
195	>	switch (argv[i][2]) {
196	>	case '\0':
197	>	otype = 'a';
198	>	readfmt(argv[++i], 1);
199	>	break;
200	>	case 'a':
201	>	otype = 'a';
202	>	break;
203	>	case 'd':
204	>	case 'D':
205	>	case 'f':
206	>	case 'F':
207	>	otype = argv[i][2];
208	>	break;
209	>	default:
210	>	goto userr;
211	>	}
212		break;
213		case 'w':
214		nowarn = !nowarn;
#	Line 134 | Line 216 | char  *argv[];
216		case 'u':
217		unbuff = !unbuff;
218		break;
219	<	default:
219	>	default:;
220	>	userr:
221		eputs("Usage: ");
222		eputs(argv[0]);
223	<	eputs(" [-b][-l][-n][-w][-u][-tS][-s svar=sval][-e expr][-f source][-i infmt][-o outfmt] [file]\n");
223	>	eputs(" [-b][-l][-n][-p][-w][-u][-tS][-s svar=sval][-e expr][-f source][-i infmt][-o outfmt] [file]\n");
224		quit(1);
225		}
226	<
226	>	if (otype != 'a')
227	>	SET_FILE_BINARY(stdout);
228	>	#ifdef getc_unlocked            /* avoid lock/unlock overhead */
229	>	flockfile(stdout);
230	>	#endif
231		if (noinput) {          /* produce a single output record */
232	+	if (i < argc) {
233	+	eputs(argv[0]);
234	+	eputs(": file argument(s) incompatible with -n\n");
235	+	quit(1);
236	+	}
237		eclock++;
238		putout();
239		quit(0);
240		}
149	–
241		if (blnkeq)             /* for efficiency */
242		nbsynch();
243
#	Line 157 | Line 248 | eputs(" [-b][-l][-n][-w][-u][-tS][-s svar=sval][-e exp
248		execute(argv[i]);
249
250		quit(0);
251	+	return 0; /* pro forma return */
252		}
253
254
255	<	nbsynch()               /* non-blank starting synch character */
255	>	static void
256	>	nbsynch(void)               /* non-blank starting synch character */
257		{
258		if (inpfmt == NULL || (inpfmt->type & F_TYP) != T_LIT)
259		return;
#	Line 171 | Line 264 | nbsynch()               /* non-blank starting synch ch
264		}
265
266
267	<	execute(file)           /* process a file */
268	<	char  *file;
267	>	static int
268	>	getinputrec(            /* get next input record */
269	>	FILE  *fp
270	>	)
271		{
272	+	if (inpfmt != NULL)
273	+	return(getrec());
274	+	if (tolower(itype) == 'd') {
275	+	if (fread(inpbuf, sizeof(double), nbicols, fp) != nbicols)
276	+	return(0);
277	+	if (itype == 'D')
278	+	swap64(inpbuf, nbicols);
279	+	return(1);
280	+	}
281	+	if (tolower(itype) == 'f') {
282	+	if (fread(inpbuf, sizeof(float), nbicols, fp) != nbicols)
283	+	return(0);
284	+	if (itype == 'F')
285	+	swap32(inpbuf, nbicols);
286	+	return(1);
287	+	}
288	+	return(fgets(inpbuf, INBSIZ, fp) != NULL);
289	+	}
290	+
291	+
292	+	static void
293	+	execute(           /* process a file */
294	+	char  *file
295	+	)
296	+	{
297		int  conditional = vardefined("cond");
298		long  nrecs = 0;
299		long  nout = 0;
#	Line 186 | Line 306 | char  *file;
306		eputs(": cannot open\n");
307		quit(1);
308		}
309	+	if (itype != 'a')
310	+	SET_FILE_BINARY(fp);
311	+	#ifdef getc_unlocked            /* avoid lock/unlock overhead */
312	+	flockfile(fp);
313	+	#endif
314		if (inpfmt != NULL)
315		initinp(fp);
316	<
317	<	while (inpfmt != NULL ? getrec() : fgets(inpbuf, INBSIZ, fp) != NULL) {
316	>
317	>	while (getinputrec(fp)) {
318		varset("recno", '=', (double)++nrecs);
319	+	varset("outno", '=', (double)(nout+1));
320		colflg = 0;
321		eclock++;
322		if (!conditional || varvalue("cond") > 0.0) {
197	–	varset("outno", '=', (double)++nout);
323		putout();
324	+	++nout;
325		}
326		}
327		fclose(fp);
328		}
329
330
331	<	putout()                /* produce an output record */
331	>	static void
332	>	putout(void)                /* produce an output record */
333		{
207	–	extern int  chanset();
334
335		colpos = 0;
336		if (outfmt != NULL)
337		putrec();
338	<	else
338	>	else if (otype == 'a')
339		chanout(chanset);
340	<	if (colpos)
340	>	else
341	>	chanout(bchanset);
342	>	if (colpos && otype == 'a')
343		putchar('\n');
344		if (unbuff)
345		fflush(stdout);
346		}
347
348
349	+	static double
350	+	l_in(char *funame)      /* function call for $channel */
351	+	{
352	+	int  n;
353	+	char  *cp;
354	+	/* get argument as integer */
355	+	n = (int)(argument(1) + .5);
356	+	if (n != 0)     /* return channel value */
357	+	return(chanvalue(n));
358	+	/* determine number of channels */
359	+	if (noinput || inpfmt != NULL)
360	+	return(0);
361	+	if (nbicols)
362	+	return(nbicols);
363	+	cp = inpbuf;    /* need to count */
364	+	for (n = 0; *cp; )
365	+	if (blnkeq && isspace(sepchar)) {
366	+	while (isspace(*cp))
367	+	cp++;
368	+	n += *cp != '\0';
369	+	while (*cp && !isspace(*cp))
370	+	cp++;
371	+	} else {
372	+	n += *cp != '\n';
373	+	while (*cp && *cp++ != sepchar)
374	+	;
375	+	}
376	+	return(n);
377	+	}
378	+
379		double
380	<	chanvalue(n)            /* return value for column n */
381	<	int  n;
380	>	chanvalue(            /* return value for column n */
381	>	int  n
382	>	)
383		{
384		int  i;
385	<	register char  *cp;
385	>	char  *cp;
386
387		if (noinput || inpfmt != NULL) {
388		eputs("no column input\n");
#	Line 233 | Line 392 | int  n;
392		eputs("illegal channel number\n");
393		quit(1);
394		}
395	+	if (nbicols) {
396	+	if (n > nbicols)
397	+	return(0.0);
398	+	if (tolower(itype) == 'd') {
399	+	cp = inpbuf + (n-1)*sizeof(double);
400	+	return(*(double *)cp);
401	+	}
402	+	cp = inpbuf + (n-1)*sizeof(float);
403	+	return(*(float *)cp);
404	+	}
405		if (n <= MAXCOL && colflg & 1L<<(n-1))
406		return(colval[n-1]);
407
#	Line 258 | Line 427 | int  n;
427		}
428
429
430	<	chanset(n, v)                   /* output column n */
431	<	int  n;
432	<	double  v;
430	>	void
431	>	chanset(                   /* output column n */
432	>	int  n,
433	>	double  v
434	>	)
435		{
436		if (colpos == 0)                /* no leading separator */
437		colpos = 1;
#	Line 272 | Line 443 | double  v;
443		}
444
445
446	<	readfmt(spec, output)                   /* read record format */
447	<	char  *spec;
448	<	int  output;
446	>	void
447	>	bchanset(                   /* output binary channel n */
448	>	int  n,
449	>	double  v
450	>	)
451		{
452	+	static char     zerobuf[sizeof(double)];
453	+	float   fval = v;
454	+
455	+	while (++colpos < n)
456	+	fwrite(zerobuf,
457	+	tolower(otype)=='d' ? sizeof(double) : sizeof(float),
458	+	1, stdout);
459	+	switch (otype) {
460	+	case 'D':
461	+	swap64((char *)&v, 1);
462	+	/* fall through */
463	+	case 'd':
464	+	fwrite(&v, sizeof(double), 1, stdout);
465	+	break;
466	+	case 'F':
467	+	swap32((char *)&fval, 1);
468	+	/* fall through */
469	+	case 'f':
470	+	fwrite(&fval, sizeof(float), 1, stdout);
471	+	break;
472	+	}
473	+	}
474	+
475	+
476	+	static void
477	+	readfmt(                   /* read record format */
478	+	char  *spec,
479	+	int  output
480	+	)
481	+	{
482		int  fd;
483		char  *inptr;
484		struct field  fmt;
485		int  res;
486	<	register struct field  *f;
486	>	struct field  *f;
487		/* check for inline format */
488		for (inptr = spec; *inptr; inptr++)
489		if (*inptr == '$')
#	Line 293 | Line 496 | int  output;
496		eputs(": cannot open\n");
497		quit(1);
498		}
499	<	res = read(fd, inpbuf+1, INBSIZ-1);
499	>	res = read(fd, inpbuf+2, INBSIZ-2);
500		if (res <= 0 || res >= INBSIZ-1) {
501		eputs(spec);
502		if (res < 0)
#	Line 305 | Line 508 | int  output;
508		quit(1);
509		}
510		close(fd);
511	<	(inptr=inpbuf+1)[res] = '\0';
511	>	(inptr=inpbuf+2)[res] = '\0';
512		}
513		f = &fmt;                               /* get fields */
514		while ((res = readfield(&inptr)) != F_NUL) {
#	Line 338 | Line 541 | int  output;
541		}
542
543
544	<	int
545	<	readfield(pp)                   /* get next field in format */
546	<	register char  **pp;
544	>	static int
545	>	readfield(                   /* get next field in format */
546	>	char  **pp
547	>	)
548		{
549		int  type = F_NUL;
550		int  width = 0;
551	<	register char  *cp;
551	>	char  *cp;
552
553		cp = inpbuf;
554		while (cp < &inpbuf[INBSIZ-1] && **pp != '\0') {
#	Line 405 | Line 609 | register char  **pp;
609
610
611		struct strvar *
612	<	getsvar(svname)                         /* get string variable */
613	<	char  *svname;
612	>	getsvar(                         /* get string variable */
613	>	char  *svname
614	>	)
615		{
616	<	register struct strvar  *sv;
616	>	struct strvar  *sv;
617
618		for (sv = svhead; sv != NULL; sv = sv->next)
619		if (!strcmp(sv->name, svname))
#	Line 422 | Line 627 | char  *svname;
627		}
628
629
630	<	svpreset(eqn)                    /* preset a string variable */
631	<	char  *eqn;
630	>	static void
631	>	svpreset(                    /* preset a string variable */
632	>	char  *eqn
633	>	)
634		{
635	<	register struct strvar  *sv;
636	<	register char  *val;
635	>	struct strvar  *sv;
636	>	char  *val;
637
638		for (val = eqn; *val != '='; val++)
639		if (!*val)
#	Line 442 | Line 649 | char  *eqn;
649		}
650
651
652	<	clearrec()                      /* clear input record variables */
652	>	static void
653	>	clearrec(void)                  /* clear input record variables */
654		{
655	<	register struct field  *f;
655	>	struct field  *f;
656
657		for (f = inpfmt; f != NULL; f = f->next)
658		switch (f->type & F_TYP) {
#	Line 461 | Line 669 | clearrec()                     /* clear input record variables */
669		}
670
671
672	<	getrec()                                /* get next record from file */
672	>	static int
673	>	getrec(void)                            /* get next record from file */
674		{
675		int  eatline;
676	<	register struct field  *f;
677	<
676	>	struct field  *f;
677	>
678		while (ipb.chr != EOF) {
679	<	eatline = !igneol && ipb.chr != '\n';
471	<	if (blnkeq)             /* beware of nbsynch() */
679	>	if (blnkeq) {           /* beware of nbsynch() */
680		while (isblnk(ipb.chr))
681	<	scaninp();
681	>	resetinp();
682	>	if (ipb.chr == EOF)
683	>	return(0);
684	>	}
685	>	eatline = (!igneol && ipb.chr != '\n');
686		clearrec();             /* start with fresh record */
687		for (f = inpfmt; f != NULL; f = f->next)
688		if (getfield(f) == -1)
689		break;
690		if (f == NULL) {
691	<	advinp();
691	>	advinp();       /* got one! */
692		return(1);
693		}
694	<	resetinp();
694	>	resetinp();             /* eat false start */
695		if (eatline) {          /* eat rest of line */
696		while (ipb.chr != '\n') {
697		if (ipb.chr == EOF)
698		return(0);
699	<	scaninp();
699	>	resetinp();
700		}
701	<	scaninp();
490	<	advinp();
701	>	resetinp();
702		}
703		}
704		return(0);
705		}
706
707
708	<	getfield(f)                             /* get next field */
709	<	register struct field  *f;
708	>	static int
709	>	getfield(                             /* get next field */
710	>	struct field  *f
711	>	)
712		{
713	<	static char  buf[MAXWORD+1];            /* no recursion! */
713	>	static char  buf[RMAXWORD+1];            /* no recursion! */
714		int  delim, inword;
715		double  d;
716		char  *np;
717	<	register char  *cp;
717	>	char  *cp;
718
719		switch (f->type & F_TYP) {
720		case T_LIT:
#	Line 530 | Line 743 | register struct field  *f;
743		delim = f->next->f.sl[0];
744		cp = buf;
745		do {
746	<	if (ipb.chr == EOF)
746	>	if (ipb.chr == EOF || ipb.chr == '\n')
747		inword = 0;
748		else if (blnkeq && delim != EOF)
749		inword = isblnk(delim) ?
#	Line 542 | Line 755 | register struct field  *f;
755		*cp++ = ipb.chr;
756		scaninp();
757		}
758	<	} while (inword && cp < &buf[MAXWORD]);
758	>	} while (inword && cp < &buf[RMAXWORD]);
759		*cp = '\0';
760		if (f->f.sv->val == NULL)
761		f->f.sv->val = savqstr(buf);    /* first setting */
#	Line 571 | Line 784 | register struct field  *f;
784		*cp++ = ipb.chr;
785		scaninp();
786		}
787	<	} while (inword && cp < &buf[MAXWORD]);
787	>	} while (inword && cp < &buf[RMAXWORD]);
788		*cp = '\0';
789		d = np==NULL ? 0. : atof(np);
790		if (!vardefined(f->f.nv))
#	Line 581 | Line 794 | register struct field  *f;
794		return(-1);                     /* doesn't match! */
795		return(0);
796		}
797	+	return -1; /* pro forma return */
798		}
799
800
801	<	putrec()                                /* output a record */
801	>	static void
802	>	putrec(void)                                /* output a record */
803		{
804	<	char  fmt[32];
805	<	register int  n;
806	<	register struct field  *f;
804	>	char  fmt[32], typ[32];
805	>	int  n;
806	>	struct field  *f;
807		int  adlast, adnext;
808	+	double  dv, av;
809
810		adlast = 0;
811		for (f = outfmt; f != NULL; f = f->next) {
#	Line 620 | Line 836 | putrec()                                /* output a re
836		break;
837		case T_NUM:
838		n = f->type & F_WID;
839	+	typ[0] = (n <= 6) ? 'g' : 'e';
840	+	typ[1] = '\0';
841	+	dv = evalue(f->f.ne);
842	+	if ((av = fabs(dv)) < 1L<<31) {
843	+	long    iv = (int)(av + .5);
844	+	if (iv && fabs(av-iv) <= av*1e-14)
845	+	strcpy(typ, ".0f");
846	+	}
847		if (adlast && adnext)
848	<	strcpy(fmt, "%g");
848	>	sprintf(fmt, "%%%s", typ);
849		else if (adlast)
850	<	sprintf(fmt, "%%-%dg", n);
850	>	sprintf(fmt, "%%-%d%s", n, typ);
851		else
852	<	sprintf(fmt, "%%%dg", n);
853	<	printf(fmt, evalue(f->f.ne));
852	>	sprintf(fmt, "%%%d%s", n, typ);
853	>	printf(fmt, dv);
854		adlast = 1;
855		break;
856		}
#	Line 634 | Line 858 | putrec()                                /* output a re
858		}
859
860
861	<	initinp(fp)                     /* prepare lookahead buffer */
862	<	FILE  *fp;
861	>	static void
862	>	initinp(FILE  *fp)                     /* prepare lookahead buffer */
863	>
864		{
865		ipb.fin = fp;
866		ipb.beg = ipb.end = inpbuf;
#	Line 645 | Line 870 | FILE  *fp;
870		}
871
872
873	<	scaninp()                       /* scan next character */
873	>	static void
874	>	scaninp(void)                       /* scan next character */
875		{
876		if (ipb.chr == EOF)
877		return;
#	Line 664 | Line 890 | scaninp()                       /* scan next character
890		}
891
892
893	<	advinp()                        /* move home to current position */
893	>	static void
894	>	advinp(void)                        /* move home to current position */
895		{
896		ipb.beg = ipb.pos;
897		}
898
899
900	<	resetinp()                      /* rewind position and advance 1 */
900	>	static void
901	>	resetinp(void)                      /* rewind position and advance 1 */
902		{
903		if (ipb.beg == NULL)            /* full */
904		ipb.beg = ipb.end;
905		ipb.pos = ipb.beg;
906		ipb.chr = *ipb.pos;
907	+	if (passive)                    /* transmit unmatched character? */
908	+	fputc(ipb.chr, stdout);
909		if (++ipb.beg >= &inpbuf[INBSIZ])
910		ipb.beg = inpbuf;
911		scaninp();
#	Line 683 | Line 913 | resetinp()                      /* rewind position and
913
914
915		void
916	<	eputs(msg)
687	<	char  *msg;
916	>	eputs(char  *msg)
917		{
918		fputs(msg, stderr);
919		}
920
921
922		void
923	<	wputs(msg)
695	<	char  *msg;
923	>	wputs(char  *msg)
924		{
925		if (!nowarn)
926		eputs(msg);
#	Line 700 | Line 928 | char  *msg;
928
929
930		void
931	<	quit(code)
704	<	int  code;
931	>	quit(int  code)
932		{
933		exit(code);
934		}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)