← Back to branch summary

~ubuntu-branches/ubuntu/utopic/texlive-bin/utopic

« back to all changes in this revision

Viewing changes to texk/dvipdfmx/dvipdfmx-20120420/src/fontmap.c

  • Committer: Package Import Robot
  • Author(s): Norbert Preining
  • Date: 2012-05-07 10:47:49 UTC
  • mfrom: (1.2.4)
  • Revision ID: package-import@ubuntu.com-20120507104749-p00ot5sajjbkp1hp
Tags: 2011.20120507-1
* new upstream checkout: uptex 1.10
* drop patches for config file inclusion in (x)dvipdfmx, included upstream
* add man page for etex
* include pmpost patches and build it
* adapt/unfuzzify patches for current sources
* disable mtx building, we have prepmx package in Debian

Show diffs side-by-side

added added

removed removed

Lines of Context:
texk/dvipdfmx/dvipdfmx-20120420/src/fontmap.c
 
1
/*  $Header: /home/cvsroot/dvipdfmx/src/fontmap.c,v 1.43 2011/03/06 03:14:14 chofchof Exp $
 
2
    
 
3
    This is dvipdfmx, an eXtended version of dvipdfm by Mark A. Wicks.
 
4
 
 
5
    Copyright (C) 2007 by Jin-Hwan Cho and Shunsaku Hirata,
 
6
    the dvipdfmx project team <dvipdfmx@project.ktug.or.kr>
 
7
    
 
8
    Copyright (C) 1998, 1999 by Mark A. Wicks <mwicks@kettering.edu>
 
9
 
 
10
    This program is free software; you can redistribute it and/or modify
 
11
    it under the terms of the GNU General Public License as published by
 
12
    the Free Software Foundation; either version 2 of the License, or
 
13
    (at your option) any later version.
 
14
    
 
15
    This program is distributed in the hope that it will be useful,
 
16
    but WITHOUT ANY WARRANTY; without even the implied warranty of
 
17
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
18
    GNU General Public License for more details.
 
19
    
 
20
    You should have received a copy of the GNU General Public License
 
21
    along with this program; if not, write to the Free Software
 
22
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
 
23
*/
 
24
 
 
25
#if HAVE_CONFIG_H
 
26
#include "config.h"
 
27
#endif
 
28
 
 
29
#include "system.h"
 
30
#include "mem.h"
 
31
#include "error.h"
 
32
 
 
33
#include "dpxfile.h"
 
34
#include "dpxutil.h"
 
35
 
 
36
#include "subfont.h"
 
37
 
 
38
#include "fontmap.h"
 
39
 
 
40
/* CIDFont */
 
41
static char *strip_options (const char *map_name, fontmap_opt *opt);
 
42
 
 
43
static int verbose = 0;
 
44
void
 
45
pdf_fontmap_set_verbose (void)
 
46
{
 
47
  verbose++;
 
48
}
 
49
 
 
50
 
 
51
void
 
52
pdf_init_fontmap_record (fontmap_rec *mrec) 
 
53
{
 
54
  ASSERT(mrec);
 
55
 
 
56
  mrec->map_name   = NULL;
 
57
 
 
58
  /* SFD char mapping */
 
59
  mrec->charmap.sfd_name   = NULL;
 
60
  mrec->charmap.subfont_id = NULL;
 
61
  /* for OFM */
 
62
  mrec->opt.mapc   = -1; /* compatibility */
 
63
 
 
64
  mrec->font_name  = NULL;
 
65
  mrec->enc_name   = NULL;
 
66
 
 
67
  mrec->opt.slant  = 0.0;
 
68
  mrec->opt.extend = 1.0;
 
69
  mrec->opt.bold   = 0.0;
 
70
 
 
71
  mrec->opt.flags  = 0;
 
72
 
 
73
  mrec->opt.design_size = -1.0;
 
74
 
 
75
  mrec->opt.tounicode = NULL;
 
76
  mrec->opt.otl_tags  = NULL; /* deactivated */
 
77
  mrec->opt.index     = 0;
 
78
  mrec->opt.charcoll  = NULL;
 
79
  mrec->opt.style     = FONTMAP_STYLE_NONE;
 
80
  mrec->opt.stemv     = -1; /* not given explicitly by an option */
 
81
}
 
82
 
 
83
void
 
84
pdf_clear_fontmap_record (fontmap_rec *mrec)
 
85
{
 
86
  ASSERT(mrec);
 
87
 
 
88
  if (mrec->map_name)
 
89
    RELEASE(mrec->map_name);
 
90
  if (mrec->charmap.sfd_name)
 
91
    RELEASE(mrec->charmap.sfd_name);
 
92
  if (mrec->charmap.subfont_id)
 
93
    RELEASE(mrec->charmap.subfont_id);
 
94
  if (mrec->enc_name)
 
95
    RELEASE(mrec->enc_name);
 
96
  if (mrec->font_name)
 
97
    RELEASE(mrec->font_name);
 
98
 
 
99
  if (mrec->opt.tounicode)
 
100
    RELEASE(mrec->opt.tounicode);
 
101
  if (mrec->opt.otl_tags)
 
102
    RELEASE(mrec->opt.otl_tags);
 
103
  if (mrec->opt.charcoll)
 
104
    RELEASE(mrec->opt.charcoll);
 
105
  pdf_init_fontmap_record(mrec);
 
106
}
 
107
 
 
108
/* strdup: just returns NULL for NULL */
 
109
static char *
 
110
mstrdup (const char *s)
 
111
{
 
112
  char  *r;
 
113
  if (!s)
 
114
    return  NULL;
 
115
  r = NEW(strlen(s) + 1, char);
 
116
  strcpy(r, s);
 
117
  return  r;
 
118
}
 
119
 
 
120
static void
 
121
pdf_copy_fontmap_record (fontmap_rec *dst, const fontmap_rec *src)
 
122
{
 
123
  ASSERT( dst && src );
 
124
 
 
125
  dst->map_name   = mstrdup(src->map_name);
 
126
 
 
127
  dst->charmap.sfd_name   = mstrdup(src->charmap.sfd_name);
 
128
  dst->charmap.subfont_id = mstrdup(src->charmap.subfont_id);
 
129
 
 
130
  dst->font_name  = mstrdup(src->font_name);
 
131
  dst->enc_name   = mstrdup(src->enc_name);
 
132
 
 
133
  dst->opt.slant  = src->opt.slant;
 
134
  dst->opt.extend = src->opt.extend;
 
135
  dst->opt.bold   = src->opt.bold;
 
136
 
 
137
  dst->opt.flags  = src->opt.flags;
 
138
  dst->opt.mapc   = src->opt.mapc;
 
139
 
 
140
  dst->opt.tounicode = mstrdup(src->opt.tounicode);
 
141
  dst->opt.otl_tags  = mstrdup(src->opt.otl_tags);
 
142
  dst->opt.index     = src->opt.index;
 
143
  dst->opt.charcoll  = mstrdup(src->opt.charcoll);
 
144
  dst->opt.style     = src->opt.style;
 
145
  dst->opt.stemv     = src->opt.stemv;
 
146
}
 
147
 
 
148
 
 
149
static void
 
150
hval_free (void *vp)
 
151
{
 
152
  fontmap_rec *mrec = (fontmap_rec *) vp;
 
153
  pdf_clear_fontmap_record(mrec);
 
154
  RELEASE(mrec);
 
155
}
 
