ReactOS 0.4.16-dev-1067-ge98bba2
cffparse.c File Reference
#include <ft2build.h>
#include "cffparse.h"
#include "cfferrs.h"
#include "cffload.h"
#include "cfftoken.h"
Include dependency graph for cffparse.c:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros

#define FT_COMPONENT   cffparse
 
#define CFF_FIELD_NUM(code, name, id)    CFF_FIELD( code, name, id, cff_kind_num )
 
#define CFF_FIELD_FIXED(code, name, id)    CFF_FIELD( code, name, id, cff_kind_fixed )
 
#define CFF_FIELD_FIXED_1000(code, name, id)    CFF_FIELD( code, name, id, cff_kind_fixed_thousand )
 
#define CFF_FIELD_STRING(code, name, id)    CFF_FIELD( code, name, id, cff_kind_string )
 
#define CFF_FIELD_BOOL(code, name, id)    CFF_FIELD( code, name, id, cff_kind_bool )
 
#define CFF_FIELD_CALLBACK(code, name, id)
 
#define CFF_FIELD_BLEND(code, id)
 
#define CFF_FIELD(code, name, id, kind)
 
#define CFF_FIELD_DELTA(code, name, max, id)
 

Functions

 cff_parser_init (CFF_Parser parser, FT_UInt code, void *object, FT_Library library, FT_UInt stackSize, FT_UShort num_designs, FT_UShort num_axes)
 
 cff_parser_done (CFF_Parser parser)
 
static FT_Long cff_parse_integer (FT_Byte *start, FT_Byte *limit)
 
static FT_Fixed cff_parse_real (FT_Byte *start, FT_Byte *limit, FT_Long power_ten, FT_Long *scaling)
 
 cff_parse_num (CFF_Parser parser, FT_Byte **d)
 
static FT_Fixed do_fixed (CFF_Parser parser, FT_Byte **d, FT_Long scaling)
 
static FT_Fixed cff_parse_fixed (CFF_Parser parser, FT_Byte **d)
 
static FT_Fixed cff_parse_fixed_scaled (CFF_Parser parser, FT_Byte **d, FT_Long scaling)
 
static FT_Fixed cff_parse_fixed_dynamic (CFF_Parser parser, FT_Byte **d, FT_Long *scaling)
 
static FT_Error cff_parse_font_matrix (CFF_Parser parser)
 
static FT_Error cff_parse_font_bbox (CFF_Parser parser)
 
static FT_Error cff_parse_private_dict (CFF_Parser parser)
 
static FT_Error cff_parse_multiple_master (CFF_Parser parser)
 
static FT_Error cff_parse_cid_ros (CFF_Parser parser)
 
static FT_Error cff_parse_vsindex (CFF_Parser parser)
 
static FT_Error cff_parse_blend (CFF_Parser parser)
 
static FT_Error cff_parse_maxstack (CFF_Parser parser)
 
 cff_parser_run (CFF_Parser parser, FT_Byte *start, FT_Byte *limit)
 

Variables

static const FT_Long power_tens []
 
static const FT_Long power_ten_limits []
 
static const CFF_Field_Handler cff_field_handlers []
 

Macro Definition Documentation

◆ CFF_FIELD

#define CFF_FIELD (   code,
  name,
  id,
  kind 
)
Value:
{ \
kind, \
FT_FIELD_OFFSET( name ), \
FT_FIELD_SIZE( name ), \
0, 0, 0 \
},
#define CFFCODE
Definition: cfftoken.h:130
Definition: inflate.c:139
Definition: name.c:39

Definition at line 1038 of file cffparse.c.

◆ CFF_FIELD_BLEND

#define CFF_FIELD_BLEND (   code,
  id 
)
Value:
{ \
0, 0, \
0, 0 \
},
static FT_Error cff_parse_blend(CFF_Parser parser)
Definition: cffparse.c:919
@ cff_kind_blend
Definition: cffparse.h:104

Definition at line 1029 of file cffparse.c.

◆ CFF_FIELD_BOOL

#define CFF_FIELD_BOOL (   code,
  name,
  id 
)     CFF_FIELD( code, name, id, cff_kind_bool )

Definition at line 1009 of file cffparse.c.

◆ CFF_FIELD_CALLBACK

#define CFF_FIELD_CALLBACK (   code,
  name,
  id 
)
Value:
{ \
0, 0, \
cff_parse_ ## name, \
0, 0 \
},
@ cff_kind_callback
Definition: cffparse.h:103

Definition at line 1020 of file cffparse.c.

◆ CFF_FIELD_DELTA

#define CFF_FIELD_DELTA (   code,
  name,
  max,
  id 
)
Value:
{ \
FT_FIELD_OFFSET( name ), \
FT_FIELD_SIZE_DELTA( name ), \
0, \
max, \
FT_FIELD_OFFSET( num_ ## name ) \
},
@ cff_kind_delta
Definition: cffparse.h:102
#define max(a, b)
Definition: svc.c:63

Definition at line 1047 of file cffparse.c.

◆ CFF_FIELD_FIXED

#define CFF_FIELD_FIXED (   code,
  name,
  id 
)     CFF_FIELD( code, name, id, cff_kind_fixed )

Definition at line 1003 of file cffparse.c.

◆ CFF_FIELD_FIXED_1000

#define CFF_FIELD_FIXED_1000 (   code,
  name,
  id 
)     CFF_FIELD( code, name, id, cff_kind_fixed_thousand )

Definition at line 1005 of file cffparse.c.

◆ CFF_FIELD_NUM

#define CFF_FIELD_NUM (   code,
  name,
  id 
)     CFF_FIELD( code, name, id, cff_kind_num )

Definition at line 1001 of file cffparse.c.

◆ CFF_FIELD_STRING

#define CFF_FIELD_STRING (   code,
  name,
  id 
)     CFF_FIELD( code, name, id, cff_kind_string )

Definition at line 1007 of file cffparse.c.

◆ FT_COMPONENT

#define FT_COMPONENT   cffparse

Definition at line 38 of file cffparse.c.

Function Documentation

◆ cff_parse_blend()

static FT_Error cff_parse_blend ( CFF_Parser  parser)
static

Definition at line 919 of file cffparse.c.

920 {
921 /* blend operator can only be used in a Private DICT */
922 CFF_Private priv = (CFF_Private)parser->object;
923 CFF_SubFont subFont;
924 CFF_Blend blend;
925 FT_UInt numBlends;
927
928
929 if ( !priv || !priv->subfont )
930 {
931 error = FT_THROW( Invalid_File_Format );
932 goto Exit;
933 }
934
935 subFont = priv->subfont;
936 blend = &subFont->blend;
937
938 if ( cff_blend_check_vector( blend,
939 priv->vsindex,
940 subFont->lenNDV,
941 subFont->NDV ) )
942 {
944 priv->vsindex,
945 subFont->lenNDV,
946 subFont->NDV );
947 if ( error )
948 goto Exit;
949 }
950
951 numBlends = (FT_UInt)cff_parse_num( parser, parser->top - 1 );
952 if ( numBlends > parser->stackSize )
953 {
954 FT_ERROR(( "cff_parse_blend: Invalid number of blends\n" ));
955 error = FT_THROW( Invalid_File_Format );
956 goto Exit;
957 }
958
959 FT_TRACE4(( " %d value%s blended\n",
960 numBlends,
961 numBlends == 1 ? "" : "s" ));
962
963 error = cff_blend_doBlend( subFont, parser, numBlends );
964
965 blend->usedBV = TRUE;
966
967 Exit:
968 return error;
969 }
cff_blend_build_vector(CFF_Blend blend, FT_UInt vsindex, FT_UInt lenNDV, FT_Fixed *NDV)
Definition: cffload.c:1387
cff_blend_doBlend(CFF_SubFont subFont, CFF_Parser parser, FT_UInt numBlends)
Definition: cffload.c:1280
cff_blend_check_vector(CFF_Blend blend, FT_UInt vsindex, FT_UInt lenNDV, FT_Fixed *NDV)
Definition: cffload.c:1561
cff_parse_num(CFF_Parser parser, FT_Byte **d)
Definition: cffparse.c:454
struct CFF_PrivateRec_ * CFF_Private
#define TRUE
Definition: types.h:120
#define FT_ERROR(varformat)
Definition: ftdebug.h:209
#define FT_THROW(e)
Definition: ftdebug.h:241
#define FT_TRACE4(varformat)
Definition: ftdebug.h:189
int FT_Error
Definition: fttypes.h:299
unsigned int FT_UInt
Definition: fttypes.h:231
if(dx< 0)
Definition: linetemp.h:194
#define error(str)
Definition: mkdosfs.c:1605
static void Exit(void)
Definition: sock.c:1330
CFF_SubFont subfont
Definition: cfftypes.h:279
FT_UInt vsindex
Definition: cfftypes.h:278
CFF_BlendRec blend
Definition: cfftypes.h:309
Definition: import.c:81

◆ cff_parse_cid_ros()

static FT_Error cff_parse_cid_ros ( CFF_Parser  parser)
static

Definition at line 851 of file cffparse.c.

852 {
853 CFF_FontRecDict dict = (CFF_FontRecDict)parser->object;
856
857
858 error = FT_ERR( Stack_Underflow );
859
860 if ( parser->top >= parser->stack + 3 )
861 {
864 if ( **data == 30 )
865 FT_TRACE1(( "cff_parse_cid_ros: real supplement is rounded\n" ));
867 if ( dict->cid_supplement < 0 )
868 FT_TRACE1(( "cff_parse_cid_ros: negative supplement %d is found\n",
869 dict->cid_supplement ));
871
872 FT_TRACE4(( " %d %d %d\n",
873 dict->cid_registry,
874 dict->cid_ordering,
875 dict->cid_supplement ));
876 }
877
878 return error;
879 }
struct CFF_FontRecDictRec_ * CFF_FontRecDict
return FT_Err_Ok
Definition: ftbbox.c:527
#define FT_TRACE1(varformat)
Definition: ftdebug.h:186
unsigned char FT_Byte
Definition: fttypes.h:154
#define FT_ERR(e)
Definition: fttypes.h:599
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
FT_UInt cid_ordering
Definition: cfftypes.h:216
FT_UInt cid_registry
Definition: cfftypes.h:215
FT_Long cid_supplement
Definition: cfftypes.h:217
enum parser_state stack[4]
Definition: inffile.c:91

◆ cff_parse_fixed()

static FT_Fixed cff_parse_fixed ( CFF_Parser  parser,
FT_Byte **  d 
)
static

Definition at line 536 of file cffparse.c.

538 {
539 return do_fixed( parser, d, 0 );
540 }
static FT_Fixed do_fixed(CFF_Parser parser, FT_Byte **d, FT_Long scaling)
Definition: cffparse.c:492
#define d
Definition: ke_i.h:81

Referenced by cff_parse_font_bbox(), and cff_parser_run().

◆ cff_parse_fixed_dynamic()

static FT_Fixed cff_parse_fixed_dynamic ( CFF_Parser  parser,
FT_Byte **  d,
FT_Long scaling 
)
static

Definition at line 558 of file cffparse.c.

561 {
562 FT_ASSERT( scaling );
563
564 if ( **d == 30 )
565 return cff_parse_real( *d, parser->limit, 0, scaling );
566 else
567 {
569 FT_Int integer_length;
570
571
572 number = cff_parse_integer( d[0], d[1] );
573
574 if ( number > 0x7FFFL )
575 {
576 for ( integer_length = 5; integer_length < 10; integer_length++ )
577 if ( number < power_tens[integer_length] )
578 break;
579
580 if ( ( number / power_tens[integer_length - 5] ) > 0x7FFFL )
581 {
582 *scaling = integer_length - 4;
583 return FT_DivFix( number, power_tens[integer_length - 4] );
584 }
585 else
586 {
587 *scaling = integer_length - 5;
588 return FT_DivFix( number, power_tens[integer_length - 5] );
589 }
590 }
591 else
592 {
593 *scaling = 0;
594 return (FT_Long)( (FT_ULong)number << 16 );
595 }
596 }
597 }
static FT_Long cff_parse_integer(FT_Byte *start, FT_Byte *limit)
Definition: cffparse.c:92
static const FT_Long power_tens[]
Definition: cffparse.c:146
static FT_Fixed cff_parse_real(FT_Byte *start, FT_Byte *limit, FT_Long power_ten, FT_Long *scaling)
Definition: cffparse.c:179
FT_DivFix(FT_Long a, FT_Long b)
Definition: ftcalc.c:608
#define FT_ASSERT(condition)
Definition: ftdebug.h:239
unsigned long FT_ULong
Definition: fttypes.h:253
signed long FT_Long
Definition: fttypes.h:242
signed int FT_Int
Definition: fttypes.h:220
static unsigned int number
Definition: dsound.c:1479

Referenced by cff_parse_font_matrix().

◆ cff_parse_fixed_scaled()

static FT_Fixed cff_parse_fixed_scaled ( CFF_Parser  parser,
FT_Byte **  d,
FT_Long  scaling 
)
static

Definition at line 546 of file cffparse.c.

549 {
550 return do_fixed( parser, d, scaling );
551 }

Referenced by cff_parser_run().

◆ cff_parse_font_bbox()

static FT_Error cff_parse_font_bbox ( CFF_Parser  parser)
static

Definition at line 727 of file cffparse.c.

