Calculate the size of BI_BITFIELDS dib sections via the width and
[wine] / dlls / wineps / mkagl.c
1 /*
2  * Copyright 2001 Ian Pilcher
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with this library; if not, write to the Free Software
16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17  */
18
19 #include <sys/types.h>
20 #include <dirent.h>
21 #include <string.h>
22 #include <stdlib.h>
23 #include <stdio.h>
24 #include <ctype.h>
25
26
27 /*
28  *  The array of glyph information
29  */
30
31 typedef struct
32 {
33     int         UV;
34     int         index;          /* in PSDRV_AGLGlyphNames */
35     const char  *name;
36     const char  *comment;
37
38 } GLYPHINFO;
39
40 static GLYPHINFO    glyphs[1500];
41 static int          num_glyphs = 0;
42
43
44 /*
45  *  Functions to search and sort the array
46  */
47
48 static int cmp_by_UV(const void *a, const void *b)
49 {
50     return ((const GLYPHINFO *)a)->UV - ((const GLYPHINFO *)b)->UV;
51 }
52
53 static int cmp_by_name(const void *a, const void *b)
54 {
55     return strcmp(((const GLYPHINFO *)a)->name, ((const GLYPHINFO *)b)->name);
56 }
57
58 inline static void sort_by_UV()
59 {
60     qsort(glyphs, num_glyphs, sizeof(GLYPHINFO), cmp_by_UV);
61 }
62
63 inline static void sort_by_name()
64 {
65     qsort(glyphs, num_glyphs, sizeof(GLYPHINFO), cmp_by_name);
66 }
67
68 inline static GLYPHINFO *search_by_name(const char *name)
69 {
70     GLYPHINFO   gi;
71
72     gi.name = name;
73
74     return (GLYPHINFO *)bsearch(&gi, glyphs, num_glyphs, sizeof(GLYPHINFO),
75             cmp_by_name);
76 }
77
78
79 /*
80  *  Use the 'optimal' combination of tabs and spaces to position the cursor
81  */
82
83 inline static void fcpto(FILE *f, int newpos, int curpos)
84 {
85     int newtpos = newpos & ~7;
86     int curtpos = curpos & ~7;
87
88     while (curtpos < newtpos)
89     {
90         fputc('\t', f);
91         curtpos += 8;
92         curpos = curtpos;
93     }
94
95     while (curpos < newpos)
96     {
97         fputc(' ', f);
98         ++curpos;
99     }
100 }
101
102 inline static void cpto(int newpos, int curpos)
103 {
104     fcpto(stdout, newpos, curpos);
105 }
106
107
108 /*
109  *  Make main() look "purty"
110  */
111
112 inline static void double_space(FILE *f)
113 {
114     fputc('\n', f);
115 }
116
117 inline static void triple_space(FILE *f)
118 {
119     fputc('\n', f);  fputc('\n', f);
120 }
121
122
123 /*
124  *  Read the Adobe Glyph List from 'glyphlist.txt'
125  */
126
127 static void read_agl()
128 {
129     FILE    *f = fopen("glyphlist.txt", "r");
130     char    linebuf[256], namebuf[128], commbuf[128];
131
132     if (f == NULL)
133     {
134         fprintf(stderr, "Error opening glyphlist.txt\n");
135         exit(__LINE__);
136     }
137
138     while (fgets(linebuf, sizeof(linebuf), f) != NULL)
139     {
140         unsigned int    UV;
141
142         if (linebuf[0] == '#')
143             continue;
144
145         sscanf(linebuf, "%X;%[^;];%[^\n]", &UV, namebuf, commbuf);
146
147         glyphs[num_glyphs].UV = (int)UV;
148         glyphs[num_glyphs].name = strdup(namebuf);
149         glyphs[num_glyphs].comment = strdup(commbuf);
150
151         if (glyphs[num_glyphs].name == NULL ||
152                 glyphs[num_glyphs].comment == NULL)
153         {
154             fprintf(stderr, "Memory allocation failure\n");
155             exit(__LINE__);
156         }
157
158         ++num_glyphs;
159     }
160
161     fclose(f);
162
163     if (num_glyphs != 1051)
164     {
165         fprintf(stderr, "Read %i glyphs\n", num_glyphs);
166         exit(__LINE__);
167     }
168 }
169
170
171 /*
172  *  Read glyph names from all AFM files in current directory
173  */
174
175 static void read_afms(FILE *f_c, FILE *f_h)
176 {
177     DIR             *d = opendir(".");
178     struct dirent   *de;
179
180     fputs(  "/*\n"
181             " *  Built-in font metrics\n"
182             " */\n"
183             "\n"
184             "const AFM *const PSDRV_BuiltinAFMs[] =\n"
185             "{\n", f_c);
186
187
188     if (d == NULL)
189     {
190         fprintf(stderr, "Error opening current directory\n");
191         exit(__LINE__);
192     }
193
194     while ((de = readdir(d)) != NULL)
195     {
196         FILE    *f;
197         char    *cp, linebuf[256], font_family[128];
198         int     i, num_metrics;
199
200         cp = strrchr(de->d_name, '.');                  /* Does it end in   */
201         if (cp == NULL || strcasecmp(cp, ".afm") != 0)  /*   .afm or .AFM?  */
202             continue;
203
204         f = fopen(de->d_name, "r");
205         if (f == NULL)
206         {
207             fprintf(stderr, "Error opening %s\n", de->d_name);
208             exit(__LINE__);
209         }
210
211         while (1)
212         {
213             if (fgets(linebuf, sizeof(linebuf), f) == NULL)
214             {
215                 fprintf(stderr, "FontName not found in %s\n", de->d_name);
216                 exit(__LINE__);
217             }
218
219             if (strncmp(linebuf, "FontName ", 9) == 0)
220                 break;
221         }
222
223         sscanf(linebuf, "FontName %[^\r\n]", font_family);
224
225         for (i = 0; font_family[i] != '\0'; ++i)
226             if (font_family[i] == '-')
227                 font_family[i] = '_';
228
229         fprintf(f_h, "extern const AFM PSDRV_%s;\n", font_family);
230         fprintf(f_c, "    &PSDRV_%s,\n", font_family);
231
232         while (1)
233         {
234             if (fgets(linebuf, sizeof(linebuf), f) == NULL)
235             {
236                 fprintf(stderr, "FamilyName not found in %s\n", de->d_name);
237                 exit(__LINE__);
238             }
239
240             if (strncmp(linebuf, "FamilyName ", 11) == 0)
241                 break;
242         }
243
244         sscanf(linebuf, "FamilyName %[^\r\n]", font_family);
245
246         while (1)
247         {
248             if (fgets(linebuf, sizeof(linebuf), f) == NULL)
249             {
250                 fprintf(stderr, "StartCharMetrics not found in %s\n",
251                         de->d_name);
252                 exit(__LINE__);
253             }
254
255             if (strncmp(linebuf, "StartCharMetrics ", 17) == 0)
256                 break;
257         }
258
259         sscanf(linebuf, "StartCharMetrics %i", &num_metrics);
260
261         for (i = 0; i < num_metrics; ++i)
262         {
263             char    namebuf[128];
264
265             if (fgets(linebuf, sizeof(linebuf), f) == NULL)
266             {
267                 fprintf(stderr, "Unexpected EOF after %i glyphs in %s\n", i,
268                         de->d_name);
269                 exit(__LINE__);
270             }
271
272             cp = strchr(linebuf, 'N');
273             if (cp == NULL || strlen(cp) < 3)
274             {
275                 fprintf(stderr, "Parse error after %i glyphs in %s\n", i,
276                         de->d_name);
277                 exit(__LINE__);
278             }
279
280             sscanf(cp, "N %s", namebuf);
281             if (search_by_name(namebuf) != NULL)
282                 continue;
283
284             sprintf(linebuf, "FONT FAMILY;%s", font_family);
285
286             glyphs[num_glyphs].UV = -1;
287             glyphs[num_glyphs].name = strdup(namebuf);
288             glyphs[num_glyphs].comment = strdup(linebuf);
289
290             if (glyphs[num_glyphs].name == NULL ||
291                     glyphs[num_glyphs].comment == NULL)
292             {
293                 fprintf(stderr, "Memory allocation failure\n");
294                 exit(__LINE__);
295             }
296
297             ++num_glyphs;
298
299             sort_by_name();
300         }
301
302         fclose(f);
303     }
304
305     closedir(d);
306
307     fputs("    NULL\n};\n", f_c);
308 }
309
310
311 /*
312  *  Write opening comments, etc.
313  */
314
315 static void write_header(FILE *f)
316 {
317     int i;
318
319     fputc('/', f);
320     for (i = 0; i < 79; ++i)
321         fputc('*', f);
322     fputs("\n"
323             " *\n"
324             " *\tFont and glyph data for the Wine PostScript driver\n"
325             " *\n"
326             " *\tCopyright 2001 Ian Pilcher\n"
327             " *\n"
328             " *\n"
329             " *\tThis data is derived from the Adobe Glyph list at\n"
330             " *\n"
331             " *\t    "
332             "http://partners.adobe.com/asn/developer/type/glyphlist.txt\n"
333             " *\n"
334             " *\tand the Adobe Font Metrics files at\n"
335             " *\n"
336             " *\t    "
337             "ftp://ftp.adobe.com/pub/adobe/type/win/all/afmfiles/base35/\n"
338             " *\n"
339             " *\twhich are Copyright 1985-1998 Adobe Systems Incorporated.\n"
340             " *\n"
341             " */\n"
342             "\n"
343             "#include \"psdrv.h\"\n"
344             "#include \"data/agl.h\"\n", f);
345 }
346
347 /*
348  *  Write the array of glyph names (also populates indexes)
349  */
350
351 static void write_glyph_names(FILE *f_c, FILE *f_h)
352 {
353     int i, num_names = 0, index = 0;
354
355     for (i = 0; i < num_glyphs; ++i)
356         if (i == 0 || strcmp(glyphs[i - 1].name, glyphs[i].name) != 0)
357             ++num_names;
358
359     fputs(  "/*\n"
360             " *  Every glyph name in the AGL and the 35 core PostScript fonts\n"
361             " */\n"
362             "\n", f_c);
363
364     fprintf(f_c, "const INT PSDRV_AGLGlyphNamesSize = %i;\n\n", num_names);
365
366     fprintf(f_c, "GLYPHNAME PSDRV_AGLGlyphNames[%i] =\n{\n", num_names);
367
368     for (i = 0; i < num_glyphs - 1; ++i)
369     {
370         int cp = 0;
371
372         if (i == 0 || strcmp(glyphs[i - 1].name, glyphs[i].name) != 0)
373         {
374             fcpto(f_h, 32, fprintf(f_h, "#define GN_%s", glyphs[i].name));
375             fprintf(f_h, "(PSDRV_AGLGlyphNames + %i)\n", index);
376
377             cp = fprintf(f_c, "    { %4i, \"%s\" },", index, glyphs[i].name);
378             glyphs[i].index = index;
379             ++index;
380         }
381         else
382         {
383             glyphs[i].index = glyphs[i - 1].index;
384         }
385
386         fcpto(f_c, 40, cp);
387
388         fprintf(f_c, "/* %s */\n", glyphs[i].comment);
389     }
390
391     fcpto(f_h, 32, fprintf(f_h, "#define GN_%s", glyphs[i].name));
392     fprintf(f_h, "(PSDRV_AGLGlyphNames + %i)\n", index);
393
394     glyphs[i].index = index;
395     fcpto(f_c, 40, fprintf(f_c, "    { %4i, \"%s\" }", index, glyphs[i].name));
396     fprintf(f_c, "/* %s */\n};\n", glyphs[i].comment);
397 }
398
399
400 /*
401  *  Write the AGL encoding vector, sorted by glyph name
402  */
403
404 static void write_encoding_by_name(FILE *f)
405 {
406     int i, size = 0, even = 1;
407
408     for (i = 0; i < num_glyphs; ++i)
409         if (glyphs[i].UV != -1 &&
410                 (i == 0 || strcmp(glyphs[i - 1].name, glyphs[i].name) != 0))
411             ++size;                 /* should be 1039 */
412
413     fputs(  "/*\n"
414             " *  The AGL encoding vector, sorted by glyph name - "
415                     "duplicates omitted\n"
416             " */\n"
417             "\n", f);
418
419     fprintf(f, "const INT PSDRV_AGLbyNameSize = %i;\n\n", size);
420     fprintf(f, "const UNICODEGLYPH PSDRV_AGLbyName[%i] =\n{\n", size);
421
422     for (i = 0; i < num_glyphs - 1; ++i)
423     {
424         int cp;
425
426         if (glyphs[i].UV == -1)
427             continue;
428
429         if (i != 0 && strcmp(glyphs[i - 1].name, glyphs[i].name) == 0)
430             continue;
431
432         cp = fprintf(f, "    { 0x%.4x, GN_%s },", glyphs[i].UV, glyphs[i].name);
433
434         even = !even;
435         if (even)
436             fputc('\n', f);
437         else
438             fcpto(f, 40, cp);
439     }
440
441     fprintf(f, "    { 0x%.4x, GN_%s }\n};\n", glyphs[i].UV, glyphs[i].name);
442 }
443
444 /*
445  *  Write the AGL encoding vector, sorted by Unicode value
446  */
447
448 static void write_encoding_by_UV(FILE *f)
449 {
450     int i, size = 0, even = 1;
451
452     for (i = 0; i < num_glyphs; ++i)
453         if (glyphs[i].UV != -1)
454             ++size;                     /* better be 1051! */
455
456     sort_by_UV();
457
458     fputs(  "/*\n"
459             " *  The AGL encoding vector, sorted by Unicode value - "
460                     "duplicates included\n"
461             " */\n"
462             "\n", f);
463
464     fprintf(f, "const INT PSDRV_AGLbyUVSize = %i;\n\n", size);
465     fprintf(f, "const UNICODEGLYPH PSDRV_AGLbyUV[%i] =\n{\n", size);
466
467     for (i = 0; i < num_glyphs - 1; ++i)
468     {
469         int cp;
470
471         if (glyphs[i].UV == -1)
472             continue;
473
474         cp = fprintf(f, "    { 0x%.4x, GN_%s },", glyphs[i].UV, glyphs[i].name);
475
476         even = !even;
477         if (even)
478             fputc('\n', f);
479         else
480             fcpto(f, 40, cp);
481     }
482
483     fprintf(f, "    { 0x%.4x, GN_%s }\n};\n", glyphs[i].UV, glyphs[i].name);
484 }
485
486
487 /*
488  *  Do it!
489  */
490
491 int main(int argc, char *argv[])
492 {
493     FILE    *f_c, *f_h;
494
495     if (argc < 3)
496     {
497         fprintf(stderr, "Usage: %s <C file> <header file>\n", argv[0]);
498         exit(__LINE__);
499     }
500
501     f_c = fopen(argv[1], "w");
502     if (f_c == NULL)
503     {
504         fprintf(stderr, "Error opening %s for writing\n", argv[1]);
505         exit(__LINE__);
506     }
507
508     f_h = fopen(argv[2], "w");
509     if (f_h == NULL)
510     {
511         fprintf(stderr, "Error opening %s for writing\n", argv[2]);
512         exit(__LINE__);
513     }
514
515     write_header(f_c);
516     triple_space(f_c);
517     read_agl();
518     read_afms(f_c, f_h);            /* also writes font list */
519     triple_space(f_c);
520     write_glyph_names(f_c, f_h);
521     triple_space(f_c);
522     write_encoding_by_name(f_c);
523     triple_space(f_c);
524     write_encoding_by_UV(f_c);
525
526     return 0;
527 }