156
 
 
157
 
 
158
static void
 
159
fill_in_defaults (fontmap_rec *mrec, const char *tex_name)
 
160
{
 
161
  if (mrec->enc_name &&
 
162
      (!strcmp(mrec->enc_name, "default") ||
 
163
       !strcmp(mrec->enc_name, "none"))) {
 
164
    RELEASE(mrec->enc_name);
 
165
    mrec->enc_name = NULL;
 
166
  }
 
167
  if (mrec->font_name && 
 
168
      (!strcmp(mrec->font_name, "default") ||
 
169
       !strcmp(mrec->font_name, "none"))) {
 
170
    RELEASE(mrec->font_name);
 
171
    mrec->font_name = NULL;
 
172
  }
 
173
  /* We *must* fill font_name either explicitly or by default */
 
174
  if (!mrec->font_name) {
 
175
    mrec->font_name = NEW(strlen(tex_name)+1, char);
 
176
    strcpy(mrec->font_name, tex_name);
 
177
  }
 
178
 
 
179
  mrec->map_name = NEW(strlen(tex_name)+1, char);
 
180
  strcpy(mrec->map_name, tex_name);
 
181
 
 
182
#ifndef WITHOUT_COMPAT
 
183
  /* Use "UCS" character collection for Unicode SFD
 
184
   * and Identity CMap combination. For backward
 
185
   * compatibility.
 
186
   */
 
187
  if (mrec->charmap.sfd_name && mrec->enc_name &&
 
188
      !mrec->opt.charcoll) {
 
189
    if ((!strcmp(mrec->enc_name, "Identity-H") ||
 
190
         !strcmp(mrec->enc_name, "Identity-V"))
 
191
          &&
 
192
         (strstr(mrec->charmap.sfd_name, "Uni")  ||
 
193
          strstr(mrec->charmap.sfd_name, "UBig") ||
 
194
          strstr(mrec->charmap.sfd_name, "UBg")  ||
 
195
          strstr(mrec->charmap.sfd_name, "UGB")  ||
 
196
          strstr(mrec->charmap.sfd_name, "UKS")  ||
 
197
          strstr(mrec->charmap.sfd_name, "UJIS"))) {
 
198
      mrec->opt.charcoll = NEW(strlen("UCS")+1, char);
 
199
      strcpy(mrec->opt.charcoll, "UCS");
 
200
    }
 
201
  }
 
202
#endif /* WITHOUT_COMPAT */
 
203
 
 
204
  return;
 
205
}
 
206
 
 
207
static char *
 
208
readline (char *buf, int buf_len, FILE *fp)
 
209
{
 
210
  char  *p, *q;
 
211
  ASSERT( buf && buf_len > 0 && fp );
 
212
  p = mfgets(buf, buf_len, fp);
 
213
  if (!p)
 
214
    return  NULL;
 
215
  q = strchr(p, '%'); /* we don't have quoted string */
 
216
  if (q)
 
217
    *q = '\0';
 
218
  return  p;
 
219
}
 
220
 
 
221
#ifndef ISBLANK
 
222
#  define ISBLANK(c) ((c) == ' ' || (c) == '\t')
 
223
#endif
 
224
static void
 
225
skip_blank (const char **pp, const char *endptr)
 
226
{
 
227
  const char  *p = *pp;
 
228
  if (!p || p >= endptr)
 
229
    return;
 
230
  for ( ; p < endptr && ISBLANK(*p); p++);
 
231
  *pp = p;
 
232
}
 
233
 
 
234
static char *
 
235
parse_string_value (const char **pp, const char *endptr)
 
236
{
 
237
  char  *q = NULL;
 
238
  const char *p = *pp;
 
239
  int    n;
 
240
 
 
241
  if (!p || p >= endptr)
 
242
    return  NULL;
 
243
  if (*p == '"')
 
244
    q = parse_c_string(&p, endptr);
 
245
  else {
 
246
    for (n = 0; p < endptr && !isspace(*p); p++, n++);
 
247
    if (n == 0)
 
248
      return  NULL;
 
249
    q = NEW(n + 1, char);
 
250
    memcpy(q, *pp, n); q[n] = '\0';
 
251
  }
 
252
 
 
253
  *pp = p;
 
254
  return  q;
 
255
}
 
256
 
 
257
/* no preceeding spaces allowed */
 
258
static char *
 
259
parse_integer_value (const char **pp, const char *endptr, int base)
 
260
{
 
261
  char  *q;
 
262
  const char *p = *pp;
 
263
  int    has_sign = 0, has_prefix = 0, n;
 
264
 
 
265
  ASSERT( base == 0 || (base >= 2 && base <= 36) );
 
266
 
 
267
  if (!p || p >= endptr)
 
268
    return  NULL;
 
269
 
 
270
  if (*p == '-' || *p == '+') {
 
271
    p++; has_sign = 1;
 
272
  }
 
273
  if ((base == 0 || base == 16) &&
 
274
      p + 2 <= endptr &&
 
275
      p[0] == '0' && p[1] == 'x') {
 
276
    p += 2; has_prefix = 1;
 
277
  }
 
278
  if (base == 0) {
 
279
    if (has_prefix)
 
280
      base = 16;
 
281
    else if (p < endptr && *p == '0')
 
282
      base = 8;
 
283
    else {
 
284
      base = 10;
 
285
    }
 
286
  }
 
287
#define ISDIGIT_WB(c,b) ( \
 
288
  ((b) <= 10 && (c) >= '0' && (c) < '0' + (b)) || \
 
289
  ((b) >  10 && ( \
 
290
      ((c) >= '0' && (c) <= '9') || \
 
291
      ((c) >= 'a' && (c) < 'a' + ((b) - 10)) || \
 
292
      ((c) >= 'A' && (c) < 'A' + ((b) - 10)) \
 
293
    ) \
 
294
  ) \
 
295
)
 
296
  for (n = 0; p < endptr && ISDIGIT_WB(*p, base); p++, n++);
 
297
  if (n == 0)
 
298
    return  NULL;
 
299
  if (has_sign)
 
300
    n += 1;
 
301
  if (has_prefix)
 
302
    n += 2;
 
303
 
 
304
  q = NEW(n + 1, char);
 
305
  memcpy(q, *pp, n); q[n] = '\0';
 
306
 
 
307
  *pp = p;
 
308
  return  q;
 
309
}
 
310
 
 
311
static int
 
312
fontmap_parse_mapdef_dpm (fontmap_rec *mrec,
 
313
                          const char *mapdef, const char *endptr)
 
