BSD 4_3_Tahoe release

[unix-history] / usr / src / usr.bin / lint / llib-lc

diff --git a/usr/src/usr.bin/lint/llib-lc b/usr/src/usr.bin/lint/llib-lc
index de3e2c3..fd85681 100644 (file)
--- a/usr/src/usr.bin/lint/llib-lc
+++ b/usr/src/usr.bin/lint/llib-lc
@@ -1,21 +1,38 @@
-/*     llib-lc 1.8     83/09/09        */
+/*     @(#)llib-lc     1.44 (Berkeley) 10/22/87        */
+

 /* LINTLIBRARY */
 /* LINTLIBRARY */

+

 #include <sys/types.h>
 #include <sys/types.h>

+#include <sys/time.h>
+
+#include <sys/wait.h>
+#include <sys/dir.h>
+#include <sys/resource.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/timeb.h>
+#include <sys/times.h>
+#include <sys/uio.h>
+#include <sys/vtimes.h>
+
+#include <netinet/in.h>
+
+#include <netns/ns.h>
+
+#include <arpa/inet.h>
+
+#include <sys/disklabel.h>

 #include <fstab.h>
 #include <grp.h>
 #include <fstab.h>
 #include <grp.h>

-#include <sys/dir.h>
+#include <ndbm.h>
+#include <netdb.h>

 #include <nlist.h>
 #include <pwd.h>
 #include <setjmp.h>
 #include <nlist.h>
 #include <pwd.h>
 #include <setjmp.h>

-#include <stdio.h>

 #include <sgtty.h>
 #include <signal.h>
 #include <sgtty.h>
 #include <signal.h>

-#include <sys/time.h>
-#include <sys/resource.h>
-#include <sys/wait.h>
-#include <sys/socket.h>
-#include <sys/stat.h>
-#include <sys/uio.h>
+#include <stdio.h>
+#include <ttyent.h>

 
        /***    SECTION 2       ***/
 int    errno;
 
        /***    SECTION 2       ***/
 int    errno;


@@ -23,6 +40,7 @@ int   errno;
 int    accept(s, a, l) struct sockaddr *a; int *l; { return s; }
 int    access( p, m) char *p; { return 0; }
 int    acct(f) char *f; { return 0;}
 int    accept(s, a, l) struct sockaddr *a; int *l; { return s; }
 int    access( p, m) char *p; { return 0; }
 int    acct(f) char *f; { return 0;}

+int    adjtime(delta, odelta) struct timeval *delta, *odelta; { return 0; }

 int    bind(s, n, l) struct sockaddr *n; { return 0; }
 char   *brk(a) char *a; { return(a); }
 int    chdir(s) char *s; { return(0); }
 int    bind(s, n, l) struct sockaddr *n; { return 0; }
 char   *brk(a) char *a; { return(a); }
 int    chdir(s) char *s; { return(0); }


@@ -35,37 +53,40 @@ int dup(f) { return(f); }
 int    dup2( o, n) { return o; }
        execve(s, v, e) char *s, *v[], *e[]; {;}
        _exit(s) {;}
 int    dup2( o, n) { return o; }
        execve(s, v, e) char *s, *v[], *e[]; {;}
        _exit(s) {;}

+int    fchmod(f, m) { return(0); }
+int    fchown(f, u, g) { return(0); }

 int    fcntl(f, c, a) { return (0); }
 int    flock( f, o ) { return 0; }
 int    fork() { return(0); }
 int    fsync( f ) { return 0; }
 int    fstat(f, b) struct stat *b; { return(0); }
 int    fcntl(f, c, a) { return (0); }
 int    flock( f, o ) { return 0; }
 int    fork() { return(0); }
 int    fsync( f ) { return 0; }
 int    fstat(f, b) struct stat *b; { return(0); }

-int    ftruncate( d, l) { return 0;}
+int    ftruncate( d, l) off_t l; { return 0;}

 int    getdtablesize() { return 20 ; }
 int    getdtablesize() { return 20 ; }

-int    getegid() { return(1); }
-int    geteuid() { return(1); }
-int    getgid() { return(1); }
-int    getgroups( n, g ) int *n, *g; { return 0; }
-int    gethostid() { return 1; }
-int    gethostname( n, l ) char *n; int *l; { return 0 ;}
+gid_t  getegid() { return((gid_t)1); }
+uid_t  geteuid() { return((uid_t)1); }
+gid_t  getgid() { return((gid_t)1); }
+int    getgroups( n, g ) int n, *g; { return 0; }
+long   gethostid() { return 1L; }
+int    gethostname( n, l ) char *n; int l; { return 0 ;}

 int    getitimer( w, v ) struct itimerval *v; { return 0; }
 int    getpagesize() { return 1; }
 int    getitimer( w, v ) struct itimerval *v; { return 0; }
 int    getpagesize() { return 1; }

