Return to sys.c CVS log

Up to [Research Unix] / researchv10dc / cmd / view2d

Annotation of researchv10dc/cmd/view2d/sys.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * A reasonable interface to the system calls
                      3:  */
                      4: #include <stdio.h>
                      5: error(a, b, c, d, e)
                      6:        char *a;
                      7: {
                      8:        extern int errno;
                      9:        extern char *sys_errlist[];
                     10:        extern int sys_nerr;
                     11:        extern char *progname;
                     12: 
                     13:        fprintf(stderr, "%s: ", progname);
                     14:        fprintf(stderr, a, b, c, d, e);
                     15:        if(errno && errno<sys_nerr)
                     16:                fprintf(stderr, ": %s\n", sys_errlist[errno]);
                     17:        else
                     18:                fprintf(stderr, "\n");
                     19:        exit(1);
                     20: }
                     21: Read(f, a, n)
                     22:        char *a;
                     23: {
                     24:        int nr, total=0;
                     25:        while(total<n){
                     26:                nr = read(f, a+total, n-total);
                     27:                if(nr<0) error("read error");
                     28:                if(nr==0) error("premature EOF");
                     29:                total += nr;
                     30:        }
                     31: }
                     32: EOFRead(f, a, n)
                     33:        char *a;
                     34: {
                     35:        int nr, total=0;
                     36:        while(total<n){
                     37:                nr = read(f, a+total, n-total);
                     38:                if(nr<0) error("read error");
                     39:                if(nr==0){
                     40:                        if(total>0) error("premature EOF");
                     41:                        else return(0);
                     42:                }
                     43:                total += nr;
                     44:        }
                     45:        return(total);
                     46: }
                     47: Write(f, a, n)
                     48:        char *a;
                     49: {
                     50:        int m;
                     51:        if((m=write(f, a, n))!=n)
                     52:                error("write error, wanted %d got %d", n, m);
                     53: }
                     54: long
                     55: Lseek(f, n, w)
                     56:        long n;
                     57: {
                     58:        long p, lseek();
                     59:        if((p=lseek(f, n, w))==-1)
                     60:                error("lseek error");
                     61:        return(p);
                     62: }
                     63: Creat(f, m)
                     64:        char *f;
                     65: {
                     66:        int fd=creat(f, m);
                     67:        if(fd<0)
                     68:                error("can't create %s", f);
                     69:        return fd;
                     70: }
                     71: Open(f, m)
                     72:        char *f;
                     73: {
                     74:        int fd=open(f, m);
                     75:        if(fd<0)
                     76:                error("can't open %s", f);
                     77:        return fd;
                     78: }
                     79: char *
                     80: Malloc(n)
                     81:        unsigned n;
                     82: {
                     83:        char *malloc(), *p=malloc(n);
                     84:        if(p==0)
                     85:                error("malloc failed");
                     86:        return p;
                     87: }
                     88: 
                     89: 
                     90: double
                     91: pow2 ( v )
                     92:   short v;
                     93: {
                     94:   /* this is only here because the system pow is so bad */
                     95:   double s = 1.0;
                     96:   while( v>0 ){ v--; s *= 2; }
                     97:   while( v<0 ){ v++; s /= 2; }
                     98:   return(s);
                     99: }

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