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