+int    getpeername(s, n, l) struct sockaddr *n; int *l; { return (0); }

 int    getpgrp(p) { return 1; }
 int    getpid() { return(1); }
 int    getppid() { return(1); }
 int    getpriority( w, who) { return 1;}
 int    getrlimit( res, rip) struct rlimit *rip; { return 0;}
 int    getrusage( res, rip) struct rusage *rip; { return 0;}
 int    getpgrp(p) { return 1; }
 int    getpid() { return(1); }
 int    getppid() { return(1); }
 int    getpriority( w, who) { return 1;}
 int    getrlimit( res, rip) struct rlimit *rip; { return 0;}
 int    getrusage( res, rip) struct rusage *rip; { return 0;}

-int    getsockname(s, name, namelen) char *name; int *namelen; { return(0); }
-int    getsockopt( s, level, opt, buf, len ) { return 0;}
+int    getsockname(s, name, namelen) struct sockaddr *name; int *namelen; { return(0); }
+int    getsockopt( s, level, opt, buf, len ) char *buf; int *len; { return 0;}

 int    gettimeofday( t, z ) struct timeval *t; struct timezone *z; { return 0;}
 int    gettimeofday( t, z ) struct timeval *t; struct timezone *z; { return 0;}

-int    getuid() { return(1); }
-int    ioctl( d, r, p) char *p; { return 0;}
+uid_t  getuid() { return((uid_t)1); }
+int    ioctl( d, r, p) u_long r; char *p; { return 0;}

 int    kill(p, s) { return(0); }
 int    killpg( pg, s) { return 0;}
 int    link(a, b) char *a, *b; { return(0); }
 int    listen( s, b ){ return 0; }
 int    kill(p, s) { return(0); }
 int    killpg( pg, s) { return 0;}
 int    link(a, b) char *a, *b; { return(0); }
 int    listen( s, b ){ return 0; }

-long   lseek(f, o, d) long o; { return(0); }
+off_t  lseek(f, o, d) off_t o; { return(o); }

 int    lstat(s, b) char *s; struct stat *b; { return(0); }
 #ifdef notdef
 int    madvise( a, l, b ) char * a; int l, b; { return 0;}
 int    lstat(s, b) char *s; struct stat *b; { return(0); }
 #ifdef notdef
 int    madvise( a, l, b ) char * a; int l, b; { return 0;}


@@ -84,7 +105,8 @@ int  munmap( a, l) char * a; { return 0;}
 int    open(f, m, stuff) char *f; { return(0); }
 int    pipe(f) int f[2]; { return(0); }
        profil(b, s, o, i) char *b; {;}
 int    open(f, m, stuff) char *f; { return(0); }
 int    pipe(f) int f[2]; { return(0); }
        profil(b, s, o, i) char *b; {;}

-int    ptrace(r, p, a, d) { return(0); }
+int    ptrace(r, p, a, d) int *a; { return(0); }
+int    quota(c, u, a, ad) char *ad; { return(0); }

 int    read(f, b, l) char *b; { return(l); }
 int    readv( d, v, l) struct iovec *v; { return l; }
 int    readlink( p, b, s ) char *p, *b; { return 1; }
 int    read(f, b, l) char *b; { return(l); }
 int    readv( d, v, l) struct iovec *v; { return l; }
 int    readlink( p, b, s ) char *p, *b; { return 1; }


@@ -96,29 +118,31 @@ int        recvmsg( s, m, f ) struct msghdr m[]; { return 1; }
 int    rename( f, t ) char *f, *t; { return 0;}
 int    rmdir( p ) char *p; { return 0;}
 char   *sbrk(i) { return((char *)0); }
 int    rename( f, t ) char *f, *t; { return 0;}
 int    rmdir( p ) char *p; { return 0;}
 char   *sbrk(i) { return((char *)0); }

-int    select( n, r, w, e, t ) int *r, *w, *e; struct timeval *t; { return n; }
+int    select( n, r, w, e, t ) fd_set *r, *w, *e; struct timeval *t; { return n; }

 int    send( s, m, l, f )  char *m; { return l; }
 int    sendto( s, m, l, f, t, tl ) char *m; struct sockaddr *t; { return l; }
 int    sendmsg( s, m, l) struct msghdr m[]; { return l; }
 int    setgroups( n, g) int *g; { return 0; }
 int    send( s, m, l, f )  char *m; { return l; }
 int    sendto( s, m, l, f, t, tl ) char *m; struct sockaddr *t; { return l; }
 int    sendmsg( s, m, l) struct msghdr m[]; { return l; }
 int    setgroups( n, g) int *g; { return 0; }