314
{
 
315
  const char  *p = mapdef;
 
316
 
 
317
  /*
 
318
   * Parse record line in map file.  First two fields (after TeX font
 
319
   * name) are position specific.  Arguments start at the first token
 
320
   * beginning with a  '-'.
 
321
   *
 
322
   * NOTE:
 
323
   *   Dvipdfm basically uses parse_ident() for parsing enc_name,
 
324
   *   font_name, and other string values which assumes PostScript-like
 
325
   *   syntax.
 
326
   *   skip_white() skips '\r' and '\n' but they should terminate
 
327
   *   fontmap line here.
 
328
   */
 
329
 
 
330
  skip_blank(&p, endptr);
 
331
  /* encoding field */
 
332
  if (p < endptr && *p != '-') { /* May be NULL */
 
333
    mrec->enc_name = parse_string_value(&p, endptr);
 
334
    skip_blank(&p, endptr);
 
335
  }
 
336
 
 
337
  /* fontname or font filename field */
 
338
  if (p < endptr && *p != '-') { /* May be NULL */
 
339
    mrec->font_name = parse_string_value(&p, endptr);
 
340
    skip_blank(&p, endptr);
 
341
  }
 
342
  if (mrec->font_name) {
 
343
    char  *tmp;
 
344
    /* Several options are encoded in font_name for
 
345
     * compatibility with dvipdfm.
 
346
     */
 
347
    tmp = strip_options(mrec->font_name, &mrec->opt);
 
348
    if (tmp) {
 
349
      RELEASE(mrec->font_name);
 
350
      mrec->font_name = tmp;
 
351
    }
 
352
  }
 
353
 
 
354
  skip_blank(&p, endptr);
 
355
  /* Parse any remaining arguments */
 
356
  while (p + 1 < endptr &&
 
357
         *p != '\r' && *p != '\n' && *p == '-') {
 
358
    char  *q, mopt = p[1];
 
359
    long   v;
 
360
 
 
361
    p += 2; skip_blank(&p, endptr);
 
362
    switch (mopt) {
 
363
 
 
364
    case  's': /* Slant option */
 
365
      q = parse_float_decimal(&p, endptr);
 
366
      if (!q) {
 
367
        WARN("Missing a number value for 's' option.");
 
368
        return  -1;
 
369
      }
 
370
      mrec->opt.slant = atof(q);
 
371
      RELEASE(q);
 
372
      break;
 
373
 
 
374
    case  'e': /* Extend option */
 
375
      q = parse_float_decimal(&p, endptr);
 
376
      if (!q) {
 
377
        WARN("Missing a number value for 'e' option.");
 
378
        return  -1;
 
379
      }
 
380
      mrec->opt.extend = atof(q);
 
381
      if (mrec->opt.extend <= 0.0) {
 
382
        WARN("Invalid value for 'e' option: %s", q);
 
383
        return  -1;
 
384
      }
 
385
      RELEASE(q);
 
386
      break;
 
387
 
 
388
    case  'b': /* Fake-bold option */
 
389
      q = parse_float_decimal(&p, endptr);
 
390
      if (!q) {
 
391
        WARN("Missing a number value for 'b' option.");
 
392
        return  -1;
 
393
      }
 
394
      mrec->opt.bold = atof(q);
 
395
      if (mrec->opt.bold <= 0.0) {
 
396
        WARN("Invalid value for 'b' option: %s", q);
 
397
        return  -1;
 
398
      }
 
399
      RELEASE(q);
 
400
      break;
 
401
 
 
402
    case  'r': /* Remap option; obsolete; just ignore */
 
403
      break;
 
404
 
 
405
    case  'i':  /* TTC index */
 
406
      q = parse_integer_value(&p, endptr, 10);
 
407
      if (!q) {
 
408
        WARN("Missing TTC index number...");
 
409
        return  -1;
 
410
      }
 
411
      mrec->opt.index = atoi(q);
 
412
      if (mrec->opt.index < 0) {
 
413
        WARN("Invalid TTC index number: %s", q);
 
414
        return  -1;
 
415
      }
 
416
      RELEASE(q);
 
417
      break;
 
418
 
 
419
    case  'p': /* UCS plane: just for testing */
 
420
      q = parse_integer_value(&p, endptr, 0);
 
421
      if (!q) {
 
422
        WARN("Missing a number for 'p' option.");
 
423
        return  -1;
 
424
      }
 
425
      v = strtol(q, NULL, 0);
 
426
      if (v < 0 || v > 16)
 
427
        WARN("Invalid value for option 'p': %s", q);
 
428
      else {
 
429
        mrec->opt.mapc = v << 16;
 
430
      }
 
431
      RELEASE(q);
 
432
      break;
 
433
 
 
434
    case  'u': /* ToUnicode */
 
435
      q = parse_string_value(&p, endptr);
 
436
      if (q)
 
437
        mrec->opt.tounicode = q;
 
438
      else {
 
439
        WARN("Missing string value for option 'u'.");
 
440
        return  -1;
 
441
      }
 
442
      break;
 
443
 
 
444
    case  'v': /* StemV */
 
445
      q = parse_integer_value(&p, endptr, 10);
 
446
      if (!q) {
 
447
        WARN("Missing a number for 'v' option.");
 
448
        return  -1;
 
449
      }
 
450
      mrec->opt.stemv = strtol(q, NULL, 0);
 
451
      RELEASE(q);
 
452
      break;
 
453
 
 
454
    /* Omega uses both single-byte and double-byte set_char command
 
455
     * even for double-byte OFMs. This confuses CMap decoder.
 
456
     */
 
457
    case  'm':
 
458
      /* Map single bytes char 0xab to double byte char 0xcdab  */
 
459
      if (p + 4 <= endptr &&
 
460
          p[0] == '<' && p[3] == '>') {
 
461
        p++;
 
462
        q = parse_integer_value(&p, endptr, 16);
 
463
        if (!q) {
 
464
          WARN("Invalid value for option 'm'.");
 
465
          return  -1;
 
466
        } else if (p < endptr && *p != '>') {
 
467
          WARN("Invalid value for option 'm': %s", q);
 
468
          RELEASE(q);
 
469
          return  -1;
 
470
        }
 
471
        v = strtol(q, NULL, 16);
 
472
        mrec->opt.mapc = ((v << 8) & 0x0000ff00L);
 
473
        RELEASE(q); p++;
 
474
      } else if (p + 4 <= endptr &&
 
475
                 !memcmp(p, "sfd:", strlen("sfd:"))) {
 
476
        char  *r;
 
477
        /* SFD mapping: sfd:Big5,00 */
 
478
        p += 4; skip_blank(&p, endptr);
 
479
        q  = parse_string_value(&p, endptr);
 
480
        if (!q) {
 
481
          WARN("Missing value for option 'm'.");
 
482
          return  -1;
 
483
        }
 
484
        r  = strchr(q, ',');
 
485
        if (!r) {
 
486
          WARN("Invalid value for option 'm': %s", q);
 
487
          RELEASE(q);
 
488
          return  -1;
 
489
        }
 
490
        *r = 0; r++; skip_blank((const char **)&r, r + strlen(r));
 
491
        if (*r == '\0') {
 
492
          WARN("Invalid value for option 'm': %s,", q);
 
493
          RELEASE(q);
 
494
          return  -1;
 
495
        }
 
496
        mrec->charmap.sfd_name   = mstrdup(q);
 
497
        mrec->charmap.subfont_id = mstrdup(r);
 
498
        RELEASE(q);
 
499
      } else if (p + 4 < endptr &&
 
500
                 !memcmp(p, "pad:", strlen("pad:"))) {
 
501
        p += 4; skip_blank(&p, endptr);
 
502
        q  = parse_integer_value(&p, endptr, 16);
 
503
        if (!q) {
 
504
          WARN("Invalid value for option 'm'.");
 
505
          return  -1;
 
506
        } else if (p < endptr && !isspace(*p)) {
 
507
          WARN("Invalid value for option 'm': %s", q);
 
508
          RELEASE(q);
 
509
          return  -1;
 
510
        }
 
511
        v = strtol(q, NULL, 16);
 
512
        mrec->opt.mapc = ((v << 8) & 0x0000ff00L);
 
513
        RELEASE(q);
 
514
      } else {
 
515
        WARN("Invalid value for option 'm'.");
 
516
        return  -1;
 
517
      }
 
518
      break;
 
519
 
 
520
    case 'w': /* Writing mode (for unicode encoding) */
 
521
      if (!mrec->enc_name ||
 
522
           strcmp(mrec->enc_name, "unicode")) {
 
523
        WARN("Fontmap option 'w' meaningless for encoding other than \"unicode\".");
 
524
        return  -1;
 
525
      }
 
526
      q  = parse_integer_value(&p, endptr, 10);
 
527
      if (!q) {
 
528
        WARN("Missing wmode value...");
 
529
        return  -1;
 
530
      }
 
531
      if (atoi(q) == 1)
 
532
        mrec->opt.flags |= FONTMAP_OPT_VERT;
 
533
      else if (atoi(q) == 0)
 
534
        mrec->opt.flags &= ~FONTMAP_OPT_VERT;
 
535
      else {
 
536
        WARN("Invalid value for option 'w': %s", q);
 
537
      }
 
538
      RELEASE(q);
 
539
      break;
 
540
 
 
541
    default:
 
542
      WARN("Unrecognized font map option: '%c'", mopt);
 
543
      return  -1;
 
544
      break;
 
545
    }
 
546
    skip_blank(&p, endptr);
 
547
  }
 
548
 
 
549
  if (p < endptr && *p != '\r' && *p != '\n') {
 
550
    WARN("Invalid char in fontmap line: %c", *p);
 
551
    return  -1;
 
552
  }
 
553
 
 
554
  return  0;
 
555
}
 