728 {
729 CFF_FontRecDict dict = (CFF_FontRecDict)parser->object;
730 FT_BBox* bbox = &dict->font_bbox;
733
734
735 error = FT_ERR( Stack_Underflow );
736
737 if ( parser->top >= parser->stack + 4 )
738 {
744
745 FT_TRACE4(( " [%d %d %d %d]\n",
746 bbox->xMin / 65536,
747 bbox->yMin / 65536,
748 bbox->xMax / 65536,
749 bbox->yMax / 65536 ));
750 }
751
752 return error;
753 }
static FT_Fixed cff_parse_fixed(CFF_Parser parser, FT_Byte **d)
Definition: cffparse.c:536
FT_RoundFix(FT_Fixed a)
Definition: ftcalc.c:88
FT_BBox bbox
Definition: ftbbox.c:468
FT_Pos xMin
Definition: ftimage.h:121
FT_Pos yMax
Definition: ftimage.h:122
FT_Pos yMin
Definition: ftimage.h:121
FT_Pos xMax
Definition: ftimage.h:122

◆ cff_parse_font_matrix()

static FT_Error cff_parse_font_matrix ( CFF_Parser  parser)
static

Definition at line 601 of file cffparse.c.

602 {
603 CFF_FontRecDict dict = (CFF_FontRecDict)parser->object;
604 FT_Matrix* matrix = &dict->font_matrix;
605 FT_Vector* offset = &dict->font_offset;
606 FT_ULong* upm = &dict->units_per_em;
608
609
610 if ( parser->top >= parser->stack + 6 )
611 {
612 FT_Fixed values[6];
613 FT_Long scalings[6];
614
615 FT_Long min_scaling, max_scaling;
616 int i;
617
618
619 dict->has_font_matrix = TRUE;
620
621 /* We expect a well-formed font matrix, this is, the matrix elements */
622 /* `xx' and `yy' are of approximately the same magnitude. To avoid */
623 /* loss of precision, we use the magnitude of the largest matrix */
624 /* element to scale all other elements. The scaling factor is then */
625 /* contained in the `units_per_em' value. */
626
627 max_scaling = FT_LONG_MIN;
628 min_scaling = FT_LONG_MAX;
629
630 for ( i = 0; i < 6; i++ )
631 {
632 values[i] = cff_parse_fixed_dynamic( parser, data++, &scalings[i] );
633 if ( values[i] )
634 {
635 if ( scalings[i] > max_scaling )
636 max_scaling = scalings[i];
637 if ( scalings[i] < min_scaling )
638 min_scaling = scalings[i];
639 }
640 }
641
642 if ( max_scaling < -9 ||
643 max_scaling > 0 ||
644 ( max_scaling - min_scaling ) < 0 ||
645 ( max_scaling - min_scaling ) > 9 )
646 {
647 FT_TRACE1(( "cff_parse_font_matrix:"
648 " strange scaling values (minimum %d, maximum %d),\n"
649 " "
650 " using default matrix\n", min_scaling, max_scaling ));
651 goto Unlikely;
652 }
653
654 for ( i = 0; i < 6; i++ )
655 {
657 FT_Long divisor, half_divisor;
658
659
660 if ( !value )
661 continue;
662
663 divisor = power_tens[max_scaling - scalings[i]];
664 half_divisor = divisor >> 1;
665
666 if ( value < 0 )
667 {
668 if ( FT_LONG_MIN + half_divisor < value )
669 values[i] = ( value - half_divisor ) / divisor;
670 else
672 }
673 else
674 {
675 if ( FT_LONG_MAX - half_divisor > value )
676 values[i] = ( value + half_divisor ) / divisor;
677 else
679 }
680 }
681
682 matrix->xx = values[0];
683 matrix->yx = values[1];
684 matrix->xy = values[2];
685 matrix->yy = values[3];
686 offset->x = values[4];
687 offset->y = values[5];
688
689 *upm = (FT_ULong)power_tens[-max_scaling];
690
691 FT_TRACE4(( " [%f %f %f %f %f %f]\n",
692 (double)matrix->xx / *upm / 65536,
693 (double)matrix->xy / *upm / 65536,
694 (double)matrix->yx / *upm / 65536,
695 (double)matrix->yy / *upm / 65536,
696 (double)offset->x / *upm / 65536,
697 (double)offset->y / *upm / 65536 ));
698
699 if ( !FT_Matrix_Check( matrix ) )
700 {
701 FT_TRACE1(( "cff_parse_font_matrix:"
702 " degenerate values, using default matrix\n" ));
703 goto Unlikely;
704 }
705
706 return FT_Err_Ok;
707 }
708 else
709 return FT_THROW( Stack_Underflow );
710
711 Unlikely:
712 /* Return default matrix in case of unlikely values. */
713
714 matrix->xx = 0x10000L;
715 matrix->yx = 0;
716 matrix->xy = 0;
717 matrix->yy = 0x10000L;
718 offset->x = 0;
719 offset->y = 0;
720 *upm = 1;
721
722 return FT_Err_Ok;
723 }
static FT_Fixed cff_parse_fixed_dynamic(CFF_Parser parser, FT_Byte **d, FT_Long *scaling)
Definition: cffparse.c:558
FT_Matrix_Check(const FT_Matrix *matrix)
Definition: ftcalc.c:751
#define FT_LONG_MIN
Definition: ftstdlib.h:66
#define FT_LONG_MAX
Definition: ftstdlib.h:67
signed long FT_Fixed
Definition: fttypes.h:287
GLintptr offset
Definition: glext.h:5920
GLuint GLenum matrix
Definition: glext.h:9407
GLuint divisor
Definition: glext.h:6313
GLboolean GLenum GLenum GLvoid * values
Definition: glext.h:5666
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
FT_Bool has_font_matrix
Definition: cfftypes.h:200
FT_Vector font_offset
Definition: cfftypes.h:202
FT_ULong units_per_em
Definition: cfftypes.h:201
FT_Matrix font_matrix
Definition: cfftypes.h:199
Definition: pdh_main.c:96

◆ cff_parse_integer()

static FT_Long cff_parse_integer ( FT_Byte start,
FT_Byte limit 
)
static

Definition at line 92 of file cffparse.c.

94 {
95 FT_Byte* p = start;
96 FT_Int v = *p++;
97 FT_Long val = 0;
98
99
100 if ( v == 28 )
101 {
102 if ( p + 2 > limit )
103 goto Bad;
104
105 val = (FT_Short)( ( (FT_UShort)p[0] << 8 ) | p[1] );
106 }
107 else if ( v == 29 )
108 {
109 if ( p + 4 > limit )
110 goto Bad;
111
112 val = (FT_Long)( ( (FT_ULong)p[0] << 24 ) |
113 ( (FT_ULong)p[1] << 16 ) |
114 ( (FT_ULong)p[2] << 8 ) |
115 (FT_ULong)p[3] );
116 }
117 else if ( v < 247 )
118 {
119 val = v - 139;
120 }
121 else if ( v < 251 )
122 {
123 if ( p + 1 > limit )
124 goto Bad;
125
126 val = ( v - 247 ) * 256 + p[0] + 108;
127 }
128 else
129 {
130 if ( p + 1 > limit )
131 goto Bad;
132
133 val = -( v - 251 ) * 256 - p[0] - 108;
134 }
135
136 Exit:
137 return val;
138
139 Bad:
140 val = 0;
141 FT_TRACE4(( "!!!END OF DATA:!!!" ));
142 goto Exit;
143 }
unsigned short FT_UShort
Definition: fttypes.h:209
signed short FT_Short
Definition: fttypes.h:198
GLuint start
Definition: gl.h:1545
const GLdouble * v
Definition: gl.h:2040
GLint limit
Definition: glext.h:10326
GLuint GLfloat * val
Definition: glext.h:7180
GLfloat GLfloat p
Definition: glext.h:8902