-int    sethostid( h ) { return 0;}
+int    sethostid( h ) long h; { return 0;}

 int    sethostname( n, l ) char *n; int l; { return 0 ;}
 int    setitimer( w, v, ov ) struct itimerval *v, *ov; { return 0; }
 int    setpgrp( g, pg) { return 0; }
 int    setpriority( w, who, pri ) { return 1;}
 int    sethostname( n, l ) char *n; int l; { return 0 ;}
 int    setitimer( w, v, ov ) struct itimerval *v, *ov; { return 0; }
 int    setpgrp( g, pg) { return 0; }
 int    setpriority( w, who, pri ) { return 1;}

-int    setregid( r, e){ return 0; }
-int    setreuid( r, e){ return 0; }
+int    setquota(s, f) char *s, *f; { return 0; }
+int    setregid( r, e) int r, e; { return 0; }
+int    setreuid( r, e) int r, e; { return 0; }

 int    setrlimit( res, rip) struct rlimit *rip; { return 0;}
        /* VARARGS */
 int    setrlimit( res, rip) struct rlimit *rip; { return 0;}
        /* VARARGS */

-int    setsockopt( s, level, opt, buf, len ) { return 0;}
+int    setsockopt( s, level, opt, buf, len ) char *buf; { return 0;}

 int    settimeofday( t, z ) struct timeval *t; struct timezone *z; { return 0;}
 int    shutdown( s, h ){ return 0;}
 int    (*signal(c, f))() int (*f)(); { return(f); }
 int    settimeofday( t, z ) struct timeval *t; struct timezone *z; { return 0;}
 int    shutdown( s, h ){ return 0;}
 int    (*signal(c, f))() int (*f)(); { return(f); }

-int    (*sigvec(c, f, m))() int (*f)(); { return(f); }
+int    sigvec(c, f, m) struct sigvec *f, *m; { return 0; }

 int    sigblock(m) { return (m); }
 int    sigsetmask(m) { return (m); }
        sigpause(m) { ; }
 int    sigblock(m) { return (m); }
 int    sigsetmask(m) { return (m); }
        sigpause(m) { ; }

-int    sigstack(a, on) char *a; int on; { ; }
+int    sigreturn(scp) struct sigcontext *scp; { return -1; }
+int    sigstack(ss, oss) struct sigstack *ss, *oss; { return 0 ; }

 int    socket( a, t, p) {return 1;}
 int    socketpair( d, t, p, s ) int s[2]; { return 0; }
 int    stat(s, b) char *s; struct stat *b; { return(0); }
 int    socket( a, t, p) {return 1;}
 int    socketpair( d, t, p, s ) int s[2]; { return 0; }
 int    stat(s, b) char *s; struct stat *b; { return(0); }


@@ -126,52 +150,87 @@ int       stat(s, b) char *s; struct stat *b; { return(0); }
 char * stk( a ) char * a; { return a; }
 char * sstk( a ) int a; { return (char *)0; }
 #endif
 char * stk( a ) char * a; { return a; }
 char * sstk( a ) int a; { return (char *)0; }
 #endif

-int    swapon( b, s ) char *b; { return 0;}
+int    swapon( s ) char *s; { return 0;}

 int    symlink( t, f) char *t, *f; { return 0;}
        sync(){;}
 int    symlink( t, f) char *t, *f; { return 0;}
        sync(){;}

-int    truncate( p, l) char *p; { return 0;}
+int    truncate( p, l) char *p; off_t l; { return 0;}

 int    umask( n ) { return n; }
 int    umask( n ) { return n; }

+int    umount(s) char *s; { return 0; }

 int    unlink(s) char *s; { return(0); }
 int    unlink(s) char *s; { return(0); }

-int    utimes( f, t ) char *f; struct timeval *t[2]; { return 0 ;}
+int    utimes( f, t ) char *f; struct timeval t[2]; { return 0 ;}

 int    vfork() { return(0); }
 int    vfork() { return(0); }

+       vhangup() { ; }

 int    wait(s) union wait *s; { return(1); }
 int    wait3( s, o, r) union wait *s; struct rusage *r; { return 1;}
 int    write(f, b, l) char *b; { return(l); }
 int    writev( f, v, l) struct iovec *v; { return l; }
 
 
 int    wait(s) union wait *s; { return(1); }
 int    wait3( s, o, r) union wait *s; struct rusage *r; { return 1;}
 int    write(f, b, l) char *b; { return(l); }
 int    writev( f, v, l) struct iovec *v; { return l; }
 
 

