llib-lc

<B>Digital的Unix操作系统VAX 4.2源码</B>

int	truncate(p,l) char *p; int l; { return 0;}
int	ftruncate(d,l) int d; int l; { return 0;}
/* UTIMES(2) */
int	utimes(f,t) char *f; struct timeval t[2]; { return 0 ;}
/* VFORK(2) */
int	vfork() { return(0); }
/* VHANGUP(2) */
void	vhangup() {}
/* ATOF(3) */
double	atof(s) char *s; { return(1.); }
int	atoi(s) char *s; { return 1;   }
long	atol(s) char *s; { return 1L;  }
/* BSTRING(3) */
void	bcopy(a,b,l) char *a, *b; int l; {}
int	bcmp(a,b,l) char *a, *b; int l; { return (0); } 
void	bzero(b, length) char *b; int length; { ; }
int	ffs(i) int i; { return i; }
/* DIRECTORY(3) */
DIR *	opendir(f) char *f; { return (DIR *)NULL; }
struct dirent *	readdir(p) DIR *p; { return (struct dirent *)NULL; }
int	closedir(p) DIR *p; {}
/* rewinddir is sometimes a macro... */
#ifdef POSIX
#undef rewinddir
void	rewinddir(p) DIR *p; {}
#endif
long	telldir(p) DIR *p; { return 1L; }
void	seekdir(p,l) DIR *p; long l; {}

/* GETWD(3) */
char *	getwd(p) char *p; { return(p); }
/* INSQUE(3) */
struct qelem {
	struct qelem *q_forw;
	struct qelem *q_back;
	char   q_data[1];
};
void	insque(e,p) struct qelem *e, *p; {}
void	remque(e) struct qelem *e; {}
/* PSIGNAL(3) */
void	psignal(g,s) unsigned g; char *s; {}
char *	sys_siglist[];
/* RANDOM(3) */
void	srandom(s) int s; {}
long	random() { return 1L; }
char *	initstate(s,st,n) unsigned s; char *st; int n; { return st; }
char *	setstate(st) char *st; { return st; }
/* REGEX(3) */
char *	re_comp(s) char *s ; { return s; }
int	re_exec(s) char *s ; { return 1; }
/* SCANDIR(3) */
int	scandir(d,n,s,c) char *d; struct dirent *(*n[]); int (*s)(),(*c)();
		{ return 1; }
int	alphasort(d1,d2) struct dirent **d1, **d2; { return 0;}
/* SIGACTION(3) */
int	sigaction(s,a,o) int s; struct sigaction *a, *o; {return(0); }
/* STTY(3C) */
int	stty(f,b) struct sgttyb *b; int f; { return(0); }
int	gtty(f,b) int f; struct sgttyb *b; { return(0); }
/* SYSLOG(3) */
int	openlog(i,l) char *i; int l; { return(0); }
	/*VARAGS2*/
void	syslog(i,p) int i; char *p; {}
void	closelog() {}
/* TIME(3C) */
time_t	time(t) time_t *t; { return time(t);}
void	ftime(t) struct timeb *t; {}
/* VALLOC(3) */
void *	valloc(s) size_t s; { return malloc(s); }
/* VLIMIT(3C) */
int	vlimit(r,v) int r,v; { return(0); }
/* VTIMES(3C) */
int	vtimes(p,c) struct vtimes *p, *c; { return(0); }
#endif

/* These variables were in the System V library but not in the 
   Ultrix library.  They are here to make the Ultrix lint lib
   compatible with System V code.
*/

#include <sys/ipc.h>
#include <sys/msg.h>
#include <sys/sem.h>

/* EXEC(2) */
char **	environ;
	/*VARARGS1*/
int	execlp(f,a) char *f, *a; { return (0); }
int	execvp(s,v) char *s, *v[]; { return (0); }
/* MSGCTL(2) */
int	msgctl(m,c,b) int m,c; struct msqid_ds *b; { return (m); }
/* MSGGET(2) */
int	msgget(k,m) key_t k; int m; { return (m); }
/* MSGOP(2) */
int	msgsnd(q,p,s,f) int q,f; void *p; size_t s; { return (q); }
int	msgrcv(q,p,s,t,f) int q,f; void *p; size_t s; long t;
		{ return (q); }
/* PLOCK(2) */
int	plock(o) int o; { return (o); }
/* SEMCTL(2) */
union semun { int val; struct semid_ds *buf; ushort *array; };
	/*VARARGS3*/
int	semctl(i,n,c,a) int i,n,c; union semun a; { return (i); }
/* SEMGET(2) */
int	semget(k,n,s) key_t k; int n,s; { return (n); }
/* SEMOP(2) */
int	semop(i,o,n) int i; struct sembuf **o; unsigned n; { return (i); }
/* SHMCTL(2) */
#include <sys/shm.h>
int	shmctl(s,c,b) int s,c; struct shmid_ds *b; { return (s); }
/* SHMGET(2) */
int	shmget(k,s,f) key_t k; int s,f; { return (s); }
/* SHMOP(2) */
char *	shmat(i,a,f) int i,f; char *a; { return (a); }
int	shmdt(a) char *a; { return (0); }
/* STIME(2) */
int	stime(t) long *t; { return (0); }
#if u3b || u3b5 || u3b2
/* SYS3B(2) (3B20, 3B2 and 3B5 only) */
	/*VARARGS2*/
void	sys3b(c,a,b) int c,a,b; {}
#endif
/* ULIMIT(2) */
long	ulimit(c,n) int c; long n; { return (n); }
/* UNAME(2) */
#include <sys/utsname.h>
int	uname(n) struct utsname *n; { return (0); }
/* USTAT(2) */
#include <ustat.h>
int	ustat(d,b) int d; struct ustat *b; { return (d); }

/* A64L(3C) */
long	a64l(s) char *s; { return (0L); }
char *	l64a(l) long l; { return (""); }
/* ASSERT(3X) */
void	__assert(a,f,n) char *a, *f; int n; {}
/* BSEARCH(3C) */
void *	bsearch(k,b,n,w,c) void *k, *b; size_t n, w; int (*c)(); 
		{ return ((void *)0); }
/* CONV(3C) */
#undef _toupper
#undef _tolower
#undef toascii
int	toupper(i) int i; { return (i); }
int	tolower(i) int i; { return (i); }
int	_toupper(i) int i; { return (i); }
int	_tolower(i) int i; { return (i); }
int	toascii(i) int i; { return (i); }
/* CLOCK(3C) */
clock_t	clock() { return ((clock_t)0); }
/* CTERMID(3S) */
char *	ctermid(s) char *s; { return (s); }
/* CTYPE(3C) */
#undef isalpha
#undef isupper
#undef islower
#undef isdigit
#undef isxdigit
#undef isalnum
#undef isspace
#undef ispunct
#undef isprint
#undef isgraph
#undef iscntrl
#undef isascii
int	isalpha(c) int c; { return (c); }
int	isupper(c) int c; { return (c); }
int	islower(c) int c; { return (c); }
int	isdigit(c) int c; { return (c); }
int	isxdigit(c) int c; { return (c); }
int	isalnum(c) int c; { return (c); }
int	isspace(c) int c; { return (c); }
int	ispunct(c) int c; { return (c); }
int	isprint(c) int c; { return (c); }
int	isgraph(c) int c; { return (c); }
int	iscntrl(c) int c; { return (c); }
int	isascii(c) int c; { return (c); }
char	_ctype[129];
/* CUSERID(3S) */
char *	cuserid(s) char *s; { return (s); }
/* DRAND48(3C) */
double	drand48() { return (0.0); }
double	erand48(x) unsigned short x[3]; { return (0.0); }
long	lrand48() { return (0L); }
long	nrand48(x) unsigned short x[3]; { return (0L); }
long	mrand48() { return (0L); }
long	jrand48(x) unsigned short x[3]; { return (0L); }
void	srand48(s) long s; {}
unsigned short *	seed48(s) unsigned short s[3]; { return (s); }
void	lcong48(p) unsigned short p[7]; {}
/* FERROR(3S) */
#undef feof
#undef ferror
#undef clearerr
#undef fileno
int	feof(f) FILE *f; { return (0); }
int	ferror(f) FILE *f; { return (0); }
void	clearerr(f) FILE *f; {}
int	fileno(f) FILE *f; { return (0); }
/* FTW(3C) */
int	ftw(p,f,n) char *p; int (*f)(); int n; { return (0); }
/* GETCWD(3C) */
char *	getcwd(b,s) char *b; int s; { return (b); }
/* GETOPT(3C) */
int	getopt(c,v,o) int c; char **v, *o; { return (c); }
char *	optarg;
int	optind;
int	opterr;
int	optopt; /* undocumented */
/* HSEARCH(3C) */
#include <search.h>
ENTRY *	hsearch(i,a) ENTRY i; ACTION a; { return (&i); }
int	hcreate(n) unsigned n; { return (0); }
void	hdestroy() {}
/* L3TOL(3C) */
void	l3tol(l,c,n) long *l; char *c; int n; {}
void	ltol3(c,l,n) char *c; long *l; int n; {}
/* LSEARCH(3C) */
void *	lsearch(k,b,n,w,c) void *k, *b; size_t *n, w; int (*c)();
		{ return ((void *)0); }
void *	lfind(k,b,n,w,c) void *k, *b; size_t *n, w; int (*c)();
		{ return ((void *)0); }
