Return to fcvt.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / old / vpr / vtools

Annotation of 43BSDReno/old/vpr/vtools/fcvt.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1983 Regents of the University of California.
        !             3:  * All rights reserved.  The Berkeley software License Agreement
        !             4:  * specifies the terms and conditions for redistribution.
        !             5:  */
        !             6: 
        !             7: #ifndef lint
        !             8: static char sccsid[] = "@(#)fcvt.c     5.1 (Berkeley) 5/15/85";
        !             9: #endif not lint
        !            10: 
        !            11: /*
        !            12:  * Convert from the SAIL font format to the Unix font format.
        !            13:  * Usage: fcvt sailfile unixfile
        !            14:  */
        !            15: 
        !            16: #include <stdio.h>
        !            17: #include <vfont.h>
        !            18: 
        !            19: int    sws;                    /* sail word size in 36 bit words */
        !            20: char   b[40000], u[2000];
        !            21: long   left(), right();
        !            22: 
        !            23: struct header vheader;
        !            24: struct dispatch disptable[256];
        !            25: 
        !            26: long rightbits[19] = {
        !            27:        0,      1,      03,     07,     017,    037,
        !            28:        077,    0177,   0377,   0777,   01777,  03777,
        !            29:        07777,  017777, 037777, 077777, 0177777,0377777,0777777
        !            30: };
        !            31: 
        !            32: main(argc, argv)
        !            33:        int argc;
        !            34:        char *argv[];
        !            35: {
        !            36:        int infd = open(argv[1], 0);
        !            37:        int outfd = creat(argv[2], 0666);
        !            38:        int n;
        !            39:        long lh, rh;
        !            40:        int base, nb, ncol, nleft, r, i;
        !            41:        int c, p;
        !            42:        /* Sail counters and things */
        !            43:        int height, maxwidth, baseline;
        !            44:        int charwidth, rastwidth, charcode, wordcount;
        !            45:        int leftkern, rowsfromtop, datarowcount;
        !            46:        /* Unix counters and things */
        !            47:        int rastrows, rastcols;
        !            48:        int curaddr;
        !            49:        int packed;     /* true if sail packed format for this glyph */
        !            50:        int nperword;
        !            51: 
        !            52:        if (infd < 0 || outfd < 0) {
        !            53:                printf("Usage: fcvt sailfile unixfile\n");
        !            54:                exit(1);
        !            55:        }
        !            56:        n = read(infd, b, sizeof b);
        !            57:        sws = 2 * n / 9;
        !            58:        if (n == sizeof b) {
        !            59:                printf("Font larger than %d bytes - recompile me\n", n);
        !            60:                exit(1);
        !            61:        }
        !            62:        close(infd);
        !            63: 
        !            64:        height = right(0201);
        !            65:        maxwidth = right(0202);
        !            66:        baseline = right(0203);
        !            67: 
        !            68:        vheader.magic = 0436;
        !            69:        /* size gets done later */
        !            70:        vheader.maxx = height;
        !            71:        vheader.maxy = maxwidth;
        !            72:        /* I don't know what xtnd would map to */
        !            73: 
        !            74:        lseek(outfd, (long) sizeof vheader + sizeof disptable, 0);
        !            75:        curaddr = 0;
        !            76: 
        !            77:        /* Look at each char */
        !            78:        for (c=0; c<0200; c++) {
        !            79:                /* Find Sail info */
        !            80:                base = right(c);
        !            81:                if (base == 0)
        !            82:                        continue;
        !            83:                charwidth = left(c);
        !            84:                rastwidth = (left(base) >> 9) & 0777;
        !            85:                if (rastwidth == 0)
        !            86:                        rastwidth = charwidth;
        !            87:                charcode = left(base) & 0777;
        !            88:                if (charcode != c)
        !            89:                        printf("bad char code %o(%c) != %o(%c)\n", charcode, charcode, c, c);
        !            90:                wordcount = right(base);
        !            91:                if (base+wordcount > sws) {
        !            92:                        printf("Bad range %o-%o > %o glyph %o\n", base, base+wordcount, sws, c);
        !            93:                        continue;
        !            94:                }
        !            95:                leftkern = (left(base+1) >> 9) & 0777;
        !            96:                rowsfromtop = left(base+1) & 0777;
        !            97:                datarowcount = right(base+1);
        !            98: 
        !            99:                rastrows = datarowcount;
        !           100:                rastcols = (rastwidth + 35) / 36 * 36;
        !           101: 
        !           102:                /* Unix disptable stuff */
        !           103:                disptable[c].addr = curaddr;
        !           104:                nb = rastrows * ((rastcols + 7) >> 3);
        !           105:                disptable[c].nbytes = nb;
        !           106:                curaddr += nb;
        !           107:                disptable[c].left = leftkern;
        !           108:                disptable[c].right = rastcols - leftkern;
        !           109:                disptable[c].up = baseline - rowsfromtop;
        !           110:                disptable[c].down = rastrows - disptable[c].up;
        !           111:                disptable[c].width = charwidth;
        !           112:                packed = (datarowcount > wordcount);
        !           113:                nperword = 36 / rastwidth;
        !           114: 
        !           115:                /* Now get the raster rows themselves */
        !           116:                p = 0;
        !           117:                ncol = rastcols / 36;
        !           118:                nleft = ((rastwidth-1) % 36 + 1);
        !           119:                base += 2;
        !           120:                for (r=0; r<rastrows; r++) {
        !           121:                        if (!packed) {
        !           122:                                for (i=0; i<ncol; i++) {
        !           123:                                        lh = left(base); rh = right(base++);
        !           124:                                        /* compensate for garbage in SAIL fonts */
        !           125:                                        if (i == ncol-1) {
        !           126:                                                if (nleft <= 18) {
        !           127:                                                        rh = 0;
        !           128:                                                        lh &= ~rightbits[18-nleft];
        !           129:                                                } else
        !           130:                                                        rh &= ~rightbits[36-nleft];
        !           131:                                        }
        !           132:                                        if (i%2) {
        !           133:                                                u[p-1] |= (lh>>14) & 017;
        !           134:                                                u[p++] = lh >> 6;
        !           135:                                                u[p++] = ((lh&077)<<2) | ((rh>>16)&03);
        !           136:                                                u[p++] = rh >> 8;
        !           137:                                                u[p++] = rh;
        !           138:                                        } else {
        !           139:                                                u[p++] = lh >> 10;
        !           140:                                                u[p++] = lh >> 2;
        !           141:                                                u[p++] = ((lh&03)<<6) | (rh>>12);
        !           142:                                                u[p++] = rh >> 4;
        !           143:                                                u[p++] = (rh & 017) << 4;
        !           144:                                        }
        !           145:                                }
        !           146:                        } else {
        !           147:                                put(r % nperword, rastwidth, left(base+r/nperword), right(base+r/nperword), u+p);
        !           148:                                p += 5; /* 5 8 bit bytes per 36 bit word */
        !           149:                        }
        !           150:                }
        !           151:                write(outfd, u, p);
        !           152:        }
        !           153:        lseek(outfd, 0, 0);
        !           154:        vheader.size = curaddr;
        !           155:        write(outfd, &vheader, sizeof vheader);
        !           156:        write(outfd, disptable, sizeof disptable);
        !           157:        close(outfd);
        !           158:        exit(0);
        !           159: }
        !           160: 
        !           161: /*
        !           162:  * put a pdp-10 style variable size byte into 8 bit Unix bytes starting
        !           163:  * at location dest.  The byte is bytesize bits, and is the bytenumth byte
        !           164:  * in the 36 bit word (lh,,rh).
        !           165:  */
        !           166: put(bytenum, bytesize, lh, rh, dest)
        !           167:        int bytenum, bytesize;
        !           168:        long lh, rh;
        !           169:        char *dest;
        !           170: {
        !           171:        register int i;
        !           172: 
        !           173:        for (i=0; i<5; i++)
        !           174:                dest[i] = 0;
        !           175:        for (i=0; i<bytenum; i++) {
        !           176:                lh <<= bytesize;
        !           177:                lh |= (rh >> 18-bytesize) & rightbits[bytesize];
        !           178:                rh <<= bytesize;
        !           179:        }
        !           180:        lh &= ~rightbits[18-bytesize];
        !           181:        /* We now have the byte we want left justified in lh */
        !           182:        lh <<= 14;
        !           183:        /* lh is now the byte we want, left justified in 32 bit word */
        !           184:        for (i=0; i<bytesize; i += 8) {
        !           185:                *dest++ = (lh >> 24) & 0377;
        !           186:                lh <<= 8;
        !           187:        }
        !           188: }
        !           189: 
        !           190: /*
        !           191:  * Return the left half (18 bits) of pdp-10 word p.
        !           192:  */
        !           193: long
        !           194: left(p)
        !           195:        int p;
        !           196: {
        !           197:        register int lp, odd;
        !           198:        register long retval;
        !           199: 
        !           200:        odd = p%2;
        !           201:        lp = 9*p/2;
        !           202:        if (p >= sws) {
        !           203:                return(0);
        !           204:        }
        !           205:        if (odd) {
        !           206:                retval  = (b[lp++] & 0017) << 14;
        !           207:                retval |= (b[lp++] & 0377) << 6;
        !           208:                retval |= (b[lp] >> 2) & 63;
        !           209:        } else {
        !           210:                retval  = (b[lp++] & 0377) << 10;
        !           211:                retval |= (b[lp++] & 0377) << 2;
        !           212:                retval |= (b[lp] >> 6) & 3;
        !           213:        }
        !           214:        return retval;
        !           215: }
        !           216: 
        !           217: /*
        !           218:  * Return the right half of 36 bit word #p.
        !           219:  */
        !           220: long
        !           221: right(p)
        !           222:        int p;
        !           223: {
        !           224:        register int lp, odd;
        !           225:        register long retval;
        !           226: 
        !           227:        odd = p%2;
        !           228:        lp = 9*p/2 + 2;
        !           229:        if (p >= sws) {
        !           230:                return(0);
        !           231:        }
        !           232:        if (odd) {
        !           233:                retval  = (b[lp++] & 0003) << 16;
        !           234:                retval |= (b[lp++] & 0377) << 8;
        !           235:                retval |= (b[lp]   & 0377);
        !           236:        } else {
        !           237:                retval  = (b[lp++] & 0077) << 12;
        !           238:                retval |= (b[lp++] & 0377) << 4;
        !           239:                retval |= (b[lp] >> 4) & 017;
        !           240:        }
        !           241:        return retval;
        !           242: }

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