![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fcvt.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / old / vpr / vtools|
Return to fcvt.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / old / vpr / vtools |
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.