Referenced by cff_parse_fixed_dynamic(), cff_parse_num(), and do_fixed().

◆ cff_parse_maxstack()

static FT_Error cff_parse_maxstack ( CFF_Parser  parser)
static

Definition at line 974 of file cffparse.c.

975 {
976 /* maxstack operator can only be used in a Top DICT */
977 CFF_FontRecDict dict = (CFF_FontRecDict)parser->object;
980
981
982 if ( !dict )
983 {
984 error = FT_THROW( Invalid_File_Format );
985 goto Exit;
986 }
987
989 if ( dict->maxstack > CFF2_MAX_STACK )
990 dict->maxstack = CFF2_MAX_STACK;
991 if ( dict->maxstack < CFF2_DEFAULT_STACK )
993
994 FT_TRACE4(( " %d\n", dict->maxstack ));
995
996 Exit:
997 return error;
998 }
#define CFF2_DEFAULT_STACK
Definition: cffparse.h:43
#define CFF2_MAX_STACK
Definition: cffparse.h:42

◆ cff_parse_multiple_master()

static FT_Error cff_parse_multiple_master ( CFF_Parser  parser)
static

Definition at line 804 of file cffparse.c.

805 {
806 CFF_FontRecDict dict = (CFF_FontRecDict)parser->object;
808
809
810#ifdef FT_DEBUG_LEVEL_TRACE
811 /* beautify tracing message */
812 if ( ft_trace_levels[FT_TRACE_COMP( FT_COMPONENT )] < 4 )
813 FT_TRACE1(( "Multiple Master CFFs not supported yet,"
814 " handling first master design only\n" ));
815 else
816 FT_TRACE1(( " (not supported yet,"
817 " handling first master design only)\n" ));
818#endif
819
820 error = FT_ERR( Stack_Underflow );
821
822 /* currently, we handle only the first argument */
823 if ( parser->top >= parser->stack + 5 )
824 {
825 FT_Long num_designs = cff_parse_num( parser, parser->stack );
826
827
828 if ( num_designs > 16 || num_designs < 2 )
829 {
830 FT_ERROR(( "cff_parse_multiple_master:"
831 " Invalid number of designs\n" ));
832 error = FT_THROW( Invalid_File_Format );
833 }
834 else
835 {
836 dict->num_designs = (FT_UShort)num_designs;
837 dict->num_axes = (FT_UShort)( parser->top - parser->stack - 4 );
838
839 parser->num_designs = dict->num_designs;
840 parser->num_axes = dict->num_axes;
841
843 }
844 }
845
846 return error;
847 }
#define FT_COMPONENT
Definition: cffparse.c:38
FT_UShort num_designs
Definition: cfftypes.h:231
FT_UShort num_axes
Definition: cfftypes.h:232

◆ cff_parse_num()

cff_parse_num ( CFF_Parser  parser,
FT_Byte **  d 
)

Definition at line 454 of file cffparse.c.

456 {
457 if ( **d == 30 )
458 {
459 /* binary-coded decimal is truncated to integer */
460 return cff_parse_real( *d, parser->limit, 0, NULL ) >> 16;
461 }
462
463 else if ( **d == 255 )
464 {
465 /* 16.16 fixed point is used internally for CFF2 blend results. */
466 /* Since these are trusted values, a limit check is not needed. */
467
468 /* After the 255, 4 bytes give the number. */
469 /* The blend value is converted to integer, with rounding; */
470 /* due to the right-shift we don't need the lowest byte. */
471#if 0
472 return (FT_Short)(
473 ( ( ( (FT_UInt32)*( d[0] + 1 ) << 24 ) |
474 ( (FT_UInt32)*( d[0] + 2 ) << 16 ) |
475 ( (FT_UInt32)*( d[0] + 3 ) << 8 ) |
476 (FT_UInt32)*( d[0] + 4 ) ) + 0x8000U ) >> 16 );
477#else
478 return (FT_Short)(
479 ( ( ( (FT_UInt32)*( d[0] + 1 ) << 16 ) |
480 ( (FT_UInt32)*( d[0] + 2 ) << 8 ) |
481 (FT_UInt32)*( d[0] + 3 ) ) + 0x80U ) >> 8 );
482#endif
483 }
484
485 else
486 return cff_parse_integer( *d, parser->limit );
487 }
#define NULL
Definition: types.h:112

Referenced by cff_blend_doBlend(), cff_parse_blend(), cff_parse_cid_ros(), cff_parse_maxstack(), cff_parse_multiple_master(), cff_parse_private_dict(), cff_parse_vsindex(), and cff_parser_run().

◆ cff_parse_private_dict()

static FT_Error cff_parse_private_dict ( CFF_Parser  parser)
static

Definition at line 757 of file cffparse.c.

758 {
759 CFF_FontRecDict dict = (CFF_FontRecDict)parser->object;
762
763
764 error = FT_ERR( Stack_Underflow );
765
766 if ( parser->top >= parser->stack + 2 )
767 {
768 FT_Long tmp;
769
770
771 tmp = cff_parse_num( parser, data++ );
772 if ( tmp < 0 )
773 {
774 FT_ERROR(( "cff_parse_private_dict: Invalid dictionary size\n" ));
775 error = FT_THROW( Invalid_File_Format );
776 goto Fail;
777 }
778 dict->private_size = (FT_ULong)tmp;
779
780 tmp = cff_parse_num( parser, data );
781 if ( tmp < 0 )
782 {
783 FT_ERROR(( "cff_parse_private_dict: Invalid dictionary offset\n" ));
784 error = FT_THROW( Invalid_File_Format );
785 goto Fail;
786 }
787 dict->private_offset = (FT_ULong)tmp;
788
789 FT_TRACE4(( " %lu %lu\n",
790 dict->private_size, dict->private_offset ));
791
793 }
794
795 Fail:
796 return error;
797 }
int Fail
Definition: ehthrow.cxx:24
FT_ULong private_size
Definition: cfftypes.h:210
FT_ULong private_offset
Definition: cfftypes.h:209

◆ cff_parse_real()

