# 2.11BSD#431 - /usr/src/usr.sbin/lpr/filters/fcvt.c

##### Functions

    left              X
    main              X
    put               X
    right             X

##### Variables

    b                 X
    disptable         X
    rightbits         X
    sws               X
    u                 X
    vheader           X

       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: }

#### Defined functions

left defined in line 193; used 9 times

- in line 21, 83-87(3), 95-96(2), 107, 123, 147

main defined in line 32; never used
put defined in line 166; used 1 times

- in line 147

right defined in line 220; used 10 times

- in line 21, 64-66(3), 80, 90, 97, 108, 123, 147

#### Defined variables

b defined in line 20; used 15 times

- in line 56-58(3), 206-212(6), 233-239(6)

disptable defined in line 24; used 11 times

- in line 74, 103-111(8), 156(2)

rightbits defined in line 26; used 4 times

- in line 128-130(2), 177-180(2)

sccsid defined in line 8; never used
sws defined in line 19; used 5 times

- in line 57, 91-92(2), 202, 229

u defined in line 20; used 12 times

- in line 133-151(12)

vheader defined in line 23; used 7 times

- in line 68-74(4), 154-155(3)

Last modified: 1987-02-18 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 1059 |