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