1ref	-D_def_map_ast=1
2
3cmd	universe
4
5hdr	dirent,direntry,filio,fmtmsg,fnmatch,jioctl,libgen,limits
6hdr	locale,ndir,nl_types,process,spawn,syslog,utime,vfork
7hdr	wchar note{ <wchar.h> and isw*() really work }end execute{
8	#include <wchar.h>
9	int
10	main()
11	{
12		wchar_t	w = 'a';
13		return iswalnum(w) == 0;
14	}
15}end
16hdr	wctype wchar.h
17
18dat	_tzname,tzname
19
20lib	BSDsetpgrp
21lib	_cleanup
22lib	atexit,bcopy,bzero,catclose,catgets,catopen,confstr,dirread,dup2
23lib	execlp,execve,execvp,execvpe
24lib	fchmod,fcntl,fmtmsg,fnmatch,fork,fsync
25lib	getconf,getdents,getdirentries,getdtablesize,getdate
26lib	getgroups,gethostname,getlogin,getpagesize,getrlimit,getuniverse
27lib	getopt,getsubopt,getopt_long,getopt_long_only
28lib	glob,index,iswblank,iswctype,killpg,link,localeconv,madvise
29lib	mbtowc,mbrtowc,memalign,memchr,memcpy,memdup,memmove,memset
30lib	mkdir,mkfifo,mktemp,mktime
31lib	mount,on_exit,onexit,opendir,pathconf
32lib	readlink,remove,rename,rewinddir,rindex,rmdir,setlocale
33lib	setpgid,setpgrp,setpgrp2,setreuid,setsid,setuid,sigaction
34lib	sigprocmask,sigsetmask,sigunblock,sigvec,socketpair
35lib	spawn,spawnve,spawnveg
36lib	strchr,strcoll,strdup,strerror,strcasecmp,strncasecmp,strrchr,strstr
37lib	strmode,strxfrm,strftime,swab,symlink,sysconf,sysinfo,syslog
38lib	telldir,tmpnam,tzset,universe,unlink,utime,wctype
39lib	ftruncate,truncate
40lib	creat64,fstat64,fstatvfs64,ftruncate64 -D_LARGEFILE64_SOURCE
41lib	lseek64,lstat64 -D_LARGEFILE64_SOURCE
42lib	open64,readdir64,stat64,statvfs64,truncate64 -D_LARGEFILE64_SOURCE
43
44lib,npt	strtod,strtold,strtol,strtoll,strtoul,strtoull stdlib.h
45lib,npt	sigflag signal.h
46
47mem	direct.d_reclen sys/types.h sys/dir.h
48mem	dirent.d_fileno,dirent.d_ino,dirent.d_namlen,dirent.d_off,dirent.d_reclen,dirent.d_type sys/types.h dirent.h
49mem	DIR sys/types.h - dirent.h - sys/dir.h
50mem	DIR.dd_fd sys/types.h - dirent.h - sys/dir.h
51mem	inheritance.pgroup spawn.h
52
53sys	dir,filio,jioctl,localedef,ptem,resource
54sys	socket,stream,systeminfo,universe,vfork
55
56typ	ino64_t,off64_t -D_LARGEFILE64_SOURCE
57typ	struct.dirent64 -D_LARGEFILE64_SOURCE dirent.h
58
59tst	tst_errno note{ errno can be assigned }end link{
60	_BEGIN_EXTERNS_
61	#define error		______error
62	#define strerror	______strerror
63	#include <errno.h>
64	#undef	error
65	#undef	strerror
66	#ifndef errno
67	extern int errno;
68	#endif
69	error() { }
70	strerror() { }
71	_END_EXTERNS_
72	int main() { errno = 0; error(); strerror(); return 0; }
73}end
74
75tst	lib_poll_fd_1 note{ fd is first arg to poll() }end execute{
76	#include <poll.h>
77	_BEGIN_EXTERNS_
78	extern int	pipe _ARG_((int*));
79	_END_EXTERNS_
80	int
81	main()
82	{	int		rw[2];
83		struct pollfd	fd;
84		if (pipe(rw) < 0) return 1;
85		fd.fd = rw[0];
86		fd.events = POLLIN;
87		fd.revents = 0;
88		if (poll(&fd, 1, 0) < 0 || fd.revents != 0) return 1;
89		if (write(rw[1], "x", 1) != 1) return 1;
90		if (poll(&fd, 1, 0) < 0 || fd.revents == 0) return 1;
91		return 0;
92	}
93}end
94
95tst	lib_poll_fd_2 note{ fd is second arg to poll() }end execute{
96	#include <poll.h>
97	_BEGIN_EXTERNS_
98	extern int	pipe _ARG_((int*));
99	_END_EXTERNS_
100	int
101	main()
102	{	int		rw[2];
103		struct pollfd	fd;
104		if (pipe(rw) < 0) return 1;
105		fd.fd = rw[0];
106		fd.events = POLLIN;
107		fd.revents = 0;
108		return poll(1, &fd, 0) < 0;
109		if (poll(1, &fd, 0) < 0 || fd.revents != 0) return 1;
110		if (write(rw[1], "x", 1) != 1) return 1;
111		if (poll(1, &fd, 0) < 0 || fd.revents == 0) return 1;
112		return 0;
113	}
114}end
115
116exp	_lib_poll	_lib_poll_fd_1||_lib_poll_fd_2
117
118tst	lib_poll_notimer note{ poll with no fds ignores timeout }end execute{
119	#include <sys/types.h>
120	#include <poll.h>
121	_BEGIN_EXTERNS_
122	extern time_t	time _ARG_((time_t*));
123	_END_EXTERNS_
124	#define TIMEOUT		4
125	int
126	main()
127	{
128		unsigned long	start;
129		unsigned long	finish;
130		struct pollfd	fd;
131		start = time((time_t*)0);
132		if (poll(&fd, 0, TIMEOUT * 1000) < 0)
133			return 0;
134		finish = time((time_t*)0);
135		return (finish - start) > (TIMEOUT / 2);
136	}
137}end
138
139tst	lib_select sys/select.h note{ select() has standard 5 arg interface }end link{
140	#include <sys/types.h>
141	#include <sys/time.h>
142	#include <sys/socket.h>
143	int
144	main()
145	{	struct timeval	tmb;
146		fd_set		rd;
147		FD_ZERO(&rd);
148		FD_SET(0,&rd);
149		tmb.tv_sec = 0;
150		tmb.tv_usec = 0;
151		select(1,&rd,(fd_set*)0,(fd_set*)0,&tmb);
152		return 0;
153	}
154}end
155
156tst	sys_select note{ select() requires <sys/select.h> }end link{
157	#include <sys/select.h>
158	int
159	main()
160	{	struct timeval	tmb;
161		fd_set		rd;
162		FD_ZERO(&rd);
163		FD_SET(0,&rd);
164		tmb.tv_sec = 0;
165		tmb.tv_usec = 0;
166		select(1,&rd,(fd_set*)0,(fd_set*)0,&tmb);
167		return 0;
168	}
169}end
170
171tst	pipe_rw note{ full duplex pipes }end execute{
172	_BEGIN_EXTERNS_
173	extern int	pipe _ARG_((int*));
174	extern int	read _ARG_((int, void*, int));
175	extern int	strcmp _ARG_((const char*, const char*));
176	extern int	write _ARG_((int, void*, int));
177	_END_EXTERNS_
178	int
179	main()
180	{
181	#if defined(__sgi) || defined(_sgi) || defined(sgi)
182		/* boot tuneable pipes force one way for bin compatibility */
183		return 1;
184	#else
185		static char	test[] = "test\n";
186		int		io[2];
187		char		buf[sizeof(test)];
188		if (pipe(io)) return 1;
189		if (write(io[1], test, sizeof(test)) != sizeof(test)) return 1;
190		if (read(io[0], buf, sizeof(test)) != sizeof(test)) return 1;
191		if (strcmp(test, buf)) return 1;
192		if (write(io[0], test, sizeof(test)) != sizeof(test)) return 1;
193		if (read(io[1], buf, sizeof(test)) != sizeof(test)) return 1;
194		if (strcmp(test, buf)) return 1;
195		return 0;
196	#endif
197	}
198}end
199
200tst	lib_vfork unistd.h stdlib.h vfork.h note{ vfork exists and it works }end execute{
201	#include <signal.h>
202	int
203	main(argc, argv)
204	int	argc;
205	char**	argv;
206	{
207		int	status;
208		char*	cmd[3];
209		if (argv[1])
210			_exit(signal(SIGHUP, SIG_DFL) != SIG_IGN);
211		signal(SIGHUP, SIG_IGN);
212		switch (vfork())
213		{
214		case -1:
215			_exit(1);
216		case 0:
217			cmd[0] = argv[0];
218			cmd[1] = "test";
219			cmd[2] = 0;
220			execv(cmd[0], cmd);
221			_exit(2);
222		}
223		status = 1;
224		_exit(wait(&status) < 0 || status != 0);
225 	}
226}end
227
228tst	real_vfork note{ vfork child shares data with parent }end execute{
229	_BEGIN_EXTERNS_
230	extern int	_exit _ARG_((int));
231	extern int	vfork _ARG_((void));
232	_END_EXTERNS_
233	int		code;
234	int
235	main()
236	{
237		code = 1;
238		if (!vfork())
239			code = 0;
240		_exit(code);
241	}
242}end
243
244tst	lib_posix_spawn unistd.h stdlib.h spawn.h -Dfork=______fork note{ posix_spawn exists and it works and its worth using }end status{
245	#include <sys/types.h>
246	#include <sys/stat.h>
247	#include <sys/wait.h>
248	#include <spawn.h>
249	#include <signal.h>
250	#include <fcntl.h>
251	#include <string.h>
252	/* if it uses fork() why bother? */
253	#undef fork
254	pid_t fork _ARG_((void)) { NOTE("uses fork()"); return -1; }
255	pid_t _fork _ARG_((void)) { NOTE("uses _fork()"); return -1; }
256	pid_t __fork _ARG_((void)) { NOTE("uses __fork()"); return -1; }
257	int
258	main(argc, argv)
259	int	argc;
260	char**	argv;
261	{
262		char*			s;
263		pid_t			pid;
264		posix_spawnattr_t	attr;
265		int			n;
266		int			status;
267		char*			cmd[3];
268		char			tmp[1024];
269		if (argv[1])
270			_exit(signal(SIGHUP, SIG_DFL) != SIG_IGN);
271		signal(SIGHUP, SIG_IGN);
272		if (posix_spawnattr_init(&attr))
273		{
274			NOTE("posix_spawnattr_init() FAILED");
275			_exit(0);
276		}
277		if (posix_spawnattr_setpgroup(&attr, 0))
278		{
279			NOTE("posix_spawnattr_setpgroup() FAILED");
280			_exit(0);
281		}
282		if (posix_spawnattr_setflags(&attr, POSIX_SPAWN_SETPGROUP))
283		{
284			NOTE("posix_spawnattr_setflags() FAILED");
285			_exit(0);
286		}
287		/* first try an a.out and verify that SIGHUP is ignored */
288		cmd[0] = argv[0];
289		cmd[1] = "test";
290		cmd[2] = 0;
291		if (posix_spawn(&pid, cmd[0], 0, &attr, cmd, 0))
292		{
293			NOTE("posix_spawn() FAILED");
294			_exit(0);
295		}
296		status = 1;
297		if (wait(&status) < 0)
298		{
299			NOTE("wait() FAILED");
300			_exit(0);
301		}
302		if (status != 0)
303		{
304			NOTE("SIGHUP ignored in parent not ignored in child");
305			_exit(0);
306		}
307		/* must return exec-type errors or its useless to us *unless* there is no [v]fork() */
308		n = strlen(cmd[0]);
309		if (n >= (sizeof(tmp) - 3))
310		{
311			NOTE("test executable path too long");
312			_exit(0);
313		}
314		strcpy(tmp, cmd[0]);
315		tmp[n] = '.';
316		tmp[n+1] = 's';
317		tmp[n+2] = 'h';
318		tmp[n+3] = 0;
319		if ((n = open(tmp, O_CREAT|O_WRONLY, S_IRWXU|S_IRWXG|S_IRWXO)) < 0 ||
320		    chmod(tmp, S_IRWXU|S_IRWXG|S_IRWXO) < 0 ||
321		    write(n, "exit 99\n", 8) != 8 ||
322		    close(n) < 0)
323		{
324			NOTE("test script create FAILED");
325			_exit(0);
326		}
327		cmd[0] = tmp;
328		n = 0; /* 0 means reject */
329		pid = -1;
330		if (posix_spawn(&pid, cmd[0], 0, &attr, cmd, 0))
331		{
332			n = 2;
333			NOTE("ENOEXEC produces posix_spawn() error (BEST)");
334		}
335		else if (pid == -1)
336			NOTE("ENOEXEC returns pid == -1");
337		else if (wait(&status) != pid)
338			NOTE("ENOEXEC produces no child process");
339		else if (!WIFEXITED(status))
340			NOTE("ENOEXEC produces signal exit");
341		else
342		{
343			status = WEXITSTATUS(status);
344			if (status == 127)
345			{
346				n = 1;
347				NOTE("ENOEXEC produces exit status 127 (GOOD)");
348			}
349			else if (status == 99)
350				NOTE("ENOEXEC invokes sh");
351			else if (status == 0)
352				NOTE("ENOEXEC reports no error");
353		}
354		_exit(n);
355 	}
356}end
357
358tst	lib_spawn_mode unistd.h stdlib.h note{ first spawn arg is mode and it works }end execute{
359	#include <signal.h>
360	#include <process.h>
361	#ifndef P_NOWAIT
362	#define P_NOWAIT _P_NOWAIT
363	#endif
364	int
365	main(argc, argv)
366	int	argc;
367	char**	argv;
368	{
369		int	status;
370		char*	cmd[3];
371		if (argv[1])
372			_exit(signal(SIGHUP, SIG_DFL) != SIG_IGN);
373		signal(SIGHUP, SIG_IGN);
374		cmd[0] = argv[0];
375		cmd[1] = "test";
376		cmd[2] = 0;
377		if (spawnv(P_NOWAIT, cmd[0], cmd) < 0)
378			_exit(1);
379		status = 1;
380		_exit(wait(&status) < 0 || status != 0);
381	}
382}end
383
384tst	stream_peek note{ ioctl(I_PEEK) works on pipe() }end execute{
385	#include <sys/types.h>
386	#include <unistd.h>
387	#include <stropts.h>
388	int
389	main()
390	{	struct strpeek	peek;
391		int		fds[2];
392		char		ctlbuf[32];
393		char		databuf[32];
394		peek.flags = 0;
395		peek.ctlbuf.maxlen = peek.ctlbuf.len = sizeof(ctlbuf);
396		peek.ctlbuf.buf = ctlbuf;
397		peek.databuf.maxlen = peek.databuf.len = sizeof(databuf);
398		peek.databuf.buf = databuf;
399		pipe(fds);
400		return ioctl(fds[0],I_PEEK,&peek) < 0;
401	}
402}end
403
404tst	socket_peek note{ recv(MSG_PEEK) works on socketpair() }end execute{
405	#include <unistd.h>
406	#include <sys/types.h>
407	#include <sys/socket.h>
408	int
409	main()
410	{
411		int		i;
412		int		fds[2];
413		char		buf[128];
414
415		static char	msg[] = "abcd";
416
417		if (socketpair(AF_UNIX, SOCK_STREAM, 0, fds))
418			return 1;
419		if (write(fds[1], msg, sizeof(msg)) != sizeof(msg))
420				return 1;
421		if (recv(fds[0], buf, sizeof(buf), MSG_PEEK) != sizeof(msg))
422			return 1;
423		for (i = 0; i < sizeof(msg); i++)
424			if (buf[i] != msg[i])
425				return 1;
426		if (read(fds[0], buf, sizeof(msg)) != sizeof(msg))
427			return 1;
428		for (i = 0; i < sizeof(msg); i++)
429			if (buf[i] != msg[i])
430				return 1;
431		return 0;
432	}
433}end
434
435tst	lib_memcmp string.h note{ standard memcmp interface that works }end execute{
436	/* sgi again -- we're sick of being their regression test */
437	#define L	8
438	char		a[L] = { '0' };
439	char		b[L] = { '1' };
440	int
441	main()
442	{
443		return memcmp(a, b, L) >= 0;
444	}
445}end
446
447tst	lib_memccpy string.h unistd.h stdlib.h fcntl.h signal.h sys/types.h sys/stat.h sys/mman.h fcntl.h note{ standard memccpy interface that works }end execute{
448	#if _STD_
449	static void gotcha(int sig)
450	#else
451	static int gotcha(sig) int sig;
452	#endif
453	{
454		exit(1);
455	}
456	#ifdef MAP_PRIVATE
457	static const char x[] = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxN";
458	#if _STD_
459	static int indict_sgi_ia64_4Q_2004(int n)
460	#else
461	static int indict_sgi_ia64_4Q_2004(n) int n;
462	#endif
463	{
464		char*		b;
465		char*		s;
466		char*		e;
467		char*		t;
468		long		m;
469		int		d;
470		char		u[1024];
471
472		static char	p[32] = {'/','t','m','p','/','m','m'};
473
474		for (d = 7; d < 13; d++)
475			p[d] = 'X';
476		p[d] = 0;
477		if ((d = mkstemp(p)) < 0)
478			return 1;
479		remove(p);
480		for (m = 0; m < n; m++)
481			if (write(d, x, sizeof(x)-1) != sizeof(x)-1)
482			{
483				close(d);
484				return 1;
485			}
486		if (lseek(d, (off_t)0, SEEK_SET))
487		{
488			close(d);
489			return 1;
490		}
491		m = n * (sizeof(x)-1);
492		if (!(b = mmap((void*)0, m, PROT_READ|PROT_WRITE, MAP_PRIVATE, d, (off_t)0)))
493		{
494			close(d);
495			return 1;
496		}
497		for (e = (s = b) + m; s < e && (t = memccpy(u, s, 'N', (e-s) > sizeof(u) ? sizeof(u) : (e-s))); s += (t-u))
498			if ((t-u) != (sizeof(x)-1) || memcmp(u, s, t-u))
499			{
500				close(d);
501				return 1;
502			}
503		if (s < e)
504		{
505			close(d);
506			return 1;
507		}
508		close(d);
509		return 0;
510	}
511	#endif
512
513	int
514	main ()
515	{
516		char	buf[1024];
517	#ifdef MAP_PRIVATE
518		char*	srcbuf;
519		char*	dstbuf;
520		int	fd;
521		size_t	siz;
522		int	i;
523	#endif
524
525	#if defined(__ia64) || defined(__ia64__) || defined(__itanium__)
526		/*
527		 * 0 faith that the itanium coders will ever get this right
528		 * prove me wrong
529		 */
530
531		return 1;
532	#endif
533
534		/*
535		 * early mac osx failed here -- fixed 3Q 2001
536		 */
537
538		if (memccpy(buf, "abc", 0, sizeof(buf)) != (buf + 4))
539			return 1;
540	#ifdef MAP_PRIVATE
541		siz = 64 * 1024;
542		if (!(dstbuf = malloc(2 * siz)))
543			return 0;
544		if ((fd = open("/dev/zero", O_RDWR)) < 0)
545			return 0;
546		if (!(srcbuf = (char*)mmap(NULL, siz, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0)))
547			return 0;
548		if (!mmap(srcbuf + siz, siz, PROT_NONE, MAP_PRIVATE, fd, 0))
549			return 0;
550		for (i = 0; i < siz; i++)
551			srcbuf[i] = 'x';
552		srcbuf[siz - 1] = 0;
553		alarm(10);
554		signal(SIGSEGV, gotcha);
555		signal(SIGBUS, gotcha);
556		signal(SIGALRM, gotcha);
557		/*
558		 * sgi ia64 dumps here as of 3Q 2001
559		 * bug acknowleged 1Q 2003
560		 */
561		memccpy(dstbuf, srcbuf, 0, siz + 10);
562		alarm(0);
563		if (strcmp(srcbuf, dstbuf))
564			return 1;
565		if (indict_sgi_ia64_4Q_2004(1))
566			return 1;
567		if (indict_sgi_ia64_4Q_2004(257))
568			return 1;
569	#endif
570		return 0;
571	}
572}end
573
574tst	lib_utime_now note{ utime works with 0 time vector }end execute{
575	#include <sys/types.h>
576	_BEGIN_EXTERNS_
577	extern int	utime _ARG_((const char*, void*));
578	_END_EXTERNS_
579	int
580	main()
581	{
582		return utime(".", (void*)0) == -1;
583	}
584}end
585
586tst	cross{
587	u=att
588	case `/bin/cat -s /dev/null/foo 2>&1` in
589	'')	;;
590	*)	case `/bin/echo '\\t'` in
591		'\t')	u=ucb ;;
592		esac
593		;;
594	esac
595	echo "#define _UNIV_DEFAULT	\"$u\"	/* default universe name */"
596}end
597
598std	cleanup note{ stuck with standard _cleanup }end noexecute{
599	_BEGIN_EXTERNS_
600	extern void exit _ARG_((int));
601	extern void _exit _ARG_((int));
602	extern void _cleanup();
603	void _cleanup() { _exit(0); }
604	_END_EXTERNS_
605	int main() { printf("cleanup\n"); exit(1); }
606}end
607
608std	remove note{ stuck with standard remove() }end nostatic{
609	_BEGIN_EXTERNS_
610	extern int unlink _ARG_((const char*));
611	_END_EXTERNS_
612	#if _STD_
613	int remove(const char* path) { return 0; }
614	#else
615	int remove(path) char* path; { return 0; }
616	#endif
617	int main() { return unlink("foo"); }
618}end
619
620std	signal note{ stuck with standard signal }end nolink{
621	_BEGIN_EXTERNS_
622	extern int abort();
623	int signal() { return 0; }
624	_END_EXTERNS_
625	int main() { signal(); abort(); return 0; }
626}end
627
628std	strcoll note{ standard strcoll works }end execute{
629	#include <string.h>
630	#define S	"hello world"
631	int
632	main()
633	{
634		char	s[] = S;
635		char	t[] = S;
636		return strcoll(s, t) || strcmp(s, t);
637	}
638}end
639
640std	strtod stdlib.h note{ stuck with standard strtod }end nostatic{
641	_BEGIN_EXTERNS_
642	#if _STD_
643	double strtod(const char* s, char** e) { return 0.0; }
644	#else
645	double strtod(s, e) char* s; char** e; { return 0.0; }
646	#endif
647	_END_EXTERNS_
648	int main() { printf(""); return strtod("1",0) != 0; }
649}end
650
651std	strtold stdlib.h note{ stuck with standard strtold }end nostatic{
652	_BEGIN_EXTERNS_
653	#if _STD_
654	long double strtold(const char* s, char** e) { return 0.0; }
655	#else
656	long double strtold(s, e) char* s; char** e; { return 0.0; }
657	#endif
658	_END_EXTERNS_
659	int main() { printf(""); return strtold("1",0) != 0; }
660}end
661
662std	strtol note{ stuck with standard strtol }end nostatic{
663	_BEGIN_EXTERNS_
664	#if _STD_
665	extern long atol(const char*);
666	long strtol(const char* s, char** e, int b) { return 0; }
667	#else
668	extern long atol();
669	long strtol(s, e, b) char* s; char** e; int b; { return 0; }
670	#endif
671	_END_EXTERNS_
672	int main() { printf(""); return (atol("1") + strtol("1",(char**)0,0)) != 0; }
673}end
674
675tst	- output{
676	int
677	main()
678	{
679	#if _UWIN
680		printf("\n");
681		printf("/* override some uwin feature tests */\n");
682		printf("#undef	_lib_execlp\n");
683		printf("#undef	_lib_execvp\n");
684		printf("#undef	_lib_execvpe\n");
685		printf("#undef	_lib_fork\n");
686		printf("#undef	_std_string\n");
687		printf("#define _std_string	1\n");
688		printf("#undef	_stream_peek\n");
689		printf("\n");
690	#endif
691
692	#if _lib_spawnveg || _lib_posix_spawn || _lib_spawn_mode || _lib_spawn && _hdr_spawn && _mem_pgroup_inheritance || _lib_vfork && _real_vfork
693		printf("#if !_AST_no_spawnveg\n");
694		printf("#define _use_spawnveg	1\n");
695		printf("#endif\n");
696		printf("\n");
697	#endif
698
699		return 0;
700	}
701
702}end
703
704tst	no64 -D_LARGEFILE64_SOURCE note{ largefile 64 broken }end execute{
705	#include <sys/types.h>
706	#include <sys/stat.h>
707	int
708	main()
709	{
710		struct stat64	st;
711		return !stat64(".", &st) && st.st_mode && st.st_mtime;
712	}
713}end pass{
714	echo "/* can we at least agree that a successful return means success? */"
715	echo "#undef	_lib_creat64"
716	echo "#undef	_lib_fstat64"
717	echo "#undef	_lib_fstatvfs64"
718	echo "#undef	_lib_ftruncate64"
719	echo "#undef	_lib_lseek64"
720	echo "#undef	_lib_lstat64"
721	echo "#undef	_lib_mmap64"
722	echo "#undef	_lib_stat64"
723	echo "#undef	_lib_statvfs64"
724	echo "#undef	_lib_truncate64"
725}end
726