w32tex
About: TeX Live provides a comprehensive TeX system including all the major TeX-related programs, macro packages, and fonts that are free software. Windows sources.
  Fossies Dox: w32tex-src.tar.xz  ("unofficial" and yet experimental doxygen-generated source code documentation)  

ttpload.c
Go to the documentation of this file.
1 /****************************************************************************
2  *
3  * ttpload.c
4  *
5  * TrueType-specific tables loader (body).
6  *
7  * Copyright (C) 1996-2020 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 <freetype/internal/ftdebug.h>
20 #include <freetype/internal/ftobjs.h>
21 #include <freetype/internal/ftstream.h>
22 #include <freetype/tttags.h>
23 
24 #include "ttpload.h"
25 
26 #ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
27 #include "ttgxvar.h"
28 #endif
29 
30 #include "tterrors.h"
31 
32 
33  /**************************************************************************
34  *
35  * The macro FT_COMPONENT is used in trace mode. It is an implicit
36  * parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log
37  * messages during execution.
38  */
39 #undef FT_COMPONENT
40 #define FT_COMPONENT ttpload
41 
42 
43  /**************************************************************************
44  *
45  * @Function:
46  * tt_face_load_loca
47  *
48  * @Description:
49  * Load the locations table.
50  *
51  * @InOut:
52  * face ::
53  * A handle to the target face object.
54  *
55  * @Input:
56  * stream ::
57  * The input stream.
58  *
59  * @Return:
60  * FreeType error code. 0 means success.
61  */
65  {
67  FT_ULong table_len;
68  FT_Int shift;
69 
70 
71  /* we need the size of the `glyf' table for malformed `loca' tables */
72  error = face->goto_table( face, TTAG_glyf, stream, &face->glyf_len );
73 
74  /* it is possible that a font doesn't have a glyf table at all */
75  /* or its size is zero */
76  if ( FT_ERR_EQ( error, Table_Missing ) )
77  {
78  face->glyf_len = 0;
79  face->glyf_offset = 0;
80  }
81  else if ( error )
82  goto Exit;
83  else
84  {
85 #ifdef FT_CONFIG_OPTION_INCREMENTAL
86  if ( face->root.internal->incremental_interface )
87  face->glyf_offset = 0;
88  else
89 #endif
90  face->glyf_offset = FT_STREAM_POS();
91  }
92 
93  FT_TRACE2(( "Locations " ));
94  error = face->goto_table( face, TTAG_loca, stream, &table_len );
95  if ( error )
96  {
97  error = FT_THROW( Locations_Missing );
98  goto Exit;
99  }
100 
101  if ( face->header.Index_To_Loc_Format != 0 )
102  {
103  shift = 2;
104 
105  if ( table_len >= 0x40000L )
106  {
107  FT_TRACE2(( "table too large\n" ));
108  table_len = 0x3FFFFL;
109  }
110  face->num_locations = table_len >> shift;
111  }
112  else
113  {
114  shift = 1;
115 
116  if ( table_len >= 0x20000L )
117  {
118  FT_TRACE2(( "table too large\n" ));
119  table_len = 0x1FFFFL;
120  }
121  face->num_locations = table_len >> shift;
122  }
123 
124  if ( face->num_locations != (FT_ULong)face->root.num_glyphs + 1 )
125  {
126  FT_TRACE2(( "glyph count mismatch! loca: %ld, maxp: %ld\n",
127  face->num_locations - 1, face->root.num_glyphs ));
128 
129  /* we only handle the case where `maxp' gives a larger value */
130  if ( face->num_locations <= (FT_ULong)face->root.num_glyphs )
131  {
132  FT_ULong new_loca_len =
133  ( (FT_ULong)face->root.num_glyphs + 1 ) << shift;
134 
135  TT_Table entry = face->dir_tables;
136  TT_Table limit = entry + face->num_tables;
137 
139  FT_Long dist = 0x7FFFFFFFL;
140  FT_Bool found = 0;
141 
142 
143  /* compute the distance to next table in font file */
144  for ( ; entry < limit; entry++ )
145  {
146  FT_Long diff = (FT_Long)entry->Offset - pos;
147 
148 
149  if ( diff > 0 && diff < dist )
150  {
151  dist = diff;
152  found = 1;
153  }
154  }
155 
156  if ( !found )
157  {
158  /* `loca' is the last table */
159  dist = (FT_Long)stream->size - pos;
160  }
161 
162  if ( new_loca_len <= (FT_ULong)dist )
163  {
164  face->num_locations = (FT_ULong)face->root.num_glyphs + 1;
165  table_len = new_loca_len;
166 
167  FT_TRACE2(( "adjusting num_locations to %ld\n",
168  face->num_locations ));
169  }
170  else
171  {
172  face->root.num_glyphs = face->num_locations
173  ? (FT_Long)face->num_locations - 1 : 0;
174 
175  FT_TRACE2(( "adjusting num_glyphs to %ld\n",
176  face->root.num_glyphs ));
177  }
178  }
179  }
180 
181  /*
182  * Extract the frame. We don't need to decompress it since
183  * we are able to parse it directly.
184  */
185  if ( FT_FRAME_EXTRACT( table_len, face->glyph_locations ) )
186  goto Exit;
187 
188  FT_TRACE2(( "loaded\n" ));
189 
190  Exit:
191  return error;
192  }
193 
194 
197  FT_UInt gindex,
198  FT_UInt *asize )
199  {
200  FT_ULong pos1, pos2;
201  FT_Byte* p;
202  FT_Byte* p_limit;
203 
204 
205  pos1 = pos2 = 0;
206 
207  if ( gindex < face->num_locations )
208  {
209  if ( face->header.Index_To_Loc_Format != 0 )
210  {
211  p = face->glyph_locations + gindex * 4;
212  p_limit = face->glyph_locations + face->num_locations * 4;
213 
214  pos1 = FT_NEXT_ULONG( p );
215  pos2 = pos1;
216 
217  if ( p + 4 <= p_limit )
218  pos2 = FT_NEXT_ULONG( p );
219  }
220  else
221  {
222  p = face->glyph_locations + gindex * 2;
223  p_limit = face->glyph_locations + face->num_locations * 2;
224 
225  pos1 = FT_NEXT_USHORT( p );
226  pos2 = pos1;
227 
228  if ( p + 2 <= p_limit )
229  pos2 = FT_NEXT_USHORT( p );
230 
231  pos1 <<= 1;
232  pos2 <<= 1;
233  }
234  }
235 
236  /* Check broken location data. */
237  if ( pos1 > face->glyf_len )
238  {
239  FT_TRACE1(( "tt_face_get_location:"
240  " too large offset (0x%08lx) found for glyph index %d,\n"
241  " "
242  " exceeding the end of `glyf' table (0x%08lx)\n",
243  pos1, gindex, face->glyf_len ));
244  *asize = 0;
245  return 0;
246  }
247 
248  if ( pos2 > face->glyf_len )
249  {
250  /* We try to sanitize the last `loca' entry. */
251  if ( gindex == face->num_locations - 2 )
252  {
253  FT_TRACE1(( "tt_face_get_location:"
254  " too large size (%ld bytes) found for glyph index %d,\n"
255  " "
256  " truncating at the end of `glyf' table to %ld bytes\n",
257  pos2 - pos1, gindex, face->glyf_len - pos1 ));
258  pos2 = face->glyf_len;
259  }
260  else
261  {
262  FT_TRACE1(( "tt_face_get_location:"
263  " too large offset (0x%08lx) found for glyph index %d,\n"
264  " "
265  " exceeding the end of `glyf' table (0x%08lx)\n",
266  pos2, gindex + 1, face->glyf_len ));
267  *asize = 0;
268  return 0;
269  }
270  }
271 
272  /* The `loca' table must be ordered; it refers to the length of */
273  /* an entry as the difference between the current and the next */
274  /* position. However, there do exist (malformed) fonts which */
275  /* don't obey this rule, so we are only able to provide an */
276  /* upper bound for the size. */
277  /* */
278  /* We get (intentionally) a wrong, non-zero result in case the */
279  /* `glyf' table is missing. */
280  if ( pos2 >= pos1 )
281  *asize = (FT_UInt)( pos2 - pos1 );
282  else
283  *asize = (FT_UInt)( face->glyf_len - pos1 );
284 
285  return pos1;
286  }
287 
288 
289  FT_LOCAL_DEF( void )
291  {
292  FT_Stream stream = face->root.stream;
293 
294 
295  FT_FRAME_RELEASE( face->glyph_locations );
296  face->num_locations = 0;
297  }
298 
299 
300 
301  /**************************************************************************
302  *
303  * @Function:
304  * tt_face_load_cvt
305  *
306  * @Description:
307  * Load the control value table into a face object.
308  *
309  * @InOut:
310  * face ::
311  * A handle to the target face object.
312  *
313  * @Input:
314  * stream ::
315  * A handle to the input stream.
316  *
317  * @Return:
318  * FreeType error code. 0 means success.
319  */
322  FT_Stream stream )
323  {
324 #ifdef TT_USE_BYTECODE_INTERPRETER
325 
326  FT_Error error;
327  FT_Memory memory = stream->memory;
328  FT_ULong table_len;
329 
330 
331  FT_TRACE2(( "CVT " ));
332 
333  error = face->goto_table( face, TTAG_cvt, stream, &table_len );
334  if ( error )
335  {
336  FT_TRACE2(( "is missing\n" ));
337 
338  face->cvt_size = 0;
339  face->cvt = NULL;
340  error = FT_Err_Ok;
341 
342  goto Exit;
343  }
344 
345  face->cvt_size = table_len / 2;
346 
347  if ( FT_NEW_ARRAY( face->cvt, face->cvt_size ) )
348  goto Exit;
349 
350  if ( FT_FRAME_ENTER( face->cvt_size * 2L ) )
351  goto Exit;
352 
353  {
354  FT_Int32* cur = face->cvt;
355  FT_Int32* limit = cur + face->cvt_size;
356 
357 
358  for ( ; cur < limit; cur++ )
359  *cur = FT_GET_SHORT() * 64;
360  }
361 
362  FT_FRAME_EXIT();
363  FT_TRACE2(( "loaded\n" ));
364 
365 #ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
366  if ( face->doblend )
367  error = tt_face_vary_cvt( face, stream );
368 #endif
369 
370  Exit:
371  return error;
372 
373 #else /* !TT_USE_BYTECODE_INTERPRETER */
374 
375  FT_UNUSED( face );
376  FT_UNUSED( stream );
377 
378  return FT_Err_Ok;
379 
380 #endif
381  }
382 
383 
384  /**************************************************************************
385  *
386  * @Function:
387  * tt_face_load_fpgm
388  *
389  * @Description:
390  * Load the font program.
391  *
392  * @InOut:
393  * face ::
394  * A handle to the target face object.
395  *
396  * @Input:
397  * stream ::
398  * A handle to the input stream.
399  *
400  * @Return:
401  * FreeType error code. 0 means success.
402  */
405  FT_Stream stream )
406  {
407 #ifdef TT_USE_BYTECODE_INTERPRETER
408 
409  FT_Error error;
410  FT_ULong table_len;
411 
412 
413  FT_TRACE2(( "Font program " ));
414 
415  /* The font program is optional */
416  error = face->goto_table( face, TTAG_fpgm, stream, &table_len );
417  if ( error )
418  {
419  face->font_program = NULL;
420  face->font_program_size = 0;
421  error = FT_Err_Ok;
422 
423  FT_TRACE2(( "is missing\n" ));
424  }
425  else
426  {
427  face->font_program_size = table_len;
428  if ( FT_FRAME_EXTRACT( table_len, face->font_program ) )
429  goto Exit;
430 
431  FT_TRACE2(( "loaded, %12ld bytes\n", face->font_program_size ));
432  }
433 
434  Exit:
435  return error;
436 
437 #else /* !TT_USE_BYTECODE_INTERPRETER */
438 
439  FT_UNUSED( face );
440  FT_UNUSED( stream );
441 
442  return FT_Err_Ok;
443 
444 #endif
445  }
446 
447 
448  /**************************************************************************
449  *
450  * @Function:
451  * tt_face_load_prep
452  *
453  * @Description:
454  * Load the cvt program.
455  *
456  * @InOut:
457  * face ::
458  * A handle to the target face object.
459  *
460  * @Input:
461  * stream ::
462  * A handle to the input stream.
463  *
464  * @Return:
465  * FreeType error code. 0 means success.
466  */
469  FT_Stream stream )
470  {
471 #ifdef TT_USE_BYTECODE_INTERPRETER
472 
473  FT_Error error;
474  FT_ULong table_len;
475 
476 
477  FT_TRACE2(( "Prep program " ));
478 
479  error = face->goto_table( face, TTAG_prep, stream, &table_len );
480  if ( error )
481  {
482  face->cvt_program = NULL;
483  face->cvt_program_size = 0;
484  error = FT_Err_Ok;
485 
486  FT_TRACE2(( "is missing\n" ));
487  }
488  else
489  {
490  face->cvt_program_size = table_len;
491  if ( FT_FRAME_EXTRACT( table_len, face->cvt_program ) )
492  goto Exit;
493 
494  FT_TRACE2(( "loaded, %12ld bytes\n", face->cvt_program_size ));
495  }
496 
497  Exit:
498  return error;
499 
500 #else /* !TT_USE_BYTECODE_INTERPRETER */
501 
502  FT_UNUSED( face );
503  FT_UNUSED( stream );
504 
505  return FT_Err_Ok;
506 
507 #endif
508  }
509 
510 
511  /**************************************************************************
512  *
513  * @Function:
514  * tt_face_load_hdmx
515  *
516  * @Description:
517  * Load the `hdmx' table into the face object.
518  *
519  * @Input:
520  * face ::
521  * A handle to the target face object.
522  *
523  * stream ::
524  * A handle to the input stream.
525  *
526  * @Return:
527  * FreeType error code. 0 means success.
528  */
529 
532  FT_Stream stream )
533  {
534  FT_Error error;
535  FT_Memory memory = stream->memory;
536  FT_UInt nn, num_records;
537  FT_ULong table_size, record_size;
538  FT_Byte* p;
539  FT_Byte* limit;
540 
541 
542  /* this table is optional */
543  error = face->goto_table( face, TTAG_hdmx, stream, &table_size );
544  if ( error || table_size < 8 )
545  return FT_Err_Ok;
546 
547  if ( FT_FRAME_EXTRACT( table_size, face->hdmx_table ) )
548  goto Exit;
549 
550  p = face->hdmx_table;
551  limit = p + table_size;
552 
553  /* Given that `hdmx' tables are losing its importance (for example, */
554  /* variation fonts introduced in OpenType 1.8 must not have this */
555  /* table) we no longer test for a correct `version' field. */
556  p += 2;
557  num_records = FT_NEXT_USHORT( p );
558  record_size = FT_NEXT_ULONG( p );
559 
560  /* The maximum number of bytes in an hdmx device record is the */
561  /* maximum number of glyphs + 2; this is 0xFFFF + 2, thus */
562  /* explaining why `record_size' is a long (which we read as */
563  /* unsigned long for convenience). In practice, two bytes are */
564  /* sufficient to hold the size value. */
565  /* */
566  /* There are at least two fonts, HANNOM-A and HANNOM-B version */
567  /* 2.0 (2005), which get this wrong: The upper two bytes of */
568  /* the size value are set to 0xFF instead of 0x00. We catch */
569  /* and fix this. */
570 
571  if ( record_size >= 0xFFFF0000UL )
572  record_size &= 0xFFFFU;
573 
574  /* The limit for `num_records' is a heuristic value. */
575  if ( num_records > 255 ||
576  ( num_records > 0 &&
577  ( record_size > 0x10001L ||
578  record_size < 4 ) ) )
579  {
580  error = FT_THROW( Invalid_File_Format );
581  goto Fail;
582  }
583 
584  if ( FT_NEW_ARRAY( face->hdmx_record_sizes, num_records ) )
585  goto Fail;
586 
587  for ( nn = 0; nn < num_records; nn++ )
588  {
589  if ( p + record_size > limit )
590  break;
591 
592  face->hdmx_record_sizes[nn] = p[0];
593  p += record_size;
594  }
595 
596  face->hdmx_record_count = nn;
597  face->hdmx_table_size = table_size;
598  face->hdmx_record_size = record_size;
599 
600  Exit:
601  return error;
602 
603  Fail:
604  FT_FRAME_RELEASE( face->hdmx_table );
605  face->hdmx_table_size = 0;
606  goto Exit;
607  }
608 
609 
610  FT_LOCAL_DEF( void )
612  {
613  FT_Stream stream = face->root.stream;
614  FT_Memory memory = stream->memory;
615 
616 
617  FT_FREE( face->hdmx_record_sizes );
618  FT_FRAME_RELEASE( face->hdmx_table );
619  }
620 
621 
622  /**************************************************************************
623  *
624  * Return the advance width table for a given pixel size if it is found
625  * in the font's `hdmx' table (if any).
626  */
629  FT_UInt ppem,
630  FT_UInt gindex )
631  {
632  FT_UInt nn;
633  FT_Byte* result = NULL;
634  FT_ULong record_size = face->hdmx_record_size;
635  FT_Byte* record = FT_OFFSET( face->hdmx_table, 8 );
636 
637 
638  for ( nn = 0; nn < face->hdmx_record_count; nn++ )
639  if ( face->hdmx_record_sizes[nn] == ppem )
640  {
641  gindex += 2;
642  if ( gindex < record_size )
643  result = record + nn * record_size + gindex;
644  break;
645  }
646 
647  return result;
648  }
649 
650 
651 /* END */
static char * dist
Definition: aptex-src.c:59
static point_t cur
Definition: backend_eps.c:108
short pos1(char c, char *s)
Definition: cfuncs.c:30
#define error(a)
Definition: dviinfo.c:48
void Exit(int code)
Definition: dvispc.c:374
#define shift
Definition: exp3.c:154
#define FT_UNUSED(arg)
typedefFT_BEGIN_HEADER struct FT_MemoryRec_ * FT_Memory
Definition: ftsystem.h:64
FT_BEGIN_HEADER typedef unsigned char FT_Bool
Definition: fttypes.h:108
unsigned long FT_ULong
Definition: fttypes.h:253
unsigned char FT_Byte
Definition: fttypes.h:154
#define FT_ERR_EQ(x, e)
Definition: fttypes.h:604
int FT_Error
Definition: fttypes.h:299
signed long FT_Long
Definition: fttypes.h:242
unsigned int FT_UInt
Definition: fttypes.h:231
signed int FT_Int
Definition: fttypes.h:220
#define FT_LOCAL_DEF(x)
#define FT_THROW(e)
Definition: ftdebug.h:243
#define FT_TRACE2(varformat)
Definition: ftdebug.h:189
#define FT_TRACE1(varformat)
Definition: ftdebug.h:188
#define FT_NEW_ARRAY(ptr, count)
Definition: ftmemory.h:341
#define FT_FREE(ptr)
Definition: ftmemory.h:337
#define FT_OFFSET(base, count)
Definition: ftmemory.h:66
#define NULL
Definition: ftobjs.h:61
#define FT_FRAME_ENTER(size)
Definition: ftstream.h:548
#define FT_FRAME_RELEASE(bytes)
Definition: ftstream.h:562
#define FT_NEXT_USHORT(buffer)
Definition: ftstream.h:244
#define FT_STREAM_POS()
Definition: ftstream.h:522
#define FT_GET_SHORT()
Definition: ftstream.h:310
#define FT_FRAME_EXIT()
Definition: ftstream.h:553
#define FT_FRAME_EXTRACT(size, bytes)
Definition: ftstream.h:556
#define FT_NEXT_ULONG(buffer)
Definition: ftstream.h:256
#define TTAG_hdmx
Definition: tttags.h:67
#define TTAG_prep
Definition: tttags.h:93
#define TTAG_cvt
Definition: tttags.h:51
#define TTAG_glyf
Definition: tttags.h:62
#define TTAG_fpgm
Definition: tttags.h:58
#define TTAG_loca
Definition: tttags.h:75
small capitals from c petite p
Definition: afcover.h:72
return FT_Err_Ok
Definition: ftbbox.c:526
FT_Face face
Definition: cffdrivr.c:659
tt_face_load_prep(TT_Face face, FT_Stream stream)
Definition: ttpload.c:468
tt_face_load_cvt(TT_Face face, FT_Stream stream)
Definition: ttpload.c:321
tt_face_free_hdmx(TT_Face face)
Definition: ttpload.c:611
tt_face_get_device_metrics(TT_Face face, FT_UInt ppem, FT_UInt gindex)
Definition: ttpload.c:628
tt_face_load_fpgm(TT_Face face, FT_Stream stream)
Definition: ttpload.c:404
tt_face_load_hdmx(TT_Face face, FT_Stream stream)
Definition: ttpload.c:531
tt_face_done_loca(TT_Face face)
Definition: ttpload.c:290
tt_face_load_loca(TT_Face face, FT_Stream stream)
Definition: ttpload.c:63
tt_face_get_location(TT_Face face, FT_UInt gindex, FT_UInt *asize)
Definition: ttpload.c:196
pdf_obj * entry
Definition: pdfdoc.c:64
const int * pos
Definition: combiners.h:905
set set set set set set set macro pixldst1 abits if abits op else op endif endm macro pixldst2 abits if abits op else op endif endm macro pixldst4 abits if abits op else op endif endm macro pixldst0 abits op endm macro pixldst3 mem_operand op endm macro pixldst30 mem_operand op endm macro pixldst abits if abits elseif abits elseif abits elseif abits elseif abits pixldst0 abits else pixldst0 abits pixldst0 abits pixldst0 abits pixldst0 abits endif elseif abits else pixldst0 abits pixldst0 abits endif elseif abits else error unsupported bpp *numpix else pixst endif endm macro pixld1_s mem_operand if asr adds SRC_WIDTH_FIXED bpl add asl mov asr adds SRC_WIDTH_FIXED bpl add asl mov asr adds SRC_WIDTH_FIXED bpl add asl mov asr adds SRC_WIDTH_FIXED bpl add asl elseif asr adds SRC_WIDTH_FIXED bpl add asl mov asr adds SRC_WIDTH_FIXED bpl add asl else error unsupported endif endm macro pixld2_s mem_operand if mov asr add asl add asl mov asr sub UNIT_X add asl mov asr add asl add asl mov asr add UNIT_X add asl else pixld1_s mem_operand pixld1_s mem_operand endif endm macro pixld0_s mem_operand if asr adds SRC_WIDTH_FIXED bpl add asl elseif asr adds SRC_WIDTH_FIXED bpl add asl endif endm macro pixld_s_internal mem_operand if mem_operand pixld2_s mem_operand pixdeinterleave basereg elseif mem_operand elseif mem_operand elseif mem_operand elseif mem_operand pixld0_s mem_operand else pixld0_s mem_operand pixld0_s mem_operand pixld0_s mem_operand pixld0_s mem_operand endif elseif mem_operand else pixld0_s mem_operand pixld0_s mem_operand endif elseif mem_operand else error unsupported mem_operand if bpp mem_operand endif endm macro vuzp8 reg2 vuzp d d &reg2 endm macro vzip8 reg2 vzip d d &reg2 endm macro pixdeinterleave basereg basereg basereg basereg basereg endif endm macro pixinterleave basereg basereg basereg basereg basereg endif endm macro PF boost_increment endif if endif PF tst PF addne PF subne PF cmp ORIG_W if endif if endif if endif PF subge ORIG_W PF subges if endif if endif if endif endif endm macro cache_preload_simple endif if dst_r_bpp pld[DST_R, #(PREFETCH_DISTANCE_SIMPLE *dst_r_bpp/8)] endif if mask_bpp pld if[MASK, #(PREFETCH_DISTANCE_SIMPLE *mask_bpp/8)] endif endif endm macro fetch_mask_pixblock pixld mask_basereg pixblock_size MASK endm macro ensure_destination_ptr_alignment process_pixblock_tail_head if beq irp skip1(dst_w_bpp<=(lowbit *8)) &&((lowbit *8)<(pixblock_size *dst_w_bpp)) .if lowbit< 16 tst DST_R
integer nn[24]
Definition: pmxab.c:90
struct stream_s stream
Definition: pts_fax.h:93
FT_Long num_glyphs
Definition: freetype.h:1036
FT_Stream stream
Definition: freetype.h:1073
FT_Face_Internal internal
Definition: freetype.h:1080
FT_Memory memory
Definition: ftsystem.h:338
int diff
Definition: tex4ht.c:3815
found
Definition: tex4ht.c:5000
int ppem
Definition: ttflib.c:39
#define limit(x)
Definition: yuvsplittoppm.c:26