static FT_Fixed cff_parse_real ( FT_Byte start,
FT_Byte limit,
FT_Long  power_ten,
FT_Long scaling 
)
static

Definition at line 179 of file cffparse.c.

183 {
184 FT_Byte* p = start;
185 FT_Int nib;
186 FT_UInt phase;
187
189 FT_Int sign = 0, exponent_sign = 0, have_overflow = 0;
190 FT_Long exponent_add, integer_length, fraction_length;
191
192
193 if ( scaling )
194 *scaling = 0;
195
196 result = 0;
197
198 number = 0;
199 exponent = 0;
200
201 exponent_add = 0;
202 integer_length = 0;
203 fraction_length = 0;
204
205 /* First of all, read the integer part. */
206 phase = 4;
207
208 for (;;)
209 {
210 /* If we entered this iteration with phase == 4, we need to */
211 /* read a new byte. This also skips past the initial 0x1E. */
212 if ( phase )
213 {
214 p++;
215
216 /* Make sure we don't read past the end. */
217 if ( p >= limit )
218 goto Bad;
219 }
220
221 /* Get the nibble. */
222 nib = (FT_Int)( p[0] >> phase ) & 0xF;
223 phase = 4 - phase;
224
225 if ( nib == 0xE )
226 sign = 1;
227 else if ( nib > 9 )
228 break;
229 else
230 {
231 /* Increase exponent if we can't add the digit. */
232 if ( number >= 0xCCCCCCCL )
233 exponent_add++;
234 /* Skip leading zeros. */
235 else if ( nib || number )
236 {
237 integer_length++;
238 number = number * 10 + nib;
239 }
240 }
241 }
242
243 /* Read fraction part, if any. */
244 if ( nib == 0xA )
245 for (;;)
246 {
247 /* If we entered this iteration with phase == 4, we need */
248 /* to read a new byte. */
249 if ( phase )
250 {
251 p++;
252
253 /* Make sure we don't read past the end. */
254 if ( p >= limit )
255 goto Bad;
256 }
257
258 /* Get the nibble. */
259 nib = ( p[0] >> phase ) & 0xF;
260 phase = 4 - phase;
261 if ( nib >= 10 )
262 break;
263
264 /* Skip leading zeros if possible. */
265 if ( !nib && !number )
266 exponent_add--;
267 /* Only add digit if we don't overflow. */
268 else if ( number < 0xCCCCCCCL && fraction_length < 9 )
269 {
270 fraction_length++;
271 number = number * 10 + nib;
272 }
273 }
274
275 /* Read exponent, if any. */
276 if ( nib == 12 )
277 {
278 exponent_sign = 1;
279 nib = 11;
280 }
281
282 if ( nib == 11 )
283 {
284 for (;;)
285 {
286 /* If we entered this iteration with phase == 4, */
287 /* we need to read a new byte. */
288 if ( phase )
289 {
290 p++;
291
292 /* Make sure we don't read past the end. */
293 if ( p >= limit )
294 goto Bad;
295 }
296
297 /* Get the nibble. */
298 nib = ( p[0] >> phase ) & 0xF;
299 phase = 4 - phase;
300 if ( nib >= 10 )
301 break;
302
303 /* Arbitrarily limit exponent. */
304 if ( exponent > 1000 )
305 have_overflow = 1;
306 else
307 exponent = exponent * 10 + nib;
308 }
309
310 if ( exponent_sign )
312 }
313
314 if ( !number )
315 goto Exit;
316
317 if ( have_overflow )
318 {
319 if ( exponent_sign )
320 goto Underflow;
321 else
322 goto Overflow;
323 }
324
325 /* We don't check `power_ten' and `exponent_add'. */
326 exponent += power_ten + exponent_add;
327
328 if ( scaling )
329 {
330 /* Only use `fraction_length'. */
331 fraction_length += integer_length;
332 exponent += integer_length;
333
334 if ( fraction_length <= 5 )
335 {
336 if ( number > 0x7FFFL )
337 {
338 result = FT_DivFix( number, 10 );
339 *scaling = exponent - fraction_length + 1;
340 }
341 else
342 {
343 if ( exponent > 0 )
344 {
345 FT_Long new_fraction_length, shift;
346
347
348 /* Make `scaling' as small as possible. */
349 new_fraction_length = FT_MIN( exponent, 5 );
350 shift = new_fraction_length - fraction_length;
351
352 if ( shift > 0 )
353 {
354 exponent -= new_fraction_length;
356 if ( number > 0x7FFFL )
357 {
358 number /= 10;
359 exponent += 1;
360 }
361 }
362 else
363 exponent -= fraction_length;
364 }
365 else
366 exponent -= fraction_length;
367
368 result = (FT_Long)( (FT_ULong)number << 16 );
369 *scaling = exponent;
370 }
371 }
372 else
373 {
374 if ( ( number / power_tens[fraction_length - 5] ) > 0x7FFFL )
375 {
376 result = FT_DivFix( number, power_tens[fraction_length - 4] );
377 *scaling = exponent - 4;
378 }
379 else
380 {
381 result = FT_DivFix( number, power_tens[fraction_length - 5] );
382 *scaling = exponent - 5;
383 }
384 }
385 }
386 else
387 {
388 integer_length += exponent;
389 fraction_length -= exponent;
390
391 if ( integer_length > 5 )
392 goto Overflow;
393 if ( integer_length < -5 )
394 goto Underflow;
395
396 /* Remove non-significant digits. */
397 if ( integer_length < 0 )
398 {
399 number /= power_tens[-integer_length];
400 fraction_length += integer_length;
401 }
402
403 /* this can only happen if exponent was non-zero */
404 if ( fraction_length == 10 )
405 {
406 number /= 10;
407 fraction_length -= 1;
408 }
409
410 /* Convert into 16.16 format. */
411 if ( fraction_length > 0 )
412 {
413 if ( ( number / power_tens[fraction_length] ) > 0x7FFFL )
414 goto Exit;
415
416 result = FT_DivFix( number, power_tens[fraction_length] );
417 }
418 else
419 {
420 number *= power_tens[-fraction_length];
421
422 if ( number > 0x7FFFL )
423 goto Overflow;
424
425 result = (FT_Long)( (FT_ULong)number << 16 );
426 }
427 }
428
429 Exit:
430 if ( sign )
431 result = -result;
432
433 return result;
434
435 Overflow:
436 result = 0x7FFFFFFFL;
437 FT_TRACE4(( "!!!OVERFLOW:!!!" ));
438 goto Exit;
439
440 Underflow:
441 result = 0;
442 FT_TRACE4(( "!!!UNDERFLOW:!!!" ));
443 goto Exit;
444
445 Bad:
446 result = 0;
447 FT_TRACE4(( "!!!END OF DATA:!!!" ));
448 goto Exit;
449 }
__int64 exponent
Definition: cvt.cpp:529
#define FT_MIN(a, b)
Definition: ftobjs.h:70
GLuint64EXT * result
Definition: glext.h:11304
#define sign(x)
Definition: mapdesc.cc:613
#define shift
Definition: input.c:1755