556
 
 
557
 
 
558
/* Parse record line in map file of DVIPS/pdfTeX format. */
 
559
static int
 
560
fontmap_parse_mapdef_dps (fontmap_rec *mrec,
 
561
                          const char *mapdef, const char *endptr)
 
562
{
 
563
  const char *p = mapdef;
 
564
  char *q;
 
565
 
 
566
  skip_blank(&p, endptr);
 
567
 
 
568
  /* The first field (after TFM name) must be PostScript name. */
 
569
  /* However, pdftex.map allows a line without PostScript name. */
 
570
 
 
571
  if (*p != '"' && *p != '<') {
 
572
    if (p < endptr) {
 
573
      q = parse_string_value(&p, endptr);
 
574
      if (q) RELEASE(q);
 
575
      skip_blank(&p, endptr);
 
576
    } else {
 
577
      WARN("Missing a PostScript font name.");
 
578
      return -1;
 
579
    }
 
580
  }
 
581
 
 
582
  if (p >= endptr) return 0;
 
583
 
 
584
  /* Parse any remaining arguments */
 
585
  while (p < endptr && *p != '\r' && *p != '\n' && (*p == '<' || *p == '"')) {
 
586
    switch (*p) {
 
587
    case '<': /* encoding or fontfile field */
 
588
      if (++p < endptr && *p == '[') p++; /*skip */
 
589
      skip_blank(&p, endptr);
 
590
      if ((q = parse_string_value(&p, endptr))) {
 
591
        int n = strlen(q);
 
592
        if (n > 4 && strncmp(q+n-4, ".enc", 4) == 0)
 
593
          mrec->enc_name = q;
 
594
        else
 
595
          mrec->font_name = q;
 
596
      }
 
597
      skip_blank(&p, endptr);
 
598
      break;
 
599
 
 
600
    case '"': /* Options */
 
601
      if ((q = parse_string_value(&p, endptr))) {
 
602
        const char *r = q, *e = q+strlen(q);
 
603
        char *s, *t;
 
604
        skip_blank(&r, e);
 
605
        while (r < e) {
 
606
          if ((s = parse_float_decimal(&r, e))) {
 
607
            skip_blank(&r, e);
 
608
            if ((t = parse_string_value(&r, e))) {
 
609
              if (strcmp(t, "SlantFont") == 0)
 
610
                mrec->opt.slant = atof(s);
 
611
              else if (strcmp(t, "ExtendFont") == 0)
 
612
                mrec->opt.extend = atof(s);
 
613
              RELEASE(t);
 
614
            }
 
615
            RELEASE(s);
 
616
          } else if ((s = parse_string_value(&r, e))) { /* skip */
 
617
            RELEASE(s);
 
618
          }
 
619
          skip_blank(&r, e);
 
620
        }
 
621
        RELEASE(q);
 
622
      }
 
623
      skip_blank(&p, endptr);
 
624
      break;
 
625
    
 
626
    default:
 
627
      WARN("Found an invalid entry: %s", p);
 
628
      return -1;
 
629
      break;
 
630
    }
 
631
    skip_blank(&p, endptr);
 
632
  }
 
633
 
 
634
  if (p < endptr && *p != '\r' && *p != '\n') {
 
635
    WARN("Invalid char in fontmap line: %c", *p);
 
636
    return -1;
 
637
  }
 
638
 
 
639
  return  0;
 
640
}
 
641
 
 
642
 
 
643
static struct ht_table *fontmap = NULL;
 
644
 
 
645
#define fontmap_invalid(m) (!(m) || !(m)->map_name || !(m)->font_name)
 
646
static char *
 
647
chop_sfd_name (const char *tex_name, char **sfd_name)
 
648
{
 
649
  char  *fontname;
 
650
  char  *p, *q;
 
651
  int    m, n, len;
 
652
 
 
653
  *sfd_name = NULL;
 
654
 
 
655
  p = strchr(tex_name, '@');
 
656
  if (!p ||
 
657
      p[1] == '\0' || p == tex_name) {
 
658
    return  NULL;
 
659
  }
 
660
  m = (int) (p - tex_name);
 
661
  p++;
 
662
  q = strchr(p, '@');
 
663
  if (!q || q == p) {
 
664
    return NULL;
 
665
  }
 
666
  n = (int) (q - p);
 
667
  q++;
 
668
 
 
669
  len = strlen(tex_name) - n;
 
670
  fontname = NEW(len+1, char);
 
671
  memcpy(fontname, tex_name, m);
 
672
  fontname[m] = '\0';
 
673
  if (*q)
 
674
    strcat(fontname, q);
 
675
 
 
676
  *sfd_name = NEW(n+1, char);
 
677
  memcpy(*sfd_name, p, n);
 
678
  (*sfd_name)[n] = '\0';
 
679
 
 
680
  return  fontname;
 
681
}
 
682
 
 
683
static char *
 
684
make_subfont_name (const char *map_name, const char *sfd_name, const char *sub_id)
 
685
{
 
686
  char  *tfm_name;
 
687
  int    n, m;
 
688
  char  *p, *q;
 
689
 
 
690
  p = strchr(map_name, '@');
 
691
  if (!p || p == map_name)
 
692
    return  NULL;
 
693
  m = (int) (p - map_name);
 
694
  q = strchr(p + 1, '@');
 
695
  if (!q || q == p + 1)
 
696
    return  NULL;
 
697
  n = (int) (q - p) + 1; /* including two '@' */
 
698
  if (strlen(sfd_name) != n - 2 ||
 
699
      memcmp(p + 1, sfd_name, n - 2))
 
700
    return  NULL;
 
701
  tfm_name = NEW(strlen(map_name) - n + strlen(sub_id) + 1, char);
 
702
  memcpy(tfm_name, map_name, m);
 
703
  tfm_name[m] = '\0';
 
704
  strcat(tfm_name, sub_id);
 
705
  if (q[1]) /* not ending with '@' */
 
706
    strcat(tfm_name, q + 1);
 
707
 
 
708
  return  tfm_name;
 
709
}
 
