File: | bitmap/pcfwrite.c |
Location: | line 271, column 10 |
Description: | Dereference of null pointer |
1 | /* | |||
2 | ||||
3 | Copyright 1990, 1994, 1998 The Open Group | |||
4 | ||||
5 | Permission to use, copy, modify, distribute, and sell this software and its | |||
6 | documentation for any purpose is hereby granted without fee, provided that | |||
7 | the above copyright notice appear in all copies and that both that | |||
8 | copyright notice and this permission notice appear in supporting | |||
9 | documentation. | |||
10 | ||||
11 | The above copyright notice and this permission notice shall be included | |||
12 | in all copies or substantial portions of the Software. | |||
13 | ||||
14 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS | |||
15 | OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | |||
16 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. | |||
17 | IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR | |||
18 | OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, | |||
19 | ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR | |||
20 | OTHER DEALINGS IN THE SOFTWARE. | |||
21 | ||||
22 | Except as contained in this notice, the name of The Open Group shall | |||
23 | not be used in advertising or otherwise to promote the sale, use or | |||
24 | other dealings in this Software without prior written authorization | |||
25 | from The Open Group. | |||
26 | ||||
27 | */ | |||
28 | ||||
29 | /* | |||
30 | * Author: Keith Packard, MIT X Consortium | |||
31 | */ | |||
32 | ||||
33 | #ifdef HAVE_CONFIG_H1 | |||
34 | #include <config.h> | |||
35 | #endif | |||
36 | ||||
37 | #include <X11/fonts/fntfilst.h> | |||
38 | #include <X11/fonts/bitmap.h> | |||
39 | #include <X11/fonts/pcf.h> | |||
40 | ||||
41 | /* Write PCF font files */ | |||
42 | ||||
43 | static CARD32 current_position; | |||
44 | ||||
45 | static int | |||
46 | pcfWrite(FontFilePtr file, char *b, int c) | |||
47 | { | |||
48 | current_position += c; | |||
49 | return FontFileWrite(file, b, c)BufFileWrite(file,b,c); | |||
50 | } | |||
51 | ||||
52 | static int | |||
53 | pcfPutLSB32(FontFilePtr file, int c) | |||
54 | { | |||
55 | current_position += 4; | |||
56 | (void) FontFilePutc(c, file)(--(file)->left ? *(file)->bufp++ = ((unsigned char)(c) ) : (*(file)->output) ((unsigned char)(c),file)); | |||
57 | (void) FontFilePutc(c >> 8, file)(--(file)->left ? *(file)->bufp++ = ((unsigned char)(c >> 8)) : (*(file)->output) ((unsigned char)(c >> 8),file )); | |||
58 | (void) FontFilePutc(c >> 16, file)(--(file)->left ? *(file)->bufp++ = ((unsigned char)(c >> 16)) : (*(file)->output) ((unsigned char)(c >> 16), file)); | |||
59 | return FontFilePutc(c >> 24, file)(--(file)->left ? *(file)->bufp++ = ((unsigned char)(c >> 24)) : (*(file)->output) ((unsigned char)(c >> 24), file)); | |||
60 | } | |||
61 | ||||
62 | static int | |||
63 | pcfPutINT32(FontFilePtr file, CARD32 format, int c) | |||
64 | { | |||
65 | current_position += 4; | |||
66 | if (PCF_BYTE_ORDER(format)(((format) & (1<<2))?1:0) == MSBFirst1) { | |||
67 | (void) FontFilePutc(c >> 24, file)(--(file)->left ? *(file)->bufp++ = ((unsigned char)(c >> 24)) : (*(file)->output) ((unsigned char)(c >> 24), file)); | |||
68 | (void) FontFilePutc(c >> 16, file)(--(file)->left ? *(file)->bufp++ = ((unsigned char)(c >> 16)) : (*(file)->output) ((unsigned char)(c >> 16), file)); | |||
69 | (void) FontFilePutc(c >> 8, file)(--(file)->left ? *(file)->bufp++ = ((unsigned char)(c >> 8)) : (*(file)->output) ((unsigned char)(c >> 8),file )); | |||
70 | return FontFilePutc(c, file)(--(file)->left ? *(file)->bufp++ = ((unsigned char)(c) ) : (*(file)->output) ((unsigned char)(c),file)); | |||
71 | } else { | |||
72 | (void) FontFilePutc(c, file)(--(file)->left ? *(file)->bufp++ = ((unsigned char)(c) ) : (*(file)->output) ((unsigned char)(c),file)); | |||
73 | (void) FontFilePutc(c >> 8, file)(--(file)->left ? *(file)->bufp++ = ((unsigned char)(c >> 8)) : (*(file)->output) ((unsigned char)(c >> 8),file )); | |||
74 | (void) FontFilePutc(c >> 16, file)(--(file)->left ? *(file)->bufp++ = ((unsigned char)(c >> 16)) : (*(file)->output) ((unsigned char)(c >> 16), file)); | |||
75 | return FontFilePutc(c >> 24, file)(--(file)->left ? *(file)->bufp++ = ((unsigned char)(c >> 24)) : (*(file)->output) ((unsigned char)(c >> 24), file)); | |||
76 | } | |||
77 | } | |||
78 | ||||
79 | static int | |||
80 | pcfPutINT16(FontFilePtr file, CARD32 format, int c) | |||
81 | { | |||
82 | current_position += 2; | |||
83 | if (PCF_BYTE_ORDER(format)(((format) & (1<<2))?1:0) == MSBFirst1) { | |||
84 | (void) FontFilePutc(c >> 8, file)(--(file)->left ? *(file)->bufp++ = ((unsigned char)(c >> 8)) : (*(file)->output) ((unsigned char)(c >> 8),file )); | |||
85 | return FontFilePutc(c, file)(--(file)->left ? *(file)->bufp++ = ((unsigned char)(c) ) : (*(file)->output) ((unsigned char)(c),file)); | |||
86 | } else { | |||
87 | (void) FontFilePutc(c, file)(--(file)->left ? *(file)->bufp++ = ((unsigned char)(c) ) : (*(file)->output) ((unsigned char)(c),file)); | |||
88 | return FontFilePutc(c >> 8, file)(--(file)->left ? *(file)->bufp++ = ((unsigned char)(c >> 8)) : (*(file)->output) ((unsigned char)(c >> 8),file )); | |||
89 | } | |||
90 | } | |||
91 | ||||
92 | /*ARGSUSED*/ | |||
93 | static int | |||
94 | pcfPutINT8(FontFilePtr file, CARD32 format, int c) | |||
95 | { | |||
96 | current_position += 1; | |||
97 | return FontFilePutc(c, file)(--(file)->left ? *(file)->bufp++ = ((unsigned char)(c) ) : (*(file)->output) ((unsigned char)(c),file)); | |||
98 | } | |||
99 | ||||
100 | static void | |||
101 | pcfWriteTOC(FontFilePtr file, PCFTablePtr table, int count) | |||
102 | { | |||
103 | CARD32 version; | |||
104 | int i; | |||
105 | ||||
106 | version = PCF_FILE_VERSION(('p'<<24)|('c'<<16)|('f'<<8)|1); | |||
107 | pcfPutLSB32(file, version); | |||
108 | pcfPutLSB32(file, count); | |||
109 | for (i = 0; i < count; i++) { | |||
110 | pcfPutLSB32(file, table->type); | |||
111 | pcfPutLSB32(file, table->format); | |||
112 | pcfPutLSB32(file, table->size); | |||
113 | pcfPutLSB32(file, table->offset); | |||
114 | table++; | |||
115 | } | |||
116 | } | |||
117 | ||||
118 | static void | |||
119 | pcfPutCompressedMetric(FontFilePtr file, CARD32 format, xCharInfo *metric) | |||
120 | { | |||
121 | pcfPutINT8(file, format, metric->leftSideBearing + 0x80); | |||
122 | pcfPutINT8(file, format, metric->rightSideBearing + 0x80); | |||
123 | pcfPutINT8(file, format, metric->characterWidth + 0x80); | |||
124 | pcfPutINT8(file, format, metric->ascent + 0x80); | |||
125 | pcfPutINT8(file, format, metric->descent + 0x80); | |||
126 | } | |||
127 | ||||
128 | static void | |||
129 | pcfPutMetric(FontFilePtr file, CARD32 format, xCharInfo *metric) | |||
130 | { | |||
131 | pcfPutINT16(file, format, metric->leftSideBearing); | |||
132 | pcfPutINT16(file, format, metric->rightSideBearing); | |||
133 | pcfPutINT16(file, format, metric->characterWidth); | |||
134 | pcfPutINT16(file, format, metric->ascent); | |||
135 | pcfPutINT16(file, format, metric->descent); | |||
136 | pcfPutINT16(file, format, metric->attributes); | |||
137 | } | |||
138 | ||||
139 | static void | |||
140 | pcfPutBitmap(FontFilePtr file, CARD32 format, CharInfoPtr pCI) | |||
141 | { | |||
142 | int count; | |||
143 | unsigned char *bits; | |||
144 | ||||
145 | count = BYTES_FOR_GLYPH(pCI, PCF_GLYPH_PAD(format))(((pCI)->metrics.ascent + (pCI)->metrics.descent) * ((( 1<<((format) & (3<<0)))) == 1 ? (((((pCI)-> metrics.rightSideBearing - (pCI)->metrics.leftSideBearing) )+7)>>3) :((1<<((format) & (3<<0)))) == 2 ? ((((((pCI)->metrics.rightSideBearing - (pCI)->metrics .leftSideBearing))+15)>>3)&~1) :((1<<((format ) & (3<<0)))) == 4 ? ((((((pCI)->metrics.rightSideBearing - (pCI)->metrics.leftSideBearing))+31)>>3)&~3) : ((1<<((format) & (3<<0)))) == 8 ? ((((((pCI)-> metrics.rightSideBearing - (pCI)->metrics.leftSideBearing) )+63)>>3)&~7) : 0)); | |||
146 | bits = (unsigned char *) pCI->bits; | |||
147 | current_position += count; | |||
148 | while (count--) | |||
149 | FontFilePutc(*bits++, file)(--(file)->left ? *(file)->bufp++ = ((unsigned char)(*bits ++)) : (*(file)->output) ((unsigned char)(*bits++),file)); | |||
150 | } | |||
151 | ||||
152 | static void | |||
153 | pcfPutAccel(FontFilePtr file, CARD32 format, FontInfoPtr pFontInfo) | |||
154 | { | |||
155 | pcfPutINT8(file, format, pFontInfo->noOverlap); | |||
156 | pcfPutINT8(file, format, pFontInfo->constantMetrics); | |||
157 | pcfPutINT8(file, format, pFontInfo->terminalFont); | |||
158 | pcfPutINT8(file, format, pFontInfo->constantWidth); | |||
159 | pcfPutINT8(file, format, pFontInfo->inkInside); | |||
160 | pcfPutINT8(file, format, pFontInfo->inkMetrics); | |||
161 | pcfPutINT8(file, format, pFontInfo->drawDirection); | |||
162 | pcfPutINT8(file, format, 0); | |||
163 | pcfPutINT32(file, format, pFontInfo->fontAscent); | |||
164 | pcfPutINT32(file, format, pFontInfo->fontDescent); | |||
165 | pcfPutINT32(file, format, pFontInfo->maxOverlap); | |||
166 | pcfPutMetric(file, format, &pFontInfo->minbounds); | |||
167 | pcfPutMetric(file, format, &pFontInfo->maxbounds); | |||
168 | if (PCF_FORMAT_MATCH(format, PCF_ACCEL_W_INKBOUNDS)(((format)&0xffffff00) == ((0x00000100)&0xffffff00))) { | |||
169 | pcfPutMetric(file, format, &pFontInfo->ink_minbounds); | |||
170 | pcfPutMetric(file, format, &pFontInfo->ink_maxbounds); | |||
171 | } | |||
172 | } | |||
173 | ||||
174 | #define S324 4 | |||
175 | #define S162 2 | |||
176 | #define S81 1 | |||
177 | ||||
178 | #define Pad(s)((((s) + 3) & ~3) - (s)) (RoundUp(s)(((s) + 3) & ~3) - (s)) | |||
179 | #define RoundUp(s)(((s) + 3) & ~3) (((s) + 3) & ~3) | |||
180 | ||||
181 | #define Compressable(i)(-128 <= (i) && (i) <= 127) (-128 <= (i) && (i) <= 127) | |||
182 | ||||
183 | #define CanCompressMetric(m)((-128 <= ((m)->leftSideBearing) && ((m)->leftSideBearing ) <= 127) && (-128 <= ((m)->rightSideBearing ) && ((m)->rightSideBearing) <= 127) && (-128 <= ((m)->characterWidth) && ((m)->characterWidth ) <= 127) && (-128 <= ((m)->ascent) && ((m)->ascent) <= 127) && (-128 <= ((m)-> descent) && ((m)->descent) <= 127) && ( m)->attributes == 0) (Compressable((m)->leftSideBearing)(-128 <= ((m)->leftSideBearing) && ((m)->leftSideBearing ) <= 127) && \ | |||
184 | Compressable((m)->rightSideBearing)(-128 <= ((m)->rightSideBearing) && ((m)->rightSideBearing ) <= 127) && \ | |||
185 | Compressable((m)->characterWidth)(-128 <= ((m)->characterWidth) && ((m)->characterWidth ) <= 127) && \ | |||
186 | Compressable((m)->ascent)(-128 <= ((m)->ascent) && ((m)->ascent) <= 127) && \ | |||
187 | Compressable((m)->descent)(-128 <= ((m)->descent) && ((m)->descent) <= 127) && \ | |||
188 | (m)->attributes == 0) | |||
189 | ||||
190 | #define CanCompressMetrics(min,max)(((-128 <= ((min)->leftSideBearing) && ((min)-> leftSideBearing) <= 127) && (-128 <= ((min)-> rightSideBearing) && ((min)->rightSideBearing) <= 127) && (-128 <= ((min)->characterWidth) && ((min)->characterWidth) <= 127) && (-128 <= ((min)->ascent) && ((min)->ascent) <= 127) && (-128 <= ((min)->descent) && ((min)->descent ) <= 127) && (min)->attributes == 0) && ((-128 <= ((max)->leftSideBearing) && ((max)-> leftSideBearing) <= 127) && (-128 <= ((max)-> rightSideBearing) && ((max)->rightSideBearing) <= 127) && (-128 <= ((max)->characterWidth) && ((max)->characterWidth) <= 127) && (-128 <= ((max)->ascent) && ((max)->ascent) <= 127) && (-128 <= ((max)->descent) && ((max)->descent ) <= 127) && (max)->attributes == 0)) (CanCompressMetric(min)((-128 <= ((min)->leftSideBearing) && ((min)-> leftSideBearing) <= 127) && (-128 <= ((min)-> rightSideBearing) && ((min)->rightSideBearing) <= 127) && (-128 <= ((min)->characterWidth) && ((min)->characterWidth) <= 127) && (-128 <= ((min)->ascent) && ((min)->ascent) <= 127) && (-128 <= ((min)->descent) && ((min)->descent ) <= 127) && (min)->attributes == 0) && CanCompressMetric(max)((-128 <= ((max)->leftSideBearing) && ((max)-> leftSideBearing) <= 127) && (-128 <= ((max)-> rightSideBearing) && ((max)->rightSideBearing) <= 127) && (-128 <= ((max)->characterWidth) && ((max)->characterWidth) <= 127) && (-128 <= ((max)->ascent) && ((max)->ascent) <= 127) && (-128 <= ((max)->descent) && ((max)->descent ) <= 127) && (max)->attributes == 0)) | |||
191 | ||||
192 | static char * | |||
193 | pcfNameForAtom(Atom a) | |||
194 | { | |||
195 | return NameForAtom(a); | |||
196 | } | |||
197 | ||||
198 | int | |||
199 | pcfWriteFont(FontPtr pFont, FontFilePtr file) | |||
200 | { | |||
201 | PCFTableRec tables[32], | |||
202 | *table; | |||
203 | CARD32 mask, | |||
204 | bit; | |||
205 | int ntables; | |||
206 | int size; | |||
207 | CARD32 format; | |||
208 | int i; | |||
209 | int cur_table; | |||
210 | int prop_string_size; | |||
211 | int glyph_string_size; | |||
212 | xCharInfo *minbounds, | |||
213 | *maxbounds; | |||
214 | xCharInfo *ink_minbounds, | |||
215 | *ink_maxbounds; | |||
216 | BitmapFontPtr bitmapFont; | |||
217 | int nencodings = 0; | |||
218 | int header_size; | |||
219 | FontPropPtr offsetProps; | |||
220 | int prop_pad = 0; | |||
221 | char *atom_name; | |||
222 | int glyph; | |||
223 | CARD32 offset; | |||
224 | ||||
225 | bitmapFont = (BitmapFontPtr) pFont->fontPrivate; | |||
226 | if (bitmapFont->bitmapExtra) { | |||
| ||||
227 | minbounds = &bitmapFont->bitmapExtra->info.minbounds; | |||
228 | maxbounds = &bitmapFont->bitmapExtra->info.maxbounds; | |||
229 | ink_minbounds = &bitmapFont->bitmapExtra->info.ink_minbounds; | |||
230 | ink_maxbounds = &bitmapFont->bitmapExtra->info.ink_maxbounds; | |||
231 | } else { | |||
232 | minbounds = &pFont->info.minbounds; | |||
233 | maxbounds = &pFont->info.maxbounds; | |||
234 | ink_minbounds = &pFont->info.ink_minbounds; | |||
235 | ink_maxbounds = &pFont->info.ink_maxbounds; | |||
236 | } | |||
237 | offsetProps = malloc(pFont->info.nprops * sizeof(FontPropRec)); | |||
238 | if (!offsetProps) { | |||
239 | pcfError("pcfWriteFont(): Couldn't allocate offsetProps (%d*%d)", | |||
240 | pFont->info.nprops, (int) sizeof(FontPropRec)); | |||
241 | return AllocError80; | |||
242 | } | |||
243 | prop_string_size = 0; | |||
244 | for (i = 0; i < pFont->info.nprops; i++) { | |||
245 | offsetProps[i].name = prop_string_size; | |||
246 | prop_string_size += strlen(pcfNameForAtom(pFont->info.props[i].name)) + 1; | |||
247 | if (pFont->info.isStringProp[i]) { | |||
248 | offsetProps[i].value = prop_string_size; | |||
249 | prop_string_size += strlen(pcfNameForAtom(pFont->info.props[i].value)) + 1; | |||
250 | } else | |||
251 | offsetProps[i].value = pFont->info.props[i].value; | |||
252 | } | |||
253 | format = PCF_FORMAT(pFont->bit, pFont->byte, pFont->glyph, pFont->scan)( (((pFont->scan) == 4 ? 2 : (pFont->scan) == 2 ? 1 : 0 ) << 4) | (((pFont->bit) == 1 ? 1 : 0) << 3) | (((pFont->byte) == 1 ? 1 : 0) << 2) | (((pFont-> glyph) == 4 ? 2 : (pFont->glyph) == 2 ? 1 : 0) << 0) ); | |||
254 | mask = 0xFFFFFFF; | |||
255 | ntables = 0; | |||
256 | table = tables; | |||
257 | while (mask) { | |||
258 | bit = lowbit(mask)((mask) & (~(mask) + 1)); | |||
259 | mask &= ~bit; | |||
260 | table->type = bit; | |||
261 | switch (bit) { | |||
262 | case PCF_PROPERTIES(1<<0): | |||
263 | table->format = PCF_DEFAULT_FORMAT0x00000000 | format; | |||
264 | size = S324 + S324 + (S324 + S81 + S324) * pFont->info.nprops; | |||
265 | prop_pad = Pad(size)((((size) + 3) & ~3) - (size)); | |||
266 | table->size = RoundUp(size)(((size) + 3) & ~3) + S324 + | |||
267 | RoundUp(prop_string_size)(((prop_string_size) + 3) & ~3); | |||
268 | table++; | |||
269 | break; | |||
270 | case PCF_ACCELERATORS(1<<1): | |||
271 | if (bitmapFont->bitmapExtra->info.inkMetrics) | |||
| ||||
272 | table->format = PCF_ACCEL_W_INKBOUNDS0x00000100 | format; | |||
273 | else | |||
274 | table->format = PCF_DEFAULT_FORMAT0x00000000 | format; | |||
275 | table->size = 100; | |||
276 | table++; | |||
277 | break; | |||
278 | case PCF_METRICS(1<<2): | |||
279 | if (CanCompressMetrics(minbounds, maxbounds)(((-128 <= ((minbounds)->leftSideBearing) && (( minbounds)->leftSideBearing) <= 127) && (-128 <= ((minbounds)->rightSideBearing) && ((minbounds)-> rightSideBearing) <= 127) && (-128 <= ((minbounds )->characterWidth) && ((minbounds)->characterWidth ) <= 127) && (-128 <= ((minbounds)->ascent) && ((minbounds)->ascent) <= 127) && (-128 <= ( (minbounds)->descent) && ((minbounds)->descent) <= 127) && (minbounds)->attributes == 0) && ((-128 <= ((maxbounds)->leftSideBearing) && (( maxbounds)->leftSideBearing) <= 127) && (-128 <= ((maxbounds)->rightSideBearing) && ((maxbounds)-> rightSideBearing) <= 127) && (-128 <= ((maxbounds )->characterWidth) && ((maxbounds)->characterWidth ) <= 127) && (-128 <= ((maxbounds)->ascent) && ((maxbounds)->ascent) <= 127) && (-128 <= ( (maxbounds)->descent) && ((maxbounds)->descent) <= 127) && (maxbounds)->attributes == 0))) { | |||
280 | table->format = PCF_COMPRESSED_METRICS0x00000100 | format; | |||
281 | size = S324 + S162 + bitmapFont->num_chars * (5 * S81); | |||
282 | table->size = RoundUp(size)(((size) + 3) & ~3); | |||
283 | } else { | |||
284 | table->format = PCF_DEFAULT_FORMAT0x00000000 | format; | |||
285 | table->size = S324 + S324 + bitmapFont->num_chars * (6 * S162); | |||
286 | } | |||
287 | table++; | |||
288 | break; | |||
289 | case PCF_BITMAPS(1<<3): | |||
290 | table->format = PCF_DEFAULT_FORMAT0x00000000 | format; | |||
291 | size = S324 + S324 + bitmapFont->num_chars * S324 + | |||
292 | GLYPHPADOPTIONS4 * S324 + | |||
293 | bitmapFont->bitmapExtra->bitmapsSizes[PCF_GLYPH_PAD_INDEX(format)((format) & (3<<0))]; | |||
294 | table->size = RoundUp(size)(((size) + 3) & ~3); | |||
295 | table++; | |||
296 | break; | |||
297 | case PCF_INK_METRICS(1<<4): | |||
298 | if (bitmapFont->ink_metrics) { | |||
299 | if (CanCompressMetrics(ink_minbounds, ink_maxbounds)(((-128 <= ((ink_minbounds)->leftSideBearing) && ((ink_minbounds)->leftSideBearing) <= 127) && ( -128 <= ((ink_minbounds)->rightSideBearing) && ( (ink_minbounds)->rightSideBearing) <= 127) && ( -128 <= ((ink_minbounds)->characterWidth) && (( ink_minbounds)->characterWidth) <= 127) && (-128 <= ((ink_minbounds)->ascent) && ((ink_minbounds )->ascent) <= 127) && (-128 <= ((ink_minbounds )->descent) && ((ink_minbounds)->descent) <= 127) && (ink_minbounds)->attributes == 0) && ((-128 <= ((ink_maxbounds)->leftSideBearing) && ((ink_maxbounds)->leftSideBearing) <= 127) && ( -128 <= ((ink_maxbounds)->rightSideBearing) && ( (ink_maxbounds)->rightSideBearing) <= 127) && ( -128 <= ((ink_maxbounds)->characterWidth) && (( ink_maxbounds)->characterWidth) <= 127) && (-128 <= ((ink_maxbounds)->ascent) && ((ink_maxbounds )->ascent) <= 127) && (-128 <= ((ink_maxbounds )->descent) && ((ink_maxbounds)->descent) <= 127) && (ink_maxbounds)->attributes == 0))) { | |||
300 | table->format = PCF_COMPRESSED_METRICS0x00000100 | format; | |||
301 | size = S324 + S162 + bitmapFont->num_chars * (5 * S81); | |||
302 | table->size = RoundUp(size)(((size) + 3) & ~3); | |||
303 | } else { | |||
304 | table->format = PCF_DEFAULT_FORMAT0x00000000 | format; | |||
305 | table->size = S324 + S324 + bitmapFont->num_chars * (6 * S162); | |||
306 | } | |||
307 | table++; | |||
308 | } | |||
309 | break; | |||
310 | case PCF_BDF_ENCODINGS(1<<5): | |||
311 | table->format = PCF_DEFAULT_FORMAT0x00000000 | format; | |||
312 | nencodings = (pFont->info.lastRow - pFont->info.firstRow + 1) * | |||
313 | (pFont->info.lastCol - pFont->info.firstCol + 1); | |||
314 | size = S324 + 5 * S162 + nencodings * S162; | |||
315 | table->size = RoundUp(size)(((size) + 3) & ~3); | |||
316 | table++; | |||
317 | break; | |||
318 | case PCF_SWIDTHS(1<<6): | |||
319 | table->format = PCF_DEFAULT_FORMAT0x00000000 | format; | |||
320 | table->size = S324 + S324 + bitmapFont->num_chars * S324; | |||
321 | table++; | |||
322 | break; | |||
323 | case PCF_GLYPH_NAMES(1<<7): | |||
324 | table->format = PCF_DEFAULT_FORMAT0x00000000 | format; | |||
325 | glyph_string_size = 0; | |||
326 | for (i = 0; i < bitmapFont->num_chars; i++) | |||
327 | glyph_string_size += strlen(pcfNameForAtom(bitmapFont->bitmapExtra->glyphNames[i])) + 1; | |||
328 | table->size = S324 + S324 + bitmapFont->num_chars * S324 + | |||
329 | S324 + RoundUp(glyph_string_size)(((glyph_string_size) + 3) & ~3); | |||
330 | table++; | |||
331 | break; | |||
332 | case PCF_BDF_ACCELERATORS(1<<8): | |||
333 | if (pFont->info.inkMetrics) | |||
334 | table->format = PCF_ACCEL_W_INKBOUNDS0x00000100 | format; | |||
335 | else | |||
336 | table->format = PCF_DEFAULT_FORMAT0x00000000 | format; | |||
337 | table->size = 100; | |||
338 | table++; | |||
339 | break; | |||
340 | } | |||
341 | } | |||
342 | ntables = table - tables; | |||
343 | offset = 0; | |||
344 | header_size = S324 + S324 + ntables * (4 * S324); | |||
345 | offset = header_size; | |||
346 | for (cur_table = 0, table = tables; | |||
347 | cur_table < ntables; | |||
348 | cur_table++, table++) { | |||
349 | table->offset = offset; | |||
350 | offset += table->size; | |||
351 | } | |||
352 | current_position = 0; | |||
353 | pcfWriteTOC(file, tables, ntables); | |||
354 | for (cur_table = 0, table = tables; | |||
355 | cur_table < ntables; | |||
356 | cur_table++, table++) { | |||
357 | if (current_position > table->offset) { | |||
358 | printf("can't go backwards... %d > %d\n", | |||
359 | (int)current_position, (int)table->offset); | |||
360 | free(offsetProps); | |||
361 | return BadFontName83; | |||
362 | } | |||
363 | while (current_position < table->offset) | |||
364 | pcfPutINT8(file, format, '\0'); | |||
365 | pcfPutLSB32(file, table->format); | |||
366 | switch (table->type) { | |||
367 | case PCF_PROPERTIES(1<<0): | |||
368 | pcfPutINT32(file, format, pFont->info.nprops); | |||
369 | for (i = 0; i < pFont->info.nprops; i++) { | |||
370 | pcfPutINT32(file, format, offsetProps[i].name); | |||
371 | pcfPutINT8(file, format, pFont->info.isStringProp[i]); | |||
372 | pcfPutINT32(file, format, offsetProps[i].value); | |||
373 | } | |||
374 | for (i = 0; i < prop_pad; i++) | |||
375 | pcfPutINT8(file, format, 0); | |||
376 | pcfPutINT32(file, format, prop_string_size); | |||
377 | for (i = 0; i < pFont->info.nprops; i++) { | |||
378 | atom_name = pcfNameForAtom(pFont->info.props[i].name); | |||
379 | pcfWrite(file, atom_name, strlen(atom_name) + 1); | |||
380 | if (pFont->info.isStringProp[i]) { | |||
381 | atom_name = pcfNameForAtom(pFont->info.props[i].value); | |||
382 | pcfWrite(file, atom_name, strlen(atom_name) + 1); | |||
383 | } | |||
384 | } | |||
385 | break; | |||
386 | case PCF_ACCELERATORS(1<<1): | |||
387 | pcfPutAccel(file, table->format, &bitmapFont->bitmapExtra->info); | |||
388 | break; | |||
389 | case PCF_METRICS(1<<2): | |||
390 | if (PCF_FORMAT_MATCH(table->format, PCF_COMPRESSED_METRICS)(((table->format)&0xffffff00) == ((0x00000100)&0xffffff00 ))) { | |||
391 | pcfPutINT16(file, format, bitmapFont->num_chars); | |||
392 | for (i = 0; i < bitmapFont->num_chars; i++) | |||
393 | pcfPutCompressedMetric(file, format, &bitmapFont->metrics[i].metrics); | |||
394 | } else { | |||
395 | pcfPutINT32(file, format, bitmapFont->num_chars); | |||
396 | for (i = 0; i < bitmapFont->num_chars; i++) | |||
397 | pcfPutMetric(file, format, &bitmapFont->metrics[i].metrics); | |||
398 | } | |||
399 | break; | |||
400 | case PCF_BITMAPS(1<<3): | |||
401 | pcfPutINT32(file, format, bitmapFont->num_chars); | |||
402 | glyph = PCF_GLYPH_PAD(format)(1<<((format) & (3<<0))); | |||
403 | offset = 0; | |||
404 | for (i = 0; i < bitmapFont->num_chars; i++) { | |||
405 | pcfPutINT32(file, format, offset); | |||
406 | offset += BYTES_FOR_GLYPH(&bitmapFont->metrics[i], glyph)(((&bitmapFont->metrics[i])->metrics.ascent + (& bitmapFont->metrics[i])->metrics.descent) * ((glyph) == 1 ? (((((&bitmapFont->metrics[i])->metrics.rightSideBearing - (&bitmapFont->metrics[i])->metrics.leftSideBearing ))+7)>>3) :(glyph) == 2 ? ((((((&bitmapFont->metrics [i])->metrics.rightSideBearing - (&bitmapFont->metrics [i])->metrics.leftSideBearing))+15)>>3)&~1) :(glyph ) == 4 ? ((((((&bitmapFont->metrics[i])->metrics.rightSideBearing - (&bitmapFont->metrics[i])->metrics.leftSideBearing ))+31)>>3)&~3) :(glyph) == 8 ? ((((((&bitmapFont ->metrics[i])->metrics.rightSideBearing - (&bitmapFont ->metrics[i])->metrics.leftSideBearing))+63)>>3)& ~7) : 0)); | |||
407 | } | |||
408 | for (i = 0; i < GLYPHPADOPTIONS4; i++) { | |||
409 | pcfPutINT32(file, format, | |||
410 | bitmapFont->bitmapExtra->bitmapsSizes[i]); | |||
411 | } | |||
412 | for (i = 0; i < bitmapFont->num_chars; i++) | |||
413 | pcfPutBitmap(file, format, &bitmapFont->metrics[i]); | |||
414 | break; | |||
415 | case PCF_INK_METRICS(1<<4): | |||
416 | if (PCF_FORMAT_MATCH(table->format, PCF_COMPRESSED_METRICS)(((table->format)&0xffffff00) == ((0x00000100)&0xffffff00 ))) { | |||
417 | pcfPutINT16(file, format, bitmapFont->num_chars); | |||
418 | for (i = 0; i < bitmapFont->num_chars; i++) | |||
419 | pcfPutCompressedMetric(file, format, &bitmapFont->ink_metrics[i]); | |||
420 | } else { | |||
421 | pcfPutINT32(file, format, bitmapFont->num_chars); | |||
422 | for (i = 0; i < bitmapFont->num_chars; i++) | |||
423 | pcfPutMetric(file, format, &bitmapFont->ink_metrics[i]); | |||
424 | } | |||
425 | break; | |||
426 | case PCF_BDF_ENCODINGS(1<<5): | |||
427 | pcfPutINT16(file, format, pFont->info.firstCol); | |||
428 | pcfPutINT16(file, format, pFont->info.lastCol); | |||
429 | pcfPutINT16(file, format, pFont->info.firstRow); | |||
430 | pcfPutINT16(file, format, pFont->info.lastRow); | |||
431 | pcfPutINT16(file, format, pFont->info.defaultCh); | |||
432 | for (i = 0; i < nencodings; i++) { | |||
433 | if (ACCESSENCODING(bitmapFont->encoding,i)(bitmapFont->encoding[(i)/128]?(bitmapFont->encoding[(i )/128][(i)%128]):0)) | |||
434 | pcfPutINT16(file, format, | |||
435 | ACCESSENCODING(bitmapFont->encoding, i)(bitmapFont->encoding[(i)/128]?(bitmapFont->encoding[(i )/128][(i)%128]):0) - | |||
436 | bitmapFont->metrics); | |||
437 | else | |||
438 | pcfPutINT16(file, format, 0xFFFF); | |||
439 | } | |||
440 | break; | |||
441 | case PCF_SWIDTHS(1<<6): | |||
442 | pcfPutINT32(file, format, bitmapFont->num_chars); | |||
443 | for (i = 0; i < bitmapFont->num_chars; i++) | |||
444 | pcfPutINT32(file, format, bitmapFont->bitmapExtra->sWidths[i]); | |||
445 | break; | |||
446 | case PCF_GLYPH_NAMES(1<<7): | |||
447 | pcfPutINT32(file, format, bitmapFont->num_chars); | |||
448 | offset = 0; | |||
449 | for (i = 0; i < bitmapFont->num_chars; i++) { | |||
450 | pcfPutINT32(file, format, offset); | |||
451 | offset += strlen(pcfNameForAtom(bitmapFont->bitmapExtra->glyphNames[i])) + 1; | |||
452 | } | |||
453 | pcfPutINT32(file, format, offset); | |||
454 | for (i = 0; i < bitmapFont->num_chars; i++) { | |||
455 | atom_name = pcfNameForAtom(bitmapFont->bitmapExtra->glyphNames[i]); | |||
456 | pcfWrite(file, atom_name, strlen(atom_name) + 1); | |||
457 | } | |||
458 | break; | |||
459 | case PCF_BDF_ACCELERATORS(1<<8): | |||
460 | pcfPutAccel(file, table->format, &pFont->info); | |||
461 | break; | |||
462 | } | |||
463 | } | |||
464 | ||||
465 | free(offsetProps); | |||
466 | return Successful85; | |||
467 | } |