Referenced by cff_parse_fixed_dynamic(), cff_parse_num(), and do_fixed().

◆ cff_parse_vsindex()

static FT_Error cff_parse_vsindex ( CFF_Parser  parser)
static

Definition at line 883 of file cffparse.c.

884 {
885 /* vsindex operator can only be used in a Private DICT */
886 CFF_Private priv = (CFF_Private)parser->object;
888 CFF_Blend blend;
890
891
892 if ( !priv || !priv->subfont )
893 {
894 error = FT_THROW( Invalid_File_Format );
895 goto Exit;
896 }
897
898 blend = &priv->subfont->blend;
899
900 if ( blend->usedBV )
901 {
902 FT_ERROR(( " cff_parse_vsindex: vsindex not allowed after blend\n" ));
903 error = FT_THROW( Syntax_Error );
904 goto Exit;
905 }
906
907 priv->vsindex = (FT_UInt)cff_parse_num( parser, data++ );
908
909 FT_TRACE4(( " %d\n", priv->vsindex ));
910
912
913 Exit:
914 return error;
915 }

◆ cff_parser_done()

cff_parser_done ( CFF_Parser  parser)

Definition at line 81 of file cffparse.c.

82 {
83 FT_Memory memory = parser->library->memory; /* for FT_FREE */
84
85
87 }
#define FT_FREE(ptr)
Definition: ftmemory.h:328
typedefFT_BEGIN_HEADER struct FT_MemoryRec_ * FT_Memory
Definition: ftsystem.h:65
static char memory[1024 *256]
Definition: process.c:116

Referenced by cff_load_private_dict(), and cff_subfont_load().

◆ cff_parser_init()

cff_parser_init ( CFF_Parser  parser,
FT_UInt  code,
void object,
FT_Library  library,
FT_UInt  stackSize,
FT_UShort  num_designs,
FT_UShort  num_axes 
)

Definition at line 42 of file cffparse.c.

49 {
50 FT_Memory memory = library->memory; /* for FT_NEW_ARRAY */
51 FT_Error error; /* for FT_NEW_ARRAY */
52
53
54 FT_ZERO( parser );
55
56#if 0
57 parser->top = parser->stack;
58#endif
59 parser->object_code = code;
60 parser->object = object;
61 parser->library = library;
62 parser->num_designs = num_designs;
63 parser->num_axes = num_axes;
64
65 /* allocate the stack buffer */
66 if ( FT_NEW_ARRAY( parser->stack, stackSize ) )
67 {
69 goto Exit;
70 }
71
72 parser->stackSize = stackSize;
73 parser->top = parser->stack; /* empty stack */
74
75 Exit:
76 return error;
77 }
FT_Library library
Definition: cffdrivr.c:661
#define FT_NEW_ARRAY(ptr, count)
Definition: ftmemory.h:332
#define FT_ZERO(p)
Definition: ftmemory.h:237
FT_Memory memory
Definition: ftobjs.h:897

Referenced by cff_load_private_dict(), and cff_subfont_load().

◆ cff_parser_run()

cff_parser_run ( CFF_Parser  parser,
FT_Byte start,
FT_Byte limit 
)

Definition at line 1138 of file cffparse.c.

