ReactOS  0.4.14-dev-554-g2f8d847
psobjs.c
Go to the documentation of this file.
1 /***************************************************************************/
2 /* */
3 /* psobjs.c */
4 /* */
5 /* Auxiliary functions for PostScript fonts (body). */
6 /* */
7 /* Copyright 1996-2018 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_POSTSCRIPT_AUX_H
21 #include FT_INTERNAL_DEBUG_H
22 #include FT_INTERNAL_CALC_H
23 #include FT_DRIVER_H
24 
25 #include "psobjs.h"
26 #include "psconv.h"
27 
28 #include "psauxerr.h"
29 #include "psauxmod.h"
30 
31 
32  /*************************************************************************/
33  /* */
34  /* The macro FT_COMPONENT is used in trace mode. It is an implicit */
35  /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
36  /* messages during execution. */
37  /* */
38 #undef FT_COMPONENT
39 #define FT_COMPONENT trace_psobjs
40 
41 
42  /*************************************************************************/
43  /*************************************************************************/
44  /***** *****/
45  /***** PS_TABLE *****/
46  /***** *****/
47  /*************************************************************************/
48  /*************************************************************************/
49 
50  /*************************************************************************/
51  /* */
52  /* <Function> */
53  /* ps_table_new */
54  /* */
55  /* <Description> */
56  /* Initializes a PS_Table. */
57  /* */
58  /* <InOut> */
59  /* table :: The address of the target table. */
60  /* */
61  /* <Input> */
62  /* count :: The table size = the maximum number of elements. */
63  /* */
64  /* memory :: The memory object to use for all subsequent */
65  /* reallocations. */
66  /* */
67  /* <Return> */
68  /* FreeType error code. 0 means success. */
69  /* */
72  FT_Int count,
74  {
76 
77 
78  table->memory = memory;
79  if ( FT_NEW_ARRAY( table->elements, count ) ||
80  FT_NEW_ARRAY( table->lengths, count ) )
81  goto Exit;
82 
83  table->max_elems = count;
84  table->init = 0xDEADBEEFUL;
85  table->num_elems = 0;
86  table->block = NULL;
87  table->capacity = 0;
88  table->cursor = 0;
89 
91 
92  Exit:
93  if ( error )
94  FT_FREE( table->elements );
95 
96  return error;
97  }
98 
99 
100  static void
102  FT_Byte* old_base )
103  {
104  FT_PtrDist delta = table->block - old_base;
105  FT_Byte** offset = table->elements;
106  FT_Byte** limit = offset + table->max_elems;
107 
108 
109  for ( ; offset < limit; offset++ )
110  {
111  if ( offset[0] )
112  offset[0] += delta;
113  }
114  }
115 
116 
117  static FT_Error
119  FT_Offset new_size )
120  {
121  FT_Memory memory = table->memory;
122  FT_Byte* old_base = table->block;
123  FT_Error error;
124 
125 
126  /* allocate new base block */
127  if ( FT_ALLOC( table->block, new_size ) )
128  {
129  table->block = old_base;
130  return error;
131  }
132 
133  /* copy elements and shift offsets */
134  if ( old_base )
135  {
136  FT_MEM_COPY( table->block, old_base, table->capacity );
137  shift_elements( table, old_base );
138  FT_FREE( old_base );
139  }
140 
141  table->capacity = new_size;
142 
143  return FT_Err_Ok;
144  }
145 
146 
147  /*************************************************************************/
148  /* */
149  /* <Function> */
150  /* ps_table_add */
151  /* */
152  /* <Description> */
153  /* Adds an object to a PS_Table, possibly growing its memory block. */
154  /* */
155  /* <InOut> */
156  /* table :: The target table. */
157  /* */
158  /* <Input> */
159  /* idx :: The index of the object in the table. */
160  /* */
161  /* object :: The address of the object to copy in memory. */
162  /* */
163  /* length :: The length in bytes of the source object. */
164  /* */
165  /* <Return> */
166  /* FreeType error code. 0 means success. An error is returned if a */
167  /* reallocation fails. */
168  /* */
171  FT_Int idx,
172  void* object,
173  FT_UInt length )
174  {
175  if ( idx < 0 || idx >= table->max_elems )
176  {
177  FT_ERROR(( "ps_table_add: invalid index\n" ));
178  return FT_THROW( Invalid_Argument );
179  }
180 
181  /* grow the base block if needed */
182  if ( table->cursor + length > table->capacity )
183  {
184  FT_Error error;
185  FT_Offset new_size = table->capacity;
186  FT_PtrDist in_offset;
187 
188 
189  in_offset = (FT_Byte*)object - table->block;
190  if ( in_offset < 0 || (FT_Offset)in_offset >= table->capacity )
191  in_offset = -1;
192 
193  while ( new_size < table->cursor + length )
194  {
195  /* increase size by 25% and round up to the nearest multiple
196  of 1024 */
197  new_size += ( new_size >> 2 ) + 1;
198  new_size = FT_PAD_CEIL( new_size, 1024 );
199  }
200 
201  error = reallocate_t1_table( table, new_size );
202  if ( error )
203  return error;
204 
205  if ( in_offset >= 0 )
206  object = table->block + in_offset;
207  }
208 
209  /* add the object to the base block and adjust offset */
210  table->elements[idx] = table->block + table->cursor;
211  table->lengths [idx] = length;
212  FT_MEM_COPY( table->block + table->cursor, object, length );
213 
214  table->cursor += length;
215  return FT_Err_Ok;
216  }
217 
218 
219  /*************************************************************************/
220  /* */
221  /* <Function> */
222  /* ps_table_done */
223  /* */
224  /* <Description> */
225  /* Finalizes a PS_TableRec (i.e., reallocate it to its current */
226  /* cursor). */
227  /* */
228  /* <InOut> */
229  /* table :: The target table. */
230  /* */
231  /* <Note> */
232  /* This function does NOT release the heap's memory block. It is up */
233  /* to the caller to clean it, or reference it in its own structures. */
234  /* */
235  FT_LOCAL_DEF( void )
237  {
238  FT_Memory memory = table->memory;
239  FT_Error error;
240  FT_Byte* old_base = table->block;
241 
242 
243  /* should never fail, because rec.cursor <= rec.size */
244  if ( !old_base )
245  return;
246 
247  if ( FT_ALLOC( table->block, table->cursor ) )
248  return;
249  FT_MEM_COPY( table->block, old_base, table->cursor );
250  shift_elements( table, old_base );
251 
252  table->capacity = table->cursor;
253  FT_FREE( old_base );
254 
255  FT_UNUSED( error );
256  }
257 
258 
259  FT_LOCAL_DEF( void )
261  {
262  FT_Memory memory = table->memory;
263 
264 
265  if ( (FT_ULong)table->init == 0xDEADBEEFUL )
266  {
267  FT_FREE( table->block );
268  FT_FREE( table->elements );
269  FT_FREE( table->lengths );
270  table->init = 0;
271  }
272  }
273 
274 
275  /*************************************************************************/
276  /*************************************************************************/
277  /***** *****/
278  /***** T1 PARSER *****/
279  /***** *****/
280  /*************************************************************************/
281  /*************************************************************************/
282 
283 
284  /* first character must be already part of the comment */
285 
286  static void
288  FT_Byte* limit )
289  {
290  FT_Byte* cur = *acur;
291 
292 
293  while ( cur < limit )
294  {
295  if ( IS_PS_NEWLINE( *cur ) )
296  break;
297  cur++;
298  }
299 
300  *acur = cur;
301  }
302 
303 
304  static void
306  FT_Byte* limit )
307  {
308  FT_Byte* cur = *acur;
309 
310 
311  while ( cur < limit )
312  {
313  if ( !IS_PS_SPACE( *cur ) )
314  {
315  if ( *cur == '%' )
316  /* According to the PLRM, a comment is equal to a space. */
317  skip_comment( &cur, limit );
318  else
319  break;
320  }
321  cur++;
322  }
323 
324  *acur = cur;
325  }
326 
327 
328 #define IS_OCTAL_DIGIT( c ) ( '0' <= (c) && (c) <= '7' )
329 
330 
331  /* first character must be `('; */
332  /* *acur is positioned at the character after the closing `)' */
333 
334  static FT_Error
336  FT_Byte* limit )
337  {
338  FT_Byte* cur = *acur;
339  FT_Int embed = 0;
340  FT_Error error = FT_ERR( Invalid_File_Format );
341  unsigned int i;
342 
343 
344  while ( cur < limit )
345  {
346  FT_Byte c = *cur;
347 
348 
349  cur++;
350 
351  if ( c == '\\' )
352  {
353  /* Red Book 3rd ed., section `Literal Text Strings', p. 29: */
354  /* A backslash can introduce three different types */
355  /* of escape sequences: */
356  /* - a special escaped char like \r, \n, etc. */
357  /* - a one-, two-, or three-digit octal number */
358  /* - none of the above in which case the backslash is ignored */
359 
360  if ( cur == limit )
361  /* error (or to be ignored?) */
362  break;
363 
364  switch ( *cur )
365  {
366  /* skip `special' escape */
367  case 'n':
368  case 'r':
369  case 't':
370  case 'b':
371  case 'f':
372  case '\\':
373  case '(':
374  case ')':
375  cur++;
376  break;
377 
378  default:
379  /* skip octal escape or ignore backslash */
380  for ( i = 0; i < 3 && cur < limit; i++ )
381  {
382  if ( !IS_OCTAL_DIGIT( *cur ) )
383  break;
384 
385  cur++;
386  }
387  }
388  }
389  else if ( c == '(' )
390  embed++;
391  else if ( c == ')' )
392  {
393  embed--;
394  if ( embed == 0 )
395  {
396  error = FT_Err_Ok;
397  break;
398  }
399  }
400  }
401 
402  *acur = cur;
403 
404  return error;
405  }
406 
407 
408  /* first character must be `<' */
409 
410  static FT_Error
412  FT_Byte* limit )
413  {
414  FT_Byte* cur = *acur;
416 
417 
418  while ( ++cur < limit )
419  {
420  /* All whitespace characters are ignored. */
421  skip_spaces( &cur, limit );
422  if ( cur >= limit )
423  break;
424 
425  if ( !IS_PS_XDIGIT( *cur ) )
426  break;
427  }
428 
429  if ( cur < limit && *cur != '>' )
430  {
431  FT_ERROR(( "skip_string: missing closing delimiter `>'\n" ));
432  err = FT_THROW( Invalid_File_Format );
433  }
434  else
435  cur++;
436 
437  *acur = cur;
438  return err;
439  }
440 
441 
442  /* first character must be the opening brace that */
443  /* starts the procedure */
444 
445  /* NB: [ and ] need not match: */
446  /* `/foo {[} def' is a valid PostScript fragment, */
447  /* even within a Type1 font */
448 
449  static FT_Error
450  skip_procedure( FT_Byte* *acur,
451  FT_Byte* limit )
452  {
453  FT_Byte* cur;
454  FT_Int embed = 0;
455  FT_Error error = FT_Err_Ok;
456 
457 
458  FT_ASSERT( **acur == '{' );
459 
460  for ( cur = *acur; cur < limit && error == FT_Err_Ok; cur++ )
461  {
462  switch ( *cur )
463  {
464  case '{':
465  embed++;
466  break;
467 
468  case '}':
469  embed--;
470  if ( embed == 0 )
471  {
472  cur++;
473  goto end;
474  }
475  break;
476 
477  case '(':
478  error = skip_literal_string( &cur, limit );
479  break;
480 
481  case '<':
482  error = skip_string( &cur, limit );
483  break;
484 
485  case '%':
486  skip_comment( &cur, limit );
487  break;
488  }
489  }
490 
491  end:
492  if ( embed != 0 )
493  error = FT_THROW( Invalid_File_Format );
494 
495  *acur = cur;
496 
497  return error;
498  }
499 
500 
501  /***********************************************************************/
502  /* */
503  /* All exported parsing routines handle leading whitespace and stop at */
504  /* the first character which isn't part of the just handled token. */
505  /* */
506  /***********************************************************************/
507 
508 
509  FT_LOCAL_DEF( void )
510  ps_parser_skip_PS_token( PS_Parser parser )
511  {
512  /* Note: PostScript allows any non-delimiting, non-whitespace */
513  /* character in a name (PS Ref Manual, 3rd ed, p31). */
514  /* PostScript delimiters are (, ), <, >, [, ], {, }, /, and %. */
515 
516  FT_Byte* cur = parser->cursor;
517  FT_Byte* limit = parser->limit;
518  FT_Error error = FT_Err_Ok;
519 
520 
521  skip_spaces( &cur, limit ); /* this also skips comments */
522  if ( cur >= limit )
523  goto Exit;
524 
525  /* self-delimiting, single-character tokens */
526  if ( *cur == '[' || *cur == ']' )
527  {
528  cur++;
529  goto Exit;
530  }
531 
532  /* skip balanced expressions (procedures and strings) */
533 
534  if ( *cur == '{' ) /* {...} */
535  {
536  error = skip_procedure( &cur, limit );
537  goto Exit;
538  }
539 
540  if ( *cur == '(' ) /* (...) */
541  {
542  error = skip_literal_string( &cur, limit );
543  goto Exit;
544  }
545 
546  if ( *cur == '<' ) /* <...> */
547  {
548  if ( cur + 1 < limit && *(cur + 1) == '<' ) /* << */
549  {
550  cur++;
551  cur++;
552  }
553  else
554  error = skip_string( &cur, limit );
555 
556  goto Exit;
557  }
558 
559  if ( *cur == '>' )
560  {
561  cur++;
562  if ( cur >= limit || *cur != '>' ) /* >> */
563  {
564  FT_ERROR(( "ps_parser_skip_PS_token:"
565  " unexpected closing delimiter `>'\n" ));
566  error = FT_THROW( Invalid_File_Format );
567  goto Exit;
568  }
569  cur++;
570  goto Exit;
571  }
572 
573  if ( *cur == '/' )
574  cur++;
575 
576  /* anything else */
577  while ( cur < limit )
578  {
579  /* *cur might be invalid (e.g., ')' or '}'), but this */
580  /* is handled by the test `cur == parser->cursor' below */
581  if ( IS_PS_DELIM( *cur ) )
582  break;
583 
584  cur++;
585  }
586 
587  Exit:
588  if ( cur < limit && cur == parser->cursor )
589  {
590  FT_ERROR(( "ps_parser_skip_PS_token:"
591  " current token is `%c' which is self-delimiting\n"
592  " "
593  " but invalid at this point\n",
594  *cur ));
595 
596  error = FT_THROW( Invalid_File_Format );
597  }
598 
599  if ( cur > limit )
600  cur = limit;
601 
602  parser->error = error;
603  parser->cursor = cur;
604  }
605 
606 
607  FT_LOCAL_DEF( void )
609  {
610  skip_spaces( &parser->cursor, parser->limit );
611  }
612 
613 
614  /* `token' here means either something between balanced delimiters */
615  /* or the next token; the delimiters are not removed. */
616 
617  FT_LOCAL_DEF( void )
619  T1_Token token )
620  {
621  FT_Byte* cur;
622  FT_Byte* limit;
623  FT_Int embed;
624 
625 
626  token->type = T1_TOKEN_TYPE_NONE;
627  token->start = NULL;
628  token->limit = NULL;
629 
630  /* first of all, skip leading whitespace */
632 
633  cur = parser->cursor;
634  limit = parser->limit;
635 
636  if ( cur >= limit )
637  return;
638 
639  switch ( *cur )
640  {
641  /************* check for literal string *****************/
642  case '(':
643  token->type = T1_TOKEN_TYPE_STRING;
644  token->start = cur;
645 
646  if ( skip_literal_string( &cur, limit ) == FT_Err_Ok )
647  token->limit = cur;
648  break;
649 
650  /************* check for programs/array *****************/
651  case '{':
652  token->type = T1_TOKEN_TYPE_ARRAY;
653  token->start = cur;
654 
655  if ( skip_procedure( &cur, limit ) == FT_Err_Ok )
656  token->limit = cur;
657  break;
658 
659  /************* check for table/array ********************/
660  /* XXX: in theory we should also look for "<<" */
661  /* since this is semantically equivalent to "["; */
662  /* in practice it doesn't matter (?) */
663  case '[':
664  token->type = T1_TOKEN_TYPE_ARRAY;
665  embed = 1;
666  token->start = cur++;
667 
668  /* we need this to catch `[ ]' */
669  parser->cursor = cur;
671  cur = parser->cursor;
672 
673  while ( cur < limit && !parser->error )
674  {
675  /* XXX: this is wrong because it does not */
676  /* skip comments, procedures, and strings */
677  if ( *cur == '[' )
678  embed++;
679  else if ( *cur == ']' )
680  {
681  embed--;
682  if ( embed <= 0 )
683  {
684  token->limit = ++cur;
685  break;
686  }
687  }
688 
689  parser->cursor = cur;
691  /* we need this to catch `[XXX ]' */
693  cur = parser->cursor;
694  }
695  break;
696 
697  /* ************ otherwise, it is any token **************/
698  default:
699  token->start = cur;
700  token->type = ( *cur == '/' ) ? T1_TOKEN_TYPE_KEY : T1_TOKEN_TYPE_ANY;
702  cur = parser->cursor;
703  if ( !parser->error )
704  token->limit = cur;
705  }
706 
707  if ( !token->limit )
708  {
709  token->start = NULL;
710  token->type = T1_TOKEN_TYPE_NONE;
711  }
712 
713  parser->cursor = cur;
714  }
715 
716 
717  /* NB: `tokens' can be NULL if we only want to count */
718  /* the number of array elements */
719 
720  FT_LOCAL_DEF( void )
722  T1_Token tokens,
723  FT_UInt max_tokens,
724  FT_Int* pnum_tokens )
725  {
726  T1_TokenRec master;
727 
728 
729  *pnum_tokens = -1;
730 
731  /* this also handles leading whitespace */
732  ps_parser_to_token( parser, &master );
733 
734  if ( master.type == T1_TOKEN_TYPE_ARRAY )
735  {
736  FT_Byte* old_cursor = parser->cursor;
737  FT_Byte* old_limit = parser->limit;
738  T1_Token cur = tokens;
739  T1_Token limit = cur + max_tokens;
740 
741 
742  /* don't include outermost delimiters */
743  parser->cursor = master.start + 1;
744  parser->limit = master.limit - 1;
745 
746  while ( parser->cursor < parser->limit )
747  {
749 
750 
752  if ( !token.type )
753  break;
754 
755  if ( tokens && cur < limit )
756  *cur = token;
757 
758  cur++;
759  }
760 
761  *pnum_tokens = (FT_Int)( cur - tokens );
762 
763  parser->cursor = old_cursor;
764  parser->limit = old_limit;
765  }
766  }
767 
768 
769  /* first character must be a delimiter or a part of a number */
770  /* NB: `coords' can be NULL if we just want to skip the */
771  /* array; in this case we ignore `max_coords' */
772 
773  static FT_Int
775  FT_Byte* limit,
776  FT_Int max_coords,
777  FT_Short* coords )
778  {
779  FT_Byte* cur = *acur;
780  FT_Int count = 0;
781  FT_Byte c, ender;
782 
783 
784  if ( cur >= limit )
785  goto Exit;
786 
787  /* check for the beginning of an array; otherwise, only one number */
788  /* will be read */
789  c = *cur;
790  ender = 0;
791 
792  if ( c == '[' )
793  ender = ']';
794  else if ( c == '{' )
795  ender = '}';
796 
797  if ( ender )
798  cur++;
799 
800  /* now, read the coordinates */
801  while ( cur < limit )
802  {
803  FT_Short dummy;
804  FT_Byte* old_cur;
805 
806 
807  /* skip whitespace in front of data */
808  skip_spaces( &cur, limit );
809  if ( cur >= limit )
810  goto Exit;
811 
812  if ( *cur == ender )
813  {
814  cur++;
815  break;
816  }
817 
818  old_cur = cur;
819 
820  if ( coords && count >= max_coords )
821  break;
822 
823  /* call PS_Conv_ToFixed() even if coords == NULL */
824  /* to properly parse number at `cur' */
825  *( coords ? &coords[count] : &dummy ) =
826  (FT_Short)( PS_Conv_ToFixed( &cur, limit, 0 ) >> 16 );
827 
828  if ( old_cur == cur )
829  {
830  count = -1;
831  goto Exit;
832  }
833  else
834  count++;
835 
836  if ( !ender )
837  break;
838  }
839 
840  Exit:
841  *acur = cur;
842  return count;
843  }
844 
845 
846  /* first character must be a delimiter or a part of a number */
847  /* NB: `values' can be NULL if we just want to skip the */
848  /* array; in this case we ignore `max_values' */
849  /* */
850  /* return number of successfully parsed values */
851 
852  static FT_Int
854  FT_Byte* limit,
855  FT_Int max_values,
856  FT_Fixed* values,
857  FT_Int power_ten )
858  {
859  FT_Byte* cur = *acur;
860  FT_Int count = 0;
861  FT_Byte c, ender;
862 
863 
864  if ( cur >= limit )
865  goto Exit;
866 
867  /* Check for the beginning of an array. Otherwise, only one number */
868  /* will be read. */
869  c = *cur;
870  ender = 0;
871 
872  if ( c == '[' )
873  ender = ']';
874  else if ( c == '{' )
875  ender = '}';
876 
877  if ( ender )
878  cur++;
879 
880  /* now, read the values */
881  while ( cur < limit )
882  {
883  FT_Fixed dummy;
884  FT_Byte* old_cur;
885 
886 
887  /* skip whitespace in front of data */
888  skip_spaces( &cur, limit );
889  if ( cur >= limit )
890  goto Exit;
891 
892  if ( *cur == ender )
893  {
894  cur++;
895  break;
896  }
897 
898  old_cur = cur;
899 
900  if ( values && count >= max_values )
901  break;
902 
903  /* call PS_Conv_ToFixed() even if coords == NULL */
904  /* to properly parse number at `cur' */
905  *( values ? &values[count] : &dummy ) =
906  PS_Conv_ToFixed( &cur, limit, power_ten );
907 
908  if ( old_cur == cur )
909  {
910  count = -1;
911  goto Exit;
912  }
913  else
914  count++;
915 
916  if ( !ender )
917  break;
918  }
919 
920  Exit:
921  *acur = cur;
922  return count;
923  }
924 
925 
926 #if 0
927 
928  static FT_String*
929  ps_tostring( FT_Byte** cursor,
930  FT_Byte* limit,
931  FT_Memory memory )
932  {
933  FT_Byte* cur = *cursor;
934  FT_UInt len = 0;
935  FT_Int count;
936  FT_String* result;
937  FT_Error error;
938 
939 
940  /* XXX: some stupid fonts have a `Notice' or `Copyright' string */
941  /* that simply doesn't begin with an opening parenthesis, even */
942  /* though they have a closing one! E.g. "amuncial.pfb" */
943  /* */
944  /* We must deal with these ill-fated cases there. Note that */
945  /* these fonts didn't work with the old Type 1 driver as the */
946  /* notice/copyright was not recognized as a valid string token */
947  /* and made the old token parser commit errors. */
948 
949  while ( cur < limit && ( *cur == ' ' || *cur == '\t' ) )
950  cur++;
951  if ( cur + 1 >= limit )
952  return 0;
953 
954  if ( *cur == '(' )
955  cur++; /* skip the opening parenthesis, if there is one */
956 
957  *cursor = cur;
958  count = 0;
959 
960  /* then, count its length */
961  for ( ; cur < limit; cur++ )
962  {
963  if ( *cur == '(' )
964  count++;
965 
966  else if ( *cur == ')' )
967  {
968  count--;
969  if ( count < 0 )
970  break;
971  }
972  }
973 
974  len = (FT_UInt)( cur - *cursor );
975  if ( cur >= limit || FT_ALLOC( result, len + 1 ) )
976  return 0;
977 
978  /* now copy the string */
980  result[len] = '\0';
981  *cursor = cur;
982  return result;
983  }
984 
985 #endif /* 0 */
986 
987 
988  static int
990  FT_Byte* limit )
991  {
992  FT_Byte* cur = *acur;
993  FT_Bool result = 0;
994 
995 
996  /* return 1 if we find `true', 0 otherwise */
997  if ( cur + 3 < limit &&
998  cur[0] == 't' &&
999  cur[1] == 'r' &&
1000  cur[2] == 'u' &&
1001  cur[3] == 'e' )
1002  {
1003  result = 1;
1004  cur += 5;
1005  }
1006  else if ( cur + 4 < limit &&
1007  cur[0] == 'f' &&
1008  cur[1] == 'a' &&
1009  cur[2] == 'l' &&
1010  cur[3] == 's' &&
1011  cur[4] == 'e' )
1012  {
1013  result = 0;
1014  cur += 6;
1015  }
1016 
1017  *acur = cur;
1018  return result;
1019  }
1020 
1021 
1022  /* load a simple field (i.e. non-table) into the current list of objects */
1023 
1027  void** objects,
1028  FT_UInt max_objects,
1029  FT_ULong* pflags )
1030  {
1032  FT_Byte* cur;
1033  FT_Byte* limit;
1034  FT_UInt count;
1035  FT_UInt idx;
1036  FT_Error error;
1038 
1039 
1040  /* this also skips leading whitespace */
1042  if ( !token.type )
1043  goto Fail;
1044 
1045  count = 1;
1046  idx = 0;
1047  cur = token.start;
1048  limit = token.limit;
1049 
1050  type = field->type;
1051 
1052  /* we must detect arrays in /FontBBox */
1053  if ( type == T1_FIELD_TYPE_BBOX )
1054  {
1055  T1_TokenRec token2;
1056  FT_Byte* old_cur = parser->cursor;
1057  FT_Byte* old_limit = parser->limit;
1058 
1059 
1060  /* don't include delimiters */
1061  parser->cursor = token.start + 1;
1062  parser->limit = token.limit - 1;
1063 
1064  ps_parser_to_token( parser, &token2 );
1065  parser->cursor = old_cur;
1066  parser->limit = old_limit;
1067 
1068  if ( token2.type == T1_TOKEN_TYPE_ARRAY )
1069  {
1071  goto FieldArray;
1072  }
1073  }
1074  else if ( token.type == T1_TOKEN_TYPE_ARRAY )
1075  {
1076  count = max_objects;
1077 
1078  FieldArray:
1079  /* if this is an array and we have no blend, an error occurs */
1080  if ( max_objects == 0 )
1081  goto Fail;
1082 
1083  idx = 1;
1084 
1085  /* don't include delimiters */
1086  cur++;
1087  limit--;
1088  }
1089 
1090  for ( ; count > 0; count--, idx++ )
1091  {
1092  FT_Byte* q = (FT_Byte*)objects[idx] + field->offset;
1093  FT_Long val;
1094  FT_String* string = NULL;
1095 
1096 
1097  skip_spaces( &cur, limit );
1098 
1099  switch ( type )
1100  {
1101  case T1_FIELD_TYPE_BOOL:
1102  val = ps_tobool( &cur, limit );
1103  goto Store_Integer;
1104 
1105  case T1_FIELD_TYPE_FIXED:
1106  val = PS_Conv_ToFixed( &cur, limit, 0 );
1107  goto Store_Integer;
1108 
1110  val = PS_Conv_ToFixed( &cur, limit, 3 );
1111  goto Store_Integer;
1112 
1113  case T1_FIELD_TYPE_INTEGER:
1114  val = PS_Conv_ToInt( &cur, limit );
1115  /* fall through */
1116 
1117  Store_Integer:
1118  switch ( field->size )
1119  {
1120  case (8 / FT_CHAR_BIT):
1121  *(FT_Byte*)q = (FT_Byte)val;
1122  break;
1123 
1124  case (16 / FT_CHAR_BIT):
1125  *(FT_UShort*)q = (FT_UShort)val;
1126  break;
1127 
1128  case (32 / FT_CHAR_BIT):
1129  *(FT_UInt32*)q = (FT_UInt32)val;
1130  break;
1131 
1132  default: /* for 64-bit systems */
1133  *(FT_Long*)q = val;
1134  }
1135  break;
1136 
1137  case T1_FIELD_TYPE_STRING:
1138  case T1_FIELD_TYPE_KEY:
1139  {
1140  FT_Memory memory = parser->memory;
1141  FT_UInt len = (FT_UInt)( limit - cur );
1142 
1143 
1144  if ( cur >= limit )
1145  break;
1146 
1147  /* we allow both a string or a name */
1148  /* for cases like /FontName (foo) def */
1149  if ( token.type == T1_TOKEN_TYPE_KEY )
1150  {
1151  /* don't include leading `/' */
1152  len--;
1153  cur++;
1154  }
1155  else if ( token.type == T1_TOKEN_TYPE_STRING )
1156  {
1157  /* don't include delimiting parentheses */
1158  /* XXX we don't handle <<...>> here */
1159  /* XXX should we convert octal escapes? */
1160  /* if so, what encoding should we use? */
1161  cur++;
1162  len -= 2;
1163  }
1164  else
1165  {
1166  FT_ERROR(( "ps_parser_load_field:"
1167  " expected a name or string\n"
1168  " "
1169  " but found token of type %d instead\n",
1170  token.type ));
1171  error = FT_THROW( Invalid_File_Format );
1172  goto Exit;
1173  }
1174 
1175  /* for this to work (FT_String**)q must have been */
1176  /* initialized to NULL */
1177  if ( *(FT_String**)q )
1178  {
1179  FT_TRACE0(( "ps_parser_load_field: overwriting field %s\n",
1180  field->ident ));
1181  FT_FREE( *(FT_String**)q );
1182  *(FT_String**)q = NULL;
1183  }
1184 
1185  if ( FT_ALLOC( string, len + 1 ) )
1186  goto Exit;
1187 
1188  FT_MEM_COPY( string, cur, len );
1189  string[len] = 0;
1190 
1191  *(FT_String**)q = string;
1192  }
1193  break;
1194 
1195  case T1_FIELD_TYPE_BBOX:
1196  {
1197  FT_Fixed temp[4];
1198  FT_BBox* bbox = (FT_BBox*)q;
1199  FT_Int result;
1200 
1201 
1202  result = ps_tofixedarray( &cur, limit, 4, temp, 0 );
1203 
1204  if ( result < 4 )
1205  {
1206  FT_ERROR(( "ps_parser_load_field:"
1207  " expected four integers in bounding box\n" ));
1208  error = FT_THROW( Invalid_File_Format );
1209  goto Exit;
1210  }
1211 
1212  bbox->xMin = FT_RoundFix( temp[0] );
1213  bbox->yMin = FT_RoundFix( temp[1] );
1214  bbox->xMax = FT_RoundFix( temp[2] );
1215  bbox->yMax = FT_RoundFix( temp[3] );
1216  }
1217  break;
1218 
1219  case T1_FIELD_TYPE_MM_BBOX:
1220  {
1221  FT_Memory memory = parser->memory;
1222  FT_Fixed* temp = NULL;
1223  FT_Int result;
1224  FT_UInt i;
1225 
1226 
1227  if ( FT_NEW_ARRAY( temp, max_objects * 4 ) )
1228  goto Exit;
1229 
1230  for ( i = 0; i < 4; i++ )
1231  {
1232  result = ps_tofixedarray( &cur, limit, (FT_Int)max_objects,
1233  temp + i * max_objects, 0 );
1234  if ( result < 0 || (FT_UInt)result < max_objects )
1235  {
1236  FT_ERROR(( "ps_parser_load_field:"
1237  " expected %d integer%s in the %s subarray\n"
1238  " "
1239  " of /FontBBox in the /Blend dictionary\n",
1240  max_objects, max_objects > 1 ? "s" : "",
1241  i == 0 ? "first"
1242  : ( i == 1 ? "second"
1243  : ( i == 2 ? "third"
1244  : "fourth" ) ) ));
1245  error = FT_THROW( Invalid_File_Format );
1246 
1247  FT_FREE( temp );
1248  goto Exit;
1249  }
1250 
1251  skip_spaces( &cur, limit );
1252  }
1253 
1254  for ( i = 0; i < max_objects; i++ )
1255  {
1256  FT_BBox* bbox = (FT_BBox*)objects[i];
1257 
1258 
1259  bbox->xMin = FT_RoundFix( temp[i ] );
1260  bbox->yMin = FT_RoundFix( temp[i + max_objects] );
1261  bbox->xMax = FT_RoundFix( temp[i + 2 * max_objects] );
1262  bbox->yMax = FT_RoundFix( temp[i + 3 * max_objects] );
1263  }
1264 
1265  FT_FREE( temp );
1266  }
1267  break;
1268 
1269  default:
1270  /* an error occurred */
1271  goto Fail;
1272  }
1273  }
1274 
1275 #if 0 /* obsolete -- keep for reference */
1276  if ( pflags )
1277  *pflags |= 1L << field->flag_bit;
1278 #else
1279  FT_UNUSED( pflags );
1280 #endif
1281 
1282  error = FT_Err_Ok;
1283 
1284  Exit:
1285  return error;
1286 
1287  Fail:
1288  error = FT_THROW( Invalid_File_Format );
1289  goto Exit;
1290  }
1291 
1292 
1293 #define T1_MAX_TABLE_ELEMENTS 32
1294 
1295 
1299  void** objects,
1300  FT_UInt max_objects,
1301  FT_ULong* pflags )
1302  {
1304  T1_Token token;
1305  FT_Int num_elements;
1307  FT_Byte* old_cursor;
1308  FT_Byte* old_limit;
1309  T1_FieldRec fieldrec = *(T1_Field)field;
1310 
1311 
1312  fieldrec.type = T1_FIELD_TYPE_INTEGER;
1315  fieldrec.type = T1_FIELD_TYPE_FIXED;
1316 
1317  ps_parser_to_token_array( parser, elements,
1318  T1_MAX_TABLE_ELEMENTS, &num_elements );
1319  if ( num_elements < 0 )
1320  {
1321  error = FT_ERR( Ignore );
1322  goto Exit;
1323  }
1324  if ( (FT_UInt)num_elements > field->array_max )
1325  num_elements = (FT_Int)field->array_max;
1326 
1327  old_cursor = parser->cursor;
1328  old_limit = parser->limit;
1329 
1330  /* we store the elements count if necessary; */
1331  /* we further assume that `count_offset' can't be zero */
1332  if ( field->type != T1_FIELD_TYPE_BBOX && field->count_offset != 0 )
1333  *(FT_Byte*)( (FT_Byte*)objects[0] + field->count_offset ) =
1334  (FT_Byte)num_elements;
1335 
1336  /* we now load each element, adjusting the field.offset on each one */
1337  token = elements;
1338  for ( ; num_elements > 0; num_elements--, token++ )
1339  {
1340  parser->cursor = token->start;
1341  parser->limit = token->limit;
1342 
1344  &fieldrec,
1345  objects,
1346  max_objects,
1347  0 );
1348  if ( error )
1349  break;
1350 
1351  fieldrec.offset += fieldrec.size;
1352  }
1353 
1354 #if 0 /* obsolete -- keep for reference */
1355  if ( pflags )
1356  *pflags |= 1L << field->flag_bit;
1357 #else
1358  FT_UNUSED( pflags );
1359 #endif
1360 
1361  parser->cursor = old_cursor;
1362  parser->limit = old_limit;
1363 
1364  Exit:
1365  return error;
1366  }
1367 
1368 
1371  {
1373  return PS_Conv_ToInt( &parser->cursor, parser->limit );
1374  }
1375 
1376 
1377  /* first character must be `<' if `delimiters' is non-zero */
1378 
1381  FT_Byte* bytes,
1382  FT_Offset max_bytes,
1383  FT_ULong* pnum_bytes,
1384  FT_Bool delimiters )
1385  {
1387  FT_Byte* cur;
1388 
1389 
1391  cur = parser->cursor;
1392 
1393  if ( cur >= parser->limit )
1394  goto Exit;
1395 
1396  if ( delimiters )
1397  {
1398  if ( *cur != '<' )
1399  {
1400  FT_ERROR(( "ps_parser_to_bytes: Missing starting delimiter `<'\n" ));
1401  error = FT_THROW( Invalid_File_Format );
1402  goto Exit;
1403  }
1404 
1405  cur++;
1406  }
1407 
1408  *pnum_bytes = PS_Conv_ASCIIHexDecode( &cur,
1409  parser->limit,
1410  bytes,
1411  max_bytes );
1412 
1413  if ( delimiters )
1414  {
1415  if ( cur < parser->limit && *cur != '>' )
1416  {
1417  FT_ERROR(( "ps_parser_to_bytes: Missing closing delimiter `>'\n" ));
1418  error = FT_THROW( Invalid_File_Format );
1419  goto Exit;
1420  }
1421 
1422  cur++;
1423  }
1424 
1425  parser->cursor = cur;
1426 
1427  Exit:
1428  return error;
1429  }
1430 
1431 
1434  FT_Int power_ten )
1435  {
1437  return PS_Conv_ToFixed( &parser->cursor, parser->limit, power_ten );
1438  }
1439 
1440 
1441  FT_LOCAL_DEF( FT_Int )
1443  FT_Int max_coords,
1444  FT_Short* coords )
1445  {
1447  return ps_tocoordarray( &parser->cursor, parser->limit,
1448  max_coords, coords );
1449  }
1450 
1451 
1452  FT_LOCAL_DEF( FT_Int )
1454  FT_Int max_values,
1455  FT_Fixed* values,
1456  FT_Int power_ten )
1457  {
1459  return ps_tofixedarray( &parser->cursor, parser->limit,
1460  max_values, values, power_ten );
1461  }
1462 
1463 
1464 #if 0
1465 
1467  T1_ToString( PS_Parser parser )
1468  {
1469  return ps_tostring( &parser->cursor, parser->limit, parser->memory );
1470  }
1471 
1472 
1474  T1_ToBool( PS_Parser parser )
1475  {
1476  return ps_tobool( &parser->cursor, parser->limit );
1477  }
1478 
1479 #endif /* 0 */
1480 
1481 
1482  FT_LOCAL_DEF( void )
1484  FT_Byte* base,
1485  FT_Byte* limit,
1486  FT_Memory memory )
1487  {
1488  parser->error = FT_Err_Ok;
1489  parser->base = base;
1490  parser->limit = limit;
1491  parser->cursor = base;
1492  parser->memory = memory;
1493  parser->funcs = ps_parser_funcs;
1494  }
1495 
1496 
1497  FT_LOCAL_DEF( void )
1499  {
1500  FT_UNUSED( parser );
1501  }
1502 
1503 
1504  /*************************************************************************/
1505  /*************************************************************************/
1506  /***** *****/
1507  /***** T1 BUILDER *****/
1508  /***** *****/
1509  /*************************************************************************/
1510  /*************************************************************************/
1511 
1512  /*************************************************************************/
1513  /* */
1514  /* <Function> */
1515  /* t1_builder_init */
1516  /* */
1517  /* <Description> */
1518  /* Initializes a given glyph builder. */
1519  /* */
1520  /* <InOut> */
1521  /* builder :: A pointer to the glyph builder to initialize. */
1522  /* */
1523  /* <Input> */
1524  /* face :: The current face object. */
1525  /* */
1526  /* size :: The current size object. */
1527  /* */
1528  /* glyph :: The current glyph object. */
1529  /* */
1530  /* hinting :: Whether hinting should be applied. */
1531  /* */
1532  FT_LOCAL_DEF( void )
1534  FT_Face face,
1535  FT_Size size,
1536  FT_GlyphSlot glyph,
1537  FT_Bool hinting )
1538  {
1539  builder->parse_state = T1_Parse_Start;
1540  builder->load_points = 1;
1541 
1542  builder->face = face;
1543  builder->glyph = glyph;
1544  builder->memory = face->memory;
1545 
1546  if ( glyph )
1547  {
1548  FT_GlyphLoader loader = glyph->internal->loader;
1549 
1550 
1551  builder->loader = loader;
1552  builder->base = &loader->base.outline;
1553  builder->current = &loader->current.outline;
1554  FT_GlyphLoader_Rewind( loader );
1555 
1556  builder->hints_globals = size->internal->module_data;
1557  builder->hints_funcs = NULL;
1558 
1559  if ( hinting )
1560  builder->hints_funcs = glyph->internal->glyph_hints;
1561  }
1562 
1563  builder->pos_x = 0;
1564  builder->pos_y = 0;
1565 
1566  builder->left_bearing.x = 0;
1567  builder->left_bearing.y = 0;
1568  builder->advance.x = 0;
1569  builder->advance.y = 0;
1570 
1571  builder->funcs = t1_builder_funcs;
1572  }
1573 
1574 
1575  /*************************************************************************/
1576  /* */
1577  /* <Function> */
1578  /* t1_builder_done */
1579  /* */
1580  /* <Description> */
1581  /* Finalizes a given glyph builder. Its contents can still be used */
1582  /* after the call, but the function saves important information */
1583  /* within the corresponding glyph slot. */
1584  /* */
1585  /* <Input> */
1586  /* builder :: A pointer to the glyph builder to finalize. */
1587  /* */
1588  FT_LOCAL_DEF( void )
1590  {
1591  FT_GlyphSlot glyph = builder->glyph;
1592 
1593 
1594  if ( glyph )
1595  glyph->outline = *builder->base;
1596  }
1597 
1598 
1599  /* check that there is enough space for `count' more points */
1602  FT_Int count )
1603  {
1604  return FT_GLYPHLOADER_CHECK_POINTS( builder->loader, count, 0 );
1605  }
1606 
1607 
1608  /* add a new point, do not check space */
1609  FT_LOCAL_DEF( void )
1611  FT_Pos x,
1612  FT_Pos y,
1613  FT_Byte flag )
1614  {
1615  FT_Outline* outline = builder->current;
1616 
1617 
1618  if ( builder->load_points )
1619  {
1620  FT_Vector* point = outline->points + outline->n_points;
1621  FT_Byte* control = (FT_Byte*)outline->tags + outline->n_points;
1622 
1623 
1624  point->x = FIXED_TO_INT( x );
1625  point->y = FIXED_TO_INT( y );
1626  *control = (FT_Byte)( flag ? FT_CURVE_TAG_ON : FT_CURVE_TAG_CUBIC );
1627  }
1628  outline->n_points++;
1629  }
1630 
1631 
1632  /* check space for a new on-curve point, then add it */
1635  FT_Pos x,
1636  FT_Pos y )
1637  {
1638  FT_Error error;
1639 
1640 
1641  error = t1_builder_check_points( builder, 1 );
1642  if ( !error )
1643  t1_builder_add_point( builder, x, y, 1 );
1644 
1645  return error;
1646  }
1647 
1648 
1649  /* check space for a new contour, then add it */
1652  {
1653  FT_Outline* outline = builder->current;
1654  FT_Error error;
1655 
1656 
1657  /* this might happen in invalid fonts */
1658  if ( !outline )
1659  {
1660  FT_ERROR(( "t1_builder_add_contour: no outline to add points to\n" ));
1661  return FT_THROW( Invalid_File_Format );
1662  }
1663 
1664  if ( !builder->load_points )
1665  {
1666  outline->n_contours++;
1667  return FT_Err_Ok;
1668  }
1669 
1670  error = FT_GLYPHLOADER_CHECK_POINTS( builder->loader, 0, 1 );
1671  if ( !error )
1672  {
1673  if ( outline->n_contours > 0 )
1674  outline->contours[outline->n_contours - 1] =
1675  (short)( outline->n_points - 1 );
1676 
1677  outline->n_contours++;
1678  }
1679 
1680  return error;
1681  }
1682 
1683 
1684  /* if a path was begun, add its first on-curve point */
1687  FT_Pos x,
1688  FT_Pos y )
1689  {
1690  FT_Error error = FT_ERR( Invalid_File_Format );
1691 
1692 
1693  /* test whether we are building a new contour */
1694 
1695  if ( builder->parse_state == T1_Parse_Have_Path )
1696  error = FT_Err_Ok;
1697  else
1698  {
1699  builder->parse_state = T1_Parse_Have_Path;
1700  error = t1_builder_add_contour( builder );
1701  if ( !error )
1702  error = t1_builder_add_point1( builder, x, y );
1703  }
1704 
1705  return error;
1706  }
1707 
1708 
1709  /* close the current contour */
1710  FT_LOCAL_DEF( void )
1712  {
1713  FT_Outline* outline = builder->current;
1714  FT_Int first;
1715 
1716 
1717  if ( !outline )
1718  return;
1719 
1720  first = outline->n_contours <= 1
1721  ? 0 : outline->contours[outline->n_contours - 2] + 1;
1722 
1723  /* in malformed fonts it can happen that a contour was started */
1724  /* but no points were added */
1725  if ( outline->n_contours && first == outline->n_points )
1726  {
1727  outline->n_contours--;
1728  return;
1729  }
1730 
1731  /* We must not include the last point in the path if it */
1732  /* is located on the first point. */
1733  if ( outline->n_points > 1 )
1734  {
1735  FT_Vector* p1 = outline->points + first;
1736  FT_Vector* p2 = outline->points + outline->n_points - 1;
1737  FT_Byte* control = (FT_Byte*)outline->tags + outline->n_points - 1;
1738 
1739 
1740  /* `delete' last point only if it coincides with the first */
1741  /* point and it is not a control point (which can happen). */
1742  if ( p1->x == p2->x && p1->y == p2->y )
1743  if ( *control == FT_CURVE_TAG_ON )
1744  outline->n_points--;
1745  }
1746 
1747  if ( outline->n_contours > 0 )
1748  {
1749  /* Don't add contours only consisting of one point, i.e., */
1750  /* check whether the first and the last point is the same. */
1751  if ( first == outline->n_points - 1 )
1752  {
1753  outline->n_contours--;
1754  outline->n_points--;
1755  }
1756  else
1757  outline->contours[outline->n_contours - 1] =
1758  (short)( outline->n_points - 1 );
1759  }
1760  }
1761 
1762 
1763  /*************************************************************************/
1764  /*************************************************************************/
1765  /***** *****/
1766  /***** CFF BUILDER *****/
1767  /***** *****/
1768  /*************************************************************************/
1769  /*************************************************************************/
1770 
1771 
1772  /*************************************************************************/
1773  /* */
1774  /* <Function> */
1775  /* cff_builder_init */
1776  /* */
1777  /* <Description> */
1778  /* Initializes a given glyph builder. */
1779  /* */
1780  /* <InOut> */
1781  /* builder :: A pointer to the glyph builder to initialize. */
1782  /* */
1783  /* <Input> */
1784  /* face :: The current face object. */
1785  /* */
1786  /* size :: The current size object. */
1787  /* */
1788  /* glyph :: The current glyph object. */
1789  /* */
1790  /* hinting :: Whether hinting is active. */
1791  /* */
1792  FT_LOCAL_DEF( void )
1794  TT_Face face,
1795  CFF_Size size,
1796  CFF_GlyphSlot glyph,
1797  FT_Bool hinting )
1798  {
1799  builder->path_begun = 0;
1800  builder->load_points = 1;
1801 
1802  builder->face = face;
1803  builder->glyph = glyph;
1804  builder->memory = face->root.memory;
1805 
1806  if ( glyph )
1807  {
1808  FT_GlyphLoader loader = glyph->root.internal->loader;
1809 
1810 
1811  builder->loader = loader;
1812  builder->base = &loader->base.outline;
1813  builder->current = &loader->current.outline;
1814  FT_GlyphLoader_Rewind( loader );
1815 
1816  builder->hints_globals = NULL;
1817  builder->hints_funcs = NULL;
1818 
1819  if ( hinting && size )
1820  {
1821  FT_Size ftsize = FT_SIZE( size );
1822  CFF_Internal internal = (CFF_Internal)ftsize->internal->module_data;
1823 
1824  if ( internal )
1825  {
1826  builder->hints_globals = (void *)internal->topfont;
1827  builder->hints_funcs = glyph->root.internal->glyph_hints;
1828  }
1829  }
1830  }
1831 
1832  builder->pos_x = 0;
1833  builder->pos_y = 0;
1834 
1835  builder->left_bearing.x = 0;
1836  builder->left_bearing.y = 0;
1837  builder->advance.x = 0;
1838  builder->advance.y = 0;
1839 
1840  builder->funcs = cff_builder_funcs;
1841  }
1842 
1843 
1844  /*************************************************************************/
1845  /* */
1846  /* <Function> */
1847  /* cff_builder_done */
1848  /* */
1849  /* <Description> */
1850  /* Finalizes a given glyph builder. Its contents can still be used */
1851  /* after the call, but the function saves important information */
1852  /* within the corresponding glyph slot. */
1853  /* */
1854  /* <Input> */
1855  /* builder :: A pointer to the glyph builder to finalize. */
1856  /* */
1857  FT_LOCAL_DEF( void )
1859  {
1860  CFF_GlyphSlot glyph = builder->glyph;
1861 
1862 
1863  if ( glyph )
1864  glyph->root.outline = *builder->base;
1865  }
1866 
1867 
1868  /* check that there is enough space for `count' more points */
1871  FT_Int count )
1872  {
1873  return FT_GLYPHLOADER_CHECK_POINTS( builder->loader, count, 0 );
1874  }
1875 
1876 
1877  /* add a new point, do not check space */
1878  FT_LOCAL_DEF( void )
1880  FT_Pos x,
1881  FT_Pos y,
1882  FT_Byte flag )
1883  {
1884  FT_Outline* outline = builder->current;
1885 
1886 
1887  if ( builder->load_points )
1888  {
1889  FT_Vector* point = outline->points + outline->n_points;
1890  FT_Byte* control = (FT_Byte*)outline->tags + outline->n_points;
1891 
1893  PS_Driver driver = (PS_Driver)FT_FACE_DRIVER( builder->face );
1894 
1895 
1896  if ( driver->hinting_engine == FT_HINTING_FREETYPE )
1897  {
1898  point->x = x >> 16;
1899  point->y = y >> 16;
1900  }
1901  else
1902 #endif
1903  {
1904  /* cf2_decoder_parse_charstrings uses 16.16 coordinates */
1905  point->x = x >> 10;
1906  point->y = y >> 10;
1907  }
1908  *control = (FT_Byte)( flag ? FT_CURVE_TAG_ON : FT_CURVE_TAG_CUBIC );
1909  }
1910 
1911  outline->n_points++;
1912  }
1913 
1914 
1915  /* check space for a new on-curve point, then add it */
1918  FT_Pos x,
1919  FT_Pos y )
1920  {
1921  FT_Error error;
1922 
1923 
1924  error = cff_check_points( builder, 1 );
1925  if ( !error )
1926  cff_builder_add_point( builder, x, y, 1 );
1927 
1928  return error;
1929  }
1930 
1931 
1932  /* check space for a new contour, then add it */
1935  {
1936  FT_Outline* outline = builder->current;
1937  FT_Error error;
1938 
1939 
1940  if ( !builder->load_points )
1941  {
1942  outline->n_contours++;
1943  return FT_Err_Ok;
1944  }
1945 
1946  error = FT_GLYPHLOADER_CHECK_POINTS( builder->loader, 0, 1 );
1947  if ( !error )
1948  {
1949  if ( outline->n_contours > 0 )
1950  outline->contours[outline->n_contours - 1] =
1951  (short)( outline->n_points - 1 );
1952 
1953  outline->n_contours++;
1954  }
1955 
1956  return error;
1957  }
1958 
1959 
1960  /* if a path was begun, add its first on-curve point */
1963  FT_Pos x,
1964  FT_Pos y )
1965  {
1967 
1968 
1969  /* test whether we are building a new contour */
1970  if ( !builder->path_begun )
1971  {
1972  builder->path_begun = 1;
1973  error = cff_builder_add_contour( builder );
1974  if ( !error )
1975  error = cff_builder_add_point1( builder, x, y );
1976  }
1977 
1978  return error;
1979  }
1980 
1981 
1982  /* close the current contour */
1983  FT_LOCAL_DEF( void )
1985  {
1986  FT_Outline* outline = builder->current;
1987  FT_Int first;
1988 
1989 
1990  if ( !outline )
1991  return;
1992 
1993  first = outline->n_contours <= 1
1994  ? 0 : outline->contours[outline->n_contours - 2] + 1;
1995 
1996  /* We must not include the last point in the path if it */
1997  /* is located on the first point. */
1998  if ( outline->n_points > 1 )
1999  {
2000  FT_Vector* p1 = outline->points + first;
2001  FT_Vector* p2 = outline->points + outline->n_points - 1;
2002  FT_Byte* control = (FT_Byte*)outline->tags + outline->n_points - 1;
2003 
2004 
2005  /* `delete' last point only if it coincides with the first */
2006  /* point and if it is not a control point (which can happen). */
2007  if ( p1->x == p2->x && p1->y == p2->y )
2008  if ( *control == FT_CURVE_TAG_ON )
2009  outline->n_points--;
2010  }
2011 
2012  if ( outline->n_contours > 0 )
2013  {
2014  /* Don't add contours only consisting of one point, i.e., */
2015  /* check whether begin point and last point are the same. */
2016  if ( first == outline->n_points - 1 )
2017  {
2018  outline->n_contours--;
2019  outline->n_points--;
2020  }
2021  else
2022  outline->contours[outline->n_contours - 1] =
2023  (short)( outline->n_points - 1 );
2024  }
2025  }
2026 
2027 
2028  /*************************************************************************/
2029  /*************************************************************************/
2030  /***** *****/
2031  /***** PS BUILDER *****/
2032  /***** *****/
2033  /*************************************************************************/
2034  /*************************************************************************/
2035 
2036  /*************************************************************************/
2037  /* */
2038  /* <Function> */
2039  /* ps_builder_init */
2040  /* */
2041  /* <Description> */
2042  /* Initializes a given glyph builder. */
2043  /* */
2044  /* <InOut> */
2045  /* builder :: A pointer to the glyph builder to initialize. */
2046  /* */
2047  /* <Input> */
2048  /* face :: The current face object. */
2049  /* */
2050  /* size :: The current size object. */
2051  /* */
2052  /* glyph :: The current glyph object. */
2053  /* */
2054  /* hinting :: Whether hinting should be applied. */
2055  /* */
2056  FT_LOCAL_DEF( void )
2058  void* builder,
2059  FT_Bool is_t1 )
2060  {
2061  FT_ZERO( ps_builder );
2062 
2063  if ( is_t1 )
2064  {
2065  T1_Builder t1builder = (T1_Builder)builder;
2066 
2067 
2068  ps_builder->memory = t1builder->memory;
2069  ps_builder->face = (FT_Face)t1builder->face;
2070  ps_builder->glyph = (CFF_GlyphSlot)t1builder->glyph;
2071  ps_builder->loader = t1builder->loader;
2072  ps_builder->base = t1builder->base;
2073  ps_builder->current = t1builder->current;
2074 
2075  ps_builder->pos_x = &t1builder->pos_x;
2076  ps_builder->pos_y = &t1builder->pos_y;
2077 
2078  ps_builder->left_bearing = &t1builder->left_bearing;
2079  ps_builder->advance = &t1builder->advance;
2080 
2081  ps_builder->bbox = &t1builder->bbox;
2082  ps_builder->path_begun = 0;
2083  ps_builder->load_points = t1builder->load_points;
2084  ps_builder->no_recurse = t1builder->no_recurse;
2085 
2086  ps_builder->metrics_only = t1builder->metrics_only;
2087  }
2088  else
2089  {
2090  CFF_Builder* cffbuilder = (CFF_Builder*)builder;
2091 
2092 
2093  ps_builder->memory = cffbuilder->memory;
2094  ps_builder->face = (FT_Face)cffbuilder->face;
2095  ps_builder->glyph = cffbuilder->glyph;
2096  ps_builder->loader = cffbuilder->loader;
2097  ps_builder->base = cffbuilder->base;
2098  ps_builder->current = cffbuilder->current;
2099 
2100  ps_builder->pos_x = &cffbuilder->pos_x;
2101  ps_builder->pos_y = &cffbuilder->pos_y;
2102 
2103  ps_builder->left_bearing = &cffbuilder->left_bearing;
2104  ps_builder->advance = &cffbuilder->advance;
2105 
2106  ps_builder->bbox = &cffbuilder->bbox;
2107  ps_builder->path_begun = cffbuilder->path_begun;
2108  ps_builder->load_points = cffbuilder->load_points;
2109  ps_builder->no_recurse = cffbuilder->no_recurse;
2110 
2111  ps_builder->metrics_only = cffbuilder->metrics_only;
2112  }
2113 
2114  ps_builder->is_t1 = is_t1;
2115  ps_builder->funcs = ps_builder_funcs;
2116  }
2117 
2118 
2119  /*************************************************************************/
2120  /* */
2121  /* <Function> */
2122  /* ps_builder_done */
2123  /* */
2124  /* <Description> */
2125  /* Finalizes a given glyph builder. Its contents can still be used */
2126  /* after the call, but the function saves important information */
2127  /* within the corresponding glyph slot. */
2128  /* */
2129  /* <Input> */
2130  /* builder :: A pointer to the glyph builder to finalize. */
2131  /* */
2132  FT_LOCAL_DEF( void )
2134  {
2135  CFF_GlyphSlot glyph = builder->glyph;
2136 
2137 
2138  if ( glyph )
2139  glyph->root.outline = *builder->base;
2140  }
2141 
2142 
2143  /* check that there is enough space for `count' more points */
2146  FT_Int count )
2147  {
2148  return FT_GLYPHLOADER_CHECK_POINTS( builder->loader, count, 0 );
2149  }
2150 
2151 
2152  /* add a new point, do not check space */
2153  FT_LOCAL_DEF( void )
2155  FT_Pos x,
2156  FT_Pos y,
2157  FT_Byte flag )
2158  {
2159  FT_Outline* outline = builder->current;
2160 
2161 
2162  if ( builder->load_points )
2163  {
2164  FT_Vector* point = outline->points + outline->n_points;
2165  FT_Byte* control = (FT_Byte*)outline->tags + outline->n_points;
2166 
2168  PS_Driver driver = (PS_Driver)FT_FACE_DRIVER( builder->face );
2169 
2170 
2171  if ( !builder->is_t1 &&
2172  driver->hinting_engine == FT_HINTING_FREETYPE )
2173  {
2174  point->x = x >> 16;
2175  point->y = y >> 16;
2176  }
2177  else
2178 #endif
2179 #ifdef T1_CONFIG_OPTION_OLD_ENGINE
2180 #ifndef CFF_CONFIG_OPTION_OLD_ENGINE
2181  PS_Driver driver = (PS_Driver)FT_FACE_DRIVER( builder->face );
2182 #endif
2183  if ( builder->is_t1 &&
2184  driver->hinting_engine == FT_HINTING_FREETYPE )
2185  {
2186  point->x = FIXED_TO_INT( x );
2187  point->y = FIXED_TO_INT( y );
2188  }
2189  else
2190 #endif
2191  {
2192  /* cf2_decoder_parse_charstrings uses 16.16 coordinates */
2193  point->x = x >> 10;
2194  point->y = y >> 10;
2195  }
2196  *control = (FT_Byte)( flag ? FT_CURVE_TAG_ON : FT_CURVE_TAG_CUBIC );
2197  }
2198  outline->n_points++;
2199  }
2200 
2201 
2202  /* check space for a new on-curve point, then add it */
2205  FT_Pos x,
2206  FT_Pos y )
2207  {
2208  FT_Error error;
2209 
2210 
2211  error = ps_builder_check_points( builder, 1 );
2212  if ( !error )
2213  ps_builder_add_point( builder, x, y, 1 );
2214 
2215  return error;
2216  }
2217 
2218 
2219  /* check space for a new contour, then add it */
2222  {
2223  FT_Outline* outline = builder->current;
2224  FT_Error error;
2225 
2226 
2227  /* this might happen in invalid fonts */
2228  if ( !outline )
2229  {
2230  FT_ERROR(( "ps_builder_add_contour: no outline to add points to\n" ));
2231  return FT_THROW( Invalid_File_Format );
2232  }
2233 
2234  if ( !builder->load_points )
2235  {
2236  outline->n_contours++;
2237  return FT_Err_Ok;
2238  }
2239 
2240  error = FT_GLYPHLOADER_CHECK_POINTS( builder->loader, 0, 1 );
2241  if ( !error )
2242  {
2243  if ( outline->n_contours > 0 )
2244  outline->contours[outline->n_contours - 1] =
2245  (short)( outline->n_points - 1 );
2246 
2247  outline->n_contours++;
2248  }
2249 
2250  return error;
2251  }
2252 
2253 
2254  /* if a path was begun, add its first on-curve point */
2257  FT_Pos x,
2258  FT_Pos y )
2259  {
2261 
2262 
2263  /* test whether we are building a new contour */
2264  if ( !builder->path_begun )
2265  {
2266  builder->path_begun = 1;
2267  error = ps_builder_add_contour( builder );
2268  if ( !error )
2269  error = ps_builder_add_point1( builder, x, y );
2270  }
2271 
2272  return error;
2273  }
2274 
2275 
2276  /* close the current contour */
2277  FT_LOCAL_DEF( void )
2279  {
2280  FT_Outline* outline = builder->current;
2281  FT_Int first;
2282 
2283 
2284  if ( !outline )
2285  return;
2286 
2287  first = outline->n_contours <= 1
2288  ? 0 : outline->contours[outline->n_contours - 2] + 1;
2289 
2290  /* in malformed fonts it can happen that a contour was started */
2291  /* but no points were added */
2292  if ( outline->n_contours && first == outline->n_points )
2293  {
2294  outline->n_contours--;
2295  return;
2296  }
2297 
2298  /* We must not include the last point in the path if it */
2299  /* is located on the first point. */
2300  if ( outline->n_points > 1 )
2301  {
2302  FT_Vector* p1 = outline->points + first;
2303  FT_Vector* p2 = outline->points + outline->n_points - 1;
2304  FT_Byte* control = (FT_Byte*)outline->tags + outline->n_points - 1;
2305 
2306 
2307  /* `delete' last point only if it coincides with the first */
2308  /* point and it is not a control point (which can happen). */
2309  if ( p1->x == p2->x && p1->y == p2->y )
2310  if ( *control == FT_CURVE_TAG_ON )
2311  outline->n_points--;
2312  }
2313 
2314  if ( outline->n_contours > 0 )
2315  {
2316  /* Don't add contours only consisting of one point, i.e., */
2317  /* check whether the first and the last point is the same. */
2318  if ( first == outline->n_points - 1 )
2319  {
2320  outline->n_contours--;
2321  outline->n_points--;
2322  }
2323  else
2324  outline->contours[outline->n_contours - 1] =
2325  (short)( outline->n_points - 1 );
2326  }
2327  }
2328 
2329 
2330  /*************************************************************************/
2331  /*************************************************************************/
2332  /***** *****/
2333  /***** OTHER *****/
2334  /***** *****/
2335  /*************************************************************************/
2336  /*************************************************************************/
2337 
2338 
2339  /*************************************************************************/
2340  /* */
2341  /* <Function> */
2342  /* ps_decoder_init */
2343  /* */
2344  /* <Description> */
2345  /* Creates a wrapper decoder for use in the combined */
2346  /* Type 1 / CFF interpreter. */
2347  /* */
2348  /* <InOut> */
2349  /* ps_decoder :: A pointer to the decoder to initialize. */
2350  /* */
2351  /* <Input> */
2352  /* decoder :: A pointer to the original decoder. */
2353  /* */
2354  /* is_t1 :: Flag indicating Type 1 or CFF */
2355  /* */
2356  FT_LOCAL_DEF( void )
2358  void* decoder,
2359  FT_Bool is_t1 )
2360  {
2361  FT_ZERO( ps_decoder );
2362 
2363  if ( is_t1 )
2364  {
2365  T1_Decoder t1_decoder = (T1_Decoder)decoder;
2366 
2367 
2368  ps_builder_init( &ps_decoder->builder,
2369  &t1_decoder->builder,
2370  is_t1 );
2371 
2372  ps_decoder->cf2_instance = &t1_decoder->cf2_instance;
2373  ps_decoder->psnames = t1_decoder->psnames;
2374 
2375  ps_decoder->num_glyphs = t1_decoder->num_glyphs;
2376  ps_decoder->glyph_names = t1_decoder->glyph_names;
2377  ps_decoder->hint_mode = t1_decoder->hint_mode;
2378  ps_decoder->blend = t1_decoder->blend;
2379 
2380  ps_decoder->num_locals = (FT_UInt)t1_decoder->num_subrs;
2381  ps_decoder->locals = t1_decoder->subrs;
2382  ps_decoder->locals_len = t1_decoder->subrs_len;
2383  ps_decoder->locals_hash = t1_decoder->subrs_hash;
2384 
2385  ps_decoder->buildchar = t1_decoder->buildchar;
2386  ps_decoder->len_buildchar = t1_decoder->len_buildchar;
2387 
2388  ps_decoder->lenIV = t1_decoder->lenIV;
2389  }
2390  else
2391  {
2392  CFF_Decoder* cff_decoder = (CFF_Decoder*)decoder;
2393 
2394 
2395  ps_builder_init( &ps_decoder->builder,
2396  &cff_decoder->builder,
2397  is_t1 );
2398 
2399  ps_decoder->cff = cff_decoder->cff;
2400  ps_decoder->cf2_instance = &cff_decoder->cff->cf2_instance;
2401  ps_decoder->current_subfont = cff_decoder->current_subfont;
2402 
2403  ps_decoder->num_globals = cff_decoder->num_globals;
2404  ps_decoder->globals = cff_decoder->globals;
2405  ps_decoder->globals_bias = cff_decoder->globals_bias;
2406  ps_decoder->num_locals = cff_decoder->num_locals;
2407  ps_decoder->locals = cff_decoder->locals;
2408  ps_decoder->locals_bias = cff_decoder->locals_bias;
2409 
2410  ps_decoder->glyph_width = &cff_decoder->glyph_width;
2411  ps_decoder->width_only = cff_decoder->width_only;
2412 
2413  ps_decoder->hint_mode = cff_decoder->hint_mode;
2414 
2415  ps_decoder->get_glyph_callback = cff_decoder->get_glyph_callback;
2416  ps_decoder->free_glyph_callback = cff_decoder->free_glyph_callback;
2417  }
2418  }
2419 
2420 
2421  /* Synthesize a SubFont object for Type 1 fonts, for use in the */
2422  /* new interpreter to access Private dict data. */
2423  FT_LOCAL_DEF( void )
2425  PS_Private priv,
2426  CFF_SubFont subfont )
2427  {
2428  CFF_Private cpriv = &subfont->private_dict;
2429  FT_UInt n, count;
2430 
2431 
2432  FT_ZERO( subfont );
2433  FT_ZERO( cpriv );
2434 
2435  count = cpriv->num_blue_values = priv->num_blue_values;
2436  for ( n = 0; n < count; n++ )
2437  cpriv->blue_values[n] = (FT_Pos)priv->blue_values[n];
2438 
2439  count = cpriv->num_other_blues = priv->num_other_blues;
2440  for ( n = 0; n < count; n++ )
2441  cpriv->other_blues[n] = (FT_Pos)priv->other_blues[n];
2442 
2443  count = cpriv->num_family_blues = priv->num_family_blues;
2444  for ( n = 0; n < count; n++ )
2445  cpriv->family_blues[n] = (FT_Pos)priv->family_blues[n];
2446 
2447  count = cpriv->num_family_other_blues = priv->num_family_other_blues;
2448  for ( n = 0; n < count; n++ )
2449  cpriv->family_other_blues[n] = (FT_Pos)priv->family_other_blues[n];
2450 
2451  cpriv->blue_scale = priv->blue_scale;
2452  cpriv->blue_shift = (FT_Pos)priv->blue_shift;
2453  cpriv->blue_fuzz = (FT_Pos)priv->blue_fuzz;
2454 
2455  cpriv->standard_width = (FT_Pos)priv->standard_width[0];
2456  cpriv->standard_height = (FT_Pos)priv->standard_height[0];
2457 
2458  count = cpriv->num_snap_widths = priv->num_snap_widths;
2459  for ( n = 0; n < count; n++ )
2460  cpriv->snap_widths[n] = (FT_Pos)priv->snap_widths[n];
2461 
2462  count = cpriv->num_snap_heights = priv->num_snap_heights;
2463  for ( n = 0; n < count; n++ )
2464  cpriv->snap_heights[n] = (FT_Pos)priv->snap_heights[n];
2465 
2466  cpriv->force_bold = priv->force_bold;
2467  cpriv->lenIV = priv->lenIV;
2468  cpriv->language_group = priv->language_group;
2469  cpriv->expansion_factor = priv->expansion_factor;
2470 
2471  cpriv->subfont = subfont;
2472 
2473 
2474  /* Initialize the random number generator. */
2475  if ( face->internal->random_seed != -1 )
2476  {
2477  /* If we have a face-specific seed, use it. */
2478  /* If non-zero, update it to a positive value. */
2479  subfont->random = (FT_UInt32)face->internal->random_seed;
2480  if ( face->internal->random_seed )
2481  {
2482  do
2483  {
2484  face->internal->random_seed = (FT_Int32)cff_random(
2485  (FT_UInt32)face->internal->random_seed );
2486 
2487  } while ( face->internal->random_seed < 0 );
2488  }
2489  }
2490  if ( !subfont->random )
2491  {
2492  FT_UInt32 seed;
2493 
2494 
2495  /* compute random seed from some memory addresses */
2496  seed = (FT_UInt32)( (FT_Offset)(char*)&seed ^
2497  (FT_Offset)(char*)&face ^
2498  (FT_Offset)(char*)&subfont );
2499  seed = seed ^ ( seed >> 10 ) ^ ( seed >> 20 );
2500  if ( seed == 0 )
2501  seed = 0x7384;
2502 
2503  subfont->random = seed;
2504  }
2505  }
2506 
2507 
2508  FT_LOCAL_DEF( void )
2510  FT_Offset length,
2511  FT_UShort seed )
2512  {
2514  buffer + length,
2515  buffer,
2516  length,
2517  &seed );
2518  }
2519 
2520 
2521  FT_LOCAL_DEF( FT_UInt32 )
2522  cff_random( FT_UInt32 r )
2523  {
2524  /* a 32bit version of the `xorshift' algorithm */
2525  r ^= r << 13;
2526  r ^= r >> 17;
2527  r ^= r << 5;
2528 
2529  return r;
2530  }
2531 
2532 
2533 /* END */
static void shift_elements(PS_Table table, FT_Byte *old_base)
Definition: psobjs.c:101
#define FT_ALLOC(ptr, size)
Definition: ftmemory.h:303
ps_table_add(PS_Table table, FT_Int idx, void *object, FT_UInt length)
Definition: psobjs.c:170
#define FIXED_TO_INT(x)
Definition: ftcalc.h:406
FT_Byte num_family_blues
Definition: cfftypes.h:244
FT_CALLBACK_TABLE_DEF const PS_Builder_FuncsRec ps_builder_funcs
Definition: psauxmod.c:65
int FT_Error
Definition: fttypes.h:300
ft_ptrdiff_t FT_PtrDist
Definition: fttypes.h:337
FT_Pos y
Definition: ftimage.h:77
signed long FT_Long
Definition: fttypes.h:242
#define CFF_CONFIG_OPTION_OLD_ENGINE
Definition: ftoption.h:797
FT_Outline * base
Definition: psaux.h:1049
unsigned long FT_ULong
Definition: fttypes.h:253
FT_Vector advance
Definition: psaux.h:793
FT_BEGIN_HEADER typedef signed long FT_Pos
Definition: ftimage.h:58
FT_Byte ** glyph_names
Definition: psaux.h:905
FT_UInt num_globals
Definition: psaux.h:1126
T1_FieldType type
Definition: psaux.h:249
FT_Int lenIV
Definition: psaux.h:907
FT_Byte ** globals
Definition: psaux.h:1132
#define FT_HINTING_FREETYPE
Definition: ftdriver.h:345
static FT_Error skip_string(FT_Byte **acur, FT_Byte *limit)
Definition: psobjs.c:411
t1_builder_done(T1_Builder builder)
Definition: psobjs.c:1589
t1_builder_add_point1(T1_Builder builder, FT_Pos x, FT_Pos y)
Definition: psobjs.c:1634
FT_Size_Internal internal
Definition: freetype.h:1678
FT_UInt * subrs_len
Definition: psaux.h:910
FT_BBox bbox
Definition: psaux.h:1058
#define error(str)
Definition: mkdosfs.c:1605
FT_Generic cf2_instance
Definition: cfftypes.h:396
FT_Render_Mode hint_mode
Definition: psaux.h:1137
cff_builder_init(CFF_Builder *builder, TT_Face face, CFF_Size size, CFF_GlyphSlot glyph, FT_Bool hinting)
Definition: psobjs.c:1793
FT_Outline * base
Definition: psaux.h:786
PS_Conv_ToFixed(FT_Byte **cursor, FT_Byte *limit, FT_Long power_ten)
Definition: psconv.c:196
FT_Pos x
Definition: ftimage.h:76
#define FT_CURVE_TAG_CUBIC
Definition: ftimage.h:455
FT_Pos blue_values[14]
Definition: cfftypes.h:247
FT_Pos other_blues[10]
Definition: cfftypes.h:248
enum T1_FieldType_ T1_FieldType
struct T1_DecoderRec_ * T1_Decoder
Definition: psaux.h:847
signed int FT_Int
Definition: fttypes.h:220
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
FT_Byte num_snap_heights
Definition: cfftypes.h:259
GLuint GLuint GLsizei count
Definition: gl.h:1545
FT_GlyphSlot glyph
Definition: psaux.h:784
FT_Bool path_begun
Definition: psaux.h:1060
FT_BBox bbox
Definition: ftbbox.c:446
FT_Vector left_bearing
Definition: psaux.h:1055
const GLint * first
Definition: glext.h:5794
FT_Pos glyph_width
Definition: psaux.h:1117
GLboolean GLenum GLenum GLvoid * values
Definition: glext.h:5666
ps_parser_load_field_table(PS_Parser parser, const T1_Field field, void **objects, FT_UInt max_objects, FT_ULong *pflags)
Definition: psobjs.c:1297
GLintptr offset
Definition: glext.h:5920
t1_builder_start_point(T1_Builder builder, FT_Pos x, FT_Pos y)
Definition: psobjs.c:1686
ps_parser_done(PS_Parser parser)
Definition: psobjs.c:1498
FT_Bool metrics_only
Definition: psaux.h:800
void * module_data
Definition: ftobjs.h:497
GLdouble n
Definition: glext.h:7729
FT_Service_PsCMaps psnames
Definition: psaux.h:903
PS_Conv_EexecDecode(FT_Byte **cursor, FT_Byte *limit, FT_Byte *buffer, FT_Offset n, FT_UShort *seed)
Definition: psconv.c:558
FT_Pos blue_shift
Definition: cfftypes.h:253
FT_RoundFix(FT_Fixed a)
Definition: ftcalc.c:88
CFF_Decoder_Free_Glyph_Callback free_glyph_callback
Definition: psaux.h:1144
CFF_SubFont current_subfont
Definition: psaux.h:1141
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
cff_check_points(CFF_Builder *builder, FT_Int count)
Definition: psobjs.c:1870
GLuint buffer
Definition: glext.h:5915
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
FT_Pos snap_widths[13]
Definition: cfftypes.h:260
PS_Blend blend
Definition: psaux.h:920
ps_parser_to_fixed(PS_Parser parser, FT_Int power_ten)
Definition: psobjs.c:1433
FT_Vector advance
Definition: psaux.h:1056
#define IS_PS_NEWLINE(ch)
Definition: psaux.h:1325
ps_parser_skip_PS_token(PS_Parser parser)
Definition: psobjs.c:510
ps_builder_check_points(PS_Builder *builder, FT_Int count)
Definition: psobjs.c:2145
FT_Byte * start
Definition: psaux.h:192
GLuint coords
Definition: glext.h:7368
ps_parser_to_fixed_array(PS_Parser parser, FT_Int max_values, FT_Fixed *values, FT_Int power_ten)
Definition: psobjs.c:1453
WORD face[3]
Definition: mesh.c:4747
#define IS_PS_SPACE(ch)
Definition: psaux.h:1329
return FT_Err_Ok
Definition: ftbbox.c:511
static char memory[1024 *256]
Definition: process.c:116
ps_builder_add_point1(PS_Builder *builder, FT_Pos x, FT_Pos y)
Definition: psobjs.c:2204
FT_Memory memory
Definition: psaux.h:1045
FT_Fixed blue_scale
Definition: cfftypes.h:252
POINTL point
Definition: edittest.c:50
FT_BEGIN_HEADER struct PS_DriverRec_ * PS_Driver
LONG y
Definition: windef.h:330
CFF_Builder builder
Definition: psaux.h:1104
FT_GlyphLoadRec base
Definition: ftgloadr.h:69
GLint limit
Definition: glext.h:10326
ps_parser_to_token(PS_Parser parser, T1_Token token)
Definition: psobjs.c:618
FT_Pos blue_fuzz
Definition: cfftypes.h:254
cff_random(FT_UInt32 r)
Definition: psobjs.c:2522
FT_Bool metrics_only
Definition: psaux.h:1064
FT_Pos family_blues[14]
Definition: cfftypes.h:249
#define FT_FACE_DRIVER(x)
Definition: ftobjs.h:634
FT_BEGIN_HEADER typedef unsigned char FT_Bool
Definition: fttypes.h:108
static FT_Error reallocate_t1_table(PS_Table table, FT_Offset new_size)
Definition: psobjs.c:118
FT_Pos standard_width
Definition: cfftypes.h:255
ps_table_new(PS_Table table, FT_Int count, FT_Memory memory)
Definition: psobjs.c:71
unsigned short(__cdecl typeof(TIFFCurrentDirectory))(struct tiff *)
Definition: typeof.h:93
FT_Bool no_recurse
Definition: psaux.h:798
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
static const CLSID * objects[]
Definition: apphelp.c:110
FT_UInt num_locals
Definition: psaux.h:1125
FT_Bool width_only
Definition: psaux.h:1121
FT_Int lenIV
Definition: cfftypes.h:264
FT_CALLBACK_TABLE_DEF const T1_Builder_FuncsRec t1_builder_funcs
Definition: psauxmod.c:73
static unsigned char bytes[4]
Definition: adnsresfilter.c:74
FT_Pos snap_heights[13]
Definition: cfftypes.h:261
ps_builder_init(PS_Builder *ps_builder, void *builder, FT_Bool is_t1)
Definition: psobjs.c:2057
#define FT_ERROR(varformat)
Definition: ftdebug.h:181
#define FT_PAD_CEIL(x, n)
Definition: ftobjs.h:90
FT_Outline outline
Definition: ftgloadr.h:52
unsigned char FT_Byte
Definition: fttypes.h:154
FT_Int globals_bias
Definition: psaux.h:1129
#define FT_THROW(e)
Definition: ftdebug.h:213
FT_Byte num_family_other_blues
Definition: cfftypes.h:245
GLuint base
Definition: 3dtext.c:35
ps_builder_close_contour(PS_Builder *builder)
Definition: psobjs.c:2278
FT_CALLBACK_TABLE_DEF const PS_Parser_FuncsRec ps_parser_funcs
Definition: psauxmod.c:43
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat token
Definition: glfuncs.h:210
FT_Bool force_bold
Definition: cfftypes.h:262
FT_Int language_group
Definition: cfftypes.h:265
unsigned int idx
Definition: utils.c:41
cff_builder_add_contour(CFF_Builder *builder)
Definition: psobjs.c:1934
smooth NULL
Definition: ftsmooth.c:416
const char * delimiter
Definition: string.c:1566
FT_Pos yMax
Definition: ftimage.h:118
FT_UInt offset
Definition: psaux.h:251
#define FT_FREE(ptr)
Definition: ftmemory.h:329
FT_Pos pos_x
Definition: psaux.h:1052
cff_builder_add_point1(CFF_Builder *builder, FT_Pos x, FT_Pos y)
Definition: psobjs.c:1917
#define FT_LOCAL_DEF(x)
Definition: ftconfig.h:388
FT_GlyphLoader loader
Definition: psaux.h:1048
struct T1_FieldRec_ * T1_Field
Definition: psaux.h:171
ps_parser_skip_spaces(PS_Parser parser)
Definition: psobjs.c:608
FT_UInt32 random
Definition: cfftypes.h:325
GLuint GLfloat * val
Definition: glext.h:7180
ps_table_release(PS_Table table)
Definition: psobjs.c:260
#define FT_ERR(e)
Definition: fttypes.h:586
ps_parser_load_field(PS_Parser parser, const T1_Field field, void **objects, FT_UInt max_objects, FT_ULong *pflags)
Definition: psobjs.c:1025
ps_parser_to_int(PS_Parser parser)
Definition: psobjs.c:1370
T1_TokenType type
Definition: psaux.h:194
#define FT_TRACE0(varformat)
Definition: ftdebug.h:157
FT_Long * buildchar
Definition: psaux.h:927
char FT_String
Definition: fttypes.h:187
GLsizeiptr size
Definition: glext.h:5919
#define FT_ZERO(p)
Definition: ftmemory.h:237
FT_Pos xMin
Definition: ftimage.h:117
if(!(yy_init))
Definition: macro.lex.yy.c:714
PS_Conv_ASCIIHexDecode(FT_Byte **cursor, FT_Byte *limit, FT_Byte *buffer, FT_Offset n)
Definition: psconv.c:465
Definition: parser.c:43
FT_Outline * current
Definition: psaux.h:1050
GLenum GLuint GLenum GLsizei length
Definition: glext.h:5579
FT_Face face
Definition: psaux.h:783
FT_Pos pos_y
Definition: psaux.h:1053
static void Exit(void)
Definition: sock.c:1331
FT_Fixed expansion_factor
Definition: cfftypes.h:266
#define IS_OCTAL_DIGIT(c)
Definition: psobjs.c:328
FT_Memory memory
Definition: psaux.h:782
static void skip_spaces(FT_Byte **acur, FT_Byte *limit)
Definition: psobjs.c:305
const GLubyte * c
Definition: glext.h:8905
FT_Pos xMax
Definition: ftimage.h:118
struct FT_FaceRec_ * FT_Face
Definition: freetype.h:503
T1_BuilderRec builder
Definition: psaux.h:895
FT_Byte num_snap_widths
Definition: cfftypes.h:258
FT_Byte ** locals
Definition: psaux.h:1131
static FT_Int ps_tofixedarray(FT_Byte **acur, FT_Byte *limit, FT_Int max_values, FT_Fixed *values, FT_Int power_ten)
Definition: psobjs.c:853
LONG x
Definition: windef.h:329
GLdouble GLdouble GLdouble GLdouble q
Definition: gl.h:2063
ps_table_done(PS_Table table)
Definition: psobjs.c:236
unsigned int error
Definition: inffile.c:97
FT_Pos pos_x
Definition: psaux.h:789
CFF_Decoder_Get_Glyph_Callback get_glyph_callback
Definition: psaux.h:1143
FT_Byte ** subrs
Definition: psaux.h:909
FT_Bool no_recurse
Definition: psaux.h:1062
FT_Vector left_bearing
Definition: psaux.h:792
ps_builder_start_point(PS_Builder *builder, FT_Pos x, FT_Pos y)
Definition: psobjs.c:2256
FT_Outline * current
Definition: psaux.h:787
TT_Face face
Definition: psaux.h:1046
static int ps_tobool(FT_Byte **acur, FT_Byte *limit)
Definition: psobjs.c:989
t1_builder_close_contour(T1_Builder builder)
Definition: psobjs.c:1711
static const WCHAR L[]
Definition: oid.c:1250
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean flag
Definition: glfuncs.h:52
FT_GlyphLoadRec current
Definition: ftgloadr.h:70
signed short FT_Short
Definition: fttypes.h:198
FT_Byte num_other_blues
Definition: cfftypes.h:243
FT_Outline outline
Definition: freetype.h:1927
cff_builder_close_contour(CFF_Builder *builder)
Definition: psobjs.c:1984
_CRTIMP void __cdecl unexpected(void)
FT_CALLBACK_TABLE_DEF const CFF_Builder_FuncsRec cff_builder_funcs
Definition: psauxmod.c:123
typedefFT_BEGIN_HEADER struct FT_MemoryRec_ * FT_Memory
Definition: ftsystem.h:66
GLenum GLsizei len
Definition: glext.h:6722
#define err(...)
#define FT_CHAR_BIT
Definition: ftconfig.h:70
#define FT_NEW_ARRAY(ptr, count)
Definition: ftmemory.h:333
Definition: mesh.c:5329
t1_decrypt(FT_Byte *buffer, FT_Offset length, FT_UShort seed)
Definition: psobjs.c:2509
#define FT_SIZE(x)
Definition: ftobjs.h:631
FT_BBox bbox
Definition: psaux.h:795
FT_Pos standard_height
Definition: cfftypes.h:256
ps_builder_add_contour(PS_Builder *builder)
Definition: psobjs.c:2221
FT_GlyphSlot glyph
Definition: freetype.h:1105
Definition: hiveinit.c:368
FT_Int locals_bias
Definition: psaux.h:1128
struct T1_BuilderRec_ * T1_Builder
Definition: psaux.h:667
struct @1623::@1624 driver
CFF_Font cff
Definition: psaux.h:1105
signed long FT_Fixed
Definition: fttypes.h:288
static FT_Error skip_literal_string(FT_Byte **acur, FT_Byte *limit)
Definition: psobjs.c:335
ps_parser_to_coord_array(PS_Parser parser, FT_Int max_coords, FT_Short *coords)
Definition: psobjs.c:1442
FT_GlyphLoader loader
Definition: psaux.h:785
const char cursor[]
Definition: icontest.c:13
ps_parser_to_bytes(PS_Parser parser, FT_Byte *bytes, FT_Offset max_bytes, FT_ULong *pnum_bytes, FT_Bool delimiters)
Definition: psobjs.c:1380
static FT_Error skip_procedure(FT_Byte **acur, FT_Byte *limit)
Definition: psobjs.c:450
static calc_node_t temp
Definition: rpn_ieee.c:38
unsigned int FT_UInt
Definition: fttypes.h:231
unsigned char dummy
Definition: maze.c:118
#define T1_MAX_TABLE_ELEMENTS
Definition: psobjs.c:1293
FT_GlyphLoader_Rewind(FT_GlyphLoader loader)
Definition: ftgloadr.c:88
FT_Bool load_points
Definition: psaux.h:1061
FT_Pos yMin
Definition: ftimage.h:117
ps_decoder_init(PS_Decoder *ps_decoder, void *decoder, FT_Bool is_t1)
Definition: psobjs.c:2357
static void skip_comment(FT_Byte **acur, FT_Byte *limit)
Definition: psobjs.c:287
t1_make_subfont(FT_Face face, PS_Private priv, CFF_SubFont subfont)
Definition: psobjs.c:2424
FT_UInt len_buildchar
Definition: psaux.h:928
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
ios_base &_STLP_CALL internal(ios_base &__s)
Definition: _ios_base.h:311
t1_builder_add_point(T1_Builder builder, FT_Pos x, FT_Pos y, FT_Byte flag)
Definition: psobjs.c:1610
FT_Int num_subrs
Definition: psaux.h:908
ps_parser_init(PS_Parser parser, FT_Byte *base, FT_Byte *limit, FT_Memory memory)
Definition: psobjs.c:1483
t1_builder_add_contour(T1_Builder builder)
Definition: psobjs.c:1651
FT_Bool load_points
Definition: psaux.h:797
Definition: import.c:86
cff_builder_start_point(CFF_Builder *builder, FT_Pos x, FT_Pos y)
Definition: psobjs.c:1962
#define FT_CURVE_TAG_ON
Definition: ftimage.h:453
struct CFF_InternalRec_ * CFF_Internal
#define c
Definition: ke_i.h:80
t1_builder_init(T1_Builder builder, FT_Face face, FT_Size size, FT_GlyphSlot glyph, FT_Bool hinting)
Definition: psobjs.c:1533
#define const
Definition: zconf.h:230
CFF_GlyphSlot glyph
Definition: psaux.h:1047
FT_Render_Mode hint_mode
Definition: psaux.h:922
FT_Hash subrs_hash
Definition: psaux.h:911
#define FT_MEM_COPY(dest, source, count)
Definition: ftmemory.h:228
FT_Byte size
Definition: psaux.h:252
#define IS_PS_DELIM(ch)
Definition: psaux.h:1344
PS_Conv_ToInt(FT_Byte **cursor, FT_Byte *limit)
Definition: psconv.c:162
FT_Byte * limit
Definition: psaux.h:193
unsigned short FT_UShort
Definition: fttypes.h:209
#define FT_GLYPHLOADER_CHECK_POINTS(_loader, _points, _contours)
Definition: ftgloadr.h:118
FT_Pos family_other_blues[10]
Definition: cfftypes.h:250
FT_Pos pos_y
Definition: psaux.h:790
cff_builder_add_point(CFF_Builder *builder, FT_Pos x, FT_Pos y, FT_Byte flag)
Definition: psobjs.c:1879
static FT_Int ps_tocoordarray(FT_Byte **acur, FT_Byte *limit, FT_Int max_coords, FT_Short *coords)
Definition: psobjs.c:774
GLuint64EXT * result
Definition: glext.h:11304
ps_parser_to_token_array(PS_Parser parser, T1_Token tokens, FT_UInt max_tokens, FT_Int *pnum_tokens)
Definition: psobjs.c:721
FT_GlyphSlotRec root
Definition: cffotypes.h:62
#define FT_UNUSED(arg)
Definition: ftconfig.h:101
#define UL
Definition: tui.h:83
FT_UInt num_glyphs
Definition: psaux.h:904
#define IS_PS_XDIGIT(ch)
Definition: psaux.h:1351
t1_builder_check_points(T1_Builder builder, FT_Int count)
Definition: psobjs.c:1601
GLenum GLuint GLint GLenum face
Definition: glext.h:7025
FT_Generic cf2_instance
Definition: psaux.h:932
FT_Byte num_blue_values
Definition: cfftypes.h:242
size_t FT_Offset
Definition: fttypes.h:324
cff_builder_done(CFF_Builder *builder)
Definition: psobjs.c:1858
ps_builder_done(PS_Builder *builder)
Definition: psobjs.c:2133
FT_CALLBACK_TABLE_DEF const PS_Table_FuncsRec ps_table_funcs
Definition: psauxmod.c:33
CFF_SubFont subfont
Definition: cfftypes.h:274
ps_builder_add_point(PS_Builder *builder, FT_Pos x, FT_Pos y, FT_Byte flag)
Definition: psobjs.c:2154