-       /***    SECTION 3       ***/
+       /***    SECTION 3       ***/
+
+struct qelem { /* this should really be defined in an include file */
+       struct qelem    *q_forw;
+       struct qelem    *q_back;
+       char            data[1];
+}

 
        /* antique system calls and unclassified */
 
        /* antique system calls and unclassified */

+       _longjmp( e, v) jmp_buf e; {;}
+int    _setjmp(e) jmp_buf e; { return(0); }

        abort() {;}
 int    abs(i) int i; { return(i); }
 int    alarm(s) unsigned s; { return(s); }
        abort() {;}
 int    abs(i) int i; { return(i); }
 int    alarm(s) unsigned s; { return(s); }

-       alphasort( d1, d2) struct direct *d1, *d2; { return 0;}
+       alphasort( d1, d2) struct direct **d1, **d2; { return 0;}

 char * asctime(t) struct tm *t; { return(""); }
 double atof(s) char *s; { return(1.); }
 int    atoi(s) char *s; { return 1;   }
 long   atol(s) char *s; { return 1L;   }
 char * asctime(t) struct tm *t; { return(""); }
 double atof(s) char *s; { return(1.); }
 int    atoi(s) char *s; { return 1;   }
 long   atol(s) char *s; { return 1L;   }

+int    bcmp(b1, b2, length) char *b1, *b2; { return 0; }
+       bcopy(src, dst, length) char *src, *dst; { ; }
+       bzero(b, length) char *b; { ; }

 char * calloc(n,s) unsigned n, s; { static char c[1]; return(c); }
 void   closedir( p ) DIR *p; {}
 char * calloc(n,s) unsigned n, s; { static char c[1]; return(c); }
 void   closedir( p ) DIR *p; {}

+       closelog() {}

 int    creat(s, m) char *s; { return(0); }
 char * crypt(k,s) char *k, *s; { return(""); }
 int    creat(s, m) char *s; { return(0); }
 char * crypt(k,s) char *k, *s; { return(""); }

-char * ctime(c) time_t *c;{ return(""); }
+char * ctime(c) long *c;{ return(""); }

 char   _ctype_[];
 char   _ctype_[];

+DBM *  dbm_open(file, flags, mode) char *file; { return (DBM *) 0; }
+void   dbm_close(db) DBM *db; { ; }
+datum  dbm_fetch(db, key) DBM *db; datum key; { return key; }
+int    dbm_store(db, key, cont, flags) DBM *db; datum key, cont; { return 0; }
+int    dbm_delete(db, key) DBM *db; datum key; { return 0; }
+datum  dbm_firstkey(db) DBM *db; { datum key; return key; }
+datum  dbm_nextkey(db) DBM *db; { datum key; return key; }

 char * ecvt(v, n, d, s) double v; int *d, *s; { return(""); }
        encrypt(s, i) char *s; {}
 int    endfsent() { return 0; }
 char * ecvt(v, n, d, s) double v; int *d, *s; { return(""); }
        encrypt(s, i) char *s; {}
 int    endfsent() { return 0; }

-int    endgrent() { return 0; }
-int    endpwent() { return 0; }
+int    endgrent() { ; }
+       endhostent() { ; }
+       endnetent() { ; }
+       endprotoent() { ; }
+       endpwent() {}
+       endservent() { ; }
+       endttyent() { ; }
+       endusershell() { ; }
+char **        environ;

        /* VARARGS */
        execl(f, a) char *f, *a; {;}
        /* VARARGS */
        execle(f, a) char *f, *a; {;}
        /* VARARGS */
        execl(f, a) char *f, *a; {;}
        /* VARARGS */
        execle(f, a) char *f, *a; {;}

+       /* VARARGS */
+       execlp(f, a) char *f, *a; {;}

        execv(s, v) char *s, *v[]; {;}
        execv(s, v) char *s, *v[]; {;}

+       execvp(s, v) char *s, *v[]; {;}
+       exect(s, v, e) char *s, *v[], *e[]; {;}

        exit(s) {;}
 char * fcvt(v, n, d, s) double v; int *d, *s; { return(""); }
        exit(s) {;}
 char * fcvt(v, n, d, s) double v; int *d, *s; { return(""); }

+int    ffs(i) { return i; }

        free(p) char *p; {;}
 double frexp( v, e) double v; int *e; { return v; }
        free(p) char *p; {;}
 double frexp( v, e) double v; int *e; { return v; }

