Return to seal.c CVS log

Up to [Research Unix] / researchv10no / cmd / asd

Annotation of researchv10no/cmd/asd/seal.c, revision 1.1

1.1     ! root        1: /*
        !             2:  *     seal - prepare a package for shipment
        !             3:  */
        !             4: 
        !             5: #include "asd.h"
        !             6: #include "seal.h"
        !             7: #include <ctype.h>
        !             8: 
        !             9: static long length;
        !            10: static unsigned long checksum;
        !            11: 
        !            12: main (argc, argv)
        !            13:        int argc;
        !            14:        char **argv;
        !            15: {
        !            16:        int rc = 0;
        !            17:        static char stdbuf[BUFSIZ];
        !            18: 
        !            19:        setbuf (stdout, stdbuf);
        !            20: 
        !            21:        length = 0;
        !            22:        checksum = 0;
        !            23: 
        !            24:        rc = getargs (argc, argv, "kK:", seal);
        !            25: 
        !            26:        printf ("!end %ld %lu\n", length, checksum);
        !            27: 
        !            28:        return rc;
        !            29: }
        !            30: 
        !            31: 
        !            32: seal (f, fname)
        !            33:        register FILE *f;
        !            34:        char *fname;
        !            35: {
        !            36:        static int first = 1;
        !            37: 
        !            38:        if (first) {
        !            39:                first = 0;
        !            40:                printf ("!<seal>\n");
        !            41:        }
        !            42: 
        !            43:        do {
        !            44:                char line[MAXLINE];
        !            45:                char outline[MAXLINE*3+10];
        !            46:                register char *p, *endl;
        !            47:                register int ch;
        !            48: 
        !            49:                /* read a line, possibly short */
        !            50:                p = line;
        !            51:                endl = line + MAXLINE;
        !            52: 
        !            53:                do {
        !            54:                        ch = getc (f);
        !            55:                        if (ch == EOF)
        !            56:                                break;
        !            57:                        *p++ = ch;
        !            58:                } while (ch != '\n' && p < endl);
        !            59: 
        !            60:                endl = p;
        !            61: 
        !            62:                /*
        !            63:                 * endl now points one past the last char
        !            64:                 * in the line we have read.  If we didn't
        !            65:                 * get any characters at all, we're done.
        !            66:                 */
        !            67: 
        !            68:                if (line == endl)
        !            69:                        return ferror (f) != 0;
        !            70: 
        !            71:                length += endl - line;
        !            72: 
        !            73:                /* now convert the line to external form */
        !            74:                ch = hrform (line, endl, outline);
        !            75:                if (ch > (endl - line + INCPW - 1) / INCPW * OUTCPW + 2)
        !            76:                        ch = mrform (line, endl, outline);
        !            77:                p = outline;
        !            78: 
        !            79:                /* if encrypting, do so */
        !            80:                if (kflag || Kflag)
        !            81:                        mangle (line, endl);
        !            82: 
        !            83:                /* accumulate the (possibly encrypted) checksum */
        !            84:                checksum = mkcsum (checksum, line, endl);
        !            85: 
        !            86:                while (--ch >= 0)
        !            87:                        putchar (*p++);
        !            88:        } while (!feof (f) && !ferror (f));
        !            89: 
        !            90:        return ferror (f) != 0;
        !            91: }
        !            92: 
        !            93: /*
        !            94:  *     convert the characters in the range (in,inend] to
        !            95:  *     storage starting at "out" -- return the number of
        !            96:  *     output characters.
        !            97:  */
        !            98: 
        !            99: int
        !           100: hrform (in, inend, out)
        !           101:        register char *in, *inend;
        !           102:        char *out;
        !           103: {
        !           104:        register char *r = out;
        !           105: 
        !           106:        /* special handling for the first character(s) */
        !           107:        if (in < inend) {
        !           108:                if (*in == '.' || *in == '!' ||
        !           109:                    (*in == 'F' && strncmp (in, "From", 4) == 0))
        !           110:                        *r++ = '\\';
        !           111: 
        !           112:                do {
        !           113:                        register int ch = (unsigned char) *in++;
        !           114: 
        !           115:                        if (isprint (ch)) {
        !           116:                                if (ch == '\\')
        !           117:                                        *r++ = '\\';
        !           118:                                *r++ = ch;
        !           119:                        } else {
        !           120:                                if (ch == ' ' || ch == '\t' || ch == '\n')
        !           121:                                        *r++ = ch;
        !           122:                                else {
        !           123:                                        *r++ = '\\';
        !           124:                                        *r++ = hextab[(ch >> 4) & 0xf];
        !           125:                                        *r++ = hextab[ch & 0xf];
        !           126:                                }
        !           127:                        }
        !           128:                } while (in < inend);
        !           129: 
        !           130:                if (r[-1] != '\n') {
        !           131:                        *r++ = '\\';
        !           132:                        *r++ = '\n';
        !           133:                }
        !           134:        }
        !           135: 
        !           136:        return r - out;
        !           137: }
        !           138: 
        !           139: int
        !           140: mrform (in, inend, out)
        !           141:        register char *in;
        !           142:        char *inend, *out;
        !           143: {
        !           144:        char *r;
        !           145:        register int len;
        !           146: 
        !           147:        len = inend - in;
        !           148:        if (len <= 0)
        !           149:                return 0;
        !           150: 
        !           151:        r = out;
        !           152: 
        !           153:        *r++ = '.';
        !           154: 
        !           155:        do {
        !           156:                register unsigned long bits;
        !           157:                register int n, outn;
        !           158:                register char *rr;
        !           159: 
        !           160:                n = len;
        !           161:                if (n > INCPW)
        !           162:                        n = INCPW;
        !           163:                len -= n;
        !           164:                outn = n + OUTCPW - INCPW;
        !           165: 
        !           166:                bits = 0;
        !           167:                do      bits = (bits << BPC) | (*in++ & BYTEMASK);
        !           168:                while (--n > 0);
        !           169: 
        !           170:                rr = r = r + outn;
        !           171:                do {
        !           172:                        *--rr = RADBASE + bits % RADIX;
        !           173:                        bits /= RADIX;
        !           174:                } while (--outn > 0);
        !           175:        } while (len > 0);
        !           176: 
        !           177:        *r++ = '\n';
        !           178: 
        !           179:        return r - out;
        !           180: }

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