Return to ckustr.c CVS log

Up to [MW Coherent from dump] / coherent / e / bin / cku179

Annotation of coherent/e/bin/cku179/ckustr.c, revision 1.1

1.1     ! root        1: #include <stdio.h>
        !             2: #include <sysexits.h>
        !             3: 
        !             4: /* string extraction/restoration routines */
        !             5: 
        !             6: /* Modify the pathname below to suit system requirements */
        !             7: 
        !             8: char   *StringFile =   "/usr/local/lib/kermit5.sr";
        !             9: 
        !            10: static int strfile = -1, ourpid = 0;
        !            11: 
        !            12: #define BUFLEN 256
        !            13: 
        !            14: errprep(offset, buf)
        !            15: unsigned short offset;
        !            16: char *buf;
        !            17: {
        !            18: register int pid = getpid();
        !            19: 
        !            20:        if (pid != ourpid) {
        !            21:                ourpid = pid;
        !            22:                if (strfile >= 0) {
        !            23:                        close(strfile);
        !            24:                        strfile = -1;
        !            25:                }
        !            26:        }
        !            27:        if (strfile < 0) {
        !            28:                char *p, *getenv();
        !            29:                if (p = getenv("KSTR")) StringFile = p;
        !            30:                strfile = open(StringFile, 0);
        !            31:                if (strfile < 0) {
        !            32: oops:
        !            33:                        fprintf(stderr, "Cannot find %s\r\n", StringFile);
        !            34:                        exit(EX_OSFILE);
        !            35:                }
        !            36:        }
        !            37:        if (lseek(strfile, (long) offset, 0) < 0
        !            38:                        || read(strfile, buf, BUFLEN) <= 0)
        !            39:                goto oops;
        !            40: }
        !            41: 
        !            42: /* extracted string front end for printf() */
        !            43: /*VARARGS1*/
        !            44: strprerror(fmt, a, b, c, d, e)
        !            45:        int fmt;
        !            46: {
        !            47:        char buf[BUFLEN];
        !            48: 
        !            49:        errprep(fmt, buf);
        !            50:        printf(buf, a, b, c, d, e);
        !            51: }
        !            52: 
        !            53: /* extracted string front end for sprintf() */
        !            54: /*VARARGS1*/
        !            55: strsrerror(fmt, obuf, a, b, c, d, e)
        !            56:        int fmt;
        !            57:        char *obuf;
        !            58: {
        !            59:        char buf[BUFLEN];
        !            60: 
        !            61:        errprep(fmt, buf);
        !            62:        sprintf(obuf, buf, a, b, c, d, e);
        !            63: }
        !            64: 
        !            65: /* extracted string front end for fprintf() */
        !            66: /*VARARGS1*/
        !            67: strfrerror(fmt, fd, a, b, c, d, e)
        !            68:        int fmt, fd;
        !            69: {
        !            70:        char buf[BUFLEN];
        !            71: 
        !            72:        errprep(fmt, buf);
        !            73:        fprintf(fd, buf, a, b, c, d, e);
        !            74: }
        !            75: 
        !            76: /* extracted string front end for perror() */
        !            77: strperror(fmt)
        !            78:        int fmt;
        !            79: {
        !            80:        char buf[BUFLEN];
        !            81: 
        !            82:        errprep(fmt, buf);
        !            83:        perror(buf);
        !            84: }

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