+       ftime(tp) struct timeb *tp; { ; }

 char * gcvt(v, n, b) double v; char *b; { return(""); }
 char * gcvt(v, n, b) double v; char *b; { return(""); }

+struct disklabel *     getdiskbyname(name) char *name; { return (struct disklabel *) 0; }

 char * getenv( n ) char *n; { return n; }
 struct fstab * getfsent() { return (struct fstab *)NULL; }
 struct fstab * getfsspec( n ) char *n; { return (struct fstab *)NULL; }
 char * getenv( n ) char *n; { return n; }
 struct fstab * getfsent() { return (struct fstab *)NULL; }
 struct fstab * getfsspec( n ) char *n; { return (struct fstab *)NULL; }


@@ -180,69 +239,160 @@ struct fstab *   getfstype( t ) char *t; { return (struct fstab *)NULL; }
 struct group * getgrent() { return (struct group *)NULL; }
 struct group * getgrgid( n ) { return (struct group *)NULL; }
 struct group * getgrnam( n ) char *n; { return (struct group *)NULL; }
 struct group * getgrent() { return (struct group *)NULL; }
 struct group * getgrgid( n ) { return (struct group *)NULL; }
 struct group * getgrnam( n ) char *n; { return (struct group *)NULL; }

+struct hostent *       gethostbyaddr(addr, len, type) char *addr; { return (struct hostent *) 0; }
+struct hostent *       gethostbyname(name) char *name; { return (struct hostent *) 0; }
+struct hostent *       gethostent() { return (struct hostent *) 0; }

 char * getlogin(){ return " "; }
 char * getlogin(){ return " "; }

+struct netent *        getnetbyaddr(net, type) { return (struct netent *) 0; }
+struct netent *        getnetbyname(name) char *name; { return (struct netent *) 0; }
+struct netent *        getnetent() { return (struct netent *) 0; }
+int    getopt(argc, argv, optstr) char **argv, *optstr; { return EOF; }

 char * getpass( n ) char *n ; { return n; }
 char * getpass( n ) char *n ; { return n; }

+struct protoent *      getprotobyname(name) char *name; { return (struct protoent *) 0; }
+struct protoent *      getprotobynumber(proto) { return (struct protoent *) 0; }
+struct protoent *      getprotoent() { return (struct protoent *) 0; }

 int    getpw( u, b) char *b;  { return 0; }
 struct passwd *        getpwent() { return (struct passwd *)NULL; }
 struct passwd *        getpwuid( n ) { return (struct passwd *)NULL; }
 struct passwd *        getpwnam( n ) char *n; { return (struct passwd *)NULL; }
 int    getpw( u, b) char *b;  { return 0; }
 struct passwd *        getpwent() { return (struct passwd *)NULL; }
 struct passwd *        getpwuid( n ) { return (struct passwd *)NULL; }
 struct passwd *        getpwnam( n ) char *n; { return (struct passwd *)NULL; }

-struct tm *    gmtime(c) time_t *c; { return gmtime(c); }
+struct servent *       getservbyname(name, proto) char *name, *proto; { return (struct servent *) 0; }
+struct servent *       getservbyport(port, proto) char *proto; { return (struct servent *) 0; }
+struct servent *       getservent() { return (struct servent *) 0; }
+struct ttyent *        getttynam(name) char *name; { return (struct ttyent *) 0; }
+char * getusershell() { return (char *) 0; }
+char * getwd(pathname) char *pathname; { return pathname; }
+struct tm *    gmtime(c) long *c; { return gmtime(c); }

 int    gtty(f, b) struct sgttyb *b; { return(0); }
 int    gtty(f, b) struct sgttyb *b; { return(0); }

+#ifndef htonl
+unsigned long htonl(hostlong) u_long hostlong; { return hostlong; }
+#endif htonl
+#ifndef htons
+unsigned short htons(hostshort) u_short hostshort; { return hostshort; }
+#endif htons

 char * index(s, c) char *s, c; { return s; }
 char * index(s, c) char *s, c; { return s; }

-long * initstate( s, st, n) unsigned s; long *st; { return st; }
+u_long inet_addr(cp) char *cp; { return 0L; }
+u_long inet_lnaof(in) struct in_addr in; { return 0L; }
+u_long inet_netof(in) struct in_addr in; { return 0L; }
+struct in_addr inet_makeaddr(net, host) { struct in_addr in; return in; }
+u_long inet_network(cp) char *cp; { return 0L; }
+char * inet_ntoa(in) struct in_addr in; { return (char *) 0; }
+int    initgroups(uname, agroup) char *uname; { return 0; }
+char * initstate( s, st, n) unsigned s; char *st; { return st; }
+       insque(elem, pred) struct qelem *elem, pred; { ; }

 int    isatty(f) { return 1; }
 double ldexp( v, e) double v; { return v; }
 int    isatty(f) { return 1; }
 double ldexp( v, e) double v; { return v; }

