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.13 by greg, Wed Jun 9 16:00:13 2004 UTC vs.
Revision 1.24 by greg, Sat May 10 01:27:14 2014 UTC

#	Line 8 | Line 8 | static const char RCSid[] = "$Id$";
8		*/
9
10		#include  <stdlib.h>
11	–	#include  <fcntl.h>
12	–	#include  <stdio.h>
13	–	#include  <string.h>
11		#include  <math.h>
12		#include  <ctype.h>
13
#	Line 25 | Line 22 | static const char RCSid[] = "$Id$";
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 81 | Line 78 | 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  bocols = 0;                /* produce binary output 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 106 | Line 104 | 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;
#	Line 135 | 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 146 | Line 153 | char  *argv[]
153		case 'i':
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
#	Line 164 | Line 175 | char  *argv[]
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);
181	>	nbicols = atoi(argv[i]+3);
182		else
183	<	nbicols = -1;
184	<	if (-nbicols*sizeof(float) > INBSIZ) {
183	>	nbicols = 1;
184	>	if (nbicols*sizeof(float) > INBSIZ) {
185		eputs(argv[0]);
186		eputs(": too many input columns\n");
187		quit(1);
#	Line 181 | Line 194 | char  *argv[]
194		case 'o':
195		switch (argv[i][2]) {
196		case '\0':
197	<	bocols = 0;
197	>	otype = 'a';
198		readfmt(argv[++i], 1);
199		break;
200		case 'a':
201	<	bocols = 0;
201	>	otype = 'a';
202		break;
203		case 'd':
204	<	bocols = 1;
192	<	break;
204	>	case 'D':
205		case 'f':
206	<	bocols = -1;
206	>	case 'F':
207	>	otype = argv[i][2];
208		break;
209	+	default:
210	+	goto userr;
211		}
212		break;
213		case 'w':
#	Line 208 | Line 223 | char  *argv[]
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		}
217	–
241		if (blnkeq)             /* for efficiency */
242		nbsynch();
243
#	Line 248 | Line 271 | FILE  *fp
271		{
272		if (inpfmt != NULL)
273		return(getrec());
274	<	if (nbicols > 0)
275	<	return(fread(inpbuf, sizeof(double),
276	<	nbicols, fp) == nbicols);
277	<	if (nbicols < 0)
278	<	return(fread(inpbuf, sizeof(float),
279	<	-nbicols, fp) == -nbicols);
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
#	Line 275 | 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 (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) {
286	–	varset("outno", '=', (double)++nout);
323		putout();
324	+	++nout;
325		}
326		}
327		fclose(fp);
#	Line 298 | Line 335 | putout(void)                /* produce an output recor
335		colpos = 0;
336		if (outfmt != NULL)
337		putrec();
338	<	else if (bocols)
302	<	chanout(bchanset);
303	<	else
338	>	else if (otype == 'a')
339		chanout(chanset);
340	<	if (colpos && !bocols)
340	>	else
341	>	chanout(bchanset);
342	>	if (colpos && otype == 'a')
343		putchar('\n');
344		if (unbuff)
345		fflush(stdout);
#	Line 313 | Line 350 | static double
350		l_in(char *funame)      /* function call for $channel */
351		{
352		int  n;
353	<	register char  *cp;
353	>	char  *cp;
354		/* get argument as integer */
355		n = (int)(argument(1) + .5);
356		if (n != 0)     /* return channel value */
#	Line 321 | Line 358 | l_in(char *funame)     /* function call for $channel */
358		/* determine number of channels */
359		if (noinput || inpfmt != NULL)
360		return(0);
361	<	if (nbicols > 0)
361	>	if (nbicols)
362		return(nbicols);
326	–	if (nbicols < 0)
327	–	return(-nbicols);
363		cp = inpbuf;    /* need to count */
364		for (n = 0; *cp; )
365		if (blnkeq && isspace(sepchar)) {
#	Line 347 | Line 382 | 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 357 | Line 392 | int  n
392		eputs("illegal channel number\n");
393		quit(1);
394		}
395	<	if (nbicols > 0) {
395	>	if (nbicols) {
396		if (n > nbicols)
397		return(0.0);
398	<	cp = inpbuf + (n-1)*sizeof(double);
399	<	return(*(double *)cp);
400	<	}
401	<	if (nbicols < 0) {
367	<	if (n > -nbicols)
368	<	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		}
#	Line 417 | Line 450 | double  v
450		)
451		{
452		static char     zerobuf[sizeof(double)];
453	+	float   fval = v;
454
455		while (++colpos < n)
456		fwrite(zerobuf,
457	<	bocols>0 ? sizeof(double) : sizeof(float),
457	>	tolower(otype)=='d' ? sizeof(double) : sizeof(float),
458		1, stdout);
459	<	if (bocols > 0)
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	<	else {
466	<	float   fval = v;
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
#	Line 441 | Line 483 | int  output
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 454 | 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 466 | 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 501 | Line 543 | int  output
543
544		static int
545		readfield(                   /* get next field in format */
546	<	register char  **pp
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 571 | Line 613 | getsvar(                         /* get string variabl
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 590 | Line 632 | svpreset(                    /* preset a string variab
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 610 | Line 652 | char  *eqn
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 631 | Line 673 | 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';
638	<	if (blnkeq)             /* beware of nbsynch() */
679	>	if (blnkeq) {           /* beware of nbsynch() */
680		while (isblnk(ipb.chr))
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)
#	Line 662 | Line 707 | getrec(void)                           /* get next record from file */
707
708		static int
709		getfield(                             /* get next field */
710	<	register struct field  *f
710	>	struct field  *f
711		)
712		{
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 756 | Line 801 | register struct field  *f
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 790 | Line 836 | putrec(void)                                /* output
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		}

Diff Legend

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