os.c revision 267654 
1/*
2 * Copyright (C) 1984-2012  Mark Nudelman
3 *
4 * You may distribute under the terms of either the GNU General Public
5 * License or the Less License, as specified in the README file.
6 *
7 * For more information, see the README file.
8 */
9
10
11/*
12 * Operating system dependent routines.
13 *
14 * Most of the stuff in here is based on Unix, but an attempt
15 * has been made to make things work on other operating systems.
16 * This will sometimes result in a loss of functionality, unless
17 * someone rewrites code specifically for the new operating system.
18 *
19 * The makefile provides defines to decide whether various
20 * Unix features are present.
21 */
22
23#include "less.h"
24#include <signal.h>
25#include <setjmp.h>
26#if HAVE_TIME_H
27#include <time.h>
28#endif
29#if HAVE_ERRNO_H
30#include <errno.h>
31#endif
32#if HAVE_VALUES_H
33#include <values.h>
34#endif
35
36#if HAVE_TIME_T
37#define time_type	time_t
38#else
39#define	time_type	long
40#endif
41
42/*
43 * BSD setjmp() saves (and longjmp() restores) the signal mask.
44 * This costs a system call or two per setjmp(), so if possible we clear the
45 * signal mask with sigsetmask(), and use _setjmp()/_longjmp() instead.
46 * On other systems, setjmp() doesn't affect the signal mask and so
47 * _setjmp() does not exist; we just use setjmp().
48 */
49#if HAVE__SETJMP && HAVE_SIGSETMASK
50#define SET_JUMP	_setjmp
51#define LONG_JUMP	_longjmp
52#else
53#define SET_JUMP	setjmp
54#define LONG_JUMP	longjmp
55#endif
56
57public int reading;
58
59static jmp_buf read_label;
60
61extern int sigs;
62
63/*
64 * Like read() system call, but is deliberately interruptible.
65 * A call to intread() from a signal handler will interrupt
66 * any pending iread().
67 */
68	public int
69iread(fd, buf, len)
70	int fd;
71	char *buf;
72	unsigned int len;
73{
74	register int n;
75
76start:
77#if MSDOS_COMPILER==WIN32C
78	if (ABORT_SIGS())
79		return (READ_INTR);
80#else
81#if MSDOS_COMPILER && MSDOS_COMPILER != DJGPPC
82	if (kbhit())
83	{
84		int c;
85
86		c = getch();
87		if (c == '\003')
88			return (READ_INTR);
89		ungetch(c);
90	}
91#endif
92#endif
93	if (SET_JUMP(read_label))
94	{
95		/*
96		 * We jumped here from intread.
97		 */
98		reading = 0;
99#if HAVE_SIGPROCMASK
100		{
101		  sigset_t mask;
102		  sigemptyset(&mask);
103		  sigprocmask(SIG_SETMASK, &mask, NULL);
104		}
105#else
106#if HAVE_SIGSETMASK
107		sigsetmask(0);
108#else
109#ifdef _OSK
110		sigmask(~0);
111#endif
112#endif
113#endif
114		return (READ_INTR);
115	}
116
117	flush();
118	reading = 1;
119#if MSDOS_COMPILER==DJGPPC
120	if (isatty(fd))
121	{
122		/*
123		 * Don't try reading from a TTY until a character is
124		 * available, because that makes some background programs
125		 * believe DOS is busy in a way that prevents those
126		 * programs from working while "less" waits.
127		 */
128		fd_set readfds;
129
130		FD_ZERO(&readfds);
131		FD_SET(fd, &readfds);
132		if (select(fd+1, &readfds, 0, 0, 0) == -1)
133			return (-1);
134	}
135#endif
136	n = read(fd, buf, len);
137#if 1
138	/*
139	 * This is a kludge to workaround a problem on some systems
140	 * where terminating a remote tty connection causes read() to
141	 * start returning 0 forever, instead of -1.
142	 */
143	{
144		extern int ignore_eoi;
145		if (!ignore_eoi)
146		{
147			static int consecutive_nulls = 0;
148			if (n == 0)
149				consecutive_nulls++;
150			else
151				consecutive_nulls = 0;
152			if (consecutive_nulls > 20)
153				quit(QUIT_ERROR);
154		}
155	}
156#endif
157	reading = 0;
158	if (n < 0)
159	{
160#if HAVE_ERRNO
161		/*
162		 * Certain values of errno indicate we should just retry the read.
163		 */
164#if MUST_DEFINE_ERRNO
165		extern int errno;
166#endif
167#ifdef EINTR
168		if (errno == EINTR)
169			goto start;
170#endif
171#ifdef EAGAIN
172		if (errno == EAGAIN)
173			goto start;
174#endif
175#endif
176		return (-1);
177	}
178	return (n);
179}
180
181/*
182 * Interrupt a pending iread().
183 */
184	public void
185intread()
186{
187	LONG_JUMP(read_label, 1);
188}
189
190/*
191 * Return the current time.
192 */
193#if HAVE_TIME
194	public long
195get_time()
196{
197	time_type t;
198
199	time(&t);
200	return (t);
201}
202#endif
203
204
205#if !HAVE_STRERROR
206/*
207 * Local version of strerror, if not available from the system.
208 */
209	static char *
210strerror(err)
211	int err;
212{
213#if HAVE_SYS_ERRLIST
214	static char buf[16];
215	extern char *sys_errlist[];
216	extern int sys_nerr;
217
218	if (err < sys_nerr)
219		return sys_errlist[err];
220	sprintf(buf, "Error %d", err);
221	return buf;
222#else
223	return ("cannot open");
224#endif
225}
226#endif
227
228/*
229 * errno_message: Return an error message based on the value of "errno".
230 */
231	public char *
232errno_message(filename)
233	char *filename;
234{
235	register char *p;
236	register char *m;
237	int len;
238#if HAVE_ERRNO
239#if MUST_DEFINE_ERRNO
240	extern int errno;
241#endif
242	p = strerror(errno);
243#else
244	p = "cannot open";
245#endif
246	len = strlen(filename) + strlen(p) + 3;
247	m = (char *) ecalloc(len, sizeof(char));
248	SNPRINTF2(m, len, "%s: %s", filename, p);
249	return (m);
250}
251
252/* #define HAVE_FLOAT 0 */
253
254	static POSITION
255muldiv(val, num, den)
256	POSITION val, num, den;
257{
258#if HAVE_FLOAT
259	double v = (((double) val) * num) / den;
260	return ((POSITION) (v + 0.5));
261#else
262	POSITION v = ((POSITION) val) * num;
263
264	if (v / num == val)
265		/* No overflow */
266		return (POSITION) (v / den);
267	else
268		/* Above calculation overflows;
269		 * use a method that is less precise but won't overflow. */
270		return (POSITION) (val / (den / num));
271#endif
272}
273
274/*
275 * Return the ratio of two POSITIONS, as a percentage.
276 * {{ Assumes a POSITION is a long int. }}
277 */
278	public int
279percentage(num, den)
280	POSITION num, den;
281{
282	return (int) muldiv(num,  (POSITION) 100, den);
283}
284
285/*
286 * Return the specified percentage of a POSITION.
287 */
288	public POSITION
289percent_pos(pos, percent, fraction)
290	POSITION pos;
291	int percent;
292	long fraction;
293{
294	/* Change percent (parts per 100) to perden (parts per NUM_FRAC_DENOM). */
295	POSITION perden = (percent * (NUM_FRAC_DENOM / 100)) + (fraction / 100);
296
297	if (perden == 0)
298		return (0);
299	return (POSITION) muldiv(pos, perden, (POSITION) NUM_FRAC_DENOM);
300}
301
302#if !HAVE_STRCHR
303/*
304 * strchr is used by regexp.c.
305 */
306	char *
307strchr(s, c)
308	char *s;
309	int c;
310{
311	for ( ;  *s != '\0';  s++)
312		if (*s == c)
313			return (s);
314	if (c == '\0')
315		return (s);
316	return (NULL);
317}
318#endif
319
320#if !HAVE_MEMCPY
321	VOID_POINTER
322memcpy(dst, src, len)
323	VOID_POINTER dst;
324	VOID_POINTER src;
325	int len;
326{
327	char *dstp = (char *) dst;
328	char *srcp = (char *) src;
329	int i;
330
331	for (i = 0;  i < len;  i++)
332		dstp[i] = srcp[i];
333	return (dst);
334}
335#endif
336
337#ifdef _OSK_MWC32
338
339/*
340 * This implements an ANSI-style intercept setup for Microware C 3.2
341 */
342	public int
343os9_signal(type, handler)
344	int type;
345	RETSIGTYPE (*handler)();
346{
347	intercept(handler);
348}
349
350#include <sgstat.h>
351
352	int
353isatty(f)
354	int f;
355{
356	struct sgbuf sgbuf;
357
358	if (_gs_opt(f, &sgbuf) < 0)
359		return -1;
360	return (sgbuf.sg_class == 0);
361}
362
363#endif
364