src/common/portio.c

#ifndef lint
static const char       RCSid[] = "$Id: portio.c,v 2.26 2021/02/19 18:00:29 greg Exp $";
#endif
/*
 * Portable i/o for binary files
 *
 * External symbols declared in rtio.h
 */

#include "copyright.h"

#include "rtio.h"

#include <math.h>


int
putstr(                         /* write null-terminated string to fp */
        char  *s,
        FILE  *fp
)
{
        do
                putc(*s, fp);
        while (*s++);

        return(ferror(fp) ? EOF : 0);
}


int
putint(                         /* write a siz-byte integer to fp */
        long  i,
        int  siz,
        FILE  *fp
)
{
        while (siz > sizeof(long)) {
                putc((i<0)*0xff, fp);
                siz--;
        }
        siz <<= 3;
        while ((siz -= 8) > 0)
                putc((int)(i>>siz & 0xff), fp);

        return(putc((int)(i & 0xff), fp) == EOF ? EOF : 0);
}


int
putflt(                         /* put out floating point number */
        double  f,
        FILE  *fp
)
{
        long  m;
        int  e;

        m = frexp(f, &e) * 0x7fffffff;
        if (e > 127) {                  /* overflow */
                m = m > 0 ? (long)0x7fffffff : -(long)0x7fffffff;
                e = 127;
        } else if (e < -128) {          /* underflow */
                m = 0;
                e = 0;
        }
        putint(m, 4, fp);
        return(putint(e, 1, fp));
}


size_t
putbinary(                      /* fwrite() replacement for small objects */
        const void *p,
        size_t elsiz,
        size_t nel,
        FILE *fp)
{
        const char      *s = (const char *)p;
        size_t          nbytes = elsiz*nel;

        if (nbytes > 128)
                return(fwrite(p, elsiz, nel, fp));
        
        while (nbytes-- > 0)
                if (putc(*s++, fp) == EOF)
                        return((elsiz*nel - nbytes)/elsiz);

        return(nel);
}


char *
getstr(                         /* get null-terminated string */
        char  *s,
        FILE  *fp
)
{
        char  *cp;
        int  c;

        cp = s;
        while ((c = getc(fp)) != EOF)
                if ((*cp++ = c) == '\0')
                        return(s);
                
        return(NULL);
}


long
getint(                         /* get a siz-byte integer */
        int  siz,
        FILE  *fp
)
{
        int  c;
        long  r;

        if ((c = getc(fp)) == EOF)
                return(EOF);
        r = c;
        if (c & 0x80)           /* sign extend? */
                r |= -256L;
        while (--siz > 0) {
                if ((c = getc(fp)) == EOF)
                        return(EOF);
                r <<= 8;
                r |= c;
        }
        return(r);
}


double
getflt(                         /* get a floating point number */
        FILE  *fp
)
{
        long    l;
        double  d;

        l = getint(4, fp);
        if (l == EOF && feof(fp))       /* EOF? */
                return((double)EOF);
        if (l == 0) {
                getc(fp);               /* exactly zero -- ignore exponent */
                return(0.0);
        }
        d = (l + .5 - (l<0)) * (1./0x7fffffff);
        return(ldexp(d, (int)getint(1, fp)));
}


