Context Navigation

source: trunk/poppler/freetype2/src/cff/cffgload.c @ 262

Last change on this file since 262 was 262, checked in by Eugene Romanenko, 12 years ago
PDF plugin: freetype library updated to version 2.3.8
File size: 85.0 KB

Line
1	/***************************************************************************/
2	/* */
3	/* cffgload.c */
4	/* */
5	/* OpenType Glyph Loader (body). */
6	/* */
7	/* Copyright 1996-2001, 2002, 2003, 2004, 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_DEBUG_H
21	#include FT_INTERNAL_CALC_H
22	#include FT_INTERNAL_STREAM_H
23	#include FT_INTERNAL_SFNT_H
24	#include FT_OUTLINE_H
25	#include FT_TRUETYPE_TAGS_H
26	#include FT_INTERNAL_POSTSCRIPT_HINTS_H
27
28	#include "cffobjs.h"
29	#include "cffload.h"
30	#include "cffgload.h"
31
32	#include "cfferrs.h"
33
34
35	/*************************************************************************/
36	/* */
37	/* The macro FT_COMPONENT is used in trace mode. It is an implicit */
38	/* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
39	/* messages during execution. */
40	/* */
41	#undef FT_COMPONENT
42	#define FT_COMPONENT trace_cffgload
43
44
45	typedef enum CFF_Operator_
46	{
47	cff_op_unknown = 0,
48
49	cff_op_rmoveto,
50	cff_op_hmoveto,
51	cff_op_vmoveto,
52
53	cff_op_rlineto,
54	cff_op_hlineto,
55	cff_op_vlineto,
56
57	cff_op_rrcurveto,
58	cff_op_hhcurveto,
59	cff_op_hvcurveto,
60	cff_op_rcurveline,
61	cff_op_rlinecurve,
62	cff_op_vhcurveto,
63	cff_op_vvcurveto,
64
65	cff_op_flex,
66	cff_op_hflex,
67	cff_op_hflex1,
68	cff_op_flex1,
69
70	cff_op_endchar,
71
72	cff_op_hstem,
73	cff_op_vstem,
74	cff_op_hstemhm,
75	cff_op_vstemhm,
76
77	cff_op_hintmask,
78	cff_op_cntrmask,
79	cff_op_dotsection, /* deprecated, acts as no-op */
80
81	cff_op_abs,
82	cff_op_add,
83	cff_op_sub,
84	cff_op_div,
85	cff_op_neg,
86	cff_op_random,
87	cff_op_mul,
88	cff_op_sqrt,
89
90	cff_op_blend,
91
92	cff_op_drop,
93	cff_op_exch,
94	cff_op_index,
95	cff_op_roll,
96	cff_op_dup,
97
98	cff_op_put,
99	cff_op_get,
100	cff_op_store,
101	cff_op_load,
102
103	cff_op_and,
104	cff_op_or,
105	cff_op_not,
106	cff_op_eq,
107	cff_op_ifelse,
108
109	cff_op_callsubr,
110	cff_op_callgsubr,
111	cff_op_return,
112
113	/* Type 1 opcodes: invalid but seen in real life */
114	cff_op_hsbw,
115	cff_op_closepath,
116	cff_op_callothersubr,
117	cff_op_pop,
118
119	/* do not remove */
120	cff_op_max
121
122	} CFF_Operator;
123
124
125	#define CFF_COUNT_CHECK_WIDTH 0x80
126	#define CFF_COUNT_EXACT 0x40
127	#define CFF_COUNT_CLEAR_STACK 0x20
128
129	/* count values which have the `CFF_COUNT_CHECK_WIDTH' flag set are */
130	/* used for checking the width and requested numbers of arguments */
131	/* only; they are set to zero afterwards */
132
133	/* the other two flags are informative only and unused currently */
134
135	static const FT_Byte cff_argument_counts[] =
136	{
137	0, /* unknown */
138
139	2 \| CFF_COUNT_CHECK_WIDTH \| CFF_COUNT_EXACT, /* rmoveto */
140	1 \| CFF_COUNT_CHECK_WIDTH \| CFF_COUNT_EXACT,
141	1 \| CFF_COUNT_CHECK_WIDTH \| CFF_COUNT_EXACT,
142
143	0 \| CFF_COUNT_CLEAR_STACK, /* rlineto */
144	0 \| CFF_COUNT_CLEAR_STACK,
145	0 \| CFF_COUNT_CLEAR_STACK,
146
147	0 \| CFF_COUNT_CLEAR_STACK, /* rrcurveto */
148	0 \| CFF_COUNT_CLEAR_STACK,
149	0 \| CFF_COUNT_CLEAR_STACK,
150	0 \| CFF_COUNT_CLEAR_STACK,
151	0 \| CFF_COUNT_CLEAR_STACK,
152	0 \| CFF_COUNT_CLEAR_STACK,
153	0 \| CFF_COUNT_CLEAR_STACK,
154
155	13, /* flex */
156	7,
157	9,
158	11,
159
160	0 \| CFF_COUNT_CHECK_WIDTH, /* endchar */
161
162	2 \| CFF_COUNT_CHECK_WIDTH, /* hstem */
163	2 \| CFF_COUNT_CHECK_WIDTH,
164	2 \| CFF_COUNT_CHECK_WIDTH,
165	2 \| CFF_COUNT_CHECK_WIDTH,
166
167	0 \| CFF_COUNT_CHECK_WIDTH, /* hintmask */
168	0 \| CFF_COUNT_CHECK_WIDTH, /* cntrmask */
169	0, /* dotsection */
170
171	1, /* abs */
172	2,
173	2,
174	2,
175	1,
176	0,
177	2,
178	1,
179
180	1, /* blend */
181
182	1, /* drop */
183	2,
184	1,
185	2,
186	1,
187
188	2, /* put */
189	1,
190	4,
191	3,
192
193	2, /* and */
194	2,
195	1,
196	2,
197	4,
198
199	1, /* callsubr */
200	1,
201	0,
202
203	2, /* hsbw */
204	0,
205	0,
206	0
207	};
208
209
210	/*************************************************************************/
211	/*************************************************************************/
212	/*************************************************************************/
213	/******** *******/
214	/******** *******/
215	/******** GENERIC CHARSTRING PARSING *******/
216	/******** *******/
217	/******** *******/
218	/*************************************************************************/
219	/*************************************************************************/
220	/*************************************************************************/
221
222
223	/*************************************************************************/
224	/* */
225	/* <Function> */
226	/* cff_builder_init */
227	/* */
228	/* <Description> */
229	/* Initializes a given glyph builder. */
230	/* */
231	/* <InOut> */
232	/* builder :: A pointer to the glyph builder to initialize. */
233	/* */
234	/* <Input> */
235	/* face :: The current face object. */
236	/* */
237	/* size :: The current size object. */
238	/* */
239	/* glyph :: The current glyph object. */
240	/* */
241	/* hinting :: Whether hinting is active. */
242	/* */
243	static void
244	cff_builder_init( CFF_Builder* builder,
245	TT_Face face,
246	CFF_Size size,
247	CFF_GlyphSlot glyph,
248	FT_Bool hinting )
249	{
250	builder->path_begun = 0;
251	builder->load_points = 1;
252
253	builder->face = face;
254	builder->glyph = glyph;
255	builder->memory = face->root.memory;
256
257	if ( glyph )
258	{
259	FT_GlyphLoader loader = glyph->root.internal->loader;
260
261
262	builder->loader = loader;
263	builder->base = &loader->base.outline;
264	builder->current = &loader->current.outline;
265	FT_GlyphLoader_Rewind( loader );
266
267	builder->hints_globals = 0;
268	builder->hints_funcs = 0;
269
270	if ( hinting && size )
271	{
272	CFF_Internal internal = (CFF_Internal)size->root.internal;
273
274
275	builder->hints_globals = (void *)internal->topfont;
276	builder->hints_funcs = glyph->root.internal->glyph_hints;
277	}
278	}
279
280	builder->pos_x = 0;
281	builder->pos_y = 0;
282
283	builder->left_bearing.x = 0;
284	builder->left_bearing.y = 0;
285	builder->advance.x = 0;
286	builder->advance.y = 0;
287	}
288
289
290	/*************************************************************************/
291	/* */
292	/* <Function> */
293	/* cff_builder_done */
294	/* */
295	/* <Description> */
296	/* Finalizes a given glyph builder. Its contents can still be used */
297	/* after the call, but the function saves important information */
298	/* within the corresponding glyph slot. */
299	/* */
300	/* <Input> */
301	/* builder :: A pointer to the glyph builder to finalize. */
302	/* */
303	static void
304	cff_builder_done( CFF_Builder* builder )
305	{
306	CFF_GlyphSlot glyph = builder->glyph;
307
308
309	if ( glyph )
310	glyph->root.outline = *builder->base;
311	}
312
313
314	/*************************************************************************/
315	/* */
316	/* <Function> */
317	/* cff_compute_bias */
318	/* */
319	/* <Description> */
320	/* Computes the bias value in dependence of the number of glyph */
321	/* subroutines. */
322	/* */
323	/* <Input> */
324	/* num_subrs :: The number of glyph subroutines. */
325	/* */
326	/* <Return> */
327	/* The bias value. */
328	static FT_Int
329	cff_compute_bias( FT_UInt num_subrs )
330	{
331	FT_Int result;
332
333
334	if ( num_subrs < 1240 )
335	result = 107;
336	else if ( num_subrs < 33900U )
337	result = 1131;
338	else
339	result = 32768U;
340
341	return result;
342	}
343
344
345	/*************************************************************************/
346	/* */
347	/* <Function> */
348	/* cff_decoder_init */
349	/* */
350	/* <Description> */
351	/* Initializes a given glyph decoder. */
352	/* */
353	/* <InOut> */
354	/* decoder :: A pointer to the glyph builder to initialize. */
355	/* */
356	/* <Input> */
357	/* face :: The current face object. */
358	/* */
359	/* size :: The current size object. */
360	/* */
361	/* slot :: The current glyph object. */
362	/* */
363	/* hinting :: Whether hinting is active. */
364	/* */
365	/* hint_mode :: The hinting mode. */
366	/* */
367	FT_LOCAL_DEF( void )
368	cff_decoder_init( CFF_Decoder* decoder,
369	TT_Face face,
370	CFF_Size size,
371	CFF_GlyphSlot slot,
372	FT_Bool hinting,
373	FT_Render_Mode hint_mode )
374	{
375	CFF_Font cff = (CFF_Font)face->extra.data;
376
377
378	/* clear everything */
379	FT_MEM_ZERO( decoder, sizeof ( *decoder ) );
380
381	/* initialize builder */
382	cff_builder_init( &decoder->builder, face, size, slot, hinting );
383
384	/* initialize Type2 decoder */
385	decoder->num_globals = cff->num_global_subrs;
386	decoder->globals = cff->global_subrs;
387	decoder->globals_bias = cff_compute_bias( decoder->num_globals );
388
389	decoder->hint_mode = hint_mode;
390	}
391
392
393	/* this function is used to select the subfont */
394	/* and the locals subrs array */
395	FT_LOCAL_DEF( FT_Error )
396	cff_decoder_prepare( CFF_Decoder* decoder,
397	CFF_Size size,
398	FT_UInt glyph_index )
399	{
400	CFF_Builder *builder = &decoder->builder;
401	CFF_Font cff = (CFF_Font)builder->face->extra.data;
402	CFF_SubFont sub = &cff->top_font;
403	FT_Error error = CFF_Err_Ok;
404
405
406	/* manage CID fonts */
407	if ( cff->num_subfonts )
408	{
409	FT_Byte fd_index = cff_fd_select_get( &cff->fd_select, glyph_index );
410
411
412	if ( fd_index >= cff->num_subfonts )
413	{
414	FT_TRACE4(( "cff_decoder_prepare: invalid CID subfont index\n" ));
415	error = CFF_Err_Invalid_File_Format;
416	goto Exit;
417	}
418
419	FT_TRACE4(( "glyph index %d (subfont %d):\n", glyph_index, fd_index ));
420
421	sub = cff->subfonts[fd_index];
422
423	if ( builder->hints_funcs )
424	{
425	CFF_Internal internal = (CFF_Internal)size->root.internal;
426
427
428	/* for CFFs without subfonts, this value has already been set */
429	builder->hints_globals = (void *)internal->subfonts[fd_index];
430	}
431	}
432	#ifdef FT_DEBUG_LEVEL_TRACE
433	else
434	FT_TRACE4(( "glyph index %d:\n", glyph_index ));
435	#endif
436
437	decoder->num_locals = sub->num_local_subrs;
438	decoder->locals = sub->local_subrs;
439	decoder->locals_bias = cff_compute_bias( decoder->num_locals );
440
441	decoder->glyph_width = sub->private_dict.default_width;
442	decoder->nominal_width = sub->private_dict.nominal_width;
443
444	Exit:
445	return error;
446	}
447
448
449	/* check that there is enough space for `count' more points */
450	static FT_Error
451	check_points( CFF_Builder* builder,
452	FT_Int count )
453	{
454	return FT_GLYPHLOADER_CHECK_POINTS( builder->loader, count, 0 );
455	}
456
457
458	/* add a new point, do not check space */
459	static void
460	cff_builder_add_point( CFF_Builder* builder,
461	FT_Pos x,
462	FT_Pos y,
463	FT_Byte flag )
464	{
465	FT_Outline* outline = builder->current;
466
467
468	if ( builder->load_points )
469	{
470	FT_Vector* point = outline->points + outline->n_points;
471	FT_Byte* control = (FT_Byte*)outline->tags + outline->n_points;
472
473
474	point->x = x >> 16;
475	point->y = y >> 16;
476	*control = (FT_Byte)( flag ? FT_CURVE_TAG_ON : FT_CURVE_TAG_CUBIC );
477
478	builder->last = *point;
479	}
480
481	outline->n_points++;
482	}
483
484
485	/* check space for a new on-curve point, then add it */
486	static FT_Error
487	cff_builder_add_point1( CFF_Builder* builder,
488	FT_Pos x,
489	FT_Pos y )
490	{
491	FT_Error error;
492
493
494	error = check_points( builder, 1 );
495	if ( !error )
496	cff_builder_add_point( builder, x, y, 1 );
497
498	return error;
499	}
500
501
502	/* check space for a new contour, then add it */
503	static FT_Error
504	cff_builder_add_contour( CFF_Builder* builder )
505	{
506	FT_Outline* outline = builder->current;
507	FT_Error error;
508
509
510	if ( !builder->load_points )
511	{
512	outline->n_contours++;
513	return CFF_Err_Ok;
514	}
515
516	error = FT_GLYPHLOADER_CHECK_POINTS( builder->loader, 0, 1 );
517	if ( !error )
518	{
519	if ( outline->n_contours > 0 )
520	outline->contours[outline->n_contours - 1] =
521	(short)( outline->n_points - 1 );
522
523	outline->n_contours++;
524	}
525
526	return error;
527	}
528
529
530	/* if a path was begun, add its first on-curve point */
531	static FT_Error
532	cff_builder_start_point( CFF_Builder* builder,
533	FT_Pos x,
534	FT_Pos y )
535	{
536	FT_Error error = CFF_Err_Ok;
537
538
539	/* test whether we are building a new contour */
540	if ( !builder->path_begun )
541	{
542	builder->path_begun = 1;
543	error = cff_builder_add_contour( builder );
544	if ( !error )
545	error = cff_builder_add_point1( builder, x, y );
546	}
547
548	return error;
549	}
550
551
552	/* close the current contour */
553	static void
554	cff_builder_close_contour( CFF_Builder* builder )
555	{
556	FT_Outline* outline = builder->current;
557
558
559	if ( !outline )
560	return;
561
562	/* XXXX: We must not include the last point in the path if it */
563	/* is located on the first point. */
564	if ( outline->n_points > 1 )
565	{
566	FT_Int first = 0;
567	FT_Vector* p1 = outline->points + first;
568	FT_Vector* p2 = outline->points + outline->n_points - 1;
569	FT_Byte* control = (FT_Byte*)outline->tags + outline->n_points - 1;
570
571
572	if ( outline->n_contours > 1 )
573	{
574	first = outline->contours[outline->n_contours - 2] + 1;
575	p1 = outline->points + first;
576	}
577
578	/* `delete' last point only if it coincides with the first */
579	/* point and if it is not a control point (which can happen). */
580	if ( p1->x == p2->x && p1->y == p2->y )
581	if ( *control == FT_CURVE_TAG_ON )
582	outline->n_points--;
583	}
584
585	if ( outline->n_contours > 0 )
586	outline->contours[outline->n_contours - 1] =
587	(short)( outline->n_points - 1 );
588	}
589
590
591	static FT_Int
592	cff_lookup_glyph_by_stdcharcode( CFF_Font cff,
593	FT_Int charcode )
594	{
595	FT_UInt n;
596	FT_UShort glyph_sid;
597
598
599	/* CID-keyed fonts don't have glyph names */
600	if ( !cff->charset.sids )
601	return -1;
602
603	/* check range of standard char code */
604	if ( charcode < 0 \|\| charcode > 255 )
605	return -1;
606
607	/* Get code to SID mapping from `cff_standard_encoding'. */
608	glyph_sid = cff_get_standard_encoding( (FT_UInt)charcode );
609
610	for ( n = 0; n < cff->num_glyphs; n++ )
611	{
612	if ( cff->charset.sids[n] == glyph_sid )
613	return n;
614	}
615
616	return -1;
617	}
618
619
620	static FT_Error
621	cff_get_glyph_data( TT_Face face,
622	FT_UInt glyph_index,
623	FT_Byte** pointer,
624	FT_ULong* length )
625	{
626	#ifdef FT_CONFIG_OPTION_INCREMENTAL
627	/* For incremental fonts get the character data using the */
628	/* callback function. */
629	if ( face->root.internal->incremental_interface )
630	{
631	FT_Data data;
632	FT_Error error =
633	face->root.internal->incremental_interface->funcs->get_glyph_data(
634	face->root.internal->incremental_interface->object,
635	glyph_index, &data );
636
637
638	pointer = (FT_Byte)data.pointer;
639	*length = data.length;
640
641	return error;
642	}
643	else
644	#endif /* FT_CONFIG_OPTION_INCREMENTAL */
645
646	{
647	CFF_Font cff = (CFF_Font)(face->extra.data);
648
649
650	return cff_index_access_element( &cff->charstrings_index, glyph_index,
651	pointer, length );
652	}
653	}
654
655
656	static void
657	cff_free_glyph_data( TT_Face face,
658	FT_Byte** pointer,
659	FT_ULong length )
660	{
661	#ifndef FT_CONFIG_OPTION_INCREMENTAL
662	FT_UNUSED( length );
663	#endif
664
665	#ifdef FT_CONFIG_OPTION_INCREMENTAL
666	/* For incremental fonts get the character data using the */
667	/* callback function. */
668	if ( face->root.internal->incremental_interface )
669	{
670	FT_Data data;
671
672
673	data.pointer = *pointer;
674	data.length = length;
675
676	face->root.internal->incremental_interface->funcs->free_glyph_data(
677	face->root.internal->incremental_interface->object,&data );
678	}
679	else
680	#endif /* FT_CONFIG_OPTION_INCREMENTAL */
681
682	{
683	CFF_Font cff = (CFF_Font)(face->extra.data);
684
685
686	cff_index_forget_element( &cff->charstrings_index, pointer );
687	}
688	}
689
690
691	static FT_Error
692	cff_operator_seac( CFF_Decoder* decoder,
693	FT_Pos adx,
694	FT_Pos ady,
695	FT_Int bchar,
696	FT_Int achar )
697	{
698	FT_Error error;
699	CFF_Builder* builder = &decoder->builder;
700	FT_Int bchar_index, achar_index;
701	TT_Face face = decoder->builder.face;
702	FT_Vector left_bearing, advance;
703	FT_Byte* charstring;
704	FT_ULong charstring_len;
705
706
707	#ifdef FT_CONFIG_OPTION_INCREMENTAL
708	/* Incremental fonts don't necessarily have valid charsets. */
709	/* They use the character code, not the glyph index, in this case. */
710	if ( face->root.internal->incremental_interface )
711	{
712	bchar_index = bchar;
713	achar_index = achar;
714	}
715	else
716	#endif /* FT_CONFIG_OPTION_INCREMENTAL */
717	{
718	CFF_Font cff = (CFF_Font)(face->extra.data);
719
720
721	bchar_index = cff_lookup_glyph_by_stdcharcode( cff, bchar );
722	achar_index = cff_lookup_glyph_by_stdcharcode( cff, achar );
723	}
724
725	if ( bchar_index < 0 \|\| achar_index < 0 )
726	{
727	FT_ERROR(( "cff_operator_seac:" ));
728	FT_ERROR(( " invalid seac character code arguments\n" ));
729	return CFF_Err_Syntax_Error;
730	}
731
732	/* If we are trying to load a composite glyph, do not load the */
733	/* accent character and return the array of subglyphs. */
734	if ( builder->no_recurse )
735	{
736	FT_GlyphSlot glyph = (FT_GlyphSlot)builder->glyph;
737	FT_GlyphLoader loader = glyph->internal->loader;
738	FT_SubGlyph subg;
739
740
741	/* reallocate subglyph array if necessary */
742	error = FT_GlyphLoader_CheckSubGlyphs( loader, 2 );
743	if ( error )
744	goto Exit;
745
746	subg = loader->current.subglyphs;
747
748	/* subglyph 0 = base character */
749	subg->index = bchar_index;
750	subg->flags = FT_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES \|
751	FT_SUBGLYPH_FLAG_USE_MY_METRICS;
752	subg->arg1 = 0;
753	subg->arg2 = 0;
754	subg++;
755
756	/* subglyph 1 = accent character */
757	subg->index = achar_index;
758	subg->flags = FT_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES;
759	subg->arg1 = (FT_Int)( adx >> 16 );
760	subg->arg2 = (FT_Int)( ady >> 16 );
761
762	/* set up remaining glyph fields */
763	glyph->num_subglyphs = 2;
764	glyph->subglyphs = loader->base.subglyphs;
765	glyph->format = FT_GLYPH_FORMAT_COMPOSITE;
766
767	loader->current.num_subglyphs = 2;
768	}
769
770	FT_GlyphLoader_Prepare( builder->loader );
771
772	/* First load `bchar' in builder */
773	error = cff_get_glyph_data( face, bchar_index,
774	&charstring, &charstring_len );
775	if ( !error )
776	{
777	error = cff_decoder_parse_charstrings( decoder, charstring,
778	charstring_len );
779
780	if ( error )
781	goto Exit;
782
783	cff_free_glyph_data( face, &charstring, charstring_len );
784	}
785
786	/* Save the left bearing and width of the base character */
787	/* as they will be erased by the next load. */
788
789	left_bearing = builder->left_bearing;
790	advance = builder->advance;
791
792	builder->left_bearing.x = 0;
793	builder->left_bearing.y = 0;
794
795	builder->pos_x = adx;
796	builder->pos_y = ady;
797
798	/* Now load `achar' on top of the base outline. */
799	error = cff_get_glyph_data( face, achar_index,
800	&charstring, &charstring_len );
801	if ( !error )
802	{
803	error = cff_decoder_parse_charstrings( decoder, charstring,
804	charstring_len );
805
806	if ( error )
807	goto Exit;
808
809	cff_free_glyph_data( face, &charstring, charstring_len );
810	}
811
812	/* Restore the left side bearing and advance width */
813	/* of the base character. */
814	builder->left_bearing = left_bearing;
815	builder->advance = advance;
816
817	builder->pos_x = 0;
818	builder->pos_y = 0;
819
820	Exit:
821	return error;
822	}
823
824
825	/*************************************************************************/
826	/* */
827	/* <Function> */
828	/* cff_decoder_parse_charstrings */
829	/* */
830	/* <Description> */
831	/* Parses a given Type 2 charstrings program. */
832	/* */
833	/* <InOut> */
834	/* decoder :: The current Type 1 decoder. */
835	/* */
836	/* <Input> */
837	/* charstring_base :: The base of the charstring stream. */
838	/* */
839	/* charstring_len :: The length in bytes of the charstring stream. */
840	/* */
841	/* <Return> */
842	/* FreeType error code. 0 means success. */
843	/* */
844	FT_LOCAL_DEF( FT_Error )
845	cff_decoder_parse_charstrings( CFF_Decoder* decoder,
846	FT_Byte* charstring_base,
847	FT_ULong charstring_len )
848	{
849	FT_Error error;
850	CFF_Decoder_Zone* zone;
851	FT_Byte* ip;
852	FT_Byte* limit;
853	CFF_Builder* builder = &decoder->builder;
854	FT_Pos x, y;
855	FT_Fixed seed;
856	FT_Fixed* stack;
857
858	T2_Hints_Funcs hinter;
859
860
861	/* set default width */
862	decoder->num_hints = 0;
863	decoder->read_width = 1;
864
865	/* compute random seed from stack address of parameter */
866	seed = (FT_Fixed)(char*)&seed ^
867	(FT_Fixed)(char*)&decoder ^
868	(FT_Fixed)(char*)&charstring_base;
869	seed = ( seed ^ ( seed >> 10 ) ^ ( seed >> 20 ) ) & 0xFFFFL;
870	if ( seed == 0 )
871	seed = 0x7384;
872
873	/* initialize the decoder */
874	decoder->top = decoder->stack;
875	decoder->zone = decoder->zones;
876	zone = decoder->zones;
877	stack = decoder->top;
878
879	hinter = (T2_Hints_Funcs)builder->hints_funcs;
880
881	builder->path_begun = 0;
882
883	zone->base = charstring_base;
884	limit = zone->limit = charstring_base + charstring_len;
885	ip = zone->cursor = zone->base;
886
887	error = CFF_Err_Ok;
888
889	x = builder->pos_x;
890	y = builder->pos_y;
891
892	/* begin hints recording session, if any */
893	if ( hinter )
894	hinter->open( hinter->hints );
895
896	/* now execute loop */
897	while ( ip < limit )
898	{
899	CFF_Operator op;
900	FT_Byte v;
901
902
903	/********************************************************************/
904	/* */
905	/* Decode operator or operand */
906	/* */
907	v = *ip++;
908	if ( v >= 32 \|\| v == 28 )
909	{
910	FT_Int shift = 16;
911	FT_Int32 val;
912
913
914	/* this is an operand, push it on the stack */
915	if ( v == 28 )
916	{
917	if ( ip + 1 >= limit )
918	goto Syntax_Error;
919	val = (FT_Short)( ( (FT_Short)ip[0] << 8 ) \| ip[1] );
920	ip += 2;
921	}
922	else if ( v < 247 )
923	val = (FT_Long)v - 139;
924	else if ( v < 251 )
925	{
926	if ( ip >= limit )
927	goto Syntax_Error;
928	val = ( (FT_Long)v - 247 ) * 256 + *ip++ + 108;
929	}
930	else if ( v < 255 )
931	{
932	if ( ip >= limit )
933	goto Syntax_Error;
934	val = -( (FT_Long)v - 251 ) * 256 - *ip++ - 108;
935	}
936	else
937	{
938	if ( ip + 3 >= limit )
939	goto Syntax_Error;
940	val = ( (FT_Int32)ip[0] << 24 ) \|
941	( (FT_Int32)ip[1] << 16 ) \|
942	( (FT_Int32)ip[2] << 8 ) \|
943	ip[3];
944	ip += 4;
945	shift = 0;
946	}
947	if ( decoder->top - stack >= CFF_MAX_OPERANDS )
948	goto Stack_Overflow;
949
950	val <<= shift;
951	*decoder->top++ = val;
952
953	#ifdef FT_DEBUG_LEVEL_TRACE
954	if ( !( val & 0xFFFFL ) )
955	FT_TRACE4(( " %ld", (FT_Int32)( val >> 16 ) ));
956	else
957	FT_TRACE4(( " %.2f", val / 65536.0 ));
958	#endif
959
960	}
961	else
962	{
963	/* The specification says that normally arguments are to be taken */
964	/* from the bottom of the stack. However, this seems not to be */
965	/* correct, at least for Acroread 7.0.8 on GNU/Linux: It pops the */
966	/* arguments similar to a PS interpreter. */
967
968	FT_Fixed* args = decoder->top;
969	FT_Int num_args = (FT_Int)( args - decoder->stack );
970	FT_Int req_args;
971
972
973	/* find operator */
974	op = cff_op_unknown;
975
976	switch ( v )
977	{
978	case 1:
979	op = cff_op_hstem;
980	break;
981	case 3:
982	op = cff_op_vstem;
983	break;
984	case 4:
985	op = cff_op_vmoveto;
986	break;
987	case 5:
988	op = cff_op_rlineto;
989	break;
990	case 6:
991	op = cff_op_hlineto;
992	break;
993	case 7:
994	op = cff_op_vlineto;
995	break;
996	case 8:
997	op = cff_op_rrcurveto;
998	break;
999	case 9:
1000	op = cff_op_closepath;
1001	break;
1002	case 10:
1003	op = cff_op_callsubr;
1004	break;
1005	case 11:
1006	op = cff_op_return;
1007	break;
1008	case 12:
1009	{
1010	if ( ip >= limit )
1011	goto Syntax_Error;
1012	v = *ip++;
1013
1014	switch ( v )
1015	{
1016	case 0:
1017	op = cff_op_dotsection;
1018	break;
1019	case 3:
1020	op = cff_op_and;
1021	break;
1022	case 4:
1023	op = cff_op_or;
1024	break;
1025	case 5:
1026	op = cff_op_not;
1027	break;
1028	case 8:
1029	op = cff_op_store;
1030	break;
1031	case 9:
1032	op = cff_op_abs;
1033	break;
1034	case 10:
1035	op = cff_op_add;
1036	break;
1037	case 11:
1038	op = cff_op_sub;
1039	break;
1040	case 12:
1041	op = cff_op_div;
1042	break;
1043	case 13:
1044	op = cff_op_load;
1045	break;
1046	case 14:
1047	op = cff_op_neg;
1048	break;
1049	case 15:
1050	op = cff_op_eq;
1051	break;
1052	case 16:
1053	op = cff_op_callothersubr;
1054	break;
1055	case 17:
1056	op = cff_op_pop;
1057	break;
1058	case 18:
1059	op = cff_op_drop;
1060	break;
1061	case 20:
1062	op = cff_op_put;
1063	break;
1064	case 21:
1065	op = cff_op_get;
1066	break;
1067	case 22:
1068	op = cff_op_ifelse;
1069	break;
1070	case 23:
1071	op = cff_op_random;
1072	break;
1073	case 24:
1074	op = cff_op_mul;
1075	break;
1076	case 26:
1077	op = cff_op_sqrt;
1078	break;
1079	case 27:
1080	op = cff_op_dup;
1081	break;
1082	case 28:
1083	op = cff_op_exch;
1084	break;
1085	case 29:
1086	op = cff_op_index;
1087	break;
1088	case 30:
1089	op = cff_op_roll;
1090	break;
1091	case 34:
1092	op = cff_op_hflex;
1093	break;
1094	case 35:
1095	op = cff_op_flex;
1096	break;
1097	case 36:
1098	op = cff_op_hflex1;
1099	break;
1100	case 37:
1101	op = cff_op_flex1;
1102	break;
1103	default:
1104	/* decrement ip for syntax error message */
1105	ip--;
1106	}
1107	}
1108	break;
1109	case 13:
1110	op = cff_op_hsbw;
1111	break;
1112	case 14:
1113	op = cff_op_endchar;
1114	break;
1115	case 16:
1116	op = cff_op_blend;
1117	break;
1118	case 18:
1119	op = cff_op_hstemhm;
1120	break;
1121	case 19:
1122	op = cff_op_hintmask;
1123	break;
1124	case 20:
1125	op = cff_op_cntrmask;
1126	break;
1127	case 21:
1128	op = cff_op_rmoveto;
1129	break;
1130	case 22:
1131	op = cff_op_hmoveto;
1132	break;
1133	case 23:
1134	op = cff_op_vstemhm;
1135	break;
1136	case 24:
1137	op = cff_op_rcurveline;
1138	break;
1139	case 25:
1140	op = cff_op_rlinecurve;
1141	break;
1142	case 26:
1143	op = cff_op_vvcurveto;
1144	break;
1145	case 27:
1146	op = cff_op_hhcurveto;
1147	break;
1148	case 29:
1149	op = cff_op_callgsubr;
1150	break;
1151	case 30:
1152	op = cff_op_vhcurveto;
1153	break;
1154	case 31:
1155	op = cff_op_hvcurveto;
1156	break;
1157	default:
1158	;
1159	}
1160
1161	if ( op == cff_op_unknown )
1162	goto Syntax_Error;
1163
1164	/* check arguments */
1165	req_args = cff_argument_counts[op];
1166	if ( req_args & CFF_COUNT_CHECK_WIDTH )
1167	{
1168	if ( num_args > 0 && decoder->read_width )
1169	{
1170	/* If `nominal_width' is non-zero, the number is really a */
1171	/* difference against `nominal_width'. Else, the number here */
1172	/* is truly a width, not a difference against `nominal_width'. */
1173	/* If the font does not set `nominal_width', then */
1174	/* `nominal_width' defaults to zero, and so we can set */
1175	/* `glyph_width' to `nominal_width' plus number on the stack */
1176	/* -- for either case. */
1177
1178	FT_Int set_width_ok;
1179
1180
1181	switch ( op )
1182	{
1183	case cff_op_hmoveto:
1184	case cff_op_vmoveto:
1185	set_width_ok = num_args & 2;
1186	break;
1187
1188	case cff_op_hstem:
1189	case cff_op_vstem:
1190	case cff_op_hstemhm:
1191	case cff_op_vstemhm:
1192	case cff_op_rmoveto:
1193	case cff_op_hintmask:
1194	case cff_op_cntrmask:
1195	set_width_ok = num_args & 1;
1196	break;
1197
1198	case cff_op_endchar:
1199	/* If there is a width specified for endchar, we either have */
1200	/* 1 argument or 5 arguments. We like to argue. */
1201	set_width_ok = ( num_args == 5 ) \|\| ( num_args == 1 );
1202	break;
1203
1204	default:
1205	set_width_ok = 0;
1206	break;
1207	}
1208
1209	if ( set_width_ok )
1210	{
1211	decoder->glyph_width = decoder->nominal_width +
1212	( stack[0] >> 16 );
1213
1214	if ( decoder->width_only )
1215	{
1216	/* we only want the advance width; stop here */
1217	break;
1218	}
1219
1220	/* Consumed an argument. */
1221	num_args--;
1222	}
1223	}
1224
1225	decoder->read_width = 0;
1226	req_args = 0;
1227	}
1228
1229	req_args &= 0x000F;
1230	if ( num_args < req_args )
1231	goto Stack_Underflow;
1232	args -= req_args;
1233	num_args -= req_args;
1234
1235	/* At this point, `args' points to the first argument of the */
1236	/* operand in case `req_args' isn't zero. Otherwise, we have */
1237	/* to adjust `args' manually. */
1238
1239	/* Note that we only pop arguments from the stack which we */
1240	/* really need and can digest so that we can continue in case */
1241	/* of superfluous stack elements. */
1242
1243	switch ( op )
1244	{
1245	case cff_op_hstem:
1246	case cff_op_vstem:
1247	case cff_op_hstemhm:
1248	case cff_op_vstemhm:
1249	/* the number of arguments is always even here */
1250	FT_TRACE4((
1251	op == cff_op_hstem ? " hstem\n" :
1252	( op == cff_op_vstem ? " vstem\n" :
1253	( op == cff_op_hstemhm ? " hstemhm\n" : " vstemhm\n" ) ) ));
1254
1255	if ( hinter )
1256	hinter->stems( hinter->hints,
1257	( op == cff_op_hstem \|\| op == cff_op_hstemhm ),
1258	num_args / 2,
1259	args - ( num_args & ~1 ) );
1260
1261	decoder->num_hints += num_args / 2;
1262	args = stack;
1263	break;
1264
1265	case cff_op_hintmask:
1266	case cff_op_cntrmask:
1267	FT_TRACE4(( op == cff_op_hintmask ? " hintmask" : " cntrmask" ));
1268
1269	/* implement vstem when needed -- */
1270	/* the specification doesn't say it, but this also works */
1271	/* with the 'cntrmask' operator */
1272	/* */
1273	if ( num_args > 0 )
1274	{
1275	if ( hinter )
1276	hinter->stems( hinter->hints,
1277	0,
1278	num_args / 2,
1279	args - ( num_args & ~1 ) );
1280
1281	decoder->num_hints += num_args / 2;
1282	}
1283
1284	if ( hinter )
1285	{
1286	if ( op == cff_op_hintmask )
1287	hinter->hintmask( hinter->hints,
1288	builder->current->n_points,
1289	decoder->num_hints,
1290	ip );
1291	else
1292	hinter->counter( hinter->hints,
1293	decoder->num_hints,
1294	ip );
1295	}
1296
1297	#ifdef FT_DEBUG_LEVEL_TRACE
1298	{
1299	FT_UInt maskbyte;
1300
1301
1302	FT_TRACE4(( " (maskbytes: " ));
1303
1304	for ( maskbyte = 0;
1305	maskbyte < (FT_UInt)(( decoder->num_hints + 7 ) >> 3);
1306	maskbyte++, ip++ )
1307	FT_TRACE4(( "0x%02X", *ip ));
1308
1309	FT_TRACE4(( ")\n" ));
1310	}
1311	#else
1312	ip += ( decoder->num_hints + 7 ) >> 3;
1313	#endif
1314	if ( ip >= limit )
1315	goto Syntax_Error;
1316	args = stack;
1317	break;
1318
1319	case cff_op_rmoveto:
1320	FT_TRACE4(( " rmoveto\n" ));
1321
1322	cff_builder_close_contour( builder );
1323	builder->path_begun = 0;
1324	x += args[-2];
1325	y += args[-1];
1326	args = stack;
1327	break;
1328
1329	case cff_op_vmoveto:
1330	FT_TRACE4(( " vmoveto\n" ));
1331
1332	cff_builder_close_contour( builder );
1333	builder->path_begun = 0;
1334	y += args[-1];
1335	args = stack;
1336	break;
1337
1338	case cff_op_hmoveto:
1339	FT_TRACE4(( " hmoveto\n" ));
1340
1341	cff_builder_close_contour( builder );
1342	builder->path_begun = 0;
1343	x += args[-1];
1344	args = stack;
1345	break;
1346
1347	case cff_op_rlineto:
1348	FT_TRACE4(( " rlineto\n" ));
1349
1350	if ( cff_builder_start_point ( builder, x, y ) \|\|
1351	check_points( builder, num_args / 2 ) )
1352	goto Fail;
1353
1354	if ( num_args < 2 )
1355	goto Stack_Underflow;
1356
1357	args -= num_args & ~1;
1358	while ( args < decoder->top )
1359	{
1360	x += args[0];
1361	y += args[1];
1362	cff_builder_add_point( builder, x, y, 1 );
1363	args += 2;
1364	}
1365	args = stack;
1366	break;
1367
1368	case cff_op_hlineto:
1369	case cff_op_vlineto:
1370	{
1371	FT_Int phase = ( op == cff_op_hlineto );
1372
1373
1374	FT_TRACE4(( op == cff_op_hlineto ? " hlineto\n"
1375	: " vlineto\n" ));
1376
1377	if ( num_args < 1 )
1378	goto Stack_Underflow;
1379
1380	if ( cff_builder_start_point ( builder, x, y ) \|\|
1381	check_points( builder, num_args ) )
1382	goto Fail;
1383
1384	args = stack;
1385	while ( args < decoder->top )
1386	{
1387	if ( phase )
1388	x += args[0];
1389	else
1390	y += args[0];
1391
1392	if ( cff_builder_add_point1( builder, x, y ) )
1393	goto Fail;
1394
1395	args++;
1396	phase ^= 1;
1397	}
1398	args = stack;
1399	}
1400	break;
1401
1402	case cff_op_rrcurveto:
1403	{
1404	FT_Int nargs;
1405
1406
1407	FT_TRACE4(( " rrcurveto\n" ));
1408
1409	if ( num_args < 6 )
1410	goto Stack_Underflow;
1411
1412	nargs = num_args - num_args % 6;
1413
1414	if ( cff_builder_start_point ( builder, x, y ) \|\|
1415	check_points( builder, nargs / 2 ) )
1416	goto Fail;
1417
1418	args -= nargs;
1419	while ( args < decoder->top )
1420	{
1421	x += args[0];
1422	y += args[1];
1423	cff_builder_add_point( builder, x, y, 0 );
1424	x += args[2];
1425	y += args[3];
1426	cff_builder_add_point( builder, x, y, 0 );
1427	x += args[4];
1428	y += args[5];
1429	cff_builder_add_point( builder, x, y, 1 );
1430	args += 6;
1431	}
1432	args = stack;
1433	}
1434	break;
1435
1436	case cff_op_vvcurveto:
1437	{
1438	FT_Int nargs;
1439
1440
1441	FT_TRACE4(( " vvcurveto\n" ));
1442
1443	if ( num_args < 4 )
1444	goto Stack_Underflow;
1445
1446	/* if num_args isn't of the form 4n or 4n+1, */
1447	/* we reduce it to 4n+1 */
1448
1449	nargs = num_args - num_args % 4;
1450	if ( num_args - nargs > 0 )
1451	nargs += 1;
1452
1453	if ( cff_builder_start_point( builder, x, y ) )
1454	goto Fail;
1455
1456	args -= nargs;
1457
1458	if ( nargs & 1 )
1459	{
1460	x += args[0];
1461	args++;
1462	nargs--;
1463	}
1464
1465	if ( check_points( builder, 3 * ( nargs / 4 ) ) )
1466	goto Fail;
1467
1468	while ( args < decoder->top )
1469	{
1470	y += args[0];
1471	cff_builder_add_point( builder, x, y, 0 );
1472	x += args[1];
1473	y += args[2];
1474	cff_builder_add_point( builder, x, y, 0 );
1475	y += args[3];
1476	cff_builder_add_point( builder, x, y, 1 );
1477	args += 4;
1478	}
1479	args = stack;
1480	}
1481	break;
1482
1483	case cff_op_hhcurveto:
1484	{
1485	FT_Int nargs;
1486
1487
1488	FT_TRACE4(( " hhcurveto\n" ));
1489
1490	if ( num_args < 4 )
1491	goto Stack_Underflow;
1492
1493	/* if num_args isn't of the form 4n or 4n+1, */
1494	/* we reduce it to 4n+1 */
1495
1496	nargs = num_args - num_args % 4;
1497	if ( num_args - nargs > 0 )
1498	nargs += 1;
1499
1500	if ( cff_builder_start_point( builder, x, y ) )
1501	goto Fail;
1502
1503	args -= nargs;
1504	if ( nargs & 1 )
1505	{
1506	y += args[0];
1507	args++;
1508	nargs--;
1509	}
1510
1511	if ( check_points( builder, 3 * ( nargs / 4 ) ) )
1512	goto Fail;
1513
1514	while ( args < decoder->top )
1515	{
1516	x += args[0];
1517	cff_builder_add_point( builder, x, y, 0 );
1518	x += args[1];
1519	y += args[2];
1520	cff_builder_add_point( builder, x, y, 0 );
1521	x += args[3];
1522	cff_builder_add_point( builder, x, y, 1 );
1523	args += 4;
1524	}
1525	args = stack;
1526	}
1527	break;
1528
1529	case cff_op_vhcurveto:
1530	case cff_op_hvcurveto:
1531	{
1532	FT_Int phase;
1533	FT_Int nargs;
1534
1535
1536	FT_TRACE4(( op == cff_op_vhcurveto ? " vhcurveto\n"
1537	: " hvcurveto\n" ));
1538
1539	if ( cff_builder_start_point( builder, x, y ) )
1540	goto Fail;
1541
1542	if ( num_args < 4 )
1543	goto Stack_Underflow;
1544
1545	/* if num_args isn't of the form 8n, 8n+1, 8n+4, or 8n+5, */
1546	/* we reduce it to the largest one which fits */
1547
1548	nargs = num_args - num_args % 4;
1549	if ( num_args - nargs > 0 )
1550	nargs += 1;
1551
1552	args -= nargs;
1553	if ( check_points( builder, ( nargs / 4 ) * 3 ) )
1554	goto Stack_Underflow;
1555
1556	phase = ( op == cff_op_hvcurveto );
1557
1558	while ( nargs >= 4 )
1559	{
1560	nargs -= 4;
1561	if ( phase )
1562	{
1563	x += args[0];
1564	cff_builder_add_point( builder, x, y, 0 );
1565	x += args[1];
1566	y += args[2];
1567	cff_builder_add_point( builder, x, y, 0 );
1568	y += args[3];
1569	if ( nargs == 1 )
1570	x += args[4];
1571	cff_builder_add_point( builder, x, y, 1 );
1572	}
1573	else
1574	{
1575	y += args[0];
1576	cff_builder_add_point( builder, x, y, 0 );
1577	x += args[1];
1578	y += args[2];
1579	cff_builder_add_point( builder, x, y, 0 );
1580	x += args[3];
1581	if ( nargs == 1 )
1582	y += args[4];
1583	cff_builder_add_point( builder, x, y, 1 );
1584	}
1585	args += 4;
1586	phase ^= 1;
1587	}
1588	args = stack;
1589	}
1590	break;
1591
1592	case cff_op_rlinecurve:
1593	{
1594	FT_Int num_lines;
1595	FT_Int nargs;
1596
1597
1598	FT_TRACE4(( " rlinecurve\n" ));
1599
1600	if ( num_args < 8 )
1601	goto Stack_Underflow;
1602
1603	nargs = num_args & ~1;
1604	num_lines = ( nargs - 6 ) / 2;
1605
1606	if ( cff_builder_start_point( builder, x, y ) \|\|
1607	check_points( builder, num_lines + 3 ) )
1608	goto Fail;
1609
1610	args -= nargs;
1611
1612	/* first, add the line segments */
1613	while ( num_lines > 0 )
1614	{
1615	x += args[0];
1616	y += args[1];
1617	cff_builder_add_point( builder, x, y, 1 );
1618	args += 2;
1619	num_lines--;
1620	}
1621
1622	/* then the curve */
1623	x += args[0];
1624	y += args[1];
1625	cff_builder_add_point( builder, x, y, 0 );
1626	x += args[2];
1627	y += args[3];
1628	cff_builder_add_point( builder, x, y, 0 );
1629	x += args[4];
1630	y += args[5];
1631	cff_builder_add_point( builder, x, y, 1 );
1632	args = stack;
1633	}
1634	break;
1635
1636	case cff_op_rcurveline:
1637	{
1638	FT_Int num_curves;
1639	FT_Int nargs;
1640
1641
1642	FT_TRACE4(( " rcurveline\n" ));
1643
1644	if ( num_args < 8 )
1645	goto Stack_Underflow;
1646
1647	nargs = num_args - 2;
1648	nargs = nargs - nargs % 6 + 2;
1649	num_curves = ( nargs - 2 ) / 6;
1650
1651	if ( cff_builder_start_point ( builder, x, y ) \|\|
1652	check_points( builder, num_curves * 3 + 2 ) )
1653	goto Fail;
1654
1655	args -= nargs;
1656
1657	/* first, add the curves */
1658	while ( num_curves > 0 )
1659	{
1660	x += args[0];
1661	y += args[1];
1662	cff_builder_add_point( builder, x, y, 0 );
1663	x += args[2];
1664	y += args[3];
1665	cff_builder_add_point( builder, x, y, 0 );
1666	x += args[4];
1667	y += args[5];
1668	cff_builder_add_point( builder, x, y, 1 );
1669	args += 6;
1670	num_curves--;
1671	}
1672
1673	/* then the final line */
1674	x += args[0];
1675	y += args[1];
1676	cff_builder_add_point( builder, x, y, 1 );
1677	args = stack;
1678	}
1679	break;
1680
1681	case cff_op_hflex1:
1682	{
1683	FT_Pos start_y;
1684
1685
1686	FT_TRACE4(( " hflex1\n" ));
1687
1688	/* adding five more points: 4 control points, 1 on-curve point */
1689	/* -- make sure we have enough space for the start point if it */
1690	/* needs to be added */
1691	if ( cff_builder_start_point( builder, x, y ) \|\|
1692	check_points( builder, 6 ) )
1693	goto Fail;
1694
1695	/* record the starting point's y position for later use */
1696	start_y = y;
1697
1698	/* first control point */
1699	x += args[0];
1700	y += args[1];
1701	cff_builder_add_point( builder, x, y, 0 );
1702
1703	/* second control point */
1704	x += args[2];
1705	y += args[3];
1706	cff_builder_add_point( builder, x, y, 0 );
1707
1708	/* join point; on curve, with y-value the same as the last */
1709	/* control point's y-value */
1710	x += args[4];
1711	cff_builder_add_point( builder, x, y, 1 );
1712
1713	/* third control point, with y-value the same as the join */
1714	/* point's y-value */
1715	x += args[5];
1716	cff_builder_add_point( builder, x, y, 0 );
1717
1718	/* fourth control point */
1719	x += args[6];
1720	y += args[7];
1721	cff_builder_add_point( builder, x, y, 0 );
1722
1723	/* ending point, with y-value the same as the start */
1724	x += args[8];
1725	y = start_y;
1726	cff_builder_add_point( builder, x, y, 1 );
1727
1728	args = stack;
1729	break;
1730	}
1731
1732	case cff_op_hflex:
1733	{
1734	FT_Pos start_y;
1735
1736
1737	FT_TRACE4(( " hflex\n" ));
1738
1739	/* adding six more points; 4 control points, 2 on-curve points */
1740	if ( cff_builder_start_point( builder, x, y ) \|\|
1741	check_points( builder, 6 ) )
1742	goto Fail;
1743
1744	/* record the starting point's y-position for later use */
1745	start_y = y;
1746
1747	/* first control point */
1748	x += args[0];
1749	cff_builder_add_point( builder, x, y, 0 );
1750
1751	/* second control point */
1752	x += args[1];
1753	y += args[2];
1754	cff_builder_add_point( builder, x, y, 0 );
1755
1756	/* join point; on curve, with y-value the same as the last */
1757	/* control point's y-value */
1758	x += args[3];
1759	cff_builder_add_point( builder, x, y, 1 );
1760
1761	/* third control point, with y-value the same as the join */
1762	/* point's y-value */
1763	x += args[4];
1764	cff_builder_add_point( builder, x, y, 0 );
1765
1766	/* fourth control point */
1767	x += args[5];
1768	y = start_y;
1769	cff_builder_add_point( builder, x, y, 0 );
1770
1771	/* ending point, with y-value the same as the start point's */
1772	/* y-value -- we don't add this point, though */
1773	x += args[6];
1774	cff_builder_add_point( builder, x, y, 1 );
1775
1776	args = stack;
1777	break;
1778	}
1779
1780	case cff_op_flex1:
1781	{
1782	FT_Pos start_x, start_y; /* record start x, y values for */
1783	/* alter use */
1784	FT_Fixed dx = 0, dy = 0; /* used in horizontal/vertical */
1785	/* algorithm below */
1786	FT_Int horizontal, count;
1787	FT_Fixed* temp;
1788
1789
1790	FT_TRACE4(( " flex1\n" ));
1791
1792	/* adding six more points; 4 control points, 2 on-curve points */
1793	if ( cff_builder_start_point( builder, x, y ) \|\|
1794	check_points( builder, 6 ) )
1795	goto Fail;
1796
1797	/* record the starting point's x, y position for later use */
1798	start_x = x;
1799	start_y = y;
1800
1801	/* XXX: figure out whether this is supposed to be a horizontal */
1802	/* or vertical flex; the Type 2 specification is vague... */
1803
1804	temp = args;
1805
1806	/* grab up to the last argument */
1807	for ( count = 5; count > 0; count-- )
1808	{
1809	dx += temp[0];
1810	dy += temp[1];
1811	temp += 2;
1812	}
1813
1814	if ( dx < 0 )
1815	dx = -dx;
1816	if ( dy < 0 )
1817	dy = -dy;
1818
1819	/* strange test, but here it is... */
1820	horizontal = ( dx > dy );
1821
1822	for ( count = 5; count > 0; count-- )
1823	{
1824	x += args[0];
1825	y += args[1];
1826	cff_builder_add_point( builder, x, y,
1827	(FT_Bool)( count == 3 ) );
1828	args += 2;
1829	}
1830
1831	/* is last operand an x- or y-delta? */
1832	if ( horizontal )
1833	{
1834	x += args[0];
1835	y = start_y;
1836	}
1837	else
1838	{
1839	x = start_x;
1840	y += args[0];
1841	}
1842
1843	cff_builder_add_point( builder, x, y, 1 );
1844
1845	args = stack;
1846	break;
1847	}
1848
1849	case cff_op_flex:
1850	{
1851	FT_UInt count;
1852
1853
1854	FT_TRACE4(( " flex\n" ));
1855
1856	if ( cff_builder_start_point( builder, x, y ) \|\|
1857	check_points( builder, 6 ) )
1858	goto Fail;
1859
1860	for ( count = 6; count > 0; count-- )
1861	{
1862	x += args[0];
1863	y += args[1];
1864	cff_builder_add_point( builder, x, y,
1865	(FT_Bool)( count == 4 \|\| count == 1 ) );
1866	args += 2;
1867	}
1868
1869	args = stack;
1870	}
1871	break;
1872
1873	case cff_op_endchar:
1874	FT_TRACE4(( " endchar\n" ));
1875
1876	/* We are going to emulate the seac operator. */
1877	if ( num_args >= 4 )
1878	{
1879	/* Save glyph width so that the subglyphs don't overwrite it. */
1880	FT_Pos glyph_width = decoder->glyph_width;
1881
1882
1883	error = cff_operator_seac( decoder,
1884	args[-4],
1885	args[-3],
1886	(FT_Int)( args[-2] >> 16 ),
1887	(FT_Int)( args[-1] >> 16 ) );
1888
1889	decoder->glyph_width = glyph_width;
1890	}
1891	else
1892	{
1893	if ( !error )
1894	error = CFF_Err_Ok;
1895
1896	cff_builder_close_contour( builder );
1897
1898	/* close hints recording session */
1899	if ( hinter )
1900	{
1901	if ( hinter->close( hinter->hints,
1902	builder->current->n_points ) )
1903	goto Syntax_Error;
1904
1905	/* apply hints to the loaded glyph outline now */
1906	hinter->apply( hinter->hints,
1907	builder->current,
1908	(PSH_Globals)builder->hints_globals,
1909	decoder->hint_mode );
1910	}
1911
1912	/* add current outline to the glyph slot */
1913	FT_GlyphLoader_Add( builder->loader );
1914	}
1915
1916	/* return now! */
1917	FT_TRACE4(( "\n" ));
1918	return error;
1919
1920	case cff_op_abs:
1921	FT_TRACE4(( " abs\n" ));
1922
1923	if ( args[0] < 0 )
1924	args[0] = -args[0];
1925	args++;
1926	break;
1927
1928	case cff_op_add:
1929	FT_TRACE4(( " add\n" ));
1930
1931	args[0] += args[1];
1932	args++;
1933	break;
1934
1935	case cff_op_sub:
1936	FT_TRACE4(( " sub\n" ));
1937
1938	args[0] -= args[1];
1939	args++;
1940	break;
1941
1942	case cff_op_div:
1943	FT_TRACE4(( " div\n" ));
1944
1945	args[0] = FT_DivFix( args[0], args[1] );
1946	args++;
1947	break;
1948
1949	case cff_op_neg:
1950	FT_TRACE4(( " neg\n" ));
1951
1952	args[0] = -args[0];
1953	args++;
1954	break;
1955
1956	case cff_op_random:
1957	{
1958	FT_Fixed Rand;
1959
1960
1961	FT_TRACE4(( " rand\n" ));
1962
1963	Rand = seed;
1964	if ( Rand >= 0x8000L )
1965	Rand++;
1966
1967	args[0] = Rand;
1968	seed = FT_MulFix( seed, 0x10000L - seed );
1969	if ( seed == 0 )
1970	seed += 0x2873;
1971	args++;
1972	}
1973	break;
1974
1975	case cff_op_mul:
1976	FT_TRACE4(( " mul\n" ));
1977
1978	args[0] = FT_MulFix( args[0], args[1] );
1979	args++;
1980	break;
1981
1982	case cff_op_sqrt:
1983	FT_TRACE4(( " sqrt\n" ));
1984
1985	if ( args[0] > 0 )
1986	{
1987	FT_Int count = 9;
1988	FT_Fixed root = args[0];
1989	FT_Fixed new_root;
1990
1991
1992	for (;;)
1993	{
1994	new_root = ( root + FT_DivFix( args[0], root ) + 1 ) >> 1;
1995	if ( new_root == root \|\| count <= 0 )
1996	break;
1997	root = new_root;
1998	}
1999	args[0] = new_root;
2000	}
2001	else
2002	args[0] = 0;
2003	args++;
2004	break;
2005
2006	case cff_op_drop:
2007	/* nothing */
2008	FT_TRACE4(( " drop\n" ));
2009
2010	break;
2011
2012	case cff_op_exch:
2013	{
2014	FT_Fixed tmp;
2015
2016
2017	FT_TRACE4(( " exch\n" ));
2018
2019	tmp = args[0];
2020	args[0] = args[1];
2021	args[1] = tmp;
2022	args += 2;
2023	}
2024	break;
2025
2026	case cff_op_index:
2027	{
2028	FT_Int idx = (FT_Int)( args[0] >> 16 );
2029
2030
2031	FT_TRACE4(( " index\n" ));
2032
2033	if ( idx < 0 )
2034	idx = 0;
2035	else if ( idx > num_args - 2 )
2036	idx = num_args - 2;
2037	args[0] = args[-( idx + 1 )];
2038	args++;
2039	}
2040	break;
2041
2042	case cff_op_roll:
2043	{
2044	FT_Int count = (FT_Int)( args[0] >> 16 );
2045	FT_Int idx = (FT_Int)( args[1] >> 16 );
2046
2047
2048	FT_TRACE4(( " roll\n" ));
2049
2050	if ( count <= 0 )
2051	count = 1;
2052
2053	args -= count;
2054	if ( args < stack )
2055	goto Stack_Underflow;
2056
2057	if ( idx >= 0 )
2058	{
2059	while ( idx > 0 )
2060	{
2061	FT_Fixed tmp = args[count - 1];
2062	FT_Int i;
2063
2064
2065	for ( i = count - 2; i >= 0; i-- )
2066	args[i + 1] = args[i];
2067	args[0] = tmp;
2068	idx--;
2069	}
2070	}
2071	else
2072	{
2073	while ( idx < 0 )
2074	{
2075	FT_Fixed tmp = args[0];
2076	FT_Int i;
2077
2078
2079	for ( i = 0; i < count - 1; i++ )
2080	args[i] = args[i + 1];
2081	args[count - 1] = tmp;
2082	idx++;
2083	}
2084	}
2085	args += count;
2086	}
2087	break;
2088
2089	case cff_op_dup:
2090	FT_TRACE4(( " dup\n" ));
2091
2092	args[1] = args[0];
2093	args++;
2094	break;
2095
2096	case cff_op_put:
2097	{
2098	FT_Fixed val = args[0];
2099	FT_Int idx = (FT_Int)( args[1] >> 16 );
2100
2101
2102	FT_TRACE4(( " put\n" ));
2103
2104	if ( idx >= 0 && idx < decoder->len_buildchar )
2105	decoder->buildchar[idx] = val;
2106	}
2107	break;
2108
2109	case cff_op_get:
2110	{
2111	FT_Int idx = (FT_Int)( args[0] >> 16 );
2112	FT_Fixed val = 0;
2113
2114
2115	FT_TRACE4(( " get\n" ));
2116
2117	if ( idx >= 0 && idx < decoder->len_buildchar )
2118	val = decoder->buildchar[idx];
2119
2120	args[0] = val;
2121	args++;
2122	}
2123	break;
2124
2125	case cff_op_store:
2126	FT_TRACE4(( " store\n"));
2127
2128	goto Unimplemented;
2129
2130	case cff_op_load:
2131	FT_TRACE4(( " load\n" ));
2132
2133	goto Unimplemented;
2134
2135	case cff_op_dotsection:
2136	/* this operator is deprecated and ignored by the parser */
2137	FT_TRACE4(( " dotsection\n" ));
2138	break;
2139
2140	case cff_op_closepath:
2141	/* this is an invalid Type 2 operator; however, there */
2142	/* exist fonts which are incorrectly converted from probably */
2143	/* Type 1 to CFF, and some parsers seem to accept it */
2144
2145	FT_TRACE4(( " closepath (invalid op)\n" ));
2146
2147	args = stack;
2148	break;
2149
2150	case cff_op_hsbw:
2151	/* this is an invalid Type 2 operator; however, there */
2152	/* exist fonts which are incorrectly converted from probably */
2153	/* Type 1 to CFF, and some parsers seem to accept it */
2154
2155	FT_TRACE4(( " hsbw (invalid op)\n" ));
2156
2157	decoder->glyph_width = decoder->nominal_width +
2158	(args[1] >> 16);
2159	x = args[0];
2160	y = 0;
2161	args = stack;
2162	break;
2163
2164	case cff_op_callothersubr:
2165	/* this is an invalid Type 2 operator; however, there */
2166	/* exist fonts which are incorrectly converted from probably */
2167	/* Type 1 to CFF, and some parsers seem to accept it */
2168
2169	FT_TRACE4(( " callothersubr (invalid op)\n" ));
2170
2171	/* don't modify stack; handle the subr as `unknown' so that */
2172	/* following `pop' operands use the arguments on stack */
2173	break;
2174
2175	case cff_op_pop:
2176	/* this is an invalid Type 2 operator; however, there */
2177	/* exist fonts which are incorrectly converted from probably */
2178	/* Type 1 to CFF, and some parsers seem to accept it */
2179
2180	FT_TRACE4(( " pop (invalid op)\n" ));
2181
2182	args++;
2183	break;
2184
2185	case cff_op_and:
2186	{
2187	FT_Fixed cond = args[0] && args[1];
2188
2189
2190	FT_TRACE4(( " and\n" ));
2191
2192	args[0] = cond ? 0x10000L : 0;
2193	args++;
2194	}
2195	break;
2196
2197	case cff_op_or:
2198	{
2199	FT_Fixed cond = args[0] \|\| args[1];
2200
2201
2202	FT_TRACE4(( " or\n" ));
2203
2204	args[0] = cond ? 0x10000L : 0;
2205	args++;
2206	}
2207	break;
2208
2209	case cff_op_eq:
2210	{
2211	FT_Fixed cond = !args[0];
2212
2213
2214	FT_TRACE4(( " eq\n" ));
2215
2216	args[0] = cond ? 0x10000L : 0;
2217	args++;
2218	}
2219	break;
2220
2221	case cff_op_ifelse:
2222	{
2223	FT_Fixed cond = ( args[2] <= args[3] );
2224
2225
2226	FT_TRACE4(( " ifelse\n" ));
2227
2228	if ( !cond )
2229	args[0] = args[1];
2230	args++;
2231	}
2232	break;
2233
2234	case cff_op_callsubr:
2235	{
2236	FT_UInt idx = (FT_UInt)( ( args[0] >> 16 ) +
2237	decoder->locals_bias );
2238
2239
2240	FT_TRACE4(( " callsubr(%d)\n", idx ));
2241
2242	if ( idx >= decoder->num_locals )
2243	{
2244	FT_ERROR(( "cff_decoder_parse_charstrings:" ));
2245	FT_ERROR(( " invalid local subr index\n" ));
2246	goto Syntax_Error;
2247	}
2248
2249	if ( zone - decoder->zones >= CFF_MAX_SUBRS_CALLS )
2250	{
2251	FT_ERROR(( "cff_decoder_parse_charstrings:"
2252	" too many nested subrs\n" ));
2253	goto Syntax_Error;
2254	}
2255
2256	zone->cursor = ip; /* save current instruction pointer */
2257
2258	zone++;
2259	zone->base = decoder->locals[idx];
2260	zone->limit = decoder->locals[idx + 1];
2261	zone->cursor = zone->base;
2262
2263	if ( !zone->base \|\| zone->limit == zone->base )
2264	{
2265	FT_ERROR(( "cff_decoder_parse_charstrings:"
2266	" invoking empty subrs!\n" ));
2267	goto Syntax_Error;
2268	}
2269
2270	decoder->zone = zone;
2271	ip = zone->base;
2272	limit = zone->limit;
2273	}
2274	break;
2275
2276	case cff_op_callgsubr:
2277	{
2278	FT_UInt idx = (FT_UInt)( ( args[0] >> 16 ) +
2279	decoder->globals_bias );
2280
2281
2282	FT_TRACE4(( " callgsubr(%d)\n", idx ));
2283
2284	if ( idx >= decoder->num_globals )
2285	{
2286	FT_ERROR(( "cff_decoder_parse_charstrings:" ));
2287	FT_ERROR(( " invalid global subr index\n" ));
2288	goto Syntax_Error;
2289	}
2290
2291	if ( zone - decoder->zones >= CFF_MAX_SUBRS_CALLS )
2292	{
2293	FT_ERROR(( "cff_decoder_parse_charstrings:"
2294	" too many nested subrs\n" ));
2295	goto Syntax_Error;
2296	}
2297
2298	zone->cursor = ip; /* save current instruction pointer */
2299
2300	zone++;
2301	zone->base = decoder->globals[idx];
2302	zone->limit = decoder->globals[idx + 1];
2303	zone->cursor = zone->base;
2304
2305	if ( !zone->base \|\| zone->limit == zone->base )
2306	{
2307	FT_ERROR(( "cff_decoder_parse_charstrings:"
2308	" invoking empty subrs!\n" ));
2309	goto Syntax_Error;
2310	}
2311
2312	decoder->zone = zone;
2313	ip = zone->base;
2314	limit = zone->limit;
2315	}
2316	break;
2317
2318	case cff_op_return:
2319	FT_TRACE4(( " return\n" ));
2320
2321	if ( decoder->zone <= decoder->zones )
2322	{
2323	FT_ERROR(( "cff_decoder_parse_charstrings:"
2324	" unexpected return\n" ));
2325	goto Syntax_Error;
2326	}
2327
2328	decoder->zone--;
2329	zone = decoder->zone;
2330	ip = zone->cursor;
2331	limit = zone->limit;
2332	break;
2333
2334	default:
2335	Unimplemented:
2336	FT_ERROR(( "Unimplemented opcode: %d", ip[-1] ));
2337
2338	if ( ip[-1] == 12 )
2339	FT_ERROR(( " %d", ip[0] ));
2340	FT_ERROR(( "\n" ));
2341
2342	return CFF_Err_Unimplemented_Feature;
2343	}
2344
2345	decoder->top = args;
2346
2347	} /* general operator processing */
2348
2349	} /* while ip < limit */
2350
2351	FT_TRACE4(( "..end..\n\n" ));
2352
2353	Fail:
2354	return error;
2355
2356	Syntax_Error:
2357	FT_TRACE4(( "cff_decoder_parse_charstrings: syntax error!\n" ));
2358	return CFF_Err_Invalid_File_Format;
2359
2360	Stack_Underflow:
2361	FT_TRACE4(( "cff_decoder_parse_charstrings: stack underflow!\n" ));
2362	return CFF_Err_Too_Few_Arguments;
2363
2364	Stack_Overflow:
2365	FT_TRACE4(( "cff_decoder_parse_charstrings: stack overflow!\n" ));
2366	return CFF_Err_Stack_Overflow;
2367	}
2368
2369
2370	/*************************************************************************/
2371	/*************************************************************************/
2372	/*************************************************************************/
2373	/******** *******/
2374	/******** *******/
2375	/******** COMPUTE THE MAXIMUM ADVANCE WIDTH *******/
2376	/******** *******/
2377	/******** The following code is in charge of computing *******/
2378	/******** the maximum advance width of the font. It *******/
2379	/******** quickly processes each glyph charstring to *******/
2380	/******** extract the value from either a `sbw' or `seac' *******/
2381	/******** operator. *******/
2382	/******** *******/
2383	/*************************************************************************/
2384	/*************************************************************************/
2385	/*************************************************************************/
2386
2387
2388	#if 0 /* unused until we support pure CFF fonts */
2389
2390
2391	FT_LOCAL_DEF( FT_Error )
2392	cff_compute_max_advance( TT_Face face,
2393	FT_Int* max_advance )
2394	{
2395	FT_Error error = CFF_Err_Ok;
2396	CFF_Decoder decoder;
2397	FT_Int glyph_index;
2398	CFF_Font cff = (CFF_Font)face->other;
2399
2400
2401	*max_advance = 0;
2402
2403	/* Initialize load decoder */
2404	cff_decoder_init( &decoder, face, 0, 0, 0, 0 );
2405
2406	decoder.builder.metrics_only = 1;
2407	decoder.builder.load_points = 0;
2408
2409	/* For each glyph, parse the glyph charstring and extract */
2410	/* the advance width. */
2411	for ( glyph_index = 0; glyph_index < face->root.num_glyphs;
2412	glyph_index++ )
2413	{
2414	FT_Byte* charstring;
2415	FT_ULong charstring_len;
2416
2417
2418	/* now get load the unscaled outline */
2419	error = cff_get_glyph_data( face, glyph_index,
2420	&charstring, &charstring_len );
2421	if ( !error )
2422	{
2423	error = cff_decoder_prepare( &decoder, size, glyph_index );
2424	if ( !error )
2425	error = cff_decoder_parse_charstrings( &decoder,
2426	charstring,
2427	charstring_len );
2428
2429	cff_free_glyph_data( face, &charstring, &charstring_len );
2430	}
2431
2432	/* ignore the error if one has occurred -- skip to next glyph */
2433	error = CFF_Err_Ok;
2434	}
2435
2436	*max_advance = decoder.builder.advance.x;
2437
2438	return CFF_Err_Ok;
2439	}
2440
2441
2442	#endif /* 0 */
2443
2444
2445	FT_LOCAL_DEF( FT_Error )
2446	cff_slot_load( CFF_GlyphSlot glyph,
2447	CFF_Size size,
2448	FT_UInt glyph_index,
2449	FT_Int32 load_flags )
2450	{
2451	FT_Error error;
2452	CFF_Decoder decoder;
2453	TT_Face face = (TT_Face)glyph->root.face;
2454	FT_Bool hinting, force_scaling;
2455	CFF_Font cff = (CFF_Font)face->extra.data;
2456
2457	FT_Matrix font_matrix;
2458	FT_Vector font_offset;
2459
2460
2461	force_scaling = FALSE;
2462
2463	/* in a CID-keyed font, consider `glyph_index' as a CID and map */
2464	/* it immediately to the real glyph_index -- if it isn't a */
2465	/* subsetted font, glyph_indices and CIDs are identical, though */
2466	if ( cff->top_font.font_dict.cid_registry != 0xFFFFU &&
2467	cff->charset.cids )
2468	{
2469	/* don't handle CID 0 (.notdef) which is directly mapped to GID 0 */
2470	if ( glyph_index != 0 )
2471	{
2472	glyph_index = cff_charset_cid_to_gindex( &cff->charset,
2473	glyph_index );
2474	if ( glyph_index == 0 )
2475	return CFF_Err_Invalid_Argument;
2476	}
2477	}
2478	else if ( glyph_index >= cff->num_glyphs )
2479	return CFF_Err_Invalid_Argument;
2480
2481	if ( load_flags & FT_LOAD_NO_RECURSE )
2482	load_flags \|= FT_LOAD_NO_SCALE \| FT_LOAD_NO_HINTING;
2483
2484	glyph->x_scale = 0x10000L;
2485	glyph->y_scale = 0x10000L;
2486	if ( size )
2487	{
2488	glyph->x_scale = size->root.metrics.x_scale;
2489	glyph->y_scale = size->root.metrics.y_scale;
2490	}
2491
2492	#ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
2493
2494	/* try to load embedded bitmap if any */
2495	/* */
2496	/* XXX: The convention should be emphasized in */
2497	/* the documents because it can be confusing. */
2498	if ( size )
2499	{
2500	CFF_Face cff_face = (CFF_Face)size->root.face;
2501	SFNT_Service sfnt = (SFNT_Service)cff_face->sfnt;
2502	FT_Stream stream = cff_face->root.stream;
2503
2504
2505	if ( size->strike_index != 0xFFFFFFFFUL &&
2506	sfnt->load_eblc &&
2507	( load_flags & FT_LOAD_NO_BITMAP ) == 0 )
2508	{
2509	TT_SBit_MetricsRec metrics;
2510
2511
2512	error = sfnt->load_sbit_image( face,
2513	size->strike_index,
2514	glyph_index,
2515	(FT_Int)load_flags,
2516	stream,
2517	&glyph->root.bitmap,
2518	&metrics );
2519
2520	if ( !error )
2521	{
2522	glyph->root.outline.n_points = 0;
2523	glyph->root.outline.n_contours = 0;
2524
2525	glyph->root.metrics.width = (FT_Pos)metrics.width << 6;
2526	glyph->root.metrics.height = (FT_Pos)metrics.height << 6;
2527
2528	glyph->root.metrics.horiBearingX = (FT_Pos)metrics.horiBearingX << 6;
2529	glyph->root.metrics.horiBearingY = (FT_Pos)metrics.horiBearingY << 6;
2530	glyph->root.metrics.horiAdvance = (FT_Pos)metrics.horiAdvance << 6;
2531
2532	glyph->root.metrics.vertBearingX = (FT_Pos)metrics.vertBearingX << 6;
2533	glyph->root.metrics.vertBearingY = (FT_Pos)metrics.vertBearingY << 6;
2534	glyph->root.metrics.vertAdvance = (FT_Pos)metrics.vertAdvance << 6;
2535
2536	glyph->root.format = FT_GLYPH_FORMAT_BITMAP;
2537
2538	if ( load_flags & FT_LOAD_VERTICAL_LAYOUT )
2539	{
2540	glyph->root.bitmap_left = metrics.vertBearingX;
2541	glyph->root.bitmap_top = metrics.vertBearingY;
2542	}
2543	else
2544	{
2545	glyph->root.bitmap_left = metrics.horiBearingX;
2546	glyph->root.bitmap_top = metrics.horiBearingY;
2547	}
2548	return error;
2549	}
2550	}
2551	}
2552
2553	#endif /* TT_CONFIG_OPTION_EMBEDDED_BITMAPS */
2554
2555	/* return immediately if we only want the embedded bitmaps */
2556	if ( load_flags & FT_LOAD_SBITS_ONLY )
2557	return CFF_Err_Invalid_Argument;
2558
2559	/* if we have a CID subfont, use its matrix (which has already */
2560	/* been multiplied with the root matrix) */
2561
2562	/* this scaling is only relevant if the PS hinter isn't active */
2563	if ( cff->num_subfonts )
2564	{
2565	FT_Byte fd_index = cff_fd_select_get( &cff->fd_select,
2566	glyph_index );
2567
2568	FT_Int top_upm = cff->top_font.font_dict.units_per_em;
2569	FT_Int sub_upm = cff->subfonts[fd_index]->font_dict.units_per_em;
2570
2571
2572	font_matrix = cff->subfonts[fd_index]->font_dict.font_matrix;
2573	font_offset = cff->subfonts[fd_index]->font_dict.font_offset;
2574
2575	if ( top_upm != sub_upm )
2576	{
2577	glyph->x_scale = FT_MulDiv( glyph->x_scale, top_upm, sub_upm );
2578	glyph->y_scale = FT_MulDiv( glyph->y_scale, top_upm, sub_upm );
2579
2580	force_scaling = TRUE;
2581	}
2582	}
2583	else
2584	{
2585	font_matrix = cff->top_font.font_dict.font_matrix;
2586	font_offset = cff->top_font.font_dict.font_offset;
2587	}
2588
2589	glyph->root.outline.n_points = 0;
2590	glyph->root.outline.n_contours = 0;
2591
2592	hinting = FT_BOOL( ( load_flags & FT_LOAD_NO_SCALE ) == 0 &&
2593	( load_flags & FT_LOAD_NO_HINTING ) == 0 );
2594
2595	glyph->root.format = FT_GLYPH_FORMAT_OUTLINE; /* by default */
2596
2597	{
2598	FT_Byte* charstring;
2599	FT_ULong charstring_len;
2600
2601
2602	cff_decoder_init( &decoder, face, size, glyph, hinting,
2603	FT_LOAD_TARGET_MODE( load_flags ) );
2604
2605	if ( load_flags & FT_LOAD_ADVANCE_ONLY )
2606	decoder.width_only = TRUE;
2607
2608	decoder.builder.no_recurse =
2609	(FT_Bool)( load_flags & FT_LOAD_NO_RECURSE );
2610
2611	/* now load the unscaled outline */
2612	error = cff_get_glyph_data( face, glyph_index,
2613	&charstring, &charstring_len );
2614	if ( !error )
2615	{
2616	error = cff_decoder_prepare( &decoder, size, glyph_index );
2617	if ( !error )
2618	{
2619	error = cff_decoder_parse_charstrings( &decoder,
2620	charstring,
2621	charstring_len );
2622
2623	cff_free_glyph_data( face, &charstring, charstring_len );
2624
2625
2626	#ifdef FT_CONFIG_OPTION_INCREMENTAL
2627	/* Control data and length may not be available for incremental */
2628	/* fonts. */
2629	if ( face->root.internal->incremental_interface )
2630	{
2631	glyph->root.control_data = 0;
2632	glyph->root.control_len = 0;
2633	}
2634	else
2635	#endif /* FT_CONFIG_OPTION_INCREMENTAL */
2636
2637	/* We set control_data and control_len if charstrings is loaded. */
2638	/* See how charstring loads at cff_index_access_element() in */
2639	/* cffload.c. */
2640	{
2641	CFF_Index csindex = &cff->charstrings_index;
2642
2643
2644	if ( csindex->offsets )
2645	{
2646	glyph->root.control_data = csindex->bytes +
2647	csindex->offsets[glyph_index] - 1;
2648	glyph->root.control_len = charstring_len;
2649	}
2650	}
2651	}
2652	}
2653
2654	/* save new glyph tables */
2655	cff_builder_done( &decoder.builder );
2656	}
2657
2658	#ifdef FT_CONFIG_OPTION_INCREMENTAL
2659
2660	/* Incremental fonts can optionally override the metrics. */
2661	if ( !error &&
2662	face->root.internal->incremental_interface &&
2663	face->root.internal->incremental_interface->funcs->get_glyph_metrics )
2664	{
2665	FT_Incremental_MetricsRec metrics;
2666
2667
2668	metrics.bearing_x = decoder.builder.left_bearing.x;
2669	metrics.bearing_y = decoder.builder.left_bearing.y;
2670	metrics.advance = decoder.builder.advance.x;
2671	error = face->root.internal->incremental_interface->funcs->get_glyph_metrics(
2672	face->root.internal->incremental_interface->object,
2673	glyph_index, FALSE, &metrics );
2674	decoder.builder.left_bearing.x = metrics.bearing_x;
2675	decoder.builder.left_bearing.y = metrics.bearing_y;
2676	decoder.builder.advance.x = metrics.advance;
2677	decoder.builder.advance.y = 0;
2678	}
2679
2680	#endif /* FT_CONFIG_OPTION_INCREMENTAL */
2681
2682	if ( !error )
2683	{
2684	/* Now, set the metrics -- this is rather simple, as */
2685	/* the left side bearing is the xMin, and the top side */
2686	/* bearing the yMax. */
2687
2688	/* For composite glyphs, return only left side bearing and */
2689	/* advance width. */
2690	if ( load_flags & FT_LOAD_NO_RECURSE )
2691	{
2692	FT_Slot_Internal internal = glyph->root.internal;
2693
2694
2695	glyph->root.metrics.horiBearingX = decoder.builder.left_bearing.x;
2696	glyph->root.metrics.horiAdvance = decoder.glyph_width;
2697	internal->glyph_matrix = font_matrix;
2698	internal->glyph_delta = font_offset;
2699	internal->glyph_transformed = 1;
2700	}
2701	else
2702	{
2703	FT_BBox cbox;
2704	FT_Glyph_Metrics* metrics = &glyph->root.metrics;
2705	FT_Vector advance;
2706	FT_Bool has_vertical_info;
2707
2708
2709	/* copy the _unscaled_ advance width */
2710	metrics->horiAdvance = decoder.glyph_width;
2711	glyph->root.linearHoriAdvance = decoder.glyph_width;
2712	glyph->root.internal->glyph_transformed = 0;
2713
2714	has_vertical_info = FT_BOOL( face->vertical_info &&
2715	face->vertical.number_Of_VMetrics > 0 &&
2716	face->vertical.long_metrics );
2717
2718	/* get the vertical metrics from the vtmx table if we have one */
2719	if ( has_vertical_info )
2720	{
2721	FT_Short vertBearingY = 0;
2722	FT_UShort vertAdvance = 0;
2723
2724
2725	( (SFNT_Service)face->sfnt )->get_metrics( face, 1,
2726	glyph_index,
2727	&vertBearingY,
2728	&vertAdvance );
2729	metrics->vertBearingY = vertBearingY;
2730	metrics->vertAdvance = vertAdvance;
2731	}
2732	else
2733	{
2734	/* make up vertical ones */
2735	if ( face->os2.version != 0xFFFFU )
2736	metrics->vertAdvance = (FT_Pos)( face->os2.sTypoAscender -
2737	face->os2.sTypoDescender );
2738	else
2739	metrics->vertAdvance = (FT_Pos)( face->horizontal.Ascender -
2740	face->horizontal.Descender );
2741	}
2742
2743	glyph->root.linearVertAdvance = metrics->vertAdvance;
2744
2745	glyph->root.format = FT_GLYPH_FORMAT_OUTLINE;
2746
2747	glyph->root.outline.flags = 0;
2748	if ( size && size->root.metrics.y_ppem < 24 )
2749	glyph->root.outline.flags \|= FT_OUTLINE_HIGH_PRECISION;
2750
2751	glyph->root.outline.flags \|= FT_OUTLINE_REVERSE_FILL;
2752
2753	/* apply the font matrix -- `xx' has already been normalized */
2754	if ( !( font_matrix.yy == 0x10000L &&
2755	font_matrix.xy == 0 &&
2756	font_matrix.yx == 0 ) )
2757	FT_Outline_Transform( &glyph->root.outline, &font_matrix );
2758
2759	if ( !( font_offset.x == 0 &&
2760	font_offset.y == 0 ) )
2761	FT_Outline_Translate( &glyph->root.outline,
2762	font_offset.x, font_offset.y );
2763
2764	advance.x = metrics->horiAdvance;
2765	advance.y = 0;
2766	FT_Vector_Transform( &advance, &font_matrix );
2767	metrics->horiAdvance = advance.x + font_offset.x;
2768
2769	advance.x = 0;
2770	advance.y = metrics->vertAdvance;
2771	FT_Vector_Transform( &advance, &font_matrix );
2772	metrics->vertAdvance = advance.y + font_offset.y;
2773
2774	if ( ( load_flags & FT_LOAD_NO_SCALE ) == 0 \|\| force_scaling )
2775	{
2776	/* scale the outline and the metrics */
2777	FT_Int n;
2778	FT_Outline* cur = &glyph->root.outline;
2779	FT_Vector* vec = cur->points;
2780	FT_Fixed x_scale = glyph->x_scale;
2781	FT_Fixed y_scale = glyph->y_scale;
2782
2783
2784	/* First of all, scale the points */
2785	if ( !hinting \|\| !decoder.builder.hints_funcs )
2786	for ( n = cur->n_points; n > 0; n--, vec++ )
2787	{
2788	vec->x = FT_MulFix( vec->x, x_scale );
2789	vec->y = FT_MulFix( vec->y, y_scale );
2790	}
2791
2792	/* Then scale the metrics */
2793	metrics->horiAdvance = FT_MulFix( metrics->horiAdvance, x_scale );
2794	metrics->vertAdvance = FT_MulFix( metrics->vertAdvance, y_scale );
2795	}
2796
2797	/* compute the other metrics */
2798	FT_Outline_Get_CBox( &glyph->root.outline, &cbox );
2799
2800	metrics->width = cbox.xMax - cbox.xMin;
2801	metrics->height = cbox.yMax - cbox.yMin;
2802
2803	metrics->horiBearingX = cbox.xMin;
2804	metrics->horiBearingY = cbox.yMax;
2805
2806	if ( has_vertical_info )
2807	metrics->vertBearingX = -metrics->width / 2;
2808	else
2809	ft_synthesize_vertical_metrics( metrics,
2810	metrics->vertAdvance );
2811	}
2812	}
2813
2814	return error;
2815	}
2816
2817
2818	/* END */

Note: See TracBrowser for help on using the repository browser.

Download in other formats: