![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to llib-lc CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / lint|
Return to llib-lc CVS log | Up to [Research Unix] / researchv10no / cmd / lint |
1.1 root 1: /* LINTLIBRARY */
2: /* Properly void-valued functions are declared void only if they
3: * are so declared in one of the included files. Otherwise they are
4: * declared VOID, which is defined as the empty string. This is
5: * a compromise to keep lint quiet about these functions, which
6: * normally are typed by default. The cost is that lint will not
7: * discover cases where the return value of a VOID function is
8: * used. And it will complain about super-honest programs that
9: * contain the proper void declaration.
10: *
11: * Although lint does not check anything but the names
12: * and sizes (if needed) of struct types, cyntax does.
13: * Thus stat.h, etc, are useless to lint, but helpful to cyntex.
14: */
15: #define VOID
16: #include <sys/types.h>
17: #include <sys/stat.h>
18: #include <sys/timeb.h>
19: #include <sys/times.h>
20: #include <label.h>
21: #include <ctype.h>
22: #include <fio.h>
23: #include <fstab.h>
24: #include <grp.h>
25: #include <libc.h>
26: #include <math.h>
27: #include <ndir.h>
28: #include <nlist.h>
29: #include <pwd.h>
30: #include <regexp.h>
31: #include <setjmp.h>
32: #include <sys/filio.h>
33: #include <sys/ttyio.h>
34: #include <signal.h>
35: #include <stdio.h>
36: #include <time.h>
37: #include <utsname.h>
38: char chrtab[][16];
39: char _ctype[];
40: char **environ;
41: int errno;
42: int gcmax; /* galloc */
43: int gcmin; /* galloc */
44: struct _iobuf _iob[_NFILE]; /* stdio */
45: char *optarg; /* getopt */
46: int optind; /* getopt */
47: int printcol; /* print */
48: int signgam; /* gamma */
49: char *sys_errlist[];
50: int sys_nerr;
51: /* line disciplines */
52: int arp_ld;
53: int buf_ld;
54: int cdkp_ld;
55: int chaos_ld;
56: int chroute_ld;
57: int conn_ld;
58: int dkp_ld;
59: int dump_ld;
60: int filter_ld;
61: int ip_ld;
62: int mesg_ld;
63: int ntty_ld;
64: int pk_ld;
65: int rdk_ld;
66: int rmesg_ld;
67: int tcp_ld;
68: int trc_ld;
69: int tty_ld;
70: int udp_ld;
71: int uxp_ld;
72: VOID abort() { }
73: int abs(i) { return i; }
74: int access(name, mode) char *name; { return 1; }
75: int acct(f) char *f; { return 1; }
76: double acos(x) double x; { return x; };
77: unsigned alarm(s) unsigned s; { return 1; }
78: char *asctime(t) struct tm *t; { return ""; }
79: double asin(x) double x; { return x; };
80: double atan(x) double x; { return x; };
81: double atan2(x, y) double x, y; { return x; };
82: double atof(s) char *s; { return 1.; }
83: int atoi(s) char *s; { return 1; }
84: long atol(s) char *s; { return 1L; }
85: double besj0(x) double x; { return x; };
86: double besj1(x) double x; { return x; };
87: double besjn(n, x) double x; { return x; };
88: double besy0(x) double x; { return x; };
89: double besy1(x) double x; { return x; };
90: double besyn(n, x) double x; { return x; };
91: int brk(a) char *a; { return 0; }
92: char *calloc(n, s) unsigned n, s; { return ""; }
93: double ceil(x) double x; { return x; };
94: VOID cfree(p) char *p; { }
95: int chdir(s) char *s; { return 1; }
96: int chmod(s, m) char *s; { return 1; }
97: int chown(s, u, g) char *s; { return 1; }
98: int chroot(d) char *d; { return 1; }
99: int clearerr(stream) FILE *stream; { return 1; }
100: int close(f) { return 1; }
101: void closedir(d) DIR *d; { }
102: double cos(x) double x; { return x; };
103: double cosh(x) double x; { return x; };
104: int creat(s, m) char *s; { return 1; }
105: char *crypt(k, s) char *k, *s; { return ""; }
106: char *ctime(c) time_t *c;{ return ""; }
107: int dialout(c, t) char *c, *t; { return 1; }
108: int dup(f) { return f; }
109: int dup2(f1, f2) { return 1; }
110: char *ecvt(v, n, d, s) double v; int *d, *s; { return ""; }
111: VOID encrypt(s, i) char *s; { }
112: VOID endfsent() { }
113: VOID endgrent() { }
114: int endpwent() { }
115: double erf(x) double x; { return x; };
116: double erfc(x) double x; { return x; };
117: /* VARARGS */
118: int execl(f, a) char *f, *a; { }
119: /* VARARGS */
120: int execlp(f, a) char *f, *a; { }
121: /* VARARGS */
122: int execle(name, a) char *name, *a; { }
123: int execv(s, v) char *s, *v[]; { }
124: int execvp(s, v) char *s, *v[]; { }
125: int execve(n, a, e) char *n, *a[], *e[]; { }
126: void exit(s) { }
127: void _exit(s) { }
128: double exp(x) double x; { return x; };
129: double fabs(x) double x; { return x; };
130: int fchmod(fd, mode) { return 1; }
131: int fchown(fd, owner, group) { return 1; }
132: int fclose(f) FILE *f; { return 1;}
133: char *fcvt(v, n, d, s) double v; int *d, *s; { return ""; }
134: FILE *fdopen(fd, m) char *m; { return stdin;}
135: int Fflush(fd) { return 1; }
136: int fflush(f) FILE *f; { return 1;}
137: int Fgetc(fd) { return 1; }
138: int fgetc(stream) FILE *stream; { return 1; }
139: int fgetflab(fd, l) struct label *l; { return 1; }
140: char *fgets( s, l, f ) char *s; FILE *f; { return ""; }
141: void Finit(fd, s) char *s; { }
142: double floor(x) double x; { return x; };
143: double fmod(x, y) double x, y; { return 1; }
144: FILE *fopen(s, m) char *s, *m; { return stdin; }
145: int fork() { return 1; }
146: /* VARARGS */ /*PRINTFLIKE2*/
147: int Fprint(fd, s) char *s; { return 1; }
148: /* VARARGS */ /*PRINTFLIKE2*/
149: int fprint(fd, s) char *s; { return 1; }
150: /* VARARGS */ /*PRINTFLIKE2*/
151: int fprintf( f, s ) FILE *f; char *s; { }
152: int Fputc(fd, c) { return 1; }
153: int fputc(c, stream) FILE *stream; { return 1; }
154: int fputs(s, f) char *s; FILE *f; { return 1;}
155: double frand() { return 1.; };
156: char *Frdline(fd) { return ""; }
157: long Fread(fd, s, n) char *s; long n; { return 1L; }
158: int fread( p, s, n, f ) char *p; FILE *f; { return 1;}
159: VOID free(p) char *p; { }
160: FILE *freopen(s, m, f) char *s, *m; FILE *f; { return stdin; }
161: double frexp(v, e) double v; int *e; { return v; }
162: /* VARARGS */ /*SCANFLIKE2*/
163: int fscanf( f, s ) FILE *f; char *s; { return 1;}
164: long Fseek(fd, o, p) long o; { return 1l; }
165: int fseek(f, o, p) FILE *f; long o; { return 1; }
166: int fsetflab(fd, l) struct label *l; { return 1; }
167: int fstat(f, b) struct stat *b; { return 1; }
168: long ftell(f) FILE *f; { return 1L; }
169: VOID Ftie(i, o) { }
170: VOID ftime(tp) struct timeb *tp; { }
171: int ftw(p, f, d) char *p; int (*f)(); { return 1; }
172: void Fundo(fd) { }
173: long Fwrite(fd, s, n) char *s; long n; { return 1; }
174: int fwrite( p, s, n, f ) char *p; FILE *f; { return 1;}
175: char *galloc(n) unsigned n; { return ""; }
176: double gamma(x) double x; { return x; };
177: VOID garbage( ) { }
178: int gcd(a, b) { return 1; }
179: char *gcvt(v, n, b) double v; char *b; { return ""; }
180: char *getcwd(b, s) char *b; { return ""; }
181: int getegid() { return 1; }
182: char *getenv(name) char *name; { return ""; }
183: int geteuid() { return 1; }
184: int getfields(s, p, n) char *s, **p; { return 1; }
185: int getflab(s, l) char *s; struct label *l; { return 1; }
186: struct fstab *getfsent() { return getfsent(); }
187: struct fstab *getfsfile(s) char *s; { return getfsfile(s); }
188: struct fstab *getfsspec(s) char *s; { return getfsspec(s); }
189: int getgid() { return 1; }
190: struct group *getgrent() { return getgrent(); }
191: struct group *getgrgid(g) { return getgrgid(g); }
192: struct group *getgrnam(s) char *s; { return getgrnam(s); }
193: int getgroups(n, g) short *g; { return 1; }
194: char *getlogin() { return ""; }
195: int getlogname(s) char *s; { return 1; }
196: int getmfields(s, p, n) char *s, **p; { return 1; }
197: int getopt(argc, argv, o) char **argv, *o; { return 1; }
198: char *getpass(p) char *p; { return ""; }
199: int getpgrp(p) { return 1; }
200: int getpid() { return 1; }
201: int getplab(l, c) struct label *l, *c; { return 1; }
202: int getppid() { return 1; }
203: struct passwd *getpwent() { return getpwent(); }
204: struct passwd *getpwnam(name) char *name; { return getpwnam(name); }
205: struct passwd *getpwuid(uid) { return getpwuid(uid); }
206: int getuid() { return 1; }
207: int getw(stream) FILE *stream; { return 1; }
208: char *getwd(buf) char *buf; { return ""; }
209: VOID gfree(p) char *p; { }
210: struct tm *gmtime(c) time_t *c; { return gmtime(c); }
211: double hypot(x, y) double x, y; { return x; };
212: VOID ialloc(ptr, size) char *ptr; unsigned size; { }
213: int ioctl(f, r, argp) struct sgttyb *argp; { return 1; }
214: int isatty(fildes) { return 1; }
215: int kill(p, s) { return 1; }
216: long labs(n) long n; { return 1L; }
217: long lcm(a, b) { return lcm(a, b); }
218: double ldexp(x,y) double x; { return x; };
219: int link(a, b) char *a, *b; { return 1; }
220: struct tm *localtime(c) time_t *c; { return localtime(c); }
221: double log(x) double x; { return x; };
222: double log10(x) double x; { return x; };
223: VOID longjmp(env, val) jmp_buf env; { }
224: long lrand() { return lrand(); }
225: long lseek(f, o, d) long o; { return 1; }
226: int lstat(n, b) char *n; struct stat *b; { return 1; }
227: VOID ltol3(cp, lp, n) char *cp; long *lp; { }
228: char *malloc(n) unsigned n; { return "";}
229: int max(a, b) { return 1; }
230: char *memccpy(s1, s2, c, n) char *s1, *s2; { return ""; }
231: char *memchr(s, c, n) char *s; { return ""; }
232: int memcmp(s1, s2, n) char *s1, *s2; { return 1; }
233: char *memcpy(s1, s2, n) char *s1, *s2; { return ""; }
234: char *memset(s, c, n) char *s; { return ""; }
235: int min(a, b) { return 1; }
236: int mkdir(s,m) char *s; { return 1; }
237: int mknod(n, m, a) char *n; { return 1; }
238: char *mktemp(p) char *p; { return "";}
239: double modf(v, iptr) double v, *iptr; { return v; }
240: VOID monitor(l, h, b, s, n) int (*l)(), (*h)(); short *b; { }
241: int mount(s, n, f) char *s, *n; { return 1; }
242: void nap(i) { }
243: void nice(p) { }
244: VOID nlist(s, p) char *s; struct nlist *p; { }
245: int nrand(val) { return 1; }
246: int onexit(f) int (*f)(); { return 1; }
247: int open(f, m) char *f; { return 1; }
248: DIR *opendir(f) char *f; { return opendir(f); }
249: void pause() { }
250: int pclose(stream) FILE *stream; { return 1; }
251: VOID perror(s) char *s; { }
252: int pipe(f) int f[2]; { return 1; }
253: FILE *popen(c, t) char *c, *t; { return popen(c, t); }
254: double pow(x, y) double x, y; { return x; }
255: double pow10(n) { return 1.; }
256: FILE *ppopen(c, t) char *c, *t; { return ppopen(c, t); }
257: /* VARARGS */ /*PRINTFLIKE1*/
258: int print( s ) char *s; { }
259: /* VARARGS */ /*PRINTFLIKE1*/
260: int printf( s ) char *s; { }
261: void profil(b, s, o, i) char *b; { }
262: int ptopen(name) char *name; { return 1; }
263: int puts(s) char *s; { return 1;}
264: int putw(w, stream) FILE *stream; { return 1; }
265: VOID qsort(b, n, w, compar) char *b; int (*compar)(); { }
266: struct passwd *pwdecode(p) char *p; { return pwdecode(p); }
267: int rand( ) { return 1; }
268: regexp *regcomp(s) char *s; { return regcomp(s); }
269: int regexec(p, s, m, n) regexp *p; char *s; regsubexp *m; { return 1; }
270: void regsub(s, t, m, n) char *s, *t; regsubexp *m; { }
271: int read(f, b, l) char *b; { return l; }
272: struct direct *readdir(d) DIR *d; { return readdir(d); }
273: int readlink(name, b, s) char *name, *b; { return 1; }
274: char *realloc(p, n) char *p; unsigned n; { return "";}
275: VOID rewind(f) FILE *f; { }
276: int rmdir(s) char *s; { return 1; }
277: char *sbrk(i) { return ""; }
278: /* VARARGS */ /*SCANFLIKE1*/
279: int scanf( f ) char *f; { return 1; }
280: void seekdir(d, loc) DIR *d; { }
281: int select(n, r, w, m) fd_set *r, *w; { return 1; }
282: VOID setbuf( f, b ) FILE *f; char *b; { }
283: char *setfields(s) char *s; { return ""; }
284: int setflab(s, l) char *s; struct label *l; { return 1; }
285: int setfsent() { return 1; }
286: int setgid(g) { return 1; }
287: int setgrent() { return 1; }
288: int setgroups(n, g) short *g; { return 1; }
289: int setjmp(e) jmp_buf e; { return 1; }
290: VOID setkey(k) char *k; { }
291: int setlogname(s) char *s; { return 1; }
292: int setpgrp(p, n) { return 1; }
293: int setplab(l, c) struct label *l, *c; { return 1; }
294: int setpwent() { return 1; }
295: int setruid(u) { return 1; }
296: unsigned long settod(u) unsigned long u; { return u; }
297: int setuid(u) { return 1; }
298: int sgn(a) { return 1; }
299: SIG_TYP signal(c, f) SIG_TYP f; { return f; }
300: double sin(x) double x; { return x; };
301: double sinh(x) double x; { return x; };
302: VOID sleep(i) unsigned i; { }
303: /* VARARGS */ /*PRINTFLIKE2*/
304: int sprint( s, f ) char *s, *f; { return 1;}
305: /* VARARGS */ /*PRINTFLIKE2*/
306: int sprintf( s, f ) char *s, *f; { return 1;}
307: double sqrt(x) double x; { return x; };
308: VOID srand(seed) { }
309: /* VARARGS */ /*SCANFLIKE2*/
310: int sscanf( s, f ) char *s, *f; { return 1; }
311: int stat(s, b) char *s; struct stat *b; { return 1; }
312: int stime(tp) long *tp; { return 1; }
313: char *strcat(a, b) char *a, *b; { return ""; }
314: char *strchr(s, c) char *s; { return ""; }
315: int strcmp(a, b) char *a, *b; { return 1; }
316: VOID strconv(s, m, n) char *s; { }
317: char *strcpy(a, b) char *a, *b; { return ""; }
318: int strcspn(s1, s2) char *s1, *s2; { return 1; }
319: char *strdup(s) char *s; { return ""; }
320: int strlen(s) char *s; { return 1; }
321: char *strncat(s1, s2, n) char *s1, *s2; { return ""; }
322: int strncmp(s1, s2, n) char *s1, *s2; { return 1; }
323: char *strncpy(s1, s2, n) char *s1, *s2; { return ""; }
324: char *strpbrk(s1, s2) char *s1, *s2; { return ""; }
325: char *strrchr(s, c) char *s; { return ""; }
326: int strspn(s1, s2) char *s1, *s2; { return 1; }
327: double strtod(s, r) char *s, **r; { return 1.; }
328: char *strtok(s1, s2) char *s1, *s2; { return ""; }
329: long strtol(s, p, b) char *s; char**p; { return 1L; }
330: unsigned long strtoul(s, p, b) char *s; char**p; { return 1; }
331: VOID swab(a, b, n) char *a, *b; { }
332: int symlink(s1, s2) char *s1, *s2; { return 1; }
333: void sync() { }
334: /* VARARGS */
335: int syscall(n) { }
336: int system(s) char *s; { return 1; }
337: double tan(x) double x; { return x; };
338: double tanh(x) double x; { return x; };
339: long telldir(d) DIR *d; { return 1L; }
340: time_t time(t) time_t *t; { return 1;}
341: long timec(s) char *s; { return 1L; }
342: long timegm(t) struct tm *t; { return 1L; }
343: long timelocal(t, s) struct tm *t; char *s; { return 1L; }
344: int times(b) struct tms *b; { }
345: char *timezone(z, dst) { return ""; }
346: char *tmpnam(s) char s[L_tmpnam]; { return ""; }
347: int tolower(c) { return 1; }
348: int toupper(c) { return 1; }
349: char *ttyname(f) { return ""; }
350: int ttyslot() { return 1; }
351: int umask(complmode) { return 1; }
352: int umount(special) char *special; { return 1; }
353: int uname(name) struct utsname *name; { return 1; }
354: int ungetc( c, f ) FILE *f; { return c; }
355: int unlink(s) char *s; { return 1; }
356: int utime(file, tp) char *file; time_t tp[2]; { return 1; }
357: int wait(s) int *s; { return 1; }
358: int write(f, b, l) char *b; { return l; }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.