-       longjmp( e, v) jmp_buf *e; {;}
-struct tm *localtime(c) time_t *c; { return localtime(c); }
+       longjmp( e, v) jmp_buf e; {;}
+       longjmperror() {;}
+struct tm *localtime(c) long *c; { return localtime(c); }

 char * malloc(n) unsigned n; {static char c; return(&c);}
 char * malloc(n) unsigned n; {static char c; return(&c);}

-double modf( v, p ) double v, *p; { return v; }
+char * memccpy(t, f, c, n) char *t, *f; { return t; }
+char * memchr(s, c, n) char *s; { return s; }
+int    memcmp(s1, s2, n) char *s1, *s2; { return 0; }
+char * memcpy(t, f, n) char *t, *f; { return t; }
+char * memset(s, c, n) char *s; { return s; }

 char * mktemp(p) char *p; { return(p);}
 char * mktemp(p) char *p; { return(p);}

+int    mkstemp(p) char *p; { return(0);}
+double modf( v, p ) double v, *p; { return v; }
+       moncontrol(mode) { ; }

        monitor(l, h, b, s, n) int (*l)(), (*h)(); short *b; {}
        monstartup( l, h) int (*l)(), (*h)(); {;}
        monitor(l, h, b, s, n) int (*l)(), (*h)(); short *b; {}
        monstartup( l, h) int (*l)(), (*h)(); {;}

-       nlist( f, n) char *f; struct nlist n[]; {;}
+int    nice(incr) { return 0; }
+int    nlist( f, n) char *f; struct nlist n[]; { return (0);}
+struct ns_addr ns_addr(name) char *name; { struct ns_addr ns; return ns; }
+char * ns_ntoa(addr) struct ns_addr addr; { return (char *) 0; }
+#ifndef ntohl
+u_long ntohl(netlong) u_long netlong; { return netlong; }
+#endif ntohl
+#ifndef ntohs
+u_short        ntohs(netshort) u_short netshort; { return netshort; }
+#endif ntohs

 DIR *  opendir( f ) char *f; { return (DIR *)NULL; }
 DIR *  opendir( f ) char *f; { return (DIR *)NULL; }

+       openlog(s, f, l) char *s; {}
+char * optarg;
+int    optind;

        pause() {;}
        perror(s) char *s; {}
        pause() {;}
        perror(s) char *s; {}

-struct direct *        readdir( p ) DIR *p; { return (struct direct *)NULL; }
+       psignal(sig, s) unsigned sig; char *s; {}

        qsort( b, n, w, c ) char *b; int (*c)(); {;}
 int    rand(){ return 1; }
 long   random() { return 1L; }
        qsort( b, n, w, c ) char *b; int (*c)(); {;}
 int    rand(){ return 1; }
 long   random() { return 1L; }

+int    rcmd(a, rp, lu, ru, c, f) char **a, *lu, *ru, *c; u_short rp; int *f; { return 0; }

 char * re_comp(s) char *s ; { return s; }
 int    re_exec(s) char *s ; { return 1; }
 char * re_comp(s) char *s ; { return s; }
 int    re_exec(s) char *s ; { return 1; }

+struct direct *        readdir( p ) DIR *p; { return (struct direct *)NULL; }

 char * realloc(p, n) char *p; unsigned n; { static char c[1]; return(c);}
 char * realloc(p, n) char *p; unsigned n; { static char c[1]; return(c);}

+       remque(elem) struct qelem *elem; { ; }
+int    rexec(a, rp, n, p, c, f) char **a, *n, *p, *c; u_short rp; int *f; { return 0; }

 char * rindex(s, c) char *s, c; { return s; }
 char * rindex(s, c) char *s, c; { return s; }

+int    rresvport(p) int *p; { return 0; }
+int    ruserok(rh, su, ru, lu) char *rh, *ru, *lu; { return 0; }

 int    scandir(d, n, s, c) char *d; struct direct *(*n[]); int (*s)(),(*c)();
                { return 1; }
 void   seekdir( p, l) DIR *p; long l; {}
 int    scandir(d, n, s, c) char *d; struct direct *(*n[]); int (*s)(),(*c)();
                { return 1; }
 void   seekdir( p, l) DIR *p; long l; {}

+int    setegid(egid) gid_t egid; { return 0; }
+int    seteuid(euid) uid_t euid; { return 0; }

 int    setfsent() { return 0; }
 int    setgrent() { return 0; }
 int    setfsent() { return 0; }
 int    setgrent() { return 0; }