1141 {
1142 FT_Byte* p = start;
1144
1145#ifdef CFF_CONFIG_OPTION_OLD_ENGINE
1146 PSAux_Service psaux;
1147
1148 FT_Library library = parser->library;
1150
1151 FT_ListRec t2s;
1152
1153
1154 FT_ZERO( &t2s );
1155#endif
1156
1157 parser->top = parser->stack;
1158 parser->start = start;
1159 parser->limit = limit;
1160 parser->cursor = start;
1161
1162 while ( p < limit )
1163 {
1164 FT_UInt v = *p;
1165
1166
1167 /* Opcode 31 is legacy MM T2 operator, not a number. */
1168 /* Opcode 255 is reserved and should not appear in fonts; */
1169 /* it is used internally for CFF2 blends. */
1170 if ( v >= 27 && v != 31 && v != 255 )
1171 {
1172 /* it's a number; we will push its position on the stack */
1173 if ( (FT_UInt)( parser->top - parser->stack ) >= parser->stackSize )
1174 goto Stack_Overflow;
1175
1176 *parser->top++ = p;
1177
1178 /* now, skip it */
1179 if ( v == 30 )
1180 {
1181 /* skip real number */
1182 p++;
1183 for (;;)
1184 {
1185 /* An unterminated floating point number at the */
1186 /* end of a dictionary is invalid but harmless. */
1187 if ( p >= limit )
1188 goto Exit;
1189 v = p[0] >> 4;
1190 if ( v == 15 )
1191 break;
1192 v = p[0] & 0xF;
1193 if ( v == 15 )
1194 break;
1195 p++;
1196 }
1197 }
1198 else if ( v == 28 )
1199 p += 2;
1200 else if ( v == 29 )
1201 p += 4;
1202 else if ( v > 246 )
1203 p += 1;
1204 }
1205#ifdef CFF_CONFIG_OPTION_OLD_ENGINE
1206 else if ( v == 31 )
1207 {
1208 /* a Type 2 charstring */
1209
1211 CFF_FontRec cff_rec;
1212 FT_Byte* charstring_base;
1213 FT_ULong charstring_len;
1214
1215 FT_Fixed* stack;
1217 FT_Byte* q;
1218
1219
1220 charstring_base = ++p;
1221
1222 /* search `endchar' operator */
1223 for (;;)
1224 {
1225 if ( p >= limit )
1226 goto Exit;
1227 if ( *p == 14 )
1228 break;
1229 p++;
1230 }
1231
1232 charstring_len = (FT_ULong)( p - charstring_base ) + 1;
1233
1234 /* construct CFF_Decoder object */
1235 FT_ZERO( &decoder );
1236 FT_ZERO( &cff_rec );
1237
1238 cff_rec.top_font.font_dict.num_designs = parser->num_designs;
1239 cff_rec.top_font.font_dict.num_axes = parser->num_axes;
1240 decoder.cff = &cff_rec;
1241
1242 psaux = (PSAux_Service)FT_Get_Module_Interface( library, "psaux" );
1243 if ( !psaux )
1244 {
1245 FT_ERROR(( "cff_parser_run: cannot access `psaux' module\n" ));
1246 error = FT_THROW( Missing_Module );
1247 goto Exit;
1248 }
1249
1250 error = psaux->cff_decoder_funcs->parse_charstrings_old(
1251 &decoder, charstring_base, charstring_len, 1 );
1252 if ( error )
1253 goto Exit;
1254
1255 /* Now copy the stack data in the temporary decoder object, */
1256 /* converting it back to charstring number representations */
1257 /* (this is ugly, I know). */
1258
1259 node = (FT_ListNode)memory->alloc( memory,
1260 sizeof ( FT_ListNodeRec ) );
1261 if ( !node )
1262 goto Out_Of_Memory_Error;
1263
1264 /* `5' is the conservative upper bound of required bytes per stack */
1265 /* element. */
1266 q = (FT_Byte*)memory->alloc( memory,
1267 5 * ( decoder.top - decoder.stack ) );
1268 if ( !q )
1269 goto Out_Of_Memory_Error;
1270
1271 node->data = q;
1272
1273 FT_List_Add( &t2s, node );
1274
1275 stack = decoder.stack;
1276
1277 while ( stack < decoder.top )
1278 {
1279 FT_ULong num;
1280 FT_Bool neg;
1281
1282
1283 if ( (FT_UInt)( parser->top - parser->stack ) >= parser->stackSize )
1284 goto Stack_Overflow;
1285
1286 *parser->top++ = q;
1287
1288 if ( *stack < 0 )
1289 {
1290 num = (FT_ULong)NEG_LONG( *stack );
1291 neg = 1;
1292 }
1293 else
1294 {
1295 num = (FT_ULong)*stack;
1296 neg = 0;
1297 }
1298
1299 if ( num & 0xFFFFU )
1300 {
1301 if ( neg )
1302 num = (FT_ULong)-num;
1303
1304 *q++ = 255;
1305 *q++ = ( num & 0xFF000000U ) >> 24;
1306 *q++ = ( num & 0x00FF0000U ) >> 16;
1307 *q++ = ( num & 0x0000FF00U ) >> 8;
1308 *q++ = num & 0x000000FFU;
1309 }
1310 else
1311 {
1312 num >>= 16;
1313
1314 if ( neg )
1315 {
1316 if ( num <= 107 )
1317 *q++ = (FT_Byte)( 139 - num );
1318 else if ( num <= 1131 )
1319 {
1320 *q++ = (FT_Byte)( ( ( num - 108 ) >> 8 ) + 251 );
1321 *q++ = (FT_Byte)( ( num - 108 ) & 0xFF );
1322 }
1323 else
1324 {
1325 num = (FT_ULong)-num;
1326
1327 *q++ = 28;
1328 *q++ = (FT_Byte)( num >> 8 );
1329 *q++ = (FT_Byte)( num & 0xFF );
1330 }
1331 }
1332 else
1333 {
1334 if ( num <= 107 )
1335 *q++ = (FT_Byte)( num + 139 );
1336 else if ( num <= 1131 )
1337 {
1338 *q++ = (FT_Byte)( ( ( num - 108 ) >> 8 ) + 247 );
1339 *q++ = (FT_Byte)( ( num - 108 ) & 0xFF );
1340 }
1341 else
1342 {
1343 *q++ = 28;
1344 *q++ = (FT_Byte)( num >> 8 );
1345 *q++ = (FT_Byte)( num & 0xFF );
1346 }
1347 }
1348 }
1349
1350 stack++;
1351 }
1352 }
1353#endif /* CFF_CONFIG_OPTION_OLD_ENGINE */
1354 else
1355 {
1356 /* This is not a number, hence it's an operator. Compute its code */
1357 /* and look for it in our current list. */
1358
1359 FT_UInt code;
1360 FT_UInt num_args;
1361 const CFF_Field_Handler* field;
1362
1363
1364 if ( (FT_UInt)( parser->top - parser->stack ) >= parser->stackSize )
1365 goto Stack_Overflow;
1366
1367 num_args = (FT_UInt)( parser->top - parser->stack );
1368 *parser->top = p;
1369 code = v;
1370
1371 if ( v == 12 )
1372 {
1373 /* two byte operator */
1374 p++;
1375 if ( p >= limit )
1376 goto Syntax_Error;
1377
1378 code = 0x100 | p[0];
1379 }
1380 code = code | parser->object_code;
1381
1382 for ( field = cff_field_handlers; field->kind; field++ )
1383 {
1384 if ( field->code == (FT_Int)code )
1385 {
1386 /* we found our field's handler; read it */
1387 FT_Long val;
1388 FT_Byte* q = (FT_Byte*)parser->object + field->offset;
1389
1390
1391#ifdef FT_DEBUG_LEVEL_TRACE
1392 FT_TRACE4(( " %s", field->id ));
1393#endif
1394
1395 /* check that we have enough arguments -- except for */
1396 /* delta encoded arrays, which can be empty */
1397 if ( field->kind != cff_kind_delta && num_args < 1 )
1398 goto Stack_Underflow;
1399
1400 switch ( field->kind )
1401 {
1402 case cff_kind_bool:
1403 case cff_kind_string:
1404 case cff_kind_num:
1406 goto Store_Number;
1407
1408 case cff_kind_fixed:
1410 goto Store_Number;
1411
1414
1415 Store_Number:
1416 switch ( field->size )
1417 {
1418 case (8 / FT_CHAR_BIT):
1419 *(FT_Byte*)q = (FT_Byte)val;
1420 break;
1421
1422 case (16 / FT_CHAR_BIT):
1423 *(FT_Short*)q = (FT_Short)val;
1424 break;
1425
1426 case (32 / FT_CHAR_BIT):
1427 *(FT_Int32*)q = (FT_Int)val;
1428 break;
1429
1430 default: /* for 64-bit systems */
1431 *(FT_Long*)q = val;
1432 }
1433
1434#ifdef FT_DEBUG_LEVEL_TRACE
1435 switch ( field->kind )
1436 {
1437 case cff_kind_bool:
1438 FT_TRACE4(( " %s\n", val ? "true" : "false" ));
1439 break;
1440
1441 case cff_kind_string:
1442 FT_TRACE4(( " %ld (SID)\n", val ));
1443 break;
1444
1445 case cff_kind_num:
1446 FT_TRACE4(( " %ld\n", val ));
1447 break;
1448
1449 case cff_kind_fixed:
1450 FT_TRACE4(( " %f\n", (double)val / 65536 ));
1451 break;
1452
1454 FT_TRACE4(( " %f\n", (double)val / 65536 / 1000 ));
1455
1456 default:
1457 ; /* never reached */
1458 }
1459#endif
1460
1461 break;
1462
1463 case cff_kind_delta:
1464 {
1465 FT_Byte* qcount = (FT_Byte*)parser->object +
1466 field->count_offset;
1467
1468 FT_Byte** data = parser->stack;
1469
1470
1471 if ( num_args > field->array_max )
1472 num_args = field->array_max;
1473
1474 FT_TRACE4(( " [" ));
1475
1476 /* store count */
1477 *qcount = (FT_Byte)num_args;
1478
1479 val = 0;
1480 while ( num_args > 0 )
1481 {
1483 switch ( field->size )
1484 {
1485 case (8 / FT_CHAR_BIT):
1486 *(FT_Byte*)q = (FT_Byte)val;
1487 break;
1488
1489 case (16 / FT_CHAR_BIT):
1490 *(FT_Short*)q = (FT_Short)val;
1491 break;
1492
1493 case (32 / FT_CHAR_BIT):
1494 *(FT_Int32*)q = (FT_Int)val;
1495 break;
1496
1497 default: /* for 64-bit systems */
1498 *(FT_Long*)q = val;
1499 }
1500
1501 FT_TRACE4(( " %ld", val ));
1502
1503 q += field->size;
1504 num_args--;
1505 }
1506
1507 FT_TRACE4(( "]\n" ));
1508 }
1509 break;
1510
1511 default: /* callback or blend */
1512 error = field->reader( parser );
1513 if ( error )
1514 goto Exit;
1515 }
1516 goto Found;
1517 }
1518 }
1519
1520 /* this is an unknown operator, or it is unsupported; */
1521 /* we will ignore it for now. */
1522
1523 Found:
1524 /* clear stack */
1525 /* TODO: could clear blend stack here, */
1526 /* but we don't have access to subFont */
1527 if ( field->kind != cff_kind_blend )
1528 parser->top = parser->stack;
1529 }
1530 p++;
1531 } /* while ( p < limit ) */
1532
1533 Exit:
1534#ifdef CFF_CONFIG_OPTION_OLD_ENGINE
1535 FT_List_Finalize( &t2s, destruct_t2s_item, memory, NULL );
1536#endif
1537 return error;
1538
1539#ifdef CFF_CONFIG_OPTION_OLD_ENGINE
1540 Out_Of_Memory_Error:
1541 error = FT_THROW( Out_Of_Memory );
1542 goto Exit;
1543#endif
1544
1545 Stack_Overflow:
1546 error = FT_THROW( Invalid_Argument );
1547 goto Exit;
1548
1549 Stack_Underflow:
1550 error = FT_THROW( Invalid_Argument );
1551 goto Exit;
1552
1553 Syntax_Error:
1554 error = FT_THROW( Invalid_Argument );
1555 goto Exit;
1556 }
return Found
Definition: dirsup.c:1270
static FT_Fixed cff_parse_fixed_scaled(CFF_Parser parser, FT_Byte **d, FT_Long scaling)
Definition: cffparse.c:546
static const CFF_Field_Handler cff_field_handlers[]
Definition: cffparse.c:1058
@ cff_kind_bool
Definition: cffparse.h:101
@ cff_kind_fixed_thousand
Definition: cffparse.h:99
@ cff_kind_fixed
Definition: cffparse.h:98
@ cff_kind_string
Definition: cffparse.h:100
@ cff_kind_num
Definition: cffparse.h:97
#define NEG_LONG(a)
Definition: ftcalc.h:479
#define ADD_LONG(a, b)
Definition: ftcalc.h:473
#define FT_CHAR_BIT
Definition: ftconfig.h:69
FT_List_Finalize(FT_List list, FT_List_Destructor destroy, FT_Memory memory, void *user)
Definition: ftutil.c:413
FT_List_Add(FT_List list, FT_ListNode node)
Definition: ftutil.c:269
FT_Get_Module_Interface(FT_Library library, const char *mod_name)
Definition: ftobjs.c:4992
struct FT_ListNodeRec_ * FT_ListNode
Definition: fttypes.h:523
FT_BEGIN_HEADER typedef unsigned char FT_Bool
Definition: fttypes.h:108
GLdouble GLdouble GLdouble GLdouble q
Definition: gl.h:2063
GLuint GLuint num
Definition: glext.h:9618
struct PSAux_ServiceRec_ * PSAux_Service
CFF_SubFontRec top_font
Definition: cfftypes.h:378
CFF_FontRecDictRec font_dict
Definition: cfftypes.h:305
const CFF_Decoder_FuncsRec * cff_decoder_funcs
Definition: psaux.h:1376
Definition: parser.c:44
const CHAR * start
Definition: inffile.c:87
Definition: format.c:80
Definition: dlist.c:348
GLvoid * data
Definition: dlist.c:359
ActualNumberDriverObjects * sizeof(PDRIVER_OBJECT)) PDRIVER_OBJECT *DriverObjectList

