llib-lc

操作系统SunOS 4.1.3版本的源码

int		sigstack(ss, oss) struct sigstack *ss, *oss; { return (0); }
int		sigsuspend(s) sigset_t *s; { return (0); }
int		sigvec(sig, vec, ovec) int sig; struct sigvec *vec, *ovec; { return (0); }
unsigned	sleep(n) unsigned n; { return (0); }
int		socket(a, t, p) { return (0); }
int		socketpair(d, t, p, s ) int s[2]; { return (0); }
		/*VARARGS2 PRINTFLIKE2*/
int		sprintf(p, s) char *p, *s; { return (0); }
void		sputl(l, b) char *b; {}
void		srand(s) unsigned s; {}
void		srand48(s) long s; {}
void		srandom(s) int s; {}
		/*VARARGS2 SCANFLIKE2*/
int		sscanf(p, s) char *p, *s; { return (0); }
int		(*ssignal(s, a))() int (*a)(); { return (a); }
int		stat(s, b) char *s; struct stat *b; { return (0); }
int		statfs(s, b) char *s; struct statfs *b; { return (0); }
int		stime(t) long *t; { return (0); }
int		strcasecmp(s1, s2) char *s1, *s2; { return (0); }
int		strcoll(s1, s2) char *s1, *s2; { return (0); }
char		*strcat(a, b) char *a, *b; { return (a); }
char		*strchr(a, b) char *a; { return (a); }
int		strcmp(a, b) char *a, *b; { return (0); }
char		*strcpy(a, b) char *a, *b; { return (a); }
size_t		strcspn(a, b) char *a, *b; { return (0); }
char		*strdup(a) char *a; { return (a); }
size_t		strftime(buf, maxsize, format, tm) char *buf, *format; size_t maxsize; struct tm *tm; {return (maxsize);}
void		string_to_decimal(pc,nmax,fortran_conventions,pd,pform,pechar) char **pc; int nmax; int fortran_conventions; decimal_record *pd; enum decimal_string_form *pform; char **pechar; {}
size_t		strlen(s) char *s; { return (0); }
int		strncasecmp(s1, s2, n) char *s1, *s2; { return (0); }
char		*strncat(a, b, n) char *a, *b; size_t n; { return (a); }
int		strncmp(a, b, n) char *a, *b; size_t n; { return (0); }
char		*strncpy(a, b, n) char *a, *b; size_t n; { return (a); }
char		*strpbrk(a, b) char *a, *b; { return (a); }
char		*strptime(buf,format,tm) char *buf, *format; struct tm *tm; {return ("");}
char		*strrchr(a, b) char *a; { return (a); }
size_t		strspn(a, b) char *a, *b; { return (0); }
char		*strstr(a,b) char *a, *b; { return (a); }
double		strtod(s, t) char *s, **t; { return (0.0); }
char		*strtok(a, b) char *a, *b; { return (a); }
long		strtol(s, t, b) char *s, **t; { return (0L); }
int		strxfrm(s1, s2, n) char *s1, *s2; { return (0); }
int		stty(fd, buf) struct sgttyb *buf; { return (0); }
void		svc_getreq(rdfds) int rdfds; {}
void		svc_getreqset(readfds) fd_set *readfds; {}
bool_t		svc_register(xprt, prog, vers, dispatch, prot) SVCXPRT *xprt; u_long prog, vers; void (*dispatch)(); int prot; { return (0); }
void		svc_run() {}
bool_t		svc_sendreply(xprt, xdr_results, xdr_location) SVCXPRT *xprt; xdrproc_t xdr_results; caddr_t xdr_location; { return (0); }
void		svc_unregister(prog, vers) u_long prog, vers; {}
void		svc_versquiet(x) SVCXPRT *x; {}
void		svcerr_auth(xprt, why) SVCXPRT *xprt; enum auth_stat why; {}
void		svcerr_decode(xprt) SVCXPRT *xprt; {}
void		svcerr_noproc(xprt) SVCXPRT *xprt; {}
void		svcerr_noprog(xprt) SVCXPRT *xprt; {}
void		svcerr_progvers(xprt, low_vers, high_vers) SVCXPRT *xprt; u_long low_vers, high_vers; {}
void		svcerr_systemerr(xprt) SVCXPRT *xprt; {}
void		svcerr_weakauth(xprt) SVCXPRT *xprt; {}
SVCXPRT		*svcfd_create(fd, sendsize, recvsize) int fd; u_int sendsize, recvsize; { return ((SVCXPRT *)0); }
SVCXPRT		*svcraw_create() { return ((SVCXPRT *)0); }
SVCXPRT		*svctcp_create(sock, sendsize, recvsize) int sock; u_int sendsize, recvsize; { return ((SVCXPRT *)0); }
SVCXPRT		*svcudp_bufcreate(sock, sendsz, recvsz) int sock; u_int sendsz, recvsz; { return ((SVCXPRT *)0); }
SVCXPRT		*svcudp_create(sock) int sock; { return ((SVCXPRT *)0); }
int		svcudp_enablecache(t, s) SVCXPRT *t; u_long s; { return (0); }
void		swab(f, t, n) char *f, *t; {}
int		swapon(s) char *s; { return (0); }
int		symlink(t, f) char *t, *f; { return (0); }
void		sync() {}
		/*VARARGS3*/