-int    setgid(g) { return(0); }
+int    setgid(g) gid_t g; { return(0); }
+       sethostent(stayopen) { ; }
+       sethostfile(name) char *name; { ; }

 int    setjmp(e) jmp_buf e; { return(0); }
        setkey(k) char *k; {}
 int    setjmp(e) jmp_buf e; { return(0); }
        setkey(k) char *k; {}

-int    setpwent() { return 0; }
-long * setstate( st ) long *st; { return st; }
-int    setuid(u) { return(0); }
+int    setlogmask(m) { return(0); }
+       setnetent(stayopen) { ; }
+       setprotoent(stayopen) { ; }
+       setpwent() {}
+       setpwfile(file) char *file; {}
+int    setrgid(rgid) gid_t rgid; { return 0; }
+int    setruid(ruid) uid_t ruid; { return 0; }
+       setservent(stayopen) { ; }
+char * setstate( st ) char *st; { return st; }
+       setttyent() { ; }
+int    setuid(u) uid_t u; { return(0); }
+       setusershell() { ; }
+int    siginterrupt(sig, flag) { return 0; }

        sleep(i) unsigned i; {}
 int    srand(s){ return s; }
 char * strcat(a, b) char *a, *b; { return a; }
        sleep(i) unsigned i; {}
 int    srand(s){ return s; }
 char * strcat(a, b) char *a, *b; { return a; }

+char * strcatn(a, b, n) char *a, *b; { return a;}
+char * strchr(s, c) char *s, c; { return s; }

 int    strcmp(a, b) char *a, *b; { return(1); }
 int    strcmp(a, b) char *a, *b; { return(1); }

+int    strcasecmp(a, b) char *a, *b; { return(1); }
+int    strcmpn(a, b, n) char *a, *b; { return(1); }

 char * strcpy(a, b) char *a, *b; { return a; }
 char * strcpy(a, b) char *a, *b; { return a; }

+char * strcpyn(a, b, n) char *a, *b; { return a; }
+int    strcspn(s, set) char *s, *set; { return(0); }

 int    strlen(s) char *s; { return(1); }
 char * strncat(a, b, n) char *a, *b; { return a;}
 int    strncmp(a, b, n) char *a, *b; { return(1); }
 int    strlen(s) char *s; { return(1); }
 char * strncat(a, b, n) char *a, *b; { return a;}
 int    strncmp(a, b, n) char *a, *b; { return(1); }

+int    strncasecmp(a, b, n) char *a, *b; { return(1); }

 char * strncpy(a, b, n) char *a, *b; { return a; }
 char * strncpy(a, b, n) char *a, *b; { return a; }

+char * strpbrk(s, brk) char *s, *brk; { return s; }
+char * strrchr(s, c) char *s, c; { return s; }
+int    strspn(s, set) char *s, *set; { return(0); }
+char * strtok(s, sep) char *s, *sep; { return s; }

 int    stty(f, b) struct sgttyb *b; { return(0); }
        swab( f, t, n) char *f, *t; {;}
 int    stty(f, b) struct sgttyb *b; { return(0); }
        swab( f, t, n) char *f, *t; {;}

+       /* VARARGS2 */
+       syslog(l, f) char *f; {}

 char * sys_errlist[];
 char * sys_errlist[];

+char * sys_siglist[];

 int    sys_nerr;
 int    system(s) char *s; { return(0); }
 long   tell(f) { return((long)0); }
 long   telldir( p ) DIR *p; { return 1L; }
 int    sys_nerr;
 int    system(s) char *s; { return(0); }
 long   tell(f) { return((long)0); }
 long   telldir( p ) DIR *p; { return 1L; }

-time_t time(t) time_t *t; { return( 0 );}
-char * timezone( z, d ){}
+long   time(t) long *t; { return( 0L );}
+int    times(tmsp) struct tms *tmsp; { return 0; }
+char * timezone( z, d ){ return (char *)0; }
+char * tmpnam(s) char *s; { return s; }

 char * ttyname(f) { return " "; }
 int    ttyslot() { return 1; }
 char * ttyname(f) { return " "; }
 int    ttyslot() { return 1; }

+unsigned       ualarm(value, interval) unsigned value, interval; { return 0; }
+       usleep(useconds) unsigned useconds; { ; }
+int    utime(name, timep) char *name; time_t *timep; { return 0; }

 char * valloc(s) unsigned s; { return malloc(s); }
 char * valloc(s) unsigned s; { return malloc(s); }