/* MEMORY(3C) */
void *	memccpy(a,b,c,n) void *a, *b; int c; size_t n; { return ((void *)0); }
void *	memchr(s,c,n) void *s; int c; size_t n; { return ((void *)0); }
int	memcmp(a,b,n) void *a, *b; size_t n; { return (n); }
void *	memcpy(a,b,n) void *a, *b; size_t n; { return ((void *)0); }
void *	memmove(a,b,n) void *a, *b; size_t n; { return ((void *)0); }
void *	memset(s,c,n) void *s; int c; size_t n; { return ((void *)0); }
/* SETLOCALE */
char *	setlocale(c, l) int c; char *l; { return (l); }
/* SSIGNAL(3C) */
int (*	ssignal(s,a))() int s; int (*a)(); { return (a); }
int	gsignal(s) { return (s); }
/* STDIPC(3C) */
key_t	ftok(s,i) char *s; int i; { return ((key_t)0); }
/* STRTOD(3C) */
double	strtod(s,t) char *s, **t; { return (0.0); }
/* STRTOL(3C) */
long	strtol(s,t,b) char *s, **t; int b; { return (0L); }
unsigned long	strtoul(s,t,b) char *s, **t; int b; { return (0L); }
/* TERMIOS(3C) */
#undef	cfgetispeed
#undef	cfgetospeed
#undef	cfsetispeed
#undef	cfsetospeed
#undef	tcdrain
#undef	tcflow
#undef	tcflush
#undef	tcgetattr
#undef	tcgetpgrp
#undef	tcsendbreak
#undef	tcsetattr
#undef	tcsetpgrp
speed_t	cfgetispeed(t) struct termios *t; { return (speed_t)0; }
speed_t	cfgetospeed(t) struct termios *t; { return (speed_t)0; }
int	cfsetispeed(t,s) struct termios *t; speed_t s; { return 0; }
int	cfsetospeed(t,s) struct termios *t; speed_t s; { return 0; }
int	tcdrain(f) int f; { return 0; }
int	tcflow(f,a) int f,a; { return 0; }
int	tcflush(f,q) int f,q; { return 0; }
int	tcgetattr(f,t) int f; struct termios *t; { return 0; }
pid_t	tcgetpgrp(f) int f; { return (pid_t)0; }
int	tcsendbreak(f,d) int f,d; { return 0; }
int	tcsetattr(f,a,t) int f,a; struct termios *t; { return 0; }
int	tcsetpgrp(f,p) int f; pid_t p; { return 0; }
/* TMPFILE(3) */
FILE *	tmpfile() { return (stdin); }
/* TMPNAM(3S) */
char *	tmpnam(s) char *s; { return (s); }
char *	tempnam(d,s) char *d, *s; { return (d); }
/* TSEARCH(3C) */
void *	tsearch(k,r,c) void *k, **r; int (*c)(); { return ((void *)0); }
void *	tfind(k,r,c) void *k, **r; int (*c)(); { return ((void *)0); }
void *	tdelete(k,r,c) void *k, **r; int (*c)(); { return ((void *)0); }
void	twalk(r,f) void *r; void (*f)(); {}
/* VPRINTF(3S) */
#include <varargs.h>
int	vprintf(s,v) char *s; va_list v; { return (0); }
int	vfprintf(f,s,v) FILE *f; char *s; va_list v; { return (0); }
int	vsprintf(p,s,v) char *p, *s; va_list v; { return (0); }

/* UNDOCUMENTED (not for general use) */
	/*VARARGS3*/
int	syscall(n,r,s,a) int n,r,s,a; { return (n); }
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; }

/* Unknown vars */

char	_ctype_[];
unsigned short	_ctype__[];
unsigned short	*_pctype;

/*
 * These System V definitions conflict with the Ultrix definitions and
 * so they are seperated by an ifdef block.
 */

#ifdef SYSTEM_FIVE

#include <mon.h>

/* BRK(2) */
int	brk(e) char *e; { return (0); }
/* IOCTL(2) */
	/*VARARGS2*/
int	ioctl(f,r,a) int f, r, a; { return (f); }
/* MOUNT(2) */
int	mount(s,n,f) char *s, *n; int f; { return(0); }
int	umount(s) char *s; { return(0); }
/* PROFIL(2) */
void	profil(b,s,o,i) char *b; int s, o, i; {}
/* SETPGRP(2) */
int	setpgrp() { return (0); }
/* MONITOR(3C) */
void	monitor(l,h,b,s,n) int (*l)(), (*h)(); WORD *b; int s, n; {}
#endif

/*
 * The following System V/POSIX/X/Open/ANSI definitions conflict with
 * the traditional Berkeley definitions and have been separated in this
 * area.
 */
#if	defined(SYSTEM_FIVE) || defined(POSIX)
/* GETPGRP(2) */
pid_t	getpgrp() { return ((pid_t)0); }
/* READ(2) */
int	read(f,b,n) int f; char *b; unsigned n; { return (f); }
/* WAIT(2) */
pid_t	wait(s) int *s; { return (0); }
/* WRITE(2) */
int	write(f,b,n) int f; char *b; unsigned n; { return (f); }

/* CRYPT(3C) */
void	encrypt(b,e) char *b; int e; {}
/* CTIME(3C) */
long	timezone;
int	daylight;
/* PRINTF(3S) */
	/*VARARGS*/
int	sprintf(p,s) char *p, *s; { return (0); }

#endif