Return to llib-lg CVS log

Up to [Research Unix] / researchv10dc / cmd / cyntax / lib

Annotation of researchv10dc/cmd/cyntax/lib/llib-lg, revision 1.1

1.1     ! root        1:        /* LINTLIBRARY */
        !             2: #define        lint
        !             3: #include <fio.h>
        !             4: #include <setjmp.h>
        !             5: #include <u.h>
        !             6: #include <gnot.h>
        !             7: #include <font.h>
        !             8: #include <libc.h>
        !             9: /*
        !            10:  * System calls
        !            11:  */
        !            12: 
        !            13: int    errno;
        !            14: int    access(name, mode) char *name; { return 1; }
        !            15: int    brk(a) char *a; { return 0; }
        !            16: int    chdir(s) char *s; { return 1; }
        !            17: int    close(f) { return 1; }
        !            18: int    create(s, m, p) char *s; long p; { return 1; }
        !            19: int    dup(f1, f2) { return 1; }
        !            20: int    errstr(e, s) char *s; { return 1; }
        !            21:        exec(f, a) char *f, **a; { }
        !            22:        /* VARARGS */
        !            23:        execl(f, a) char *f, *a; { }
        !            24: void   exit(n) { }
        !            25: int    fmount(s) char*s; { return 1L; }
        !            26: int    fork() { return 1; }
        !            27: int    fstat(f, d) Dir *d; { return 1; }
        !            28: int    getpgrp() { return 1; }
        !            29: int    getpid() { return 1; }
        !            30: int    mount(s, n) char *s, *n; { return 1; }
        !            31: int    newpgrp() { return 1; }
        !            32: int    open(f, m) char *f; { return 1; }
        !            33: int    pipe(f) int f[2]; { return 1; }
        !            34: long   read(f, b, l) char *b; long l; { return l; }
        !            35: int    remove(s) char *s; { return 1; }
        !            36: void   *sbrk(i) long i; { return (void *)0; }
        !            37: long   seek(f, o, d) long o; { return 1; }
        !            38: int    sleep(s) long s; { return 1; }
        !            39: int    stat(s, d) char *s; Dir *d; { return 1; }
        !            40: long   times(b) long *b; { return 1L; }
        !            41: int    unmount(a, b) char *a, *b; { return 1; }
        !            42: int    userstr(t, d, uid, s) char *s; { return 1; }
        !            43: int    wait() { return 1; }
        !            44: long   write(f, b, l) char *b; long l; { return l; }
        !            45: 
        !            46: /*
        !            47:  * String routines
        !            48:  */
        !            49: 
        !            50: char   *strcat(a, b) char *a, *b; { return ""; }
        !            51: char   *strchr(s, c) char *s; { return ""; }
        !            52: int    strcmp(a, b) char *a, *b; { return 1; }
        !            53: char   *strcpy(a, b) char *a, *b; { return ""; }
        !            54: long   strcspn(s1, s2) char *s1, *s2; { return 1; }
        !            55: char   *strdup(s) char *s; { return ""; }
        !            56: long   strlen(s) char *s; { return 1; }
        !            57: char   *strncat(s1, s2, n) char *s1, *s2; { return ""; }
        !            58: int    strncmp(s1, s2, n) char *s1, *s2; { return 1; }
        !            59: char   *strncpy(s1, s2, n) char *s1, *s2; { return ""; }
        !            60: char   *strpbrk(s1, s2) char *s1, *s2; { return ""; }
        !            61: char   *strrchr(s, c) char *s; { return ""; }
        !            62: long   strspn(s1, s2) char *s1, *s2; { return 1; }
        !            63: char   *strtok(s1, s2) char *s1, *s2; { return ""; }
        !            64: 
        !            65: /*
        !            66:  * Memory routines
        !            67:  */
        !            68: 
        !            69: void   *memccpy(s1, s2, c, n) char *s1, *s2; long n; { return (void *)""; }
        !            70: void   *memchr(s, c, n) char *s; long n; { return (void *)""; }
        !            71: int    memcmp(s1, s2, n) char *s1, *s2; long n; { return 1; }
        !            72: void   *memcpy(s1, s2, n) char *s1, *s2; long n; { return (void *)""; }
        !            73: void   *memset(s, c, n) char *s; long n; { return (void *)""; } 
        !            74: void   *malloc(n) unsigned long n; { return (void *)"";}
        !            75: void   free(p) char *p; { }
        !            76:        ialloc(ptr, size) char *ptr; unsigned size; { }
        !            77: void   *realloc(p, n) char *p; unsigned n; { return (void *)"";}
        !            78: 
        !            79: /*
        !            80:  * Formatted I/O routines
        !            81:  */
        !            82: int    atoi(s) char *s; { return 1; }
        !            83: long   atol(s) char *s; { return 1L; }
        !            84:        /* VARARGS */ /*PRINTFLIKE1*/
        !            85:        print( s ) char *s; { }
        !            86:        /* VARARGS */ /*PRINTFLIKE2*/
        !            87:        fprint(f, s) int f; char *s; { }
        !            88:        /* VARARGS */ /*PRINTFLIKE2*/
        !            89:        sprint(f, s) char *f; char *s; { }
        !            90: 
        !            91: /*
        !            92:  * FIO routines
        !            93:  */
        !            94: 
        !            95: int    Fflush(fd){ return(fd); }
        !            96: int    Fgetc(fd){ return(fd); }
        !            97: void   Finit(fd, buf) char *buf; { return; }
        !            98:        /* VARARGS */ /*PRINTFLIKE2*/
        !            99: int    Fprint(fd, fmt) char *fmt; { return(fd); }
        !           100: int    Fputc(fd, c) { return(c); }
        !           101: char   *Frdline(fd) { return(""); }
        !           102: long   Fread(fd, addr, n) char *addr; long n; { return(n); }
        !           103: long   Fseek(fd, n, cmd) long n; { return(n); }
        !           104: void   Fundo(fd) { return; }
        !           105: long   Fwrite(fd, addr, nbytes) char *addr; long nbytes; { return(0); }
        !           106: 
        !           107: /*
        !           108:  * Misc
        !           109:  */
        !           110: 
        !           111: int    abs(i) { return i; }
        !           112: void   longjmp(env, val) jmp_buf env; { }
        !           113: long   lrand() { return lrand(); }
        !           114: int    nrand(val) { return 1; }
        !           115: char   *mktemp(p) char *p; { return "";}
        !           116: void   perror(s) char *s; { }
        !           117: void   qsort(b, n, w, compar) char *b; int (*compar)(); { }
        !           118: int    rand( ) { return 1; }
        !           119: int    setjmp(e) jmp_buf e; { return 1; }
        !           120: void   srand(seed) { }
        !           121:        swab(a, b, n) char *a, *b; { }
        !           122: 
        !           123: /*
        !           124:  * Graphics
        !           125:  */
        !           126: static                 Point p;
        !           127: static                 Rectangle r;
        !           128: Bitmap                 display;
        !           129: Point          Pt(a, b) { return p; }
        !           130: Rectangle      Rect(a, b, c, d) { return r; }
        !           131: Rectangle      Rpt(p, q) Point p, q; { return r; }
        !           132: Point          add(p, q) Point p, q; { return p; }
        !           133: Point          sub(p, q) Point p, q; { return p; }
        !           134: Point          mul(p, a) Point p; { return p; }
        !           135: Point          div(p, a) Point p; { return p; }
        !           136: int            eqpt(p, q) Point p, q; { return 0; }
        !           137: int            eqrect(r, s) Rectangle r, s; { return 0; }
        !           138: int            rectXrect(r, s) Rectangle r, s; { return 0; }
        !           139: int            ptinrect(p, r) Point p; Rectangle r; { return 0; }
        !           140: int            rectclip(rp, b) Rectangle *rp, b; { return 0; }
        !           141: Rectangle      rsubp(r, p) Rectangle r; Point p; { return r; }
        !           142: Rectangle      raddp(r, p) Rectangle r; Point p; { return r; }
        !           143: Rectangle      inset(r, a) Rectangle r; { return r; }
        !           144: Point          string(b, p, f, s, m) Bitmap *b; Point p; Font *f; char *s;
        !           145:                        { return p; }
        !           146: int            strwidth(f, s) Font *f; char *s; { return 0; }
        !           147: Bitmap         *balloc(r, l) Rectangle r; { return &display; }
        !           148: ulong          *addr(b, p) Bitmap *b; Point p; { return display.base; }
        !           149: void           bitblt(d, p, s, r, m) Bitmap *d, *s; Point p; Rectangle r; {}
        !           150: void           rectf(d, r, m) Bitmap *d; Rectangle r; {}
        !           151: void           texture(d, r, t, m) Bitmap *d; Rectangle r; Texture *t; {}
        !           152: void           point(d, p, v, m) Bitmap *d; Point p; ulong v; {}

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