+int    vlimit(limit, value) { return 0; }
+int    vtimes(par, ch) struct vtimes *par, *ch; { return 0; }

 
        /* standard I/O library */
 
 
        /* standard I/O library */
 


@@ -252,36 +402,42 @@ int       fflush(f) FILE *f; {return(0);}
 int    fgetc(f)  FILE *f; {return 0; }
 char * fgets( s, l, f ) char *s; FILE *f; { return(s); }
 int    _filbuf( f ) FILE *f; { return 0; }
 int    fgetc(f)  FILE *f; {return 0; }
 char * fgets( s, l, f ) char *s; FILE *f; { return(s); }
 int    _filbuf( f ) FILE *f; { return 0; }

-/* the unsigned is due to putc and putchar macro expansion */
-int    _flsbuf( c, f ) unsigned c; FILE *f; { return 0; }
+int    _flsbuf( c, f ) unsigned char c; FILE *f; { return 0; }

 FILE * fopen(s,m) char *s, *m; { return(stdin); }
 FILE * fopen(s,m) char *s, *m; { return(stdin); }

-       /* VARARGS */
+       /* VARARGS2 */

        fprintf( f, s ) FILE *f; char *s; {;}
 int    fputc(c, f) char c; FILE *f; {return 0; }
        fputs(s,f) char *s; FILE *f; {;}
 int    fread( p, s, n, f ) char *p; FILE *f; {return(1);}
 FILE * freopen(s, m, f) char *s, *m; FILE *f; { return(stdin); }
        fprintf( f, s ) FILE *f; char *s; {;}
 int    fputc(c, f) char c; FILE *f; {return 0; }
        fputs(s,f) char *s; FILE *f; {;}
 int    fread( p, s, n, f ) char *p; FILE *f; {return(1);}
 FILE * freopen(s, m, f) char *s, *m; FILE *f; { return(stdin); }

-       /* VARARGS */
+       /* VARARGS2 */

        fscanf( f, s ) FILE *f; char *s; {return(1);}
        fscanf( f, s ) FILE *f; char *s; {return(1);}

-       fseek(f, o, p) FILE *f; long o; { return(0); }
+int    fseek(f, o, p) FILE *f; long o; { return(0); }

 long   ftell(f) FILE *f; { return(0L); }
 int    fwrite( p, s, n, f ) char *p; FILE *f; {return(0);}
 long   ftell(f) FILE *f; { return(0L); }
 int    fwrite( p, s, n, f ) char *p; FILE *f; {return(0);}

+#ifndef getc
+int    getc(f) FILE *f; { return EOF; }
+#endif getc

 int    getw(f) FILE *f; { return 0;}
 char * gets( s ) char *s; { return(s); }
 int    getw(f) FILE *f; { return 0;}
 char * gets( s ) char *s; { return(s); }

-struct _iobuf _iob[_NFILE];
+struct _iobuf _iob[];

 int    pclose( f ) FILE *f; { return 0; }
 FILE * popen( c, t ) char *c, *t; { return(stdin); }
 int    pclose( f ) FILE *f; { return 0; }
 FILE * popen( c, t ) char *c, *t; { return(stdin); }

-       /* VARARGS */
+       /* VARARGS1 */

        printf( s ) char *s; {;}
        puts(s) char *s;{;}
        printf( s ) char *s; {;}
        puts(s) char *s;{;}

+#ifndef putc
+int    putc(c, f) char c; FILE *f; { return 0; }
+#endif putc

 int    putw(w, f) FILE *f; { return 0;}
        rewind(f) FILE *f; {;}
 int    putw(w, f) FILE *f; { return 0;}
        rewind(f) FILE *f; {;}

-       /* VARARGS */
+       /* VARARGS1 */

        scanf( f ) char *f; {return(1); }
        setbuf( f, b ) FILE *f; char *b; {;}
        setbuffer( f, b, s ) FILE *f; char *b; {;}
        scanf( f ) char *f; {return(1); }
        setbuf( f, b ) FILE *f; char *b; {;}
        setbuffer( f, b, s ) FILE *f; char *b; {;}

-       /* VARARGS */
-char * sprintf( s, f ) char *s, *f; { return(s);}
-       /* VARARGS */
+       setlinebuf( f ) FILE *f; {;}
+       /* VARARGS2 */
+int    sprintf( s, f ) char *s, *f; { return(s);}
+       /* VARARGS2 */

        sscanf( s, f ) char *s, *f; { return(1); }
        ungetc( c, f ) FILE *f; {  return(c); }
        sscanf( s, f ) char *s, *f; { return(1); }
        ungetc( c, f ) FILE *f; {  return(c); }