Return to lib.c CVS log

Up to [Research Unix] / researchv9 / jtools / src / pi

Annotation of researchv9/jtools/src/pi/lib.c, revision 1.1.1.1

1.1       root        1: #include <CC/sys/types.h>
                      2: #include <CC/sys/stat.h>
                      3: #include <sgtty.h>
                      4: #include <stdio.h>
                      5: #include <sys/param.h>
                      6: #include <sys/dir.h>
                      7: #include <errno.h>
                      8: #include "lib.h"
                      9: #include <ctype.h>
                     10: #include <pads.pub>
                     11: SRCFILE("lib.c")
                     12: 
                     13: char *index(register char *sp, char c)
                     14: {
                     15:         do {
                     16:                 if (*sp == c) return sp;
                     17:         } while (*sp++);
                     18:         return 0;
                     19: }
                     20: 
                     21: char *rindex(register char *sp, char c)
                     22: {
                     23:         register char *r = 0;
                     24: 
                     25:         do {
                     26:                 if (*sp == c)
                     27:                         r = sp;
                     28:         } while (*sp++);
                     29:         return r;
                     30: }
                     31: 
                     32: char *basename(char *path)
                     33: {
                     34:        char *lsi = rindex(path, '/');
                     35:        return lsi ? lsi+1 : path; 
                     36: }
                     37: 
                     38: char *slashname(char *path)
                     39: {
                     40:        return sf("%0.*s", strlen(path)-strlen(basename(path)),  path);
                     41: }
                     42: 
                     43: int alldigits(char *p)
                     44: {
                     45:        if( !p ) return 0;
                     46:        while( isdigit(*p) ) ++p;
                     47:        return !*p;
                     48: }
                     49: 
                     50: char *Name(char *s, int i)
                     51: {
                     52:        static char buf[8][32];
                     53:        static cycle;
                     54:        char *t = buf[(cycle++,cycle%=8)];
                     55:        sprintf( t, s, i );
                     56:        return t;
                     57: }
                     58:        
                     59: char *SysErr(char *s)
                     60: {
                     61:        extern int errno, sys_nerr;
                     62:        extern char *sys_errlist[];
                     63: 
                     64:        if( errno>=sys_nerr || errno<1 ) return sf( "%s errno=%d", s, errno);
                     65:        return sf( "%s %s", s, sys_errlist[errno] );
                     66: }
                     67: 
                     68: char *strcatfmt(char *s, char *f ... )
                     69: {
                     70:        int *a = (int*)&f;
                     71:        sprintf( &s[strlen(s)], f, a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8] );
                     72:        return s;
                     73: }
                     74: 
                     75: int ReadOK( int fd, char *addr, int req )
                     76: {
                     77:        int got;
                     78: 
                     79:        got = read(fd,addr,req);
                     80:        trace( "ReadOK(%d,%d,%d) %d", fd, addr, req, got );
                     81:        return got == req;
                     82: }
                     83: 
                     84: int WriteOK( int fd, char *addr, int req )
                     85: {
                     86:        int got;
                     87: 
                     88:        got = write(fd,addr,req);
                     89:        trace( "WriteOK(%d,%d,%d) %d", fd, addr, req, got );
                     90:        return got == req;
                     91: }
                     92: 
                     93: long modified( int fd )
                     94: {
                     95:        struct stat buf;
                     96: 
                     97:        fstat( fd, &buf );
                     98:        trace( "fd=%d buf.st_mtime=%d", fd, buf.st_mtime );
                     99:        return buf.st_mtime;
                    100: }

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