size_t
getbinary(                      /* fread() replacement for small objects */
        void *p,
        size_t elsiz,
        size_t nel,
        FILE *fp)
{
        char    *s = (char *)p;
        size_t  nbytes = elsiz*nel;
        int     c;

        if (nbytes > 128)
                return(fread(p, elsiz, nel, fp));
        
        while (nbytes-- > 0) {
                if ((c = getc(fp)) == EOF)
                        return((elsiz*nel - nbytes)/elsiz);
                *s++ = c;
        }
        return(nel);
}
Revision:	2.27
Committed:	Mon Jul 12 17:42:51 2021 UTC (4 years, 3 months ago) by greg
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rad5R4, rad6R0, HEAD
Changes since 2.26:	+2 -2 lines
Log Message:	perf: minor efficiency improvements
#	User	Rev	Content
1	greg	2.1	#ifndef lint
2	greg	2.27	static const char RCSid[] = "$Id: portio.c,v 2.26 2021/02/19 18:00:29 greg Exp $";
3	greg	2.1	#endif
4			/*
5			* Portable i/o for binary files
6	greg	2.6	*
7	greg	2.14	* External symbols declared in rtio.h
8	greg	2.6	*/
9
10	greg	2.7	#include "copyright.h"
11	greg	2.1
12	schorsch	2.8	#include "rtio.h"
13	greg	2.1
14	greg	2.9	#include <math.h>
15	greg	2.10
16	greg	2.3
17	greg	2.25	int
18	greg	2.15	putstr( /* write null-terminated string to fp */
19			char *s,
20			FILE *fp
21			)
22	greg	2.1	{
23			do
24			putc(*s, fp);
25	greg	2.26	while (*s++);
26	greg	2.25
27	greg	2.26	return(ferror(fp) ? EOF : 0);
28	greg	2.1	}
29
30
31	greg	2.25	int
32	greg	2.15	putint( /* write a siz-byte integer to fp */
33			long i,
34			int siz,
35			FILE *fp
36			)
37	greg	2.1	{
38	greg	2.24	while (siz > sizeof(long)) {
39			putc((i<0)*0xff, fp);
40			siz--;
41			}
42	greg	2.18	siz <<= 3;
43	greg	2.22	while ((siz -= 8) > 0)
44	greg	2.18	putc((int)(i>>siz & 0xff), fp);
45	greg	2.25
46			return(putc((int)(i & 0xff), fp) == EOF ? EOF : 0);
47	greg	2.1	}
48
49
50	greg	2.25	int
51	greg	2.15	putflt( /* put out floating point number */
52			double f,
53			FILE *fp
54			)
55	greg	2.1	{
56	greg	2.13	long m;
57	greg	2.1	int e;
58
59	greg	2.13	m = frexp(f, &e) * 0x7fffffff;
60			if (e > 127) { /* overflow */
61			m = m > 0 ? (long)0x7fffffff : -(long)0x7fffffff;
62			e = 127;
63			} else if (e < -128) { /* underflow */
64			m = 0;
65			e = 0;
66			}
67			putint(m, 4, fp);
68	greg	2.25	return(putint(e, 1, fp));
69	greg	2.1	}
70
71
72	greg	2.23	size_t
73	greg	2.16	putbinary( /* fwrite() replacement for small objects */
74	greg	2.19	const void *p,
75	greg	2.23	size_t elsiz,
76			size_t nel,
77	greg	2.16	FILE *fp)
78			{
79	greg	2.19	const char s = (const char )p;
80	greg	2.23	size_t nbytes = elsiz*nel;
81	greg	2.16
82	greg	2.22	if (nbytes > 128)
83	greg	2.19	return(fwrite(p, elsiz, nel, fp));
84	greg	2.16
85			while (nbytes-- > 0)
86	greg	2.21	if (putc(*s++, fp) == EOF)
87			return((elsiz*nel - nbytes)/elsiz);
88	greg	2.16
89			return(nel);
90			}
91
92
93	greg	2.1	char *
94	greg	2.15	getstr( /* get null-terminated string */
95			char *s,
96			FILE *fp
97			)
98	greg	2.1	{
99	greg	2.15	char *cp;
100			int c;
101	greg	2.1
102			cp = s;
103			while ((c = getc(fp)) != EOF)
104			if ((*cp++ = c) == '\0')
105			return(s);
106
107			return(NULL);
108			}
109
110
111			long
112	greg	2.15	getint( /* get a siz-byte integer */
113			int siz,
114			FILE *fp
115			)
116	greg	2.1	{
117	greg	2.15	int c;
118			long r;
119	greg	2.1
120			if ((c = getc(fp)) == EOF)
121			return(EOF);
122	greg	2.24	r = c;
123			if (c & 0x80) /* sign extend? */
124	greg	2.25	r \|= -256L;
125	greg	2.1	while (--siz > 0) {
126			if ((c = getc(fp)) == EOF)
127			return(EOF);
128			r <<= 8;
129			r \|= c;
130			}
131			return(r);
132			}
133
134
135			double
136	greg	2.15	getflt( /* get a floating point number */
137			FILE *fp
138			)
139	greg	2.1	{
140	greg	2.5	long l;
141	greg	2.2	double d;
142	greg	2.1
143	greg	2.5	l = getint(4, fp);
144	greg	2.15	if (l == EOF && feof(fp)) /* EOF? */
145			return((double)EOF);
146	greg	2.12	if (l == 0) {
147			getc(fp); /* exactly zero -- ignore exponent */
148			return(0.0);
149			}
150	greg	2.27	d = (l + .5 - (l<0)) * (1./0x7fffffff);
151	greg	2.1	return(ldexp(d, (int)getint(1, fp)));
152			}
153	greg	2.16
154
155	greg	2.23	size_t
156	greg	2.16	getbinary( /* fread() replacement for small objects */
157	greg	2.19	void *p,
158	greg	2.23	size_t elsiz,
159			size_t nel,
160	greg	2.16	FILE *fp)
161			{
162	greg	2.19	char s = (char )p;
163	greg	2.23	size_t nbytes = elsiz*nel;
164	greg	2.16	int c;
165
166	greg	2.22	if (nbytes > 128)
167	greg	2.19	return(fread(p, elsiz, nel, fp));
168	greg	2.16
169			while (nbytes-- > 0) {
170			if ((c = getc(fp)) == EOF)
171			return((elsiz*nel - nbytes)/elsiz);
172			*s++ = c;
173			}
174			return(nel);
175			}