Referenced by cff_load_private_dict(), and cff_subfont_load().

◆ do_fixed()

static FT_Fixed do_fixed ( CFF_Parser  parser,
FT_Byte **  d,
FT_Long  scaling 
)
static

Definition at line 492 of file cffparse.c.

495 {
496 if ( **d == 30 )
497 return cff_parse_real( *d, parser->limit, scaling, NULL );
498 else
499 {
500 FT_Long val = cff_parse_integer( *d, parser->limit );
501
502
503 if ( scaling )
504 {
505 if ( FT_ABS( val ) > power_ten_limits[scaling] )
506 {
507 val = val > 0 ? 0x7FFFFFFFL : -0x7FFFFFFFL;
508 goto Overflow;
509 }
510
511 val *= power_tens[scaling];
512 }
513
514 if ( val > 0x7FFF )
515 {
516 val = 0x7FFFFFFFL;
517 goto Overflow;
518 }
519 else if ( val < -0x7FFF )
520 {
521 val = -0x7FFFFFFFL;
522 goto Overflow;
523 }
524
525 return (FT_Long)( (FT_ULong)val << 16 );
526
527 Overflow:
528 FT_TRACE4(( "!!!OVERFLOW:!!!" ));
529 return val;
530 }
531 }
static const FT_Long power_ten_limits[]
Definition: cffparse.c:162
#define FT_ABS(a)
Definition: ftobjs.h:73

Referenced by cff_parse_fixed(), and cff_parse_fixed_scaled().

Variable Documentation

◆ cff_field_handlers

const CFF_Field_Handler cff_field_handlers[]
static
Initial value:
=
{
{ 0, 0, 0, 0, 0, 0, 0 }
}

Definition at line 1058 of file cffparse.c.

Referenced by cff_parser_run().

◆ power_ten_limits

const FT_Long power_ten_limits[]
static
Initial value:
=
{
FT_LONG_MAX / 10L,
FT_LONG_MAX / 100L,
FT_LONG_MAX / 1000L,
FT_LONG_MAX / 10000L,
FT_LONG_MAX / 100000L,
FT_LONG_MAX / 1000000L,
FT_LONG_MAX / 10000000L,
FT_LONG_MAX / 100000000L,
FT_LONG_MAX / 1000000000L,
}

Definition at line 162 of file cffparse.c.

Referenced by do_fixed().

◆ power_tens

const FT_Long power_tens[]
static
Initial value:
=
{
1L,
10L,
100L,
1000L,
10000L,
100000L,
1000000L,
10000000L,
100000000L,
1000000000L
}

Definition at line 146 of file cffparse.c.

Referenced by cff_parse_fixed_dynamic(), cff_parse_font_matrix(), cff_parse_real(), and do_fixed().