projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
- Update to trunk
[reactos.git] / lib / 3rdparty / freetype / src / psnames / psmodule.c
1 /***************************************************************************/
2 /* */
3 /* psmodule.c */
4 /* */
5 /* PSNames module implementation (body). */
6 /* */
7 /* Copyright 1996-2001, 2002, 2003, 2005, 2006, 2007, 2008 by */
8 /* David Turner, Robert Wilhelm, and Werner Lemberg. */
9 /* */
10 /* This file is part of the FreeType project, and may only be used, */
11 /* modified, and distributed under the terms of the FreeType project */
12 /* license, LICENSE.TXT. By continuing to use, modify, or distribute */
13 /* this file you indicate that you have read the license and */
14 /* understand and accept it fully. */
15 /* */
16 /***************************************************************************/
17
18
19 #include <ft2build.h>
20 #include FT_INTERNAL_OBJECTS_H
21 #include FT_SERVICE_POSTSCRIPT_CMAPS_H
22
23 #include "psmodule.h"
24 #include "pstables.h"
25
26 #include "psnamerr.h"
27 #include "pspic.h"
28
29
30 #ifdef FT_CONFIG_OPTION_POSTSCRIPT_NAMES
31
32
33 #ifdef FT_CONFIG_OPTION_ADOBE_GLYPH_LIST
34
35
36 #define VARIANT_BIT 0x80000000UL
37 #define BASE_GLYPH( code ) ( (FT_UInt32)( (code) & ~VARIANT_BIT ) )
38
39
40 /* Return the Unicode value corresponding to a given glyph. Note that */
41 /* we do deal with glyph variants by detecting a non-initial dot in */
42 /* the name, as in `A.swash' or `e.final'; in this case, the */
43 /* VARIANT_BIT is set in the return value. */
44 /* */
45 static FT_UInt32
46 ps_unicode_value( const char* glyph_name )
47 {
48 /* If the name begins with `uni', then the glyph name may be a */
49 /* hard-coded unicode character code. */
50 if ( glyph_name[0] == 'u' &&
51 glyph_name[1] == 'n' &&
52 glyph_name[2] == 'i' )
53 {
54 /* determine whether the next four characters following are */
55 /* hexadecimal. */
56
57 /* XXX: Add code to deal with ligatures, i.e. glyph names like */
58 /* `uniXXXXYYYYZZZZ'... */
59
60 FT_Int count;
61 FT_UInt32 value = 0;
62 const char* p = glyph_name + 3;
63
64
65 for ( count = 4; count > 0; count--, p++ )
66 {
67 char c = *p;
68 unsigned int d;
69
70
71 d = (unsigned char)c - '0';
72 if ( d >= 10 )
73 {
74 d = (unsigned char)c - 'A';
75 if ( d >= 6 )
76 d = 16;
77 else
78 d += 10;
79 }
80
81 /* Exit if a non-uppercase hexadecimal character was found */
82 /* -- this also catches character codes below `0' since such */
83 /* negative numbers cast to `unsigned int' are far too big. */
84 if ( d >= 16 )
85 break;
86
87 value = ( value << 4 ) + d;
88 }
89
90 /* there must be exactly four hex digits */
91 if ( count == 0 )
92 {
93 if ( *p == '\0' )
94 return value;
95 if ( *p == '.' )
96 return (FT_UInt32)( value | VARIANT_BIT );
97 }
98 }
99
100 /* If the name begins with `u', followed by four to six uppercase */
101 /* hexadecimal digits, it is a hard-coded unicode character code. */
102 if ( glyph_name[0] == 'u' )
103 {
104 FT_Int count;
105 FT_UInt32 value = 0;
106 const char* p = glyph_name + 1;
107
108
109 for ( count = 6; count > 0; count--, p++ )
110 {
111 char c = *p;
112 unsigned int d;
113
114
115 d = (unsigned char)c - '0';
116 if ( d >= 10 )
117 {
118 d = (unsigned char)c - 'A';
119 if ( d >= 6 )
120 d = 16;
121 else
122 d += 10;
123 }
124
125 if ( d >= 16 )
126 break;
127
128 value = ( value << 4 ) + d;
129 }
130
131 if ( count <= 2 )
132 {
133 if ( *p == '\0' )
134 return value;
135 if ( *p == '.' )
136 return (FT_UInt32)( value | VARIANT_BIT );
137 }
138 }
139
140 /* Look for a non-initial dot in the glyph name in order to */
141 /* find variants like `A.swash', `e.final', etc. */
142 {
143 const char* p = glyph_name;
144 const char* dot = NULL;
145
146
147 for ( ; *p; p++ )
148 {
149 if ( *p == '.' && p > glyph_name )
150 {
151 dot = p;
152 break;
153 }
154 }
155
156 /* now look up the glyph in the Adobe Glyph List */
157 if ( !dot )
158 return (FT_UInt32)ft_get_adobe_glyph_index( glyph_name, p );
159 else
160 return (FT_UInt32)( ft_get_adobe_glyph_index( glyph_name, dot ) |
161 VARIANT_BIT );
162 }
163 }
164
165
166 /* ft_qsort callback to sort the unicode map */
167 FT_CALLBACK_DEF( int )
168 compare_uni_maps( const void* a,
169 const void* b )
170 {
171 PS_UniMap* map1 = (PS_UniMap*)a;
172 PS_UniMap* map2 = (PS_UniMap*)b;
173 FT_UInt32 unicode1 = BASE_GLYPH( map1->unicode );
174 FT_UInt32 unicode2 = BASE_GLYPH( map2->unicode );
175
176
177 /* sort base glyphs before glyph variants */
178 if ( unicode1 == unicode2 )
179 {
180 if ( map1->unicode > map2->unicode )
181 return 1;
182 else if ( map1->unicode < map2->unicode )
183 return -1;
184 else
185 return 0;
186 }
187 else
188 {
189 if ( unicode1 > unicode2 )
190 return 1;
191 else if ( unicode1 < unicode2 )
192 return -1;
193 else
194 return 0;
195 }
196 }
197
198
199 /* support for extra glyphs not handled (well) in AGL; */
200 /* we add extra mappings for them if necessary */
201
202 #define EXTRA_GLYPH_LIST_SIZE 10
203
204 static const FT_UInt32 ft_extra_glyph_unicodes[EXTRA_GLYPH_LIST_SIZE] =
205 {
206 /* WGL 4 */
207 0x0394,
208 0x03A9,
209 0x2215,
210 0x00AD,
211 0x02C9,
212 0x03BC,
213 0x2219,
214 0x00A0,
215 /* Romanian */
216 0x021A,
217 0x021B
218 };
219
220 static const char ft_extra_glyph_names[] =
221 {
222 'D','e','l','t','a',0,
223 'O','m','e','g','a',0,
224 'f','r','a','c','t','i','o','n',0,
225 'h','y','p','h','e','n',0,
226 'm','a','c','r','o','n',0,
227 'm','u',0,
228 'p','e','r','i','o','d','c','e','n','t','e','r','e','d',0,
229 's','p','a','c','e',0,
230 'T','c','o','m','m','a','a','c','c','e','n','t',0,
231 't','c','o','m','m','a','a','c','c','e','n','t',0
232 };
233
234 static const FT_Int
235 ft_extra_glyph_name_offsets[EXTRA_GLYPH_LIST_SIZE] =
236 {
237 0,
238 6,
239 12,
240 21,
241 28,
242 35,
243 38,
244 53,
245 59,
246 72
247 };
248
249
250 static void
251 ps_check_extra_glyph_name( const char* gname,
252 FT_UInt glyph,
253 FT_UInt* extra_glyphs,
254 FT_UInt *states )
255 {
256 FT_UInt n;
257
258
259 for ( n = 0; n < EXTRA_GLYPH_LIST_SIZE; n++ )
260 {
261 if ( ft_strcmp( ft_extra_glyph_names +
262 ft_extra_glyph_name_offsets[n], gname ) == 0 )
263 {
264 if ( states[n] == 0 )
265 {
266 /* mark this extra glyph as a candidate for the cmap */
267 states[n] = 1;
268 extra_glyphs[n] = glyph;
269 }
270
271 return;
272 }
273 }
274 }
275
276
277 static void
278 ps_check_extra_glyph_unicode( FT_UInt32 uni_char,
279 FT_UInt *states )
280 {
281 FT_UInt n;
282
283
284 for ( n = 0; n < EXTRA_GLYPH_LIST_SIZE; n++ )
285 {
286 if ( uni_char == ft_extra_glyph_unicodes[n] )
287 {
288 /* disable this extra glyph from being added to the cmap */
289 states[n] = 2;
290
291 return;
292 }
293 }
294 }
295
296
297 /* Build a table that maps Unicode values to glyph indices. */
298 static FT_Error
299 ps_unicodes_init( FT_Memory memory,
300 PS_Unicodes table,
301 FT_UInt num_glyphs,
302 PS_GetGlyphNameFunc get_glyph_name,
303 PS_FreeGlyphNameFunc free_glyph_name,
304 FT_Pointer glyph_data )
305 {
306 FT_Error error;
307
308 FT_UInt extra_glyph_list_states[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
309 FT_UInt extra_glyphs[EXTRA_GLYPH_LIST_SIZE];
310
311
312 /* we first allocate the table */
313 table->num_maps = 0;
314 table->maps = 0;
315
316 if ( !FT_NEW_ARRAY( table->maps, num_glyphs + EXTRA_GLYPH_LIST_SIZE ) )
317 {
318 FT_UInt n;
319 FT_UInt count;
320 PS_UniMap* map;
321 FT_UInt32 uni_char;
322
323
324 map = table->maps;
325
326 for ( n = 0; n < num_glyphs; n++ )
327 {
328 const char* gname = get_glyph_name( glyph_data, n );
329
330
331 if ( gname )
332 {
333 ps_check_extra_glyph_name( gname, n,
334 extra_glyphs, extra_glyph_list_states );
335 uni_char = ps_unicode_value( gname );
336
337 if ( BASE_GLYPH( uni_char ) != 0 )
338 {
339 ps_check_extra_glyph_unicode( uni_char,
340 extra_glyph_list_states );
341 map->unicode = uni_char;
342 map->glyph_index = n;
343 map++;
344 }
345
346 if ( free_glyph_name )
347 free_glyph_name( glyph_data, gname );
348 }
349 }
350
351 for ( n = 0; n < EXTRA_GLYPH_LIST_SIZE; n++ )
352 {
353 if ( extra_glyph_list_states[n] == 1 )
354 {
355 /* This glyph name has an additional representation. */
356 /* Add it to the cmap. */
357
358 map->unicode = ft_extra_glyph_unicodes[n];
359 map->glyph_index = extra_glyphs[n];
360 map++;
361 }
362 }
363
364 /* now compress the table a bit */
365 count = (FT_UInt)( map - table->maps );
366
367 if ( count == 0 )
368 {
369 FT_FREE( table->maps );
370 if ( !error )
371 error = PSnames_Err_Invalid_Argument; /* No unicode chars here! */
372 }
373 else {
374 /* Reallocate if the number of used entries is much smaller. */
375 if ( count < num_glyphs / 2 )
376 {
377 (void)FT_RENEW_ARRAY( table->maps, num_glyphs, count );
378 error = PSnames_Err_Ok;
379 }
380
381 /* Sort the table in increasing order of unicode values, */
382 /* taking care of glyph variants. */
383 ft_qsort( table->maps, count, sizeof ( PS_UniMap ),
384 compare_uni_maps );
385 }
386
387 table->num_maps = count;
388 }
389
390 return error;
391 }
392
393
394 static FT_UInt
395 ps_unicodes_char_index( PS_Unicodes table,
396 FT_UInt32 unicode )
397 {
398 PS_UniMap *min, *max, *mid, *result = NULL;
399
400
401 /* Perform a binary search on the table. */
402
403 min = table->maps;
404 max = min + table->num_maps - 1;
405
406 while ( min <= max )
407 {
408 FT_UInt32 base_glyph;
409
410
411 mid = min + ( ( max - min ) >> 1 );
412
413 if ( mid->unicode == unicode )
414 {
415 result = mid;
416 break;
417 }
418
419 base_glyph = BASE_GLYPH( mid->unicode );
420
421 if ( base_glyph == unicode )
422 result = mid; /* remember match but continue search for base glyph */
423
424 if ( min == max )
425 break;
426
427 if ( base_glyph < unicode )
428 min = mid + 1;
429 else
430 max = mid - 1;
431 }
432
433 if ( result )
434 return result->glyph_index;
435 else
436 return 0;
437 }
438
439
440 static FT_UInt32
441 ps_unicodes_char_next( PS_Unicodes table,
442 FT_UInt32 *unicode )
443 {
444 FT_UInt result = 0;
445 FT_UInt32 char_code = *unicode + 1;
446
447
448 {
449 FT_UInt min = 0;
450 FT_UInt max = table->num_maps;
451 FT_UInt mid;
452 PS_UniMap* map;
453 FT_UInt32 base_glyph;
454
455
456 while ( min < max )
457 {
458 mid = min + ( ( max - min ) >> 1 );
459 map = table->maps + mid;
460
461 if ( map->unicode == char_code )
462 {
463 result = map->glyph_index;
464 goto Exit;
465 }
466
467 base_glyph = BASE_GLYPH( map->unicode );
468
469 if ( base_glyph == char_code )
470 result = map->glyph_index;
471
472 if ( base_glyph < char_code )
473 min = mid + 1;
474 else
475 max = mid;
476 }
477
478 if ( result )
479 goto Exit; /* we have a variant glyph */
480
481 /* we didn't find it; check whether we have a map just above it */
482 char_code = 0;
483
484 if ( min < table->num_maps )
485 {
486 map = table->maps + min;
487 result = map->glyph_index;
488 char_code = BASE_GLYPH( map->unicode );
489 }
490 }
491
492 Exit:
493 *unicode = char_code;
494 return result;
495 }
496
497
498 #endif /* FT_CONFIG_OPTION_ADOBE_GLYPH_LIST */
499
500
501 static const char*
502 ps_get_macintosh_name( FT_UInt name_index )
503 {
504 if ( name_index >= FT_NUM_MAC_NAMES )
505 name_index = 0;
506
507 return ft_standard_glyph_names + ft_mac_names[name_index];
508 }
509
510
511 static const char*
512 ps_get_standard_strings( FT_UInt sid )
513 {
514 if ( sid >= FT_NUM_SID_NAMES )
515 return 0;
516
517 return ft_standard_glyph_names + ft_sid_names[sid];
518 }
519
520
521 #ifdef FT_CONFIG_OPTION_ADOBE_GLYPH_LIST
522 FT_DEFINE_SERVICE_PSCMAPSREC(pscmaps_interface,
523 (PS_Unicode_ValueFunc) ps_unicode_value,
524 (PS_Unicodes_InitFunc) ps_unicodes_init,
525 (PS_Unicodes_CharIndexFunc)ps_unicodes_char_index,
526 (PS_Unicodes_CharNextFunc) ps_unicodes_char_next,
527
528 (PS_Macintosh_NameFunc) ps_get_macintosh_name,
529 (PS_Adobe_Std_StringsFunc) ps_get_standard_strings,
530
531 t1_standard_encoding,
532 t1_expert_encoding
533 )
534
535 #else
536
537 FT_DEFINE_SERVICE_PSCMAPSREC(pscmaps_interface,
538 0,
539 0,
540 0,
541 0,
542
543 (PS_Macintosh_NameFunc) ps_get_macintosh_name,
544 (PS_Adobe_Std_StringsFunc) ps_get_standard_strings,
545
546 t1_standard_encoding,
547 t1_expert_encoding
548 )
549
550 #endif /* FT_CONFIG_OPTION_ADOBE_GLYPH_LIST */
551
552
553 FT_DEFINE_SERVICEDESCREC1(pscmaps_services,
554 FT_SERVICE_ID_POSTSCRIPT_CMAPS, &FT_PSCMAPS_INTERFACE_GET
555 )
556
557
558
559
560 static FT_Pointer
561 psnames_get_service( FT_Module module,
562 const char* service_id )
563 {
564 FT_Library library = module->library;
565 FT_UNUSED(library);
566
567 return ft_service_list_lookup( FT_PSCMAPS_SERVICES_GET, service_id );
568 }
569
570 #endif /* FT_CONFIG_OPTION_POSTSCRIPT_NAMES */
571
572
573 #ifndef FT_CONFIG_OPTION_POSTSCRIPT_NAMES
574 #define PUT_PS_NAMES_SERVICE(a) 0
575 #else
576 #define PUT_PS_NAMES_SERVICE(a) a
577 #endif
578
579 FT_DEFINE_MODULE(psnames_module_class,
580
581 0, /* this is not a font driver, nor a renderer */
582 sizeof ( FT_ModuleRec ),
583
584 "psnames", /* driver name */
585 0x10000L, /* driver version */
586 0x20000L, /* driver requires FreeType 2 or above */
587
588 PUT_PS_NAMES_SERVICE((void*)&FT_PSCMAPS_INTERFACE_GET), /* module specific interface */
589 (FT_Module_Constructor)0,
590 (FT_Module_Destructor) 0,
591 (FT_Module_Requester) PUT_PS_NAMES_SERVICE(psnames_get_service)
592 )
593
594
595
596 /* END */
A free Windows-compatible Operating System