710
 
 
711
/* "foo@A@ ..." is expanded to
 
712
 *   fooab ... -m sfd:A,ab
 
713
 *   ...
 
714
 *   fooyz ... -m sfd:A,yz
 
715
 * where 'ab' ... 'yz' is subfont IDs in SFD 'A'.
 
716
 */
 
717
int
 
718
pdf_append_fontmap_record (const char *kp, const fontmap_rec *vp)
 
719
{
 
720
  fontmap_rec *mrec;
 
721
  char        *fnt_name, *sfd_name = NULL;
 
722
 
 
723
  if (!kp || fontmap_invalid(vp)) {
 
724
    WARN("Invalid fontmap record...");
 
725
    return -1;
 
726
  }
 
727
 
 
728
  if (verbose > 3)
 
729
    MESG("fontmap>> append key=\"%s\"...", kp);
 
730
 
 
731
  fnt_name = chop_sfd_name(kp, &sfd_name);
 
732
  if (fnt_name && sfd_name) {
 
733
    char  *tfm_name;
 
734
    char **subfont_ids;
 
735
    int    n = 0;
 
736
    subfont_ids = sfd_get_subfont_ids(sfd_name, &n);
 
737
    if (!subfont_ids)
 
738
      return  -1;
 
739
    while (n-- > 0) {
 
740
      tfm_name = make_subfont_name(kp, sfd_name, subfont_ids[n]);
 
741
      if (!tfm_name)
 
742
        continue;
 
743
      mrec = ht_lookup_table(fontmap, tfm_name, strlen(tfm_name));
 
744
      if (!mrec) {
 
745
        mrec = NEW(1, fontmap_rec);
 
746
        pdf_init_fontmap_record(mrec);
 
747
        mrec->map_name = mstrdup(kp); /* link */
 
748
        mrec->charmap.sfd_name   = mstrdup(sfd_name);
 
749
        mrec->charmap.subfont_id = mstrdup(subfont_ids[n]);
 
750
        ht_insert_table(fontmap, tfm_name, strlen(tfm_name), mrec);
 
751
      }
 
752
      RELEASE(tfm_name);
 
753
    }
 
754
    RELEASE(fnt_name);
 
755
    RELEASE(sfd_name);
 
756
  }
 
757
 
 
758
  mrec = ht_lookup_table(fontmap, kp, strlen(kp));
 
759
  if (!mrec) {
 
760
    mrec = NEW(1, fontmap_rec);
 
761
    pdf_copy_fontmap_record(mrec, vp);
 
762
    if (mrec->map_name && !strcmp(kp, mrec->map_name)) {
 
763
      RELEASE(mrec->map_name);
 
764
      mrec->map_name = NULL;
 
765
    }
 
766
    ht_insert_table(fontmap, kp, strlen(kp), mrec);
 
767
  }
 
768
  if (verbose > 3)
 
769
    MESG("\n");
 
770
 
 
771
  return  0;
 
772
}
 
773
 
 
774
int
 
775
pdf_remove_fontmap_record (const char *kp)
 
776
{
 
777
  char  *fnt_name, *sfd_name = NULL;
 
778
 
 
779
  if (!kp)
 
780
    return  -1;
 
781
 
 
782
  if (verbose > 3)
 
783
    MESG("fontmap>> remove key=\"%s\"...", kp);
 
784
 
 
785
  fnt_name = chop_sfd_name(kp, &sfd_name);
 
786
  if (fnt_name && sfd_name) {
 
787
    char  *tfm_name;
 
788
    char **subfont_ids;
 
789
    int    n = 0;
 
790
    subfont_ids = sfd_get_subfont_ids(sfd_name, &n);
 
791
    if (!subfont_ids)
 
792
      return  -1;
 
793
    if (verbose > 3)
 
794
      MESG("\nfontmap>> Expand @%s@:", sfd_name);
 
795
    while (n-- > 0) {
 
796
      tfm_name = make_subfont_name(kp, sfd_name, subfont_ids[n]);
 
797
      if (!tfm_name)
 
798
        continue;
 
799
      if (verbose > 3)
 
800
        MESG(" %s", tfm_name);
 
801
      ht_remove_table(fontmap, tfm_name, strlen(tfm_name));
 
802
      RELEASE(tfm_name);
 
803
    }
 
804
    RELEASE(fnt_name);
 
805
    RELEASE(sfd_name);
 
806
  }
 
807
 
 
808
  ht_remove_table(fontmap, kp, strlen(kp));
 
809
 
 
810
  if (verbose > 3)
 
811
    MESG("\n");
 
812
 
 
813
  return  0;
 
814
}
 
815
 
 
816
int
 
817
pdf_insert_fontmap_record (const char *kp, const fontmap_rec *vp)
 
818
{
 
819
  fontmap_rec *mrec;
 
820
  char        *fnt_name, *sfd_name;
 
821
 
 
822
  if (!kp || fontmap_invalid(vp)) {
 
823
    WARN("Invalid fontmap record...");
 
824
    return -1;
 
825
  }
 
826
 
 
827
  if (verbose > 3)
 
828
    MESG("fontmap>> insert key=\"%s\"...", kp);
 
829
 
 
830
  fnt_name = chop_sfd_name(kp, &sfd_name);
 
831
  if (fnt_name && sfd_name) {
 
832
    char  *tfm_name;
 
833
    char **subfont_ids;
 
834
    int    n = 0;
 
835
    subfont_ids = sfd_get_subfont_ids(sfd_name, &n);
 
836
    if (!subfont_ids) {
 
837
      RELEASE(fnt_name);
 
838
      RELEASE(sfd_name);
 
839
      return  -1;
 
840
    }
 
841
    if (verbose > 3)
 
842
      MESG("\nfontmap>> Expand @%s@:", sfd_name);
 
843
    while (n-- > 0) {
 
844
      tfm_name = make_subfont_name(kp, sfd_name, subfont_ids[n]);
 
845
      if (!tfm_name)
 
846
        continue;
 
847
      if (verbose > 3)
 
848
        MESG(" %s", tfm_name);
 
849
      mrec = NEW(1, fontmap_rec);
 
850
      pdf_init_fontmap_record(mrec);
 
851
      mrec->map_name = mstrdup(kp); /* link to this entry */
 
852
      mrec->charmap.sfd_name   = mstrdup(sfd_name);
 
853
      mrec->charmap.subfont_id = mstrdup(subfont_ids[n]);
 
854
      ht_insert_table(fontmap, tfm_name, strlen(tfm_name), mrec);
 
855
      RELEASE(tfm_name);
 
856
    }
 
857
    RELEASE(fnt_name);
 
858
    RELEASE(sfd_name);
 
859
  }
 
860
 
 
861
  mrec = NEW(1, fontmap_rec);
 
862
  pdf_copy_fontmap_record(mrec, vp);
 
863
  if (mrec->map_name && !strcmp(kp, mrec->map_name)) {
 
864
    RELEASE(mrec->map_name);
 
865
    mrec->map_name = NULL;
 
866
  }
 
867
  ht_insert_table(fontmap, kp, strlen(kp), mrec);
 
868
 
 
869
  if (verbose > 3)
 
870
    MESG("\n");
 
871
 
 
872
  return  0;
 
873
}
 
874
 
 
875
 
 
876
int
 
877
pdf_read_fontmap_line (fontmap_rec *mrec, const char *mline, long mline_len, int format)
 
878
{
 
879
  int    error;
 
880
  char  *q;
 
881
  const char *p, *endptr;
 
882
 
 
883
  ASSERT(mrec);
 
884
 
 
885
  p      = mline;
 
886
  endptr = p + mline_len;
 
887
 
 
888
  skip_blank(&p, endptr);
 
889
  if (p >= endptr)
 
890
    return -1;
 
891
 
 
892
  q = parse_string_value(&p, endptr);
 
893
  if (!q)
 
894
    return -1;
 
895
 
 
896
  if (format > 0) /* DVIPDFM format */
 
897
    error = fontmap_parse_mapdef_dpm(mrec, p, endptr);
 
898
  else /* DVIPS/pdfTeX format */
 
899
    error = fontmap_parse_mapdef_dps(mrec, p, endptr);
 
900
  if (!error) {
 
901
    char  *fnt_name, *sfd_name = NULL;
 
902
    fnt_name = chop_sfd_name(q, &sfd_name);
 
903
    if (fnt_name && sfd_name) {
 
904
      if (!mrec->font_name) {
 
905
      /* In the case of subfonts, the base name (before the character '@')
 
906
       * will be used as a font_name by default.
 
907
       * Otherwise tex_name will be used as a font_name by default.
 
908
       */
 
909
        mrec->font_name = fnt_name;
 
910
      } else {
 
911
        RELEASE(fnt_name);
 
912
      }
 
913
      if (mrec->charmap.sfd_name)
 
914
        RELEASE(mrec->charmap.sfd_name);
 
915
      mrec->charmap.sfd_name = sfd_name ;
 
916
    }
 
917
    fill_in_defaults(mrec, q);
 
918
  }
 
919
  RELEASE(q);
 
920
 
 
921
  return  error;
 
922
}
 
923
 
 
924
/* DVIPS/pdfTeX fontmap line if one of the following three cases found:
 
925
 *
 
926
 * (1) any line including the character '"'
 
927
 * (2) any line including the character '<'
 
928
 * (3) if the line consists of two entries (tfmname and psname)
 
929
 *
 
930
 * DVIPDFM fontmap line otherwise.
 
931
 */
 
932
int
 
933
is_pdfm_mapline (const char *mline) /* NULL terminated. */
 
934
{
 
935
  int   n = 0;
 
936
  const char *p, *endptr;
 
937
 
 
938
  if (strchr(mline, '"') || strchr(mline, '<'))
 
939
    return -1; /* DVIPS/pdfTeX format */
 
940
 
 
941
  p      = mline;
 
942
  endptr = p + strlen(mline);
 
943
 
 
944
  skip_blank(&p, endptr);
 
945
 
 
946
  while (p < endptr) {
 
947
    /* Break if '-' preceeded by blanks is found. (DVIPDFM format) */
 
948
    if (*p == '-') return 1;
 
949
    for (n++; p < endptr && !ISBLANK(*p); p++);
 
950
    skip_blank(&p, endptr);
 
951
  }
 
952
 
 
953
  /* Two entries: TFM_NAME PS_NAME only (DVIPS format)
 
954
   * Otherwise (DVIPDFM format) */
 
955
  return (n == 2 ? 0 : 1);
 
956
}
 
957
 
 
958
int
 
959
pdf_load_fontmap_file (const char *filename, int mode)
 
960
{
 
961
  fontmap_rec *mrec;
 
962
  FILE        *fp;
 
963
  const char  *p = NULL, *endptr;
 
964
  long         llen, lpos  = 0;
 
965
  int          error = 0, format = 0;
 
966
 
 
967
  ASSERT(filename);
 
968
  ASSERT(fontmap) ;
 
969
 
 
970
  if (verbose)
 
971
    MESG("<FONTMAP:%s", filename);
 
972
 
 
973
  fp = DPXFOPEN(filename, DPX_RES_TYPE_FONTMAP);
 
974
  if (!fp) {
 
975
    WARN("Couldn't open font map file \"%s\".", filename);
 
976
    return  -1;
 
977
  }
 
978
 
 
979
  while (!error &&
 
980
         (p = readline(work_buffer, WORK_BUFFER_SIZE, fp)) != NULL) {
 
981
    int m;
 
982
 
 
983
    lpos++;
 
984
    llen   = strlen(work_buffer);
 
985
    endptr = p + llen;
 
986
 
 
987
    skip_blank(&p, endptr);
 
988
    if (p == endptr)
 
989
      continue;
 
990
 
 
991
    m = is_pdfm_mapline(p);
 
992
 
 
993
    if (format * m < 0) { /* mismatch */
 
994
      WARN("Found a mismatched fontmap line %d from %s.", lpos, filename);
 
995
      WARN("-- Ignore the current input buffer: %s", p);
 
996
      continue;
 
997
    } else
 
998
      format += m;
 
999
 
 
1000
    mrec  = NEW(1, fontmap_rec);
 
1001
    pdf_init_fontmap_record(mrec);
 
1002
 
 
1003
    /* format > 0: DVIPDFM, format <= 0: DVIPS/pdfTeX */
 
1004
    error = pdf_read_fontmap_line(mrec, p, llen, format);
 
1005
    if (error) {
 
1006
      WARN("Invalid map record in fontmap line %d from %s.", lpos, filename);
 
1007
      WARN("-- Ignore the current input buffer: %s", p);
 
1008
      pdf_clear_fontmap_record(mrec);
 
1009
      RELEASE(mrec);
 
1010
      continue;
 
1011
    } else {
 
1012
      switch (mode) {
 
1013
      case FONTMAP_RMODE_REPLACE:
 
1014
        pdf_insert_fontmap_record(mrec->map_name, mrec);
 
1015
        break;
 
1016
      case FONTMAP_RMODE_APPEND:
 
1017
        pdf_append_fontmap_record(mrec->map_name, mrec);
 
1018
        break;
 
1019
      case FONTMAP_RMODE_REMOVE:
 
1020
        pdf_remove_fontmap_record(mrec->map_name);
 
1021
        break;
 
1022
      }
 
1023
    }
 
1024
    pdf_clear_fontmap_record(mrec);
 
1025
    RELEASE(mrec);
 
1026
  }
 
1027
  DPXFCLOSE(fp);
 
1028
 
 
1029
  if (verbose)
 
1030
    MESG(">");
 
1031
 
 
1032
  return  error;
 
1033
}
 
1034
 
 
1035
#if  0
 
1036
/* tfm_name="dmjhira10", map_name="dmj@DNP@10", sfd_name="DNP"
 
1037
 *  --> sub_id="hira"
 
1038
 * Test if tfm_name can be really considered as subfont.
 
1039
 */
 
1040
static int
 
1041
test_subfont (const char *tfm_name, const char *map_name, const char *sfd_name)
 
1042
{
 
1043
  int    r = 0;
 
1044
  char **ids;
 
1045
  int    n, m;
 
1046
  char  *p = (char *) map_name;
 
1047
  char  *q = (char *) tfm_name;
 
1048
 
 
1049
  ASSERT( tfm_name && map_name && sfd_name );
 
1050
 
 
1051
  /* until first occurence of '@' */
 
1052
  for ( ; *p && *q && *p == *q && *p != '@'; p++, q++);
 
1053
  if (*p != '@')
 
1054
    return  0;
 
1055
  p++;
 
1056
  /* compare sfd_name (should be always true here) */
 
1057
  if (strlen(p) <= strlen(sfd_name) ||
 
1058
      memcmp(p, sfd_name, strlen(sfd_name)) ||
 
1059
      p[strlen(sfd_name)] != '@')
 
1060
    return  0;
 
1061
  /* check tfm_name follows second '@' */
 
1062
  p += strlen(sfd_name) + 1;
 
1063
  if (*p) {
 
1064
    char  *r = (char *) tfm_name;
 
1065
    r += strlen(tfm_name) - strlen(p);
 
1066
    if (strcmp(r, p))
 
1067
      return  0;
 
1068
  }
 
1069
  /* Now 'p' is located at next to SFD name terminator
 
1070
   * (second '@') in map_name and 'q' is at first char
 
1071
   * of subfont_id substring in tfm_name.
 
1072
   */
 
1073
  n  = strlen(q) - strlen(p); /* length of subfont_id string */
 
1074
  if (n <= 0)
 
1075
    return  0;
 
1076
  /* check if n-length substring 'q' is valid as subfont ID */
 
1077
  ids = sfd_get_subfont_ids(sfd_name, &m);
 
1078
  if (!ids)
 
1079
    return  0;
 
1080
  while (!r && m-- > 0) {
 
1081
    if (strlen(ids[m]) == n &&
 
1082
        !memcmp(q, ids[m], n)) {
 
1083
      r = 1;
 
1084
    }
 
1085
  }
 
1086
 
 
1087
  return  r;
 
1088
}
 
1089
#endif  /* 0 */
 
1090
 
 
1091
 
 
1092
fontmap_rec *
 
1093
pdf_lookup_fontmap_record (const char *tfm_name)
 
1094
{
 
1095
  fontmap_rec *mrec = NULL;
 
1096
 
 
1097
  if (fontmap && tfm_name)
 
1098
    mrec = ht_lookup_table(fontmap, tfm_name, strlen(tfm_name));
 
1099
 
 
1100
  return  mrec;
 
1101
}
 
1102
 
 
1103
 
 
1104
void
 
1105
pdf_init_fontmaps (void)
 
1106
{
 
1107
  fontmap = NEW(1, struct ht_table);
 
1108
  ht_init_table(fontmap, hval_free);
 
1109
}
 
1110
 
 
1111
void
 
1112
pdf_close_fontmaps (void)
 
1113
{
 
1114
  if (fontmap) {
 
1115
    ht_clear_table(fontmap);
 
1116
    RELEASE(fontmap);
 
1117
  }
 
1118
  fontmap = NULL;
 
1119
 
 
1120
  release_sfd_record();
 
1121
}
 
1122
 
 
1123
#if 0
 
1124
void
 
1125
pdf_clear_fontmaps (void)
 
1126
{
 
1127
  pdf_close_fontmaps();
 
1128
  pdf_init_fontmaps();
 
1129
}
 
1130
#endif
 
1131
 
 
1132
/* CIDFont options
 
1133
 *
 
1134
 * FORMAT:
 
1135
 *
 
1136
 *   (:int:)?!?string(/string)?(,string)?
 
1137
 */
 
1138
 
 
1139
static char *
 
1140
substr (const char **str, char stop)
 
1141
{
 
1142
  char *sstr;
 
1143
  const char *endptr;
 
1144
 
 
1145
  endptr = strchr(*str, stop);
 
1146
  if (!endptr || endptr == *str)
 
1147
    return NULL;
 
1148
  sstr = NEW(endptr-(*str)+1, char);
 
1149
  memcpy(sstr, *str, endptr-(*str));
 
1150
  sstr[endptr-(*str)] = '\0';
 
1151
 
 
1152
  *str = endptr+1;
 
1153
  return sstr;
 
1154
}
 
1155
 
 
1156
#include <ctype.h>
 
1157
#define CID_MAPREC_CSI_DELIM '/'
 
1158
 
 
1159
static char *
 
1160
strip_options (const char *map_name, fontmap_opt *opt)
 
1161
{
 
1162
  char *font_name;
 
1163
  const char *p;
 
1164
  char *next = NULL;
 
1165
  int   have_csi = 0, have_style = 0;
 
1166
 
 
1167
  ASSERT(opt);
 
1168
 
 
1169
  p = map_name;
 
1170
  font_name      = NULL;
 
1171
  opt->charcoll  = NULL;
 
1172
  opt->index     = 0;
 
1173
  opt->style     = FONTMAP_STYLE_NONE;
 
1174
  opt->flags     = 0;
 
1175
 
 
1176
  if (*p == ':' && isdigit(*(p+1))) {
 
1177
    opt->index = (int) strtoul(p+1, &next, 10);
 
1178
    if (*next == ':')
 
1179
      p = next + 1;
 
1180
    else {
 
1181
      opt->index = 0;
 
1182
    }
 
1183
  }
 
1184
  if (*p == '!') { /* no-embedding */
 
1185
    if (*(++p) == '\0')
 
1186
      ERROR("Invalid map record: %s (--> %s)", map_name, p);
 
1187
    opt->flags |= FONTMAP_OPT_NOEMBED;
 
1188
  }
 
1189
 
 
1190
  if ((next = strchr(p, CID_MAPREC_CSI_DELIM)) != NULL) {
 
1191
    if (next == p)
 
1192
      ERROR("Invalid map record: %s (--> %s)", map_name, p);
 
1193
    font_name = substr(&p, CID_MAPREC_CSI_DELIM);
 
1194
    have_csi  = 1;
 
1195
  } else if ((next = strchr(p, ',')) != NULL) {
 
1196
    if (next == p)
 
1197
      ERROR("Invalid map record: %s (--> %s)", map_name, p);
 
1198
    font_name = substr(&p, ',');
 
1199
    have_style = 1;
 
1200
  } else {
 
1201
    font_name = NEW(strlen(p)+1, char);
 
1202
    strcpy(font_name, p);
 
1203
  }
 
1204
 
 
1205
  if (have_csi) {
 
1206
    if ((next = strchr(p, ',')) != NULL) {
 
1207
      opt->charcoll = substr(&p, ',');
 
1208
      have_style = 1;
 
1209
    } else if (p[0] == '\0') {
 
1210
      ERROR("Invalid map record: %s.", map_name);
 
1211
    } else {
 
1212
      opt->charcoll = NEW(strlen(p)+1, char);
 
1213
      strcpy(opt->charcoll, p);
 
1214
    }
 
1215
  }
 
1216
 
 
1217
  if (have_style) {
 
1218
    if (!strncmp(p, "BoldItalic", 10)) {
 
1219
      if (*(p+10))
 
1220
        ERROR("Invalid map record: %s (--> %s)", map_name, p);
 
1221
      opt->style = FONTMAP_STYLE_BOLDITALIC;
 
1222
    } else if (!strncmp(p, "Bold", 4)) {
 
1223
      if (*(p+4))
 
1224
        ERROR("Invalid map record: %s (--> %s)", map_name, p);
 
1225
      opt->style = FONTMAP_STYLE_BOLD;
 
1226
    } else if (!strncmp(p, "Italic", 6)) {
 
1227
      if (*(p+6))
 
1228
        ERROR("Invalid map record: %s (--> %s)", map_name, p);
 
1229
      opt->style = FONTMAP_STYLE_ITALIC;
 
1230
    }
 
1231
  }
 
1232
 
 
1233
  return font_name;
 
1234
}
 
1235
 
 
1236
#if  DPXTEST
 
1237
static void
 
1238
dump_fontmap_rec (const char *key, const fontmap_rec *mrec)
 
1239
{
 
1240
  fontmap_opt *opt = (fontmap_opt *) &mrec->opt;
 
1241
 
 
1242
  if (mrec->map_name)
 
1243
    fprintf(stdout, "  <!-- subfont");
 
1244
  else
 
1245
    fprintf(stdout, "  <insert");
 
1246
  fprintf(stdout, " id=\"%s\"", key);
 
1247
  if (mrec->map_name)
 
1248
    fprintf(stdout, " map-name=\"%s\"", mrec->map_name);
 
1249
  if (mrec->enc_name)
 
1250
    fprintf(stdout, " enc-name=\"%s\"",  mrec->enc_name);
 
1251
  if (mrec->font_name)
 
1252
    fprintf(stdout, " font-name=\"%s\"", mrec->font_name);
 
1253
  if (mrec->charmap.sfd_name && mrec->charmap.subfont_id) {
 
1254
    fprintf(stdout, " charmap=\"sfd:%s,%s\"",
 
1255
            mrec->charmap.sfd_name, mrec->charmap.subfont_id);
 
1256
  }
 
1257
  if (opt->slant != 0.0)
 
1258
    fprintf(stdout, " font-slant=\"%g\"", opt->slant);
 
1259
  if (opt->extend != 1.0)
 
1260
    fprintf(stdout, " font-extend=\"%g\"", opt->extend);
 
1261
  if (opt->charcoll)
 
1262
    fprintf(stdout, " glyph-order=\"%s\"", opt->charcoll);
 
1263
  if (opt->tounicode)
 
1264
    fprintf(stdout, " tounicode=\"%s\"", opt->tounicode);
 
1265
  if (opt->index != 0)
 
1266
    fprintf(stdout, " ttc-index=\"%d\"", opt->index);
 
1267
  if (opt->flags & FONTMAP_OPT_NOEMBED)
 
1268
    fprintf(stdout, " embedding=\"no\"");
 
1269
  if (opt->mapc >= 0) {
 
1270
    fprintf(stdout, " charmap=\"pad:");
 
1271
    if (opt->mapc > 0xffff)
 
1272
      fprintf(stdout, "%02x %02x", (opt->mapc >> 16) & 0xff, (opt->mapc >> 8) & 0xff);
 
1273
    else
 
1274
      fprintf(stdout, "%02x", (opt->mapc >> 8) & 0xff);
 
1275
    fprintf(stdout, "\"");
 
1276
  }
 
1277
  if (opt->flags & FONTMAP_OPT_VERT)
 
1278
    fprintf(stdout, " writing-mode=\"vertical\"");
 
1279
  if (opt->style != FONTMAP_STYLE_NONE) {
 
1280
    fprintf(stdout, " font-style=\"");
 
1281
    switch (opt->style) {
 
1282
    case FONTMAP_STYLE_BOLD:
 
1283
      fprintf(stdout, "bold");
 
1284
      break;
 
1285
    case FONTMAP_STYLE_ITALIC:
 
1286
      fprintf(stdout, "italic");
 
1287
      break;
 
1288
    case FONTMAP_STYLE_BOLDITALIC:
 
1289
      fprintf(stdout, "bolditalic");
 
1290
      break;
 
1291
    }
 
1292
    fprintf(stdout, "\"");
 
1293
  }
 
1294
  if (mrec->map_name)
 
1295
    fprintf(stdout, " / -->\n");
 
1296
  else
 
1297
    fprintf(stdout, " />\n");
 
1298
}
 
1299
 
 
1300
void
 
1301
dump_fontmaps (void)
 
1302
{
 
1303
  struct ht_iter iter;
 
1304
  fontmap_rec   *mrec;
 
1305
  char           key[128], *kp;
 
1306
  int            kl;
 
1307
 
 
1308
  if (!fontmap)
 
1309
    return;
 
1310
 
 
1311
  fprintf(stdout, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
 
1312
  fprintf(stdout, "<!DOCTYPE fontmap SYSTEM \"fontmap.dtd\">\n");
 
1313
  fprintf(stdout, "<fontmap id=\"%s\">\n", "foo");
 
1314
  if (ht_set_iter(fontmap, &iter) == 0) {
 
1315
    do {
 
1316
      kp   = ht_iter_getkey(&iter, &kl);
 
1317
      mrec = ht_iter_getval(&iter);
 
1318
      if (kl > 127)
 
1319
        continue;
 
1320
      memcpy(key, kp, kl); key[kl] = 0;
 
1321
      dump_fontmap_rec(key, mrec);
 
1322
    } while (!ht_iter_next(&iter));
 
1323
  }
 
1324
  ht_clear_iter(&iter);
 
1325
  fprintf(stdout, "</fontmap>\n");
 
1326
 
 
1327
  return;
 
1328
}
 
1329
 
 
1330
void
 
1331
test_fontmap_help (void)
 
1332
{
 
1333
  fprintf(stdout, "usage: fontmap [options] [mapfile...]\n");
 
1334
  fprintf(stdout, "-l, --lookup string\n");
 
1335
  fprintf(stdout, "  Lookup fontmap entry for 'string' after loading mapfile(s).\n");
 
1336
}
 
1337
 
 
1338
int
 
1339
test_fontmap_main (int argc, char *argv[])
 
1340
{
 
1341
  int    i;
 
1342
  char  *key = NULL;
 
1343
 
 
1344
  for (;;) {
 
1345
    int  c, optidx = 0;
 
1346
    static struct option long_options[] = {
 
1347
      {"lookup", 1, 0, 'l'},
 
1348
      {"help",   0, 0, 'h'},
 
1349
      {0, 0, 0, 0}
 
1350
    };
 
1351
    c = getopt_long(argc, argv, "l:h", long_options, &optidx);
 
1352
    if (c == -1)
 
1353
      break;
 
1354
 
 
1355
    switch (c) {
 
1356
    case  'l':
 
1357
      key = optarg;
 
1358
      break;
 
1359
    case  'h':
 
1360
      test_fontmap_help();
 
1361
      return  0;
 
1362
      break;
 
1363
    default:
 
1364
      test_fontmap_help();
 
1365
      return  -1;
 
1366
      break;
 
1367
    }
 
1368
  }
 
1369
 
 
1370
  pdf_init_fontmaps();
 
1371
  for (i = optind; i < argc; i++)
 
1372
    pdf_load_fontmap_file(argv[i], FONTMAP_RMODE_REPLACE);
 
1373
 
 
1374
  if (key == NULL)
 
1375
    dump_fontmaps();
 
1376
  else {
 
1377
    fontmap_rec *mrec;
 
1378
    mrec = pdf_lookup_fontmap_record(key);
 
1379
    if (mrec)
 
1380
      dump_fontmap_rec(key, mrec);
 
1381
    else {
 
1382
      WARN("Fontmap entry \"%s\" not found.", key);
 
1383
    }
 
1384
  }
 
1385
  pdf_close_fontmaps();
 
1386
 
 
1387
  return  0;
 
1388
}
 
1389
#endif /* DPXTEST */