Return to llib-lc CVS log

Up to [CSRG BSD Unix] / 3BSD / cmd / lint

Annotation of 3BSD/cmd/lint/llib-lc, revision 1.1

1.1     ! root        1:        /* LINTLIBRARY */
        !             2: #include <stdio.h>
        !             3: #include <sgtty.h>
        !             4: #include <sys/types.h>
        !             5: #include <sys/stat.h>
        !             6: #include <time.h>
        !             7: int    errno;
        !             8: int    alarm(s) unsigned s; { return(s); }
        !             9: char   *brk(a) char *a; { return(a); }
        !            10: int    chdir(s) char *s; { return(0); }
        !            11: int    chmod(s, m) char *s; { return(0); }
        !            12: int    chown(s, u, g) char *s; { return(0); }
        !            13: int    close(f) { return(0); }
        !            14: int    creat(s, m) char *s; { return(0); }
        !            15: int    dup(f) { return(f); }
        !            16:        /* VARARGS */
        !            17:        execl(f, a) char *f, *a; {;}
        !            18:        execv(s, v) char *s, *v[]; {;}
        !            19:        exit(s) {;}
        !            20: int    fork() { return(0); }
        !            21: int    fstat(f, b) struct stat *b; { return(0); }
        !            22: int    getgid() { return(1); }
        !            23: int    getegid() { return(1); }
        !            24: int    getpid() { return(1); }
        !            25: int    getuid() { return(1); }
        !            26: int    geteuid() { return(1); }
        !            27: int    gtty(f, b) struct sgttyb *b; { return(0); }
        !            28: int    kill(p, s) { return(0); }
        !            29: int    link(a, b) char *a, *b; { return(0); }
        !            30: long   lseek(f, o, d) long o; { return(0); }
        !            31: int    mknod(n, m, a) char *n; { return(0); }
        !            32: char   *mktemp(p) char *p; { return(p);}
        !            33: int    mount(s, n, f) char *s, *n; { return(0); }
        !            34: int    nice(p) { return(0); }
        !            35: int    open(f, m) char *f; { return(0); }
        !            36:        pause() {;}
        !            37: int    pipe(f) int f[2]; { return(0); }
        !            38:        profil(b, s, o, i) char *b; {;}
        !            39: int    ptrace(r, p, a, d) { return(0); }
        !            40: int    read(f, b, l) char *b; { return(l); }
        !            41: char   *sbrk(i) { return((char *)0); }
        !            42: int    seek(f, o, p) { return(0); }
        !            43: int    setgid(g) { return(0); }
        !            44: int    setuid(u) { return(0); }
        !            45: int    (*signal(c, f))() int (*f)(); { return(f); }
        !            46: int    stat(s, b) char *s; struct stat *b; { return(0); }
        !            47: char   *strcat(a, b) char *a, *b; { ; }
        !            48: int    strcmp(a, b) char *a, *b; { return(1); }
        !            49: char   *strcpy(a, b) char *a, *b; { ; }
        !            50: int    strlen(s) char *s; { return(1); }
        !            51: int    stty(f, b) struct sgttyb *b; { return(0); }
        !            52: long   tell(f) { return((long)0); }
        !            53: int    system(s) char *s; { return(0); }
        !            54: time_t time(t) time_t *t; { return( 0 );}
        !            55: int    unlink(s) char *s; { return(0); }
        !            56: int    wait(s) int *s; { return(1); }
        !            57: int    write(f, b, l) char *b; { return(l); }
        !            58: char   *calloc(n,s) unsigned n, s; { static char c[1]; return(c); }
        !            59: char   *malloc(n) unsigned n; {static char c; return(&c);}
        !            60: char   *realloc(p, n) char *p; unsigned n; { static char c; return(&c);}
        !            61:        free(p) char *p; {;}
        !            62:        fclose(f) FILE *f; {return(0);}
        !            63:        fflush(f) FILE *f; {return(0);}
        !            64: char   *fgets( s, l, f ) char *s; FILE *f; { return(s); }
        !            65: FILE   *fopen(s,m) char *s, *m; { return(stdin); }
        !            66: FILE   *freopen(s, m, f) char *s, *m; FILE *f; { return(stdin); }
        !            67: FILE   *fdopen(fd, m) char *m; { return(stdin);}
        !            68:        /* VARARGS */
        !            69:        fprintf( f, s ) FILE *f; char *s; {;}
        !            70:        fputs(s,f) char *s; FILE *f; {;}
        !            71:        fread( p, s, n, f ) char *p; FILE *f; {return(1);}
        !            72:        /* VARARGS */
        !            73:        fscanf( f, s ) FILE *f; char *s; {return(1);}
        !            74: int    fwrite( p, s, n, f ) char *p; FILE *f; {return(0);}
        !            75:        intss(){return(1); }
        !            76:        /* VARARGS */
        !            77:        printf( s ) char *s; {;}
        !            78:        rewind(f) FILE *f; {;}
        !            79:        /* VARARGS */
        !            80:        scanf( f ) char *f; {return(1); }
        !            81:        setbuf( f, b ) FILE *f; char *b; {;}
        !            82:        /* VARARGS */
        !            83: char   *sprintf( s, f ) char *s, *f; { return(s);}
        !            84:        /* VARARGS */
        !            85:        sscanf( s, f ) char *s, *f; { return(1); }
        !            86:        ungetc( c, f ) FILE *f; {  return(c); }
        !            87: char   *ctime(c) time_t *c;{ return(""); }
        !            88: struct tm *localtime(c) time_t *c; { return localtime(c); }
        !            89: struct tm *gmtime(c) time_t *c; { return gmtime(c); }
        !            90: char   *asctime(t) struct tm *t; { return(""); }
        !            91:        abort() {}
        !            92: int    abs(i) int i; { return(i); }
        !            93: double atof(s) char *s; { return(1.); }
        !            94: char   *crypt(k,s) char *k, *s; { return(""); }
        !            95:        setkey(k) char *k; {}
        !            96:        encrypt(s, i) char *s; {}
        !            97: char   *ecvt(v, n, d, s) double v; int *d, *s; { return(""); }
        !            98: char   *fcvt(v, n, d, s) double v; int *d, *s; { return(""); }
        !            99: char   *gcvt(v, n, b) double v; char *b; { return(""); }
        !           100:        monitor(l, h, b, s, n) int (*l)(), (*h)(); short *b; {}
        !           101:        perror(s) char *s; {}
        !           102:        setjmp(e) int e[3]; { return(0); }
        !           103:        sleep(i) unsigned i; {}
        !           104: struct _iobuf _iob[_NFILE];
        !           105: char   _ctype_[];

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.