int		syscall(n, r, s, a) { return (n); }
long		sysconf(n) { static long x; return (x); }
		/*VARARGS2 PRINTFLIKE2*/
int		syslog(l, f) char *f; {}
int		system(s) char *s; { return (0); }
int		tcdrain(f) { return (0); }
int		tcflow(f, a) { return (0); }
int		tcflush(f, q) { return (0); }
int		tcgetattr(f, t) struct termios *t; { return (0); }
pid_t		tcgetpgrp(f) { static pid_t p; return (p); }
int		tcsendbreak(f, d) { return (0); }
int		tcsetattr(f, o, t) struct termios *t; { return (0); }
int		tcsetpgrp(f, p) pid_t p; { return (0); }
char		*tdelete(k, r, c) char *k, **r; int (*c)(); { return (k); }
long		tell(f) { return (0L); }
long		telldir(d) DIR *d; { return 0L; }
char		*tempnam(d, s) char *d, *s; { return (d); }
char		*tfind(k, r, c) char *k, **r; int (*c)(); { return (k); }
time_t		time(t) time_t *t; { return (*t);}
time_t		timegm(t) struct tm *t; { return (0); }
time_t		timelocal(t) struct tm *t; { return (0); }
time_t		timeoff(t, o) struct tm *t; long o; { return (0); }
clock_t		times(b) struct tms *b; { static clock_t x; return (x); }
FILE		*tmpfile() { return (stdin); }
char		*tmpnam(s) char *s; { return (s); }
int		toascii(i) { return (i); }
int		tolower(i) { return (i); }
int		_tolower(i) { return (i); }
int		toupper(i) { return (i); }
int		_toupper(i) { return (i); }
int		truncate(p, l) char *p; off_t l; { return (0); }
char		*tsearch(k, r, c) char *k, **r; int (*c)(); { return (k); }
char		*ttyname(f) { return (""); }
int		ttyslot() { return (0); }
void		twalk(r, f) char *r; void (*f)(); {}
void		tzset() {}
void		tzsetwall() {}
unsigned	ualarm(value, interval) unsigned value, interval; { return 0; }
daddr_t		ulimit(c, n) daddr_t n; { return (n); }
mode_t		umask(c) mode_t c; { return (c); }
int		umount(s) char *s; { return (0); }
int		unadvfs(s) char *s; { return (0); }
int		uname(n) struct utsname *n; { return (0); }
int		ungetc(c, f) FILE *f; { return (c); }
int		unlink(s) char *s; { return (0); }
int		unmount(s) char *s; { return (0); }
int		user2netname(netname, uid, domain) char *netname; int uid; char *domain; { return (0); }
void		usleep(useconds) unsigned useconds; { ; }
int		ustat(d, b) struct ustat *b; { return (d); }
int		utime(f, t) char *f; struct utimbuf *t; { return (0); }
int		utimes( f, t ) char *f; struct timeval *t; { return 0 ;}
char		*valloc(s) unsigned s; { return (""); }
int		vadvise(p) { return (p); }
int		vfork() { return (0); }
int		vfprintf(f, s, v) FILE *f; char *s; va_list v; { return (0); }
void		vhangup() {}
int		vprintf(s, v) char *s; va_list v; { return (0); }
int		vsprintf(p, s, v) char *p, *s; va_list v; { return (0); }
int		vsyslog(l, f, v) char *f; va_list v; {}
pid_t		wait(s) int *s; { static pid_t p; return (p); }
int		wait3(s, o, r) union wait *s; struct rusage *r; { return (1); }
int		wait4(pid, s, o, r) union wait *s; struct rusage *r; { return (1); }
pid_t		waitpid(p, s, o) pid_t p; int *s; { return (p); }
size_t		wcstombs(s, p, n) char *s; wchar_t *p; size_t n; { return (n); }
int		wctomb(s, pwc, n) char *s; wchar_t *pwc; size_t n; { return (0); }
int		write(f, b, n) char *b; unsigned n; { return (f); }
int		writev(f, v, l) struct iovec *v; {return (f); }
bool_t		xdr_accepted_reply(xdrs, ar) XDR *xdrs; struct accepted_reply *ar; { return (0); }
bool_t		xdr_array(xdrs, addrp, sizep, maxsize, elsize, elproc) XDR *xdrs; caddr_t *addrp; u_int *sizep, maxsize, elsize; xdrproc_t elproc; { return (0); }
bool_t		xdr_authdes_cred(xdrs, cred) XDR *xdrs; struct authdes_cred *cred;{ return (0); }
bool_t		xdr_authdes_verf(xdrs, verf) XDR *xdrs; struct authdes_verf *verf; { return (0); }
bool_t		xdr_authunix_parms(xdrs, p) XDR *xdrs; struct authunix_parms *p; { return (0); }
bool_t		xdr_bool(xdrs, bp) XDR *xdrs; bool_t *bp; { return (0); }
bool_t		xdr_bytes(xdrs, cpp, sizep, maxsize) XDR *xdrs; char **cpp; u_int *sizep, maxsize; { return (0); }
bool_t		xdr_callhdr(xdrs, cmsg) XDR *xdrs; struct rpc_msg *cmsg; { return (0); }
bool_t		xdr_callmsg(xdrs, cmsg) XDR *xdrs; struct rpc_msg *cmsg; { return (0); }
bool_t		xdr_char(xdrs, cp) XDR *xdrs; char *cp; { return (0); }
bool_t		xdr_cryptkeyarg(xdrs, objp) XDR *xdrs; cryptkeyarg *objp; { return (0); }
bool_t		xdr_cryptkeyres(xdrs, objp) XDR *xdrs; cryptkeyres *objp; { return (0); }
bool		xdr_datum(xdrs, p) XDR * xdrs; datum * p; { return (0); }
bool_t		xdr_des_block(xdrs, blkp) XDR *xdrs; des_block *blkp; { return (0); }
bool_t		xdr_double(xdrs, dp) XDR *xdrs; double *dp; { return (0); }
bool_t		xdr_enum(xdrs, ep) XDR *xdrs; enum_t *ep; { return (0); }
bool_t		xdr_float(xdrs, fp) XDR *xdrs; float *fp; { return (0); }
void		xdr_free(proc, objp) xdrproc_t proc; char *objp; {}
bool_t		xdr_getcredres(xdrs, objp) XDR *xdrs; getcredres *objp; { return (0); }
bool_t		xdr_int(xdrs, ip) XDR *xdrs; int *ip; { return (0); }
bool_t		xdr_keybuf(xdrs, objp) XDR *xdrs; keybuf objp; { return (0); }
bool_t		xdr_keystatus(xdrs, objp) XDR *xdrs; keystatus *objp; { return (0); }
bool_t		xdr_long(xdrs, lp) XDR *xdrs; long *lp; { return (0); }
bool_t		xdr_netnamestr(xdrs, objp) XDR *xdrs; netnamestr *objp; { return (0); }
bool_t		xdr_netobj(xdrs, np) XDR *xdrs; struct netobj *np; { return (0); }
bool_t		xdr_opaque(xdrs, cp, cnt) XDR *xdrs; caddr_t cp; u_int cnt; { return (0); }
bool_t		xdr_opaque_auth(xdrs, ap) XDR *xdrs; struct opaque_auth *ap; { return (0); }
bool_t		xdr_pmap(xdrs, regs) XDR *xdrs; struct pmap *regs; { return (0); }
bool_t		xdr_pmaplist(xdrs, rp) XDR *xdrs; struct pmaplist **rp; { return (0); }
bool_t		xdr_pointer(xdrs,objpp,obj_size,xdr_obj) XDR *xdrs; char **objpp; u_int obj_size; xdrproc_t xdr_obj; { return (0); }
bool_t		xdr_pwdnm(xdrs,objp) XDR *xdrs; pwdnm *objp; { return (0); }
bool_t		xdr_reference(xdrs, pp, size, proc) XDR *xdrs; caddr_t *pp; u_int size; xdrproc_t proc; { return (0); }
bool_t		xdr_rejected_reply(xdrs, rr) XDR *xdrs; struct rejected_reply *rr; { return (0); }
bool_t		xdr_replymsg(xdrs, rmsg) XDR *xdrs; struct rpc_msg *rmsg; { return (0); }
bool_t		xdr_rmtcall_args(xdrs, cap) XDR *xdrs; struct rmtcallargs *cap; { return (0); }
int		xdr_rmtcallres(xdrs, crp) XDR *xdrs; struct rmtcallres *crp; { return (0); }
bool_t		xdr_short(xdrs, sp) XDR *xdrs; short *sp; { return (0); }
bool_t		xdr_string(xdrs, cpp, maxsize) XDR *xdrs; char **cpp; u_int maxsize; { return (0); }
bool_t		xdr_u_char(xdrs, cp) XDR *xdrs; char *cp; { return (0); }
bool_t		xdr_u_int(xdrs, up) XDR *xdrs; u_int *up; { return (0); }
bool_t		xdr_u_long(xdrs, ulp) XDR *xdrs; u_long *ulp; { return (0); }
bool_t		xdr_u_short(xdrs, usp) XDR *xdrs; u_short *usp; { return (0); }
bool_t		xdr_union(xdrs, dscmp, unp, choices, dfault) XDR *xdrs; enum_t *dscmp; char *unp; struct xdr_discrim *choices; xdrproc_t dfault; { return (0); }
bool_t		xdr_unixcred(xdrs, objp) XDR *xdrs; unixcred *objp; { return (0); }
bool_t		xdr_vector(xdrs, basep, nelem, elemsize, xdr_elem) XDR *xdrs; char *basep; u_int nelem, elemsize; xdrproc_t xdr_elem; { return (0); }
bool_t		xdr_void() { return (0); }
bool_t		xdr_wrapstring(xdrs, cpp) XDR *xdrs; char **cpp; { return (0); }
bool		xdr_ypall(xdrs, c) XDR * xdrs; struct ypall_callback *c; { return (0); }
bool_t		xdr_yp_buf(x,o) XDR *x; /*yp_buf*/ char *o; { return (0); }
bool		xdr_yp_binding(xdrs, ps) XDR * xdrs; struct ypbind_binding *ps; { return (0); }
bool		xdr_yp_inaddr(xdrs, ps) XDR * xdrs; struct in_addr *ps; { return (0); }
bool		xdr_ypbind_resp(xdrs, ps) XDR * xdrs; struct ypbind_resp *ps; { return (0); }
bool		xdr_ypbind_setdom(xdrs, ps) XDR *xdrs; struct ypbind_setdom *ps; { return (0); }
bool		xdr_ypdomain_wrap_string(xdrs, ppstring) XDR * xdrs; char **ppstring; { return (0); }
bool		xdr_ypmaplist(xdrs, ps) XDR *xdrs; struct ypmaplist **ps; { return (0); }
bool		xdr_ypmaplist_wrap_string(xdrs, ps) XDR *xdrs; char *ps; { return (0); }
bool		xdr_ypmap_parms(xdrs, ps) XDR *xdrs; struct ypmap_parms *ps; { return (0); }
bool		xdr_ypmap_wrap_string(xdrs, ppstring) XDR * xdrs; char **ppstring;  { return (0); }
bool		xdr_ypowner_wrap_string(xdrs, ppstring) XDR * xdrs; char **ppstring; { return (0); }
bool		xdr_yppushresp_xfr(xdrs, ps) XDR * xdrs; struct yppushresp_xfr *ps; { return (0); }
bool		xdr_ypreq_key(xdrs, ps) XDR *xdrs; struct ypreq_key *ps; { return (0); }
bool		xdr_ypreq_nokey(xdrs, ps) XDR * xdrs; struct ypreq_nokey *ps; { return (0); }
bool		xdr_ypreq_xfr(xdrs, ps) XDR * xdrs; struct ypreq_xfr *ps; { return (0); }
bool		xdr_ypresp_key_val(xdrs, ps) XDR * xdrs; struct ypresp_key_val *ps; { return (0); }
bool		xdr_ypresp_maplist(xdrs, ps) XDR * xdrs; struct ypresp_maplist *ps; { return (0); }
bool		xdr_ypresp_master(xdrs, ps) XDR * xdrs; struct ypresp_master *ps; { return (0); }
bool		xdr_ypresp_order(xdrs, ps) XDR * xdrs; struct ypresp_order *ps; { return (0); }
bool		xdr_ypresp_val(xdrs, ps) XDR * xdrs; struct ypresp_val *ps; { return (0); }
void		xdrmem_create(xdrs, addr, size, op) XDR *xdrs; caddr_t addr; u_int size; enum xdr_op op; {}
void		xdrrec_create(xdrs, sendsize, recvsize, tcp_handle, readit, writeit) XDR *xdrs; u_int sendsize, recvsize; caddr_t tcp_handle; int (*readit)(); int (*writeit)(); {}
bool_t		xdrrec_endofrecord(xdrs, sendnow) XDR *xdrs; bool_t sendnow; { return (0); }
bool_t		xdrrec_eof(xdrs) XDR *xdrs; { return (0); }
int		xdrrec_readbytes(xdrs, addr, l) XDR *xdrs; caddr_t addr; u_int l; { return (0); }
bool_t		xdrrec_skiprecord(xdrs) XDR *xdrs; { return (0); }
void		xdrstdio_create(xdrs, file, op) XDR *xdrs; FILE *file; enum xdr_op op; {}
void		xprt_register(xprt) SVCXPRT *xprt; {}
void		xprt_unregister(xprt) SVCXPRT *xprt; {}
int		yp_all(d, m, c) char *d, *m; struct ypall_callback *c; { return (0); }
int		yp_bind(i) char *i; { return (0); }
int		yp_first(id, im, ok, okl, ov, ovl) char *id, *im; char **ok, **ov; int *okl, *ovl; { return (0); }
int		yp_get_default_domain(o) char **o; { return (0); }
int		yp_master(d, m, ms) char *d, *m, **ms; { return (0); }
int		yp_match(id, im, ik, ikl, ov, ovl) char *id, *im, *ik; char **ov; int *ovl; { return (0); }
int		yp_next(id, im, ik, ikl, ok, okl, ov, ovl) char *id, *im, *ik; char **ok, **ov; int *okl, *ovl; { return (0); }
int		yp_order(id, im, o) char *id, *im; int *o; { return (0); }
int		yp_softbind(d, t) char *d; { return (0); }
void		yp_unbind(i) char *i; {}
int		yp_update(dom, m, o, k, kl, d, dl) char *dom, *m, *k, *d; unsigned o; { return (0); }
char		*yperr_string(c) { return (""); }
int		ypprot_err(i) unsigned i; { return (0); }