psintrp.c File Reference
#include "psft.h"#include <freetype/internal/ftdebug.h>#include <freetype/internal/services/svcfftl.h>#include "psglue.h"#include "psfont.h"#include "psstack.h"#include "pshints.h"#include "psintrp.h"#include "pserror.h"#include "psobjs.h"#include "t1decode.h"
Include dependency graph for psintrp.c:
This graph shows which files directly or indirectly include this file:
Go to the source code of this file.
Macros | |
| #define | FT_COMPONENT cf2interp |
| #define | PS_STORAGE_SIZE 3 |
Macro Definition Documentation
◆ FT_COMPONENT
◆ PS_STORAGE_SIZE
| #define PS_STORAGE_SIZE 3 |
Enumeration Type Documentation
◆ anonymous enum
| anonymous enum |
Definition at line 199 of file psintrp.c.
200 {
233 };
◆ anonymous enum
| anonymous enum |
Definition at line 235 of file psintrp.c.
236 {
276 };
Function Documentation
◆ cf2_doBlend()
Definition at line 418 of file psintrp.c.
421 {
422 CF2_UInt delta;
426
427
429 delta = base + numBlends;
430
432 {
434
435 /* start with first term */
437
438
442 cf2_stack_getReal( opStack,
443 delta++ ) ) );
444
445 /* store blended result */
447 }
448
449 /* leave only `numBlends' results on stack */
450 cf2_stack_pop( opStack, numOperands - numBlends );
451 }
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
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 GLint GLint j
Definition: glfuncs.h:250
cf2_stack_setReal(CF2_Stack stack, CF2_UInt idx, CF2_Fixed val)
Definition: psstack.c:212
Definition: uninitialized_test.cpp:81
Referenced by cf2_interpT2CharString().
◆ cf2_doFlex()
|
static |
Definition at line 335 of file psintrp.c.
341 {
342 CF2_Fixed vals[14];
344 FT_Bool isHFlex;
346
347
348 vals[0] = *curX;
349 vals[1] = *curY;
350 idx = 0;
352 top = isHFlex ? 9 : 10;
353
355 {
359 idx++ ) );
360 }
361
362 if ( isHFlex )
363 vals[9 + 2] = *curY;
364
365 if ( doConditionalLastRead )
366 {
371
372
373 if ( lastIsX )
374 {
375 vals[12] = ADD_INT32( vals[10], lastVal );
376 vals[13] = *curY;
377 }
378 else
379 {
380 vals[12] = *curX;
381 vals[13] = ADD_INT32( vals[11], lastVal );
382 }
383 }
384 else
385 {
386 if ( readFromStack[10] )
387 vals[12] = ADD_INT32( vals[10],
389 else
390 vals[12] = *curX;
391
392 if ( readFromStack[11] )
393 vals[13] = ADD_INT32( vals[11],
395 else
396 vals[13] = *curY;
397 }
398
401 vals[j * 6 + 3],
402 vals[j * 6 + 4],
403 vals[j * 6 + 5],
404 vals[j * 6 + 6],
405 vals[j * 6 + 7] );
406
407 cf2_stack_clear( opStack );
408
409 *curX = vals[12];
410 *curY = vals[13];
411 }
cf2_glyphpath_curveTo(CF2_GlyphPath glyphpath, CF2_Fixed x1, CF2_Fixed y1, CF2_Fixed x2, CF2_Fixed y2, CF2_Fixed x3, CF2_Fixed y3)
Definition: pshints.c:1814
Referenced by cf2_interpT2CharString().
◆ cf2_doStems()
|
static |
Definition at line 281 of file psintrp.c.
287 {
291
292 /* variable accumulates delta values from operand stack */
293 CF2_Fixed position = hintOffset;
294
297 " No width. Use hsbw/sbw as first op\n" ));
298
302
305
307 {
308 /* construct a CF2_StemHint and push it onto the list */
309 CF2_StemHintRec stemhint;
310
311
312 stemhint.min =
313 position = ADD_INT32( position,
315 stemhint.max =
316 position = ADD_INT32( position,
318
320 stemhint.maxDS =
321 stemhint.minDS = 0;
322
324 }
325
326 cf2_stack_clear( opStack );
327
328 exit:
329 /* cf2_doStems must define a width (may be default) */
330 *haveWidth = TRUE;
331 }
Definition: mk_font.cpp:20
Definition: pshints.h:86
Referenced by cf2_interpT2CharString().
◆ cf2_hintmask_getMaskPtr()
| cf2_hintmask_getMaskPtr | ( | CF2_HintMask | hintmask | ) |
◆ cf2_hintmask_init()
| cf2_hintmask_init | ( | CF2_HintMask | hintmask, |
| FT_Error * | error | ||
| ) |
Definition at line 66 of file psintrp.c.
Referenced by cf2_hintmap_build(), and cf2_interpT2CharString().
◆ cf2_hintmask_isNew()
| cf2_hintmask_isNew | ( | const CF2_HintMask | hintmask | ) |
Definition at line 83 of file psintrp.c.
Referenced by cf2_glyphpath_curveTo(), cf2_glyphpath_lineTo(), and cf2_glyphpath_moveTo().
◆ cf2_hintmask_isValid()
| cf2_hintmask_isValid | ( | const CF2_HintMask | hintmask | ) |
Definition at line 76 of file psintrp.c.
77 {
79 }
Referenced by cf2_hintmap_build(), and cf2_interpT2CharString().
◆ cf2_hintmask_read()
|
static |
Definition at line 131 of file psintrp.c.
134 {
136
137#ifndef CF2_NDEBUG
138 /* these are the bits in the final mask byte that should be zero */
139 /* Note: this variable is only used in an assert expression below */
140 /* and then only if CF2_NDEBUG is not defined */
142#endif
143
144
145 /* initialize counts and isValid */
147 return;
148
150
152
153 /* set mask and advance interpreter's charstring pointer */
155 {
158 }
159
161
162 /* assert any unused bits in last byte are zero unless there's a prior */
163 /* error */
164 /* bitCount -> mask, 0 -> 0, 1 -> 7f, 2 -> 3f, ... 6 -> 3, 7 -> 1 */
165#ifndef CF2_NDEBUG
167 *hintmask->error );
168#endif
169 }
static size_t cf2_hintmask_setCounts(CF2_HintMask hintmask, size_t bitCount)
Definition: psintrp.c:108
Referenced by cf2_interpT2CharString().
◆ cf2_hintmask_setAll()
| cf2_hintmask_setAll | ( | CF2_HintMask | hintmask, |
| size_t | bitCount | ||
| ) |
Definition at line 173 of file psintrp.c.
175 {
178
179
180 /* initialize counts and isValid */
182 return;
183
187
188 /* set mask to all ones */
191
192 /* clear unused bits */
193 /* bitCount -> mask, 0 -> 0, 1 -> 7f, 2 -> 3f, ... 6 -> 3, 7 -> 1 */
195 }
ActualNumberDriverObjects * sizeof(PDRIVER_OBJECT)) PDRIVER_OBJECT *DriverObjectList
Referenced by cf2_hintmap_build().
◆ cf2_hintmask_setCounts()
|
static |
Definition at line 108 of file psintrp.c.
110 {
112 {
113 /* total of h and v stems must be <= 96 */
115 return 0;
116 }
117
118 hintmask->bitCount = bitCount;
120
123
124 return bitCount;
125 }
Referenced by cf2_hintmask_read(), and cf2_hintmask_setAll().
◆ cf2_hintmask_setNew()
| cf2_hintmask_setNew | ( | CF2_HintMask | hintmask, |
| FT_Bool | val | ||
| ) |
Definition at line 90 of file psintrp.c.
Referenced by cf2_hintmap_build().
◆ cf2_interpT2CharString()
| cf2_interpT2CharString | ( | CF2_Font | font, |
| CF2_Buffer | buf, | ||
| CF2_OutlineCallbacks | callbacks, | ||
| const FT_Vector * | translation, | ||
| FT_Bool | doingSeac, | ||
| CF2_Fixed | curX, | ||
| CF2_Fixed | curY, | ||
| CF2_Fixed * | width | ||
| ) |
Definition at line 471 of file psintrp.c.
479 {
480 /* lastError is used for errors that are immediately tested */
482
483 /* pointer to parsed font object */
485
488
491
492 /* stuff for Type 1 */
493 FT_Int known_othersubr_result_cnt = 0;
496
497#define PS_STORAGE_SIZE 3
499 FT_Int result_cnt = 0;
500
501 /* save this for hinting seac accents */
502 CF2_Fixed hintOriginY = curY;
503
505 FT_UInt stackSize;
507
510
511 /* instruction limit; 20,000,000 matches Avalon */
512 FT_UInt32 instructionLimit = 20000000UL;
513
514 CF2_ArrStackRec subrStack;
515
516 FT_Bool haveWidth;
518
520
521 /* TODO: placeholders for hint structures */
522
523 /* objects used for hinting */
524 CF2_ArrStackRec hStemHintArray;
525 CF2_ArrStackRec vStemHintArray;
526
527 CF2_HintMaskRec hintMask;
528#ifdef __REACTOS__
530 if (!glyphPath_allocated) return;
531/* Ugly but it allows us to reduce the diff */
532#define glyphPath (*glyphPath_allocated)
533#else
534 CF2_GlyphPathRec glyphPath;
535#endif
536
539 FT_ZERO( &flexStore );
540
541 /* initialize the remaining objects */
542 cf2_arrstack_init( &subrStack,
543 memory,
544 error,
546 cf2_arrstack_init( &hStemHintArray,
547 memory,
548 error,
550 cf2_arrstack_init( &vStemHintArray,
551 memory,
552 error,
554
555 /* initialize CF2_StemHint arrays */
557
558 /* initialize path map to manage drawing operations */
559
560 /* Note: last 4 params are used to handle `MoveToPermissive', which */
561 /* may need to call `hintMap.Build' */
562 /* TODO: MoveToPermissive is gone; are these still needed? */
563 cf2_glyphpath_init( &glyphPath,
564 font,
565 callbacks,
566 scaleY,
567 /* hShift, */
568 &hStemHintArray,
569 &vStemHintArray,
570 &hintMask,
571 hintOriginY,
572 &font->blues,
573 translation );
574
575 /*
576 * Initialize state for width parsing. From the CFF Spec:
577 *
578 * The first stack-clearing operator, which must be one of hstem,
579 * hstemhm, vstem, vstemhm, cntrmask, hintmask, hmoveto, vmoveto,
580 * rmoveto, or endchar, takes an additional argument - the width (as
581 * described earlier), which may be expressed as zero or one numeric
582 * argument.
583 *
584 * What we implement here uses the first validly specified width, but
585 * does not detect errors for specifying more than one width.
586 *
587 * If one of the above operators occurs without explicitly specifying
588 * a width, we assume the default width.
589 *
590 * CFF2 charstrings always return the default width (0).
591 *
592 */
595
596 /*
597 * Note: At this point, all pointers to resources must be NULL
598 * and all local objects must be initialized.
599 * There must be no branches to `exit:' above this point.
600 *
601 */
602
603 /* allocate an operand stack */
605 : CF2_OPERAND_STACK_SIZE;
607
608 if ( !opStack )
609 {
610 lastError = FT_THROW( Out_Of_Memory );
612 }
613
614 /* initialize subroutine stack by placing top level charstring as */
615 /* first element (max depth plus one for the charstring) */
616 /* Note: Caller owns and must finalize the first charstring. */
617 /* Our copy of it does not change that requirement. */
619
621
622 /* catch errors so far */
625
627 charstringIndex = 0; /* entry is valid now */
628
629 /* main interpreter loop */
630 while ( 1 )
631 {
633 FT_ASSERT( known_othersubr_result_cnt == 0 ||
634 result_cnt == 0 );
635
637 {
638 /* If we've reached the end of the charstring, simulate a */
639 /* cf2_cmdRETURN or cf2_cmdENDCHAR. */
640 /* We do this for both CFF and CFF2. */
641 if ( charstringIndex )
643 else
645 }
646 else
647 {
649
650 /* Explicit RETURN and ENDCHAR in CFF2 should be ignored. */
651 /* Note: Trace message will report 0 instead of 11 or 14. */
653 font->isCFF2 )
654 op1 = cf2_cmdRESERVED_0;
655 }
656
658 {
659 if ( !initial_map_ready &&
660 !( op1 == cf2_cmdHSTEM ||
661 op1 == cf2_cmdVSTEM ||
662 op1 == cf2_cmdHSBW ||
663 op1 == cf2_cmdCALLSUBR ||
664 op1 == cf2_cmdRETURN ||
665 op1 == cf2_cmdESC ||
666 op1 == cf2_cmdENDCHAR ||
667 op1 >= 32 /* Numbers */ ) )
668 {
669 /* Skip outline commands first time round. */
670 /* `endchar' will trigger initial hintmap build */
671 /* and rewind the charstring. */
673 cf2_stack_clear( opStack );
674 continue;
675 }
676
677 if ( result_cnt > 0 &&
678 !( op1 == cf2_cmdCALLSUBR ||
679 op1 == cf2_cmdRETURN ||
680 op1 == cf2_cmdESC ||
681 op1 >= 32 /* Numbers */ ) )
682 {
683 /* all operands have been transferred by previous pops */
684 result_cnt = 0;
685 }
686
688 {
690 " no `div' after large integer\n" ));
691
692 large_int = FALSE;
693 }
694 }
695
696 /* check for errors once per loop */
699
700 instructionLimit--;
701 if ( instructionLimit == 0 )
702 {
703 lastError = FT_THROW( Invalid_Glyph_Format );
705 }
706
707 switch( op1 )
708 {
712 /* we may get here if we have a prior error */
714 break;
715
718
720 break; /* clear stack & ignore */
721
723 {
724 /* vsindex not allowed after blend */
725 lastError = FT_THROW( Invalid_Glyph_Format );
727 }
728
729 {
731
732
735 }
736 break;
737
739 {
740 FT_UInt numBlends;
741
742
744
746 break; /* clear stack & ignore */
747
748 /* do we have a `blend' op in a non-variant font? */
750 {
751 lastError = FT_THROW( Invalid_Glyph_Format );
753 }
754
755 /* check cached blend vector */
757 font->vsindex,
758 font->lenNDV,
759 font->NDV ) )
760 {
762 font->vsindex,
763 font->lenNDV,
764 font->NDV );
765 if ( lastError )
767 }
768
769 /* do the blend */
771 if ( numBlends > stackSize )
772 {
773 lastError = FT_THROW( Invalid_Glyph_Format );
775 }
776
778
780 }
781 continue; /* do not clear the stack */
782
786 : " hstem" ));
787
789 {
790 /* never add hints after the mask is computed */
791 /* except if in Type 1 mode (no hintmask op) */
793 {
795 " invalid horizontal hint mask\n" ));
796 break;
797 }
798 }
799
800 /* add left-sidebearing correction in Type 1 mode */
802 opStack,
803 &hStemHintArray,
804 width,
805 &haveWidth,
807 : 0 );
808
811
812 break;
813
817 : " vstem" ));
818
820 {
821 /* never add hints after the mask is computed */
822 /* except if in Type 1 mode (no hintmask op) */
824 {
826 " invalid vertical hint mask\n" ));
827 break;
828 }
829 }
830
831 /* add left-sidebearing correction in Type 1 mode */
833 opStack,
834 &vStemHintArray,
835 width,
836 &haveWidth,
838 : 0 );
839
842
843 break;
844
847
850 " No width. Use hsbw/sbw as first op\n" ));
851
854 nominalWidthX );
855
856 /* width is defined or default after this */
857 haveWidth = TRUE;
858
861
863
865 cf2_glyphpath_moveTo( &glyphPath, curX, curY );
866
867 break;
868
870 {
873
874
876
878 {
880 idx + 0 ) );
882 idx + 1 ) );
883
884 cf2_glyphpath_lineTo( &glyphPath, curX, curY );
885 }
886
887 cf2_stack_clear( opStack );
888 }
889 continue; /* no need to clear stack again */
890
893 {
896
898
899
901
903 {
905
906
907 if ( isX )
909 else
911
912 isX = !isX;
913
914 cf2_glyphpath_lineTo( &glyphPath, curX, curY );
915 }
916
917 cf2_stack_clear( opStack );
918 }
919 continue;
920
923 {
926
927
929 : " rrcurveto" ));
930
932 {
934
935
942
944
945 curX = x3;
946 curY = y3;
947 idx += 6;
948 }
949
951 {
953 idx + 0 ) );
955 idx + 1 ) );
956
957 cf2_glyphpath_lineTo( &glyphPath, curX, curY );
958 }
959
960 cf2_stack_clear( opStack );
961 }
962 continue; /* no need to clear stack again */
963
967 else
968 {
970
971 /* if there is no path, `closepath' is a no-op */
972 cf2_glyphpath_closeOpenPath( &glyphPath );
973
974 haveWidth = TRUE;
975 }
976 break;
977
980 {
981 CF2_Int subrNum;
982
983
985 : " callsubr" ));
986
989 {
990 /* max subr plus one for charstring */
991 lastError = FT_THROW( Invalid_Glyph_Format );
993 }
994
995 /* push our current CFF charstring region on subrStack */
996 charstring = (CF2_Buffer)
998 &subrStack,
999 (size_t)charstringIndex + 1 );
1000
1001 /* set up the new CFF region and pointer */
1002 subrNum = cf2_stack_popInt( opStack );
1003
1005 {
1007 decoder->locals_hash );
1008
1009
1011 subrNum = *val;
1012 else
1013 subrNum = -1;
1014 }
1015
1016 switch ( op1 )
1017 {
1020 subrNum + decoder->globals_bias,
1021 charstringIndex + 1 ));
1022
1024 subrNum,
1025 charstring ) )
1026 {
1027 lastError = FT_THROW( Invalid_Glyph_Format );
1029 }
1030 break;
1031
1032 default:
1033 /* cf2_cmdCALLSUBR */
1035 subrNum + decoder->locals_bias,
1036 charstringIndex + 1 ));
1037
1039 subrNum,
1040 charstring ) )
1041 {
1042 lastError = FT_THROW( Invalid_Glyph_Format );
1044 }
1045 }
1046
1047 charstringIndex += 1; /* entry is valid now */
1048 }
1049 continue; /* do not clear the stack */
1050
1053
1054 if ( charstringIndex < 1 )
1055 {
1056 /* Note: cannot return from top charstring */
1057 lastError = FT_THROW( Invalid_Glyph_Format );
1059 }
1060
1061 /* restore position in previous charstring */
1062 charstring = (CF2_Buffer)
1063 cf2_arrstack_getPointer(
1064 &subrStack,
1065 (CF2_UInt)--charstringIndex );
1066 continue; /* do not clear the stack */
1067
1069 {
1071
1072
1073 /* first switch for 2-byte operators handles CFF2 */
1074 /* and opcodes that are reserved for both CFF and CFF2 */
1075 switch ( op2 )
1076 {
1078 {
1080 {
1087 };
1088
1089
1091
1092 cf2_doFlex( opStack,
1093 &curX,
1094 &curY,
1095 &glyphPath,
1096 readFromStack,
1098 }
1099 continue;
1100
1102 {
1104 {
1111 };
1112
1113
1115
1116 cf2_doFlex( opStack,
1117 &curX,
1118 &curY,
1119 &glyphPath,
1120 readFromStack,
1122 }
1123 break; /* TODO: why is this not a continue? */
1124
1126 {
1128 {
1135 };
1136
1137
1139
1140 cf2_doFlex( opStack,
1141 &curX,
1142 &curY,
1143 &glyphPath,
1144 readFromStack,
1146 }
1147 continue;
1148
1150 {
1152 {
1159 };
1160
1161
1163
1164 cf2_doFlex( opStack,
1165 &curX,
1166 &curY,
1167 &glyphPath,
1168 readFromStack,
1170 }
1171 continue;
1172
1173 /* these opcodes are always reserved */
1181 break;
1182
1183 default:
1184 {
1188 {
1189 /* all operands have been transferred by previous pops */
1190 result_cnt = 0;
1191 }
1192 else
1193 {
1194 /* second switch for 2-byte operators handles */
1195 /* CFF and Type 1 */
1196 switch ( op2 )
1197 {
1198
1200 /* something about `flip type of locking' -- ignore it */
1202
1203 break;
1204
1207 /*
1208 * Type 1: Type 2:
1209 * x0 dx0 x1 dx1 x2 dx2 vstem3 x dx {dxa dxb}* vstem
1210 * y0 dy0 y1 dy1 y2 dy2 hstem3 y dy {dya dyb}* hstem
1211 * relative to lsb point relative to zero
1212 *
1213 */
1214 {
1217 else
1218 {
1220
1222
1223
1225 : " hstem3" ));
1226
1228
1232
1233 cf2_stack_setReal(
1234 opStack, 2,
1236 cf2_stack_getReal( opStack, 1 ) ) );
1237 cf2_stack_setReal(
1238 opStack, 4,
1240 cf2_stack_getReal( opStack, 3 ) ) );
1241
1242 /* add left-sidebearing correction */
1244 opStack,
1245 isV ? &vStemHintArray : &hStemHintArray,
1246 width,
1247 &haveWidth,
1248 isV ? decoder->builder.left_bearing->x
1249 : decoder->builder.left_bearing->y );
1250
1253 }
1254 }
1255 break;
1256
1258 {
1261
1262
1264
1267
1269 }
1270 continue; /* do not clear the stack */
1271
1273 {
1276
1277
1279
1282
1284 }
1285 continue; /* do not clear the stack */
1286
1288 {
1290
1291
1293
1295
1297 }
1298 continue; /* do not clear the stack */
1299
1303 else
1304 {
1306 CF2_Int bchar_index, achar_index;
1308
1309#ifdef FT_CONFIG_OPTION_INCREMENTAL
1311#endif
1312 CF2_BufferRec component;
1313 CF2_Fixed dummyWidth;
1314
1317
1321
1322
1324
1325 if ( doingSeac )
1326 {
1328 lastError = FT_THROW( Invalid_Glyph_Format );
1330 }
1331
1333 {
1335 lastError = FT_THROW( Invalid_Glyph_Format );
1337 }
1338
1339 /* `glyph_names' is set to 0 for CID fonts which do */
1340 /* not include an encoding. How can we deal with */
1341 /* these? */
1342#ifdef FT_CONFIG_OPTION_INCREMENTAL
1344 !face->root.internal->incremental_interface )
1345#else
1347#endif /* FT_CONFIG_OPTION_INCREMENTAL */
1348 {
1349 FT_ERROR((
1350 "cf2_interpT2CharString: (Type 1 seac)"
1351 " glyph names table not available in this font\n" ));
1352 lastError = FT_THROW( Invalid_Glyph_Format );
1354 }
1355
1356 /* seac weirdness */
1357 adx += decoder->builder.left_bearing->x;
1358
1359#ifdef FT_CONFIG_OPTION_INCREMENTAL
1361 {
1362 /* the caller must handle the font encoding also */
1363 bchar_index = bchar;
1364 achar_index = achar;
1365 }
1366 else
1367#endif
1368 {
1369 bchar_index = t1_lookup_glyph_by_stdcharcode_ps(
1370 decoder, bchar );
1371 achar_index = t1_lookup_glyph_by_stdcharcode_ps(
1372 decoder, achar );
1373 }
1374
1375 if ( bchar_index < 0 || achar_index < 0 )
1376 {
1377 FT_ERROR((
1378 "cf2_interpT2CharString: (Type 1 seac)"
1379 " invalid seac character code arguments\n" ));
1380 lastError = FT_THROW( Invalid_Glyph_Format );
1382 }
1383
1384 /* if we are trying to load a composite glyph, */
1385 /* do not load the accent character and return */
1386 /* the array of subglyphs. */
1388 {
1391 FT_SubGlyph subg;
1392
1393
1394 /* reallocate subglyph array if necessary */
1397 {
1400 }
1401
1402 subg = loader->current.subglyphs;
1403
1404 /* subglyph 0 = base character */
1405 subg->index = bchar_index;
1406 subg->flags = FT_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES |
1408 subg->arg1 = 0;
1409 subg->arg2 = 0;
1410 subg++;
1411
1412 /* subglyph 1 = accent character */
1413 subg->index = achar_index;
1414 subg->flags = FT_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES;
1417
1418 /* set up remaining glyph fields */
1419 glyph->num_subglyphs = 2;
1420 glyph->subglyphs = loader->base.subglyphs;
1421 glyph->format = FT_GLYPH_FORMAT_COMPOSITE;
1422
1423 loader->current.num_subglyphs = 2;
1424
1426 }
1427
1428 /* First load `bchar' in builder */
1429 /* now load the unscaled outline */
1430
1431 /* prepare loader */
1433
1435 (FT_UInt)bchar_index,
1436 &component );
1438 {
1441 }
1442
1443 /* save the left bearing and width of the SEAC */
1444 /* glyph as they will be erased by the next load */
1445
1446 left_bearing = *decoder->builder.left_bearing;
1448
1450 &component,
1451 callbacks,
1452 translation,
1453 TRUE,
1454 0,
1455 0,
1456 &dummyWidth );
1458
1459 /* If the SEAC glyph doesn't have a (H)SBW of its */
1460 /* own use the values from the base glyph. */
1461
1462 if ( !haveWidth )
1463 {
1464 left_bearing = *decoder->builder.left_bearing;
1466 }
1467
1468 decoder->builder.left_bearing->x = 0;
1469 decoder->builder.left_bearing->y = 0;
1470
1471 /* Now load `achar' on top of */
1472 /* the base outline */
1473
1475 (FT_UInt)achar_index,
1476 &component );
1478 {
1481 }
1483 &component,
1484 callbacks,
1485 translation,
1486 TRUE,
1487 adx - asb,
1488 ady,
1489 &dummyWidth );
1491
1492 /* restore the left side bearing and advance width */
1493 /* of the SEAC glyph or base character (saved above) */
1494
1495 *decoder->builder.left_bearing = left_bearing;
1497
1499 }
1500 break;
1501
1505 else
1506 {
1507 CF2_Fixed lsb_x, lsb_y;
1508 PS_Builder* builder;
1509
1510
1512
1513 builder = &decoder->builder;
1514
1517
1518 lsb_y = cf2_stack_popFixed( opStack );
1519 lsb_x = cf2_stack_popFixed( opStack );
1520
1525
1526 haveWidth = TRUE;
1527
1528 /* the `metrics_only' indicates that we only want */
1529 /* to compute the glyph's metrics (lsb + advance */
1530 /* width), not load the rest of it; so exit */
1531 /* immediately */
1534
1535 if ( initial_map_ready )
1536 {
1537 curX = ADD_INT32( curX, lsb_x );
1538 curY = ADD_INT32( curY, lsb_y );
1539 }
1540 }
1541 break;
1542
1544 {
1546
1547
1549
1551
1554 else
1556 }
1557 continue; /* do not clear the stack */
1558
1560 {
1561 CF2_F16Dot16 summand1;
1562 CF2_F16Dot16 summand2;
1563
1564
1566
1567 summand2 = cf2_stack_popFixed( opStack );
1568 summand1 = cf2_stack_popFixed( opStack );
1569
1570 cf2_stack_pushFixed( opStack,
1571 ADD_INT32( summand1,
1572 summand2 ) );
1573 }
1574 continue; /* do not clear the stack */
1575
1577 {
1578 CF2_F16Dot16 minuend;
1579 CF2_F16Dot16 subtrahend;
1580
1581
1583
1584 subtrahend = cf2_stack_popFixed( opStack );
1585 minuend = cf2_stack_popFixed( opStack );
1586
1587 cf2_stack_pushFixed( opStack,
1588 SUB_INT32( minuend, subtrahend ) );
1589 }
1590 continue; /* do not clear the stack */
1591
1593 {
1594 CF2_F16Dot16 dividend;
1596
1597
1599
1601 {
1604
1605 large_int = FALSE;
1606 }
1607 else
1608 {
1610 dividend = cf2_stack_popFixed( opStack );
1611 }
1612
1613 cf2_stack_pushFixed( opStack,
1615
1616 }
1617 continue; /* do not clear the stack */
1618
1620 {
1622
1623
1625
1627
1630 else
1632 }
1633 continue; /* do not clear the stack */
1634
1636 {
1639
1640
1642
1645
1647 }
1648 continue; /* do not clear the stack */
1649
1653 else
1654 {
1655 CF2_Int subr_no;
1658 CF2_UInt opIdx = 0;
1659
1660
1662
1663 subr_no = cf2_stack_popInt( opStack );
1665
1666 /********************************************************
1667 *
1668 * remove all operands to callothersubr from the stack
1669 *
1670 * for handled othersubrs, where we know the number of
1671 * arguments, we increase the stack by the value of
1672 * known_othersubr_result_cnt
1673 *
1674 * for unhandled othersubrs the following pops adjust
1675 * the stack pointer as necessary
1676 */
1677
1680
1682
1683 known_othersubr_result_cnt = 0;
1684 result_cnt = 0;
1685
1686 /* XXX TODO: The checks to `arg_count == <whatever>' */
1687 /* might not be correct; an othersubr expects a */
1688 /* certain number of operands on the PostScript stack */
1689 /* (as opposed to the T1 stack) but it doesn't have to */
1690 /* put them there by itself; previous othersubrs might */
1691 /* have left the operands there if they were not */
1692 /* followed by an appropriate number of pops */
1693 /* */
1694 /* On the other hand, Adobe Reader 7.0.8 for Linux */
1695 /* doesn't accept a font that contains charstrings */
1696 /* like */
1697 /* */
1698 /* 100 200 2 20 callothersubr */
1699 /* 300 1 20 callothersubr pop */
1700 /* */
1701 /* Perhaps this is the reason why BuildCharArray */
1702 /* exists. */
1703
1704 switch ( subr_no )
1705 {
1706 case 0: /* end flex feature */
1708 goto Unexpected_OtherSubr;
1709
1710 if ( initial_map_ready &&
1711 ( !decoder->flex_state ||
1712 decoder->num_flex_vectors != 7 ) )
1713 {
1715 " unexpected flex end\n" ));
1716 lastError = FT_THROW( Invalid_Glyph_Format );
1718 }
1719
1720 /* the two `results' are popped */
1721 /* by the following setcurrentpoint */
1722 cf2_stack_pushFixed( opStack, curX );
1723 cf2_stack_pushFixed( opStack, curY );
1724 known_othersubr_result_cnt = 2;
1725 break;
1726
1727 case 1: /* start flex feature */
1729 goto Unexpected_OtherSubr;
1730
1731 if ( !initial_map_ready )
1732 break;
1733
1736
1737 decoder->flex_state = 1;
1738 decoder->num_flex_vectors = 0;
1739 break;
1740
1741 case 2: /* add flex vectors */
1742 {
1744 FT_Int idx2;
1745
1746
1748 goto Unexpected_OtherSubr;
1749
1750 if ( !initial_map_ready )
1751 break;
1752
1754 {
1756 " missing flex start\n" ));
1757 lastError = FT_THROW( Invalid_Glyph_Format );
1759 }
1760
1761 /* note that we should not add a point for */
1762 /* index 0; this will move our current position */
1763 /* to the flex point without adding any point */
1764 /* to the outline */
1767 {
1768 /* in malformed fonts it is possible to have */
1769 /* other opcodes in the middle of a flex (which */
1770 /* don't increase `num_flex_vectors'); we thus */
1771 /* have to check whether we can add a point */
1772
1774 1 ) )
1775 {
1776 lastError = FT_THROW( Invalid_Glyph_Format );
1778 }
1779
1780 /* map: 1->2 2->4 3->6 4->2 5->4 6->6 */
1782
1783 flexStore[idx2 - 2] = curX;
1784 flexStore[idx2 - 1] = curY;
1785
1787 cf2_glyphpath_curveTo( &glyphPath,
1788 flexStore[0],
1789 flexStore[1],
1790 flexStore[2],
1791 flexStore[3],
1792 flexStore[4],
1793 flexStore[5] );
1794 }
1795 }
1796 break;
1797
1798 case 3: /* change hints */
1800 goto Unexpected_OtherSubr;
1801
1802 if ( initial_map_ready )
1803 {
1804 /* do not clear hints if initial hintmap */
1805 /* is not ready - we need to collate all */
1806 cf2_arrstack_clear( &vStemHintArray );
1807 cf2_arrstack_clear( &hStemHintArray );
1808
1812 }
1813
1814 known_othersubr_result_cnt = 1;
1815 break;
1816
1817 case 12:
1818 case 13:
1819 /* counter control hints, clear stack */
1820 cf2_stack_clear( opStack );
1821 break;
1822
1823 case 14:
1824 case 15:
1825 case 16:
1826 case 17:
1827 case 18: /* multiple masters */
1828 {
1830 FT_UInt num_points, nn, mm;
1831 CF2_UInt delta;
1833
1834
1835 if ( !blend )
1836 {
1837 FT_ERROR((
1838 "cf2_interpT2CharString:"
1839 " unexpected multiple masters operator\n" ));
1840 lastError = FT_THROW( Invalid_Glyph_Format );
1842 }
1843
1844 num_points = (FT_UInt)subr_no - 13 +
1845 ( subr_no == 18 );
1847 blend->num_designs ) )
1848 {
1849 FT_ERROR((
1850 "cf2_interpT2CharString:"
1851 " incorrect number of multiple masters arguments\n" ));
1852 lastError = FT_THROW( Invalid_Glyph_Format );
1854 }
1855
1856 /* We want to compute */
1857 /* */
1858 /* a0*w0 + a1*w1 + ... + ak*wk */
1859 /* */
1860 /* but we only have a0, a1-a0, a2-a0, ..., ak-a0. */
1861 /* */
1862 /* However, given that w0 + w1 + ... + wk == 1, we */
1863 /* can rewrite it easily as */
1864 /* */
1865 /* a0 + (a1-a0)*w1 + (a2-a0)*w2 + ... + (ak-a0)*wk */
1866 /* */
1867 /* where k == num_designs-1. */
1868 /* */
1869 /* I guess that's why it's written in this `compact' */
1870 /* form. */
1871 /* */
1872 delta = opIdx + num_points;
1873 values = opIdx;
1874 for ( nn = 0; nn < num_points; nn++ )
1875 {
1877 values );
1878
1879
1881 tmp = ADD_INT32( tmp,
1882 FT_MulFix(
1883 cf2_stack_getReal( opStack,
1884 delta++ ),
1885 blend->weight_vector[mm] ) );
1886
1888 }
1889 cf2_stack_pop( opStack,
1891
1892 known_othersubr_result_cnt = (FT_Int)num_points;
1893 break;
1894 }
1895
1896 case 19:
1897 /* <idx> 1 19 callothersubr */
1898 /* ==> replace elements starting from index */
1899 /* cvi( <idx> ) of BuildCharArray with */
1900 /* WeightVector */
1901 {
1904
1905
1907 goto Unexpected_OtherSubr;
1908
1910
1913 decoder->len_buildchar )
1914 goto Unexpected_OtherSubr;
1915
1917 blend->weight_vector,
1918 blend->num_designs *
1920 }
1921 break;
1922
1923 case 20:
1924 /* <arg1> <arg2> 2 20 callothersubr pop */
1925 /* ==> push <arg1> + <arg2> onto T1 stack */
1926 {
1927 CF2_F16Dot16 summand1;
1928 CF2_F16Dot16 summand2;
1929
1930
1932 goto Unexpected_OtherSubr;
1933
1934 summand2 = cf2_stack_popFixed( opStack );
1935 summand1 = cf2_stack_popFixed( opStack );
1936
1937 cf2_stack_pushFixed( opStack,
1938 ADD_INT32( summand1,
1939 summand2 ) );
1940 known_othersubr_result_cnt = 1;
1941 }
1942 break;
1943
1944 case 21:
1945 /* <arg1> <arg2> 2 21 callothersubr pop */
1946 /* ==> push <arg1> - <arg2> onto T1 stack */
1947 {
1948 CF2_F16Dot16 minuend;
1949 CF2_F16Dot16 subtrahend;
1950
1951
1953 goto Unexpected_OtherSubr;
1954
1955 subtrahend = cf2_stack_popFixed( opStack );
1956 minuend = cf2_stack_popFixed( opStack );
1957
1958 cf2_stack_pushFixed( opStack,
1959 SUB_INT32( minuend,
1960 subtrahend ) );
1961 known_othersubr_result_cnt = 1;
1962 }
1963 break;
1964
1965 case 22:
1966 /* <arg1> <arg2> 2 22 callothersubr pop */
1967 /* ==> push <arg1> * <arg2> onto T1 stack */
1968 {
1969 CF2_F16Dot16 factor1;
1970 CF2_F16Dot16 factor2;
1971
1972
1974 goto Unexpected_OtherSubr;
1975
1976 factor2 = cf2_stack_popFixed( opStack );
1977 factor1 = cf2_stack_popFixed( opStack );
1978
1979 cf2_stack_pushFixed( opStack,
1980 FT_MulFix( factor1, factor2 ) );
1981 known_othersubr_result_cnt = 1;
1982 }
1983 break;
1984
1985 case 23:
1986 /* <arg1> <arg2> 2 23 callothersubr pop */
1987 /* ==> push <arg1> / <arg2> onto T1 stack */
1988 {
1989 CF2_F16Dot16 dividend;
1991
1992
1994 goto Unexpected_OtherSubr;
1995
1997 dividend = cf2_stack_popFixed( opStack );
1998
2000 goto Unexpected_OtherSubr;
2001
2002 cf2_stack_pushFixed( opStack,
2003 FT_DivFix( dividend,
2004 divisor ) );
2005 known_othersubr_result_cnt = 1;
2006 }
2007 break;
2008
2009 case 24:
2010 /* <val> <idx> 2 24 callothersubr */
2011 /* ==> set BuildCharArray[cvi( <idx> )] = <val> */
2012 {
2015
2016
2018 goto Unexpected_OtherSubr;
2019
2021
2024 goto Unexpected_OtherSubr;
2025
2027 cf2_stack_popFixed( opStack );
2028 }
2029 break;
2030
2031 case 25:
2032 /* <idx> 1 25 callothersubr pop */
2033 /* ==> push BuildCharArray[cvi( idx )] */
2034 /* onto T1 stack */
2035 {
2038
2039
2041 goto Unexpected_OtherSubr;
2042
2044
2047 goto Unexpected_OtherSubr;
2048
2049 cf2_stack_pushFixed( opStack,
2051 known_othersubr_result_cnt = 1;
2052 }
2053 break;
2054
2055#if 0
2056 case 26:
2057 /* <val> mark <idx> */
2058 /* ==> set BuildCharArray[cvi( <idx> )] = <val>, */
2059 /* leave mark on T1 stack */
2060 /* <val> <idx> */
2061 /* ==> set BuildCharArray[cvi( <idx> )] = <val> */
2064 break;
2065#endif
2066
2067 case 27:
2068 /* <res1> <res2> <val1> <val2> 4 27 callothersubr pop */
2069 /* ==> push <res1> onto T1 stack if <val1> <= <val2>, */
2070 /* otherwise push <res2> */
2071 {
2074 CF2_F16Dot16 cond1;
2075 CF2_F16Dot16 cond2;
2076
2077
2079 goto Unexpected_OtherSubr;
2080
2081 cond2 = cf2_stack_popFixed( opStack );
2082 cond1 = cf2_stack_popFixed( opStack );
2085
2086 cf2_stack_pushFixed( opStack,
2088 known_othersubr_result_cnt = 1;
2089 }
2090 break;
2091
2092 case 28:
2093 /* 0 28 callothersubr pop */
2094 /* ==> push random value from interval [0, 1) */
2095 /* onto stack */
2096 {
2098
2099
2101 goto Unexpected_OtherSubr;
2102
2103 /* only use the lower 16 bits of `random' */
2104 /* to generate a number in the range (0;1] */
2106 ( ( decoder->current_subfont->random & 0xFFFF ) + 1 );
2107
2108 decoder->current_subfont->random =
2110
2112 known_othersubr_result_cnt = 1;
2113 }
2114 break;
2115
2116 default:
2118 {
2120
2121
2122 FT_ERROR((
2123 "cf2_interpT2CharString (Type 1 mode):"
2124 " unknown othersubr [%d %d], wish me luck\n",
2125 arg_cnt, subr_no ));
2126
2127 /* store the unused args */
2128 /* for this unhandled OtherSubr */
2129
2132 result_cnt = arg_cnt;
2133
2136 cf2_stack_popFixed( opStack );
2137
2138 break;
2139 }
2140 /* fall through */
2141
2142 Unexpected_OtherSubr:
2144 " invalid othersubr [%d %d]\n",
2145 arg_cnt, subr_no ));
2146 lastError = FT_THROW( Invalid_Glyph_Format );
2148 }
2149 }
2150 continue; /* do not clear the stack */
2151
2155 else
2156 {
2158
2159 if ( known_othersubr_result_cnt > 0 )
2160 {
2161 known_othersubr_result_cnt--;
2162 /* ignore, we pushed the operands ourselves */
2163 continue;
2164 }
2165
2166 if ( result_cnt == 0 )
2167 {
2169 " no more operands for othersubr\n" ));
2170 lastError = FT_THROW( Invalid_Glyph_Format );
2172 }
2173
2174 result_cnt--;
2176 }
2177 continue; /* do not clear the stack */
2178
2181
2183 continue; /* do not clear the stack */
2184
2186 {
2189
2190
2192
2195
2198 }
2199 continue; /* do not clear the stack */
2200
2202 {
2204
2205
2207
2209
2212 }
2213 continue; /* do not clear the stack */
2214
2216 {
2219 CF2_F16Dot16 cond1;
2220 CF2_F16Dot16 cond2;
2221
2222
2224
2225 cond2 = cf2_stack_popFixed( opStack );
2226 cond1 = cf2_stack_popFixed( opStack );
2229
2230 cf2_stack_pushFixed( opStack,
2232 }
2233 continue; /* do not clear the stack */
2234
2236 {
2238
2239
2241
2242 /* only use the lower 16 bits of `random' */
2243 /* to generate a number in the range (0;1] */
2245 ( ( decoder->current_subfont->random & 0xFFFF ) + 1 );
2246
2247 decoder->current_subfont->random =
2249
2251 }
2252 continue; /* do not clear the stack */
2253
2255 {
2256 CF2_F16Dot16 factor1;
2257 CF2_F16Dot16 factor2;
2258
2259
2261
2262 factor2 = cf2_stack_popFixed( opStack );
2263 factor1 = cf2_stack_popFixed( opStack );
2264
2265 cf2_stack_pushFixed( opStack,
2266 FT_MulFix( factor1, factor2 ) );
2267 }
2268 continue; /* do not clear the stack */
2269
2271 {
2273
2274
2276
2279 {
2280 /* use a start value that doesn't make */
2281 /* the algorithm's addition overflow */
2283 FT_Fixed new_root;
2284
2285
2286 /* Babylonian method */
2287 for (;;)
2288 {
2291 break;
2292 root = new_root;
2293 }
2294 arg = new_root;
2295 }
2296 else
2297 arg = 0;
2298
2300 }
2301 continue; /* do not clear the stack */
2302
2304 {
2306
2307
2309
2311
2314 }
2315 continue; /* do not clear the stack */
2316
2318 {
2321
2322
2324
2327
2330 }
2331 continue; /* do not clear the stack */
2332
2334 {
2337
2338
2340
2343
2345 {
2346 /* for `cf2_stack_getReal', */
2347 /* index 0 is bottom of stack */
2348 CF2_UInt gr_idx;
2349
2350
2352 gr_idx = size - 1;
2354 gr_idx = 0;
2355 else
2357
2358 cf2_stack_pushFixed( opStack,
2359 cf2_stack_getReal( opStack,
2360 gr_idx ) );
2361 }
2362 }
2363 continue; /* do not clear the stack */
2364
2366 {
2369
2370
2372
2375
2377 }
2378 continue; /* do not clear the stack */
2379
2383 else
2384 {
2386
2387 if ( !initial_map_ready )
2388 break;
2389
2390 /* From the T1 specification, section 6.4: */
2391 /* */
2392 /* The setcurrentpoint command is used only in */
2393 /* conjunction with results from OtherSubrs */
2394 /* procedures. */
2395
2396 /* known_othersubr_result_cnt != 0 is already handled */
2397 /* above. */
2398
2399 /* Note, however, that both Ghostscript and Adobe */
2400 /* Distiller handle this situation by silently */
2401 /* ignoring the inappropriate `setcurrentpoint' */
2402 /* instruction. So we do the same. */
2403#if 0
2404
2406 {
2408 " unexpected `setcurrentpoint'\n" ));
2409 goto Syntax_Error;
2410 }
2411 else
2412 ...
2413#endif
2414
2415 curY = cf2_stack_popFixed( opStack );
2416 curX = cf2_stack_popFixed( opStack );
2417
2418 decoder->flex_state = 0;
2419 }
2420 break;
2421
2422 } /* end of 2nd switch checking op2 */
2423 }
2424 }
2425 } /* end of 1st switch checking op2 */
2426 } /* case cf2_cmdESC */
2427
2428 break;
2429
2433 else
2434 {
2435 CF2_Fixed lsb_x;
2436 PS_Builder* builder;
2437
2438
2440
2441 builder = &decoder->builder;
2442
2445
2446 lsb_x = cf2_stack_popFixed( opStack );
2447
2449 lsb_x );
2450
2451 haveWidth = TRUE;
2452
2453 /* the `metrics_only' indicates that we only want to compute */
2454 /* the glyph's metrics (lsb + advance width), not load the */
2455 /* rest of it; so exit immediately */
2458
2459 if ( initial_map_ready )
2460 curX = ADD_INT32( curX, lsb_x );
2461 }
2462 break;
2463
2466
2468 {
2470 "Build initial hintmap, rewinding...\n" ));
2471
2472 /* trigger initial hintmap build */
2473 cf2_glyphpath_moveTo( &glyphPath, curX, curY );
2474
2475 initial_map_ready = TRUE;
2476
2477 /* change hints routine - clear for rewind */
2478 cf2_arrstack_clear( &vStemHintArray );
2479 cf2_arrstack_clear( &hStemHintArray );
2480
2484
2485 /* rewind charstring */
2486 /* some charstrings use endchar from a final subroutine call */
2487 /* without returning, detect these and exit to the top level */
2488 /* charstring */
2489 while ( charstringIndex > 0 )
2490 {
2492
2493 /* restore position in previous charstring */
2494 charstring = (CF2_Buffer)
2495 cf2_arrstack_getPointer(
2496 &subrStack,
2497 (CF2_UInt)--charstringIndex );
2498 }
2499 charstring->ptr = charstring->start;
2500
2501 break;
2502 }
2503
2505 cf2_stack_count( opStack ) == 5 )
2506 {
2507 if ( !haveWidth )
2509 nominalWidthX );
2510 }
2511
2512 /* width is defined or default after this */
2513 haveWidth = TRUE;
2514
2517
2518 /* close path if still open */
2519 cf2_glyphpath_closeOpenPath( &glyphPath );
2520
2521 /* disable seac for CFF2 and Type1 */
2522 /* (charstring ending with args on stack) */
2524 {
2525 /* must be either 4 or 5 -- */
2526 /* this is a (deprecated) implied `seac' operator */
2527
2528 CF2_Int achar;
2529 CF2_Int bchar;
2530 CF2_BufferRec component;
2533
2534
2535 if ( doingSeac )
2536 {
2537 lastError = FT_THROW( Invalid_Glyph_Format );
2539 }
2540
2541 achar = cf2_stack_popInt( opStack );
2542 bchar = cf2_stack_popInt( opStack );
2543
2544 curY = cf2_stack_popFixed( opStack );
2545 curX = cf2_stack_popFixed( opStack );
2546
2549 {
2552 }
2554 &component,
2555 callbacks,
2556 translation,
2557 TRUE,
2558 curX,
2559 curY,
2560 &dummyWidth );
2562
2565 {
2568 }
2570 &component,
2571 callbacks,
2572 translation,
2573 TRUE,
2574 0,
2575 0,
2576 &dummyWidth );
2578 }
2580
2583 /* the final \n in the tracing message gets added in */
2584 /* `cf2_hintmask_read' (which also traces the mask bytes) */
2586
2587 /* never add hints after the mask is computed */
2589 cf2_hintmask_isValid( &hintMask ) )
2590 {
2592 break;
2593 }
2594
2595 /* if there are arguments on the stack, there this is an */
2596 /* implied cf2_cmdVSTEMHM */
2598 opStack,
2599 &vStemHintArray,
2600 width,
2601 &haveWidth,
2602 0 );
2603
2606
2608 {
2609 /* consume the hint mask bytes which follow the operator */
2610 cf2_hintmask_read( &hintMask,
2611 charstring,
2612 cf2_arrstack_size( &hStemHintArray ) +
2613 cf2_arrstack_size( &vStemHintArray ) );
2614 }
2615 else
2616 {
2617 /*
2618 * Consume the counter mask bytes which follow the operator:
2619 * Build a temporary hint map, just to place and lock those
2620 * stems participating in the counter mask. These are most
2621 * likely the dominant hstems, and are grouped together in a
2622 * few counter groups, not necessarily in correspondence
2623 * with the hint groups. This reduces the chances of
2624 * conflicts between hstems that are initially placed in
2625 * separate hint groups and then brought together. The
2626 * positions are copied back to `hStemHintArray', so we can
2627 * discard `counterMask' and `counterHintMap'.
2628 *
2629 */
2630#ifdef __REACTOS__
2632 CF2_HintMaskRec counterMask;
2633 if (!counterHintMap_allocated)
2634 {
2635 lastError = FT_Err_Out_Of_Memory;
2637 }
2638/* Ugly but it allows us to reduce the diff */
2639#define counterHintMap (*counterHintMap_allocated)
2640#else
2641 CF2_HintMapRec counterHintMap;
2642 CF2_HintMaskRec counterMask;
2643#endif
2644
2645 cf2_hintmap_init( &counterHintMap,
2646 font,
2647 &glyphPath.initialHintMap,
2648 &glyphPath.hintMoves,
2649 scaleY );
2651
2652 cf2_hintmask_read( &counterMask,
2653 charstring,
2654 cf2_arrstack_size( &hStemHintArray ) +
2655 cf2_arrstack_size( &vStemHintArray ) );
2656 cf2_hintmap_build( &counterHintMap,
2657 &hStemHintArray,
2658 &vStemHintArray,
2659 &counterMask,
2660 0,
2661 FALSE );
2662#ifdef __REACTOS__
2663 free(counterHintMap_allocated);
2664#undef counterHintMap
2665#endif
2666 }
2667 break;
2668
2671
2674 " No width. Use hsbw/sbw as first op\n" ));
2675
2678 nominalWidthX );
2679
2680 /* width is defined or default after this */
2681 haveWidth = TRUE;
2682
2685
2688
2690 cf2_glyphpath_moveTo( &glyphPath, curX, curY );
2691
2692 break;
2693
2696
2699 " No width. Use hsbw/sbw as first op\n" ));
2700
2703 nominalWidthX );
2704
2705 /* width is defined or default after this */
2706 haveWidth = TRUE;
2707
2710
2712
2714 cf2_glyphpath_moveTo( &glyphPath, curX, curY );
2715
2716 break;
2717
2719 {
2722
2723
2725
2727 {
2729 idx + 0 ) );
2731 idx + 1 ) );
2732
2733 cf2_glyphpath_lineTo( &glyphPath, curX, curY );
2734 idx += 2;
2735 }
2736
2738 {
2740
2741
2748
2750
2751 curX = x3;
2752 curY = y3;
2753 idx += 6;
2754 }
2755
2756 cf2_stack_clear( opStack );
2757 }
2758 continue; /* no need to clear stack again */
2759
2761 {
2764
2765
2766 /* if `cf2_stack_count' isn't of the form 4n or 4n+1, */
2767 /* we enforce it by clearing the second bit */
2768 /* (and sorting the stack indexing to suit) */
2769 count = count1 & ~2U;
2771
2773
2775 {
2777
2778
2780 {
2782
2783 idx++;
2784 }
2785 else
2786 x1 = curX;
2787
2793
2795
2796 curX = x3;
2797 curY = y3;
2798 idx += 4;
2799 }
2800
2801 cf2_stack_clear( opStack );
2802 }
2803 continue; /* no need to clear stack again */
2804
2806 {
2809
2810
2811 /* if `cf2_stack_count' isn't of the form 4n or 4n+1, */
2812 /* we enforce it by clearing the second bit */
2813 /* (and sorting the stack indexing to suit) */
2814 count = count1 & ~2U;
2816
2818
2820 {
2822
2823
2825 {
2827
2828 idx++;
2829 }
2830 else
2831 y1 = curY;
2832
2838
2840
2841 curX = x3;
2842 curY = y3;
2843 idx += 4;
2844 }
2845
2846 cf2_stack_clear( opStack );
2847 }
2848 continue; /* no need to clear stack again */
2849
2852 {
2855
2857
2858
2859 /* if `cf2_stack_count' isn't of the form 8n, 8n+1, */
2860 /* 8n+4, or 8n+5, we enforce it by clearing the */
2861 /* second bit */
2862 /* (and sorting the stack indexing to suit) */
2863 count = count1 & ~2U;
2865
2867
2869 {
2871
2872
2873 if ( alternate )
2874 {
2876 y1 = curY;
2880
2882 {
2884
2885 idx++;
2886 }
2887 else
2889
2890 alternate = FALSE;
2891 }
2892 else
2893 {
2894 x1 = curX;
2899
2901 {
2903
2904 idx++;
2905 }
2906 else
2908
2909 alternate = TRUE;
2910 }
2911
2913
2914 curX = x3;
2915 curY = y3;
2916 idx += 4;
2917 }
2918
2919 cf2_stack_clear( opStack );
2920 }
2921 continue; /* no need to clear stack again */
2922
2924 {
2926
2929
2930
2932 byte2 );
2933
2935
2937 }
2938 continue;
2939
2940 default:
2941 /* numbers */
2942 {
2943 if ( /* op1 >= 32 && */ op1 <= 246 )
2944 {
2946
2947
2948 v = op1 - 139;
2949
2951
2952 /* -107 .. 107 */
2954 }
2955
2956 else if ( /* op1 >= 247 && */ op1 <= 250 )
2957 {
2959
2960
2961 v = op1;
2962 v -= 247;
2963 v *= 256;
2965 v += 108;
2966
2968
2969 /* 108 .. 1131 */
2971 }
2972
2973 else if ( /* op1 >= 251 && */ op1 <= 254 )
2974 {
2976
2977
2978 v = op1;
2979 v -= 251;
2980 v *= 256;
2983
2985
2986 /* -1131 .. -108 */
2988 }
2989
2990 else /* op1 == 255 */
2991 {
2993
2994 FT_UInt32 byte1 = (FT_UInt32)cf2_buf_readByte( charstring );
2995 FT_UInt32 byte2 = (FT_UInt32)cf2_buf_readByte( charstring );
2996 FT_UInt32 byte3 = (FT_UInt32)cf2_buf_readByte( charstring );
2997 FT_UInt32 byte4 = (FT_UInt32)cf2_buf_readByte( charstring );
2998
2999
3001 ( byte2 << 16 ) |
3002 ( byte3 << 8 ) |
3003 byte4 );
3004
3005 /*
3006 * For Type 1:
3007 *
3008 * According to the specification, values > 32000 or < -32000
3009 * must be followed by a `div' operator to make the result be
3010 * in the range [-32000;32000]. We expect that the second
3011 * argument of `div' is not a large number. Additionally, we
3012 * don't handle stuff like `<large1> <large2> <num> div <num>
3013 * div' or <large1> <large2> <num> div div'. This is probably
3014 * not allowed anyway.
3015 *
3016 * <large> <num> <num>+ div is not checked but should not be
3017 * allowed as the large value remains untouched.
3018 *
3019 */
3021 {
3023 {
3024 if ( large_int )
3026 " no `div' after large integer\n" ));
3027 else
3028 large_int = TRUE;
3029 }
3030
3032
3034 }
3035 else
3036 {
3038
3040 }
3041 }
3042 }
3043 continue; /* don't clear stack */
3044
3045 } /* end of switch statement checking `op1' */
3046
3047 cf2_stack_clear( opStack );
3048
3049 } /* end of main interpreter loop */
3050
3051 /* we get here if the charstring ends without cf2_cmdENDCHAR */
3053 " charstring ends without ENDCHAR\n" ));
3054
3055 exit:
3056 /* check whether last error seen is also the first one */
3058
3061
3062 /* free resources from objects we've used */
3063 cf2_glyphpath_finalize( &glyphPath );
3064 cf2_arrstack_finalize( &vStemHintArray );
3065 cf2_arrstack_finalize( &hStemHintArray );
3066 cf2_arrstack_finalize( &subrStack );
3067 cf2_stack_free( opStack );
3068
3070
3071#ifdef __REACTOS__
3072 free(glyphPath_allocated);
3073#undef glyphPath
3074#endif
3075 return;
3076 }
_STLP_MOVE_TO_STD_NAMESPACE void _STLP_CALL advance(_InputIterator &__i, _Distance __n)
Definition: _iterator_base.h:515
#define FT_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES
Definition: freetype.h:3955
cannot open resource broken file module version is too low unimplemented feature broken offset within table missing module invalid glyph index unsupported glyph image format invalid outline too many hints invalid object handle invalid module handle invalid size handle invalid charmap handle invalid stream handle too many extensions unlisted object invalid stream seek invalid stream read invalid frame operation invalid frame read raster corrupted negative height while rastering invalid opcode stack overflow bad argument invalid reference found ENDF opcode in execution stream invalid code range too many function definitions SFNT font table missing name table missing horizontal PostScript(post) table missing" ) FT_ERRORDEF_( Invalid_Horiz_Metrics
FT_GlyphLoader_CheckSubGlyphs(FT_GlyphLoader loader, FT_UInt n_subs)
Definition: ftgloadr.c:293
Definition: nsiface.idl:2307
cf2_arrstack_getPointer(const CF2_ArrStack arrstack, size_t idx)
Definition: psarrst.c:187
cf2_arrstack_setCount(CF2_ArrStack arrstack, size_t numElements)
Definition: psarrst.c:140
cf2_arrstack_init(CF2_ArrStack arrstack, FT_Memory memory, FT_Error *error, size_t sizeItem)
Definition: psarrst.c:56
FT_BEGIN_HEADER struct CF2_ArrStackRec_ CF2_ArrStackRec
cf2_freeSeacComponent(PS_Decoder *decoder, CF2_Buffer buf)
Definition: psft.c:708
cf2_freeT1SeacComponent(PS_Decoder *decoder, CF2_Buffer buf)
Definition: psft.c:767
cf2_initLocalRegionBuffer(PS_Decoder *decoder, CF2_Int subrNum, CF2_Buffer buf)
Definition: psft.c:798
cf2_initGlobalRegionBuffer(PS_Decoder *decoder, CF2_Int subrNum, CF2_Buffer buf)
Definition: psft.c:632
cf2_getT1SeacComponent(PS_Decoder *decoder, FT_UInt glyph_index, CF2_Buffer buf)
Definition: psft.c:721
cf2_getSeacComponent(PS_Decoder *decoder, CF2_Int code, CF2_Buffer buf)
Definition: psft.c:660
cf2_glyphpath_moveTo(CF2_GlyphPath glyphpath, CF2_Fixed x, CF2_Fixed y)
Definition: pshints.c:1678
cf2_hintmap_build(CF2_HintMap hintmap, CF2_ArrStack hStemHintArray, CF2_ArrStack vStemHintArray, CF2_HintMask hintMask, CF2_Fixed hintOrigin, FT_Bool initialMap)
Definition: pshints.c:805
cf2_glyphpath_closeOpenPath(CF2_GlyphPath glyphpath)
Definition: pshints.c:1904
cf2_glyphpath_lineTo(CF2_GlyphPath glyphpath, CF2_Fixed x, CF2_Fixed y)
Definition: pshints.c:1708
cf2_hintmap_init(CF2_HintMap hintmap, CF2_Font font, CF2_HintMap initialMap, CF2_ArrStack hintMoves, CF2_Fixed scale)
Definition: pshints.c:274
cf2_glyphpath_init(CF2_GlyphPath glyphpath, CF2_Font font, CF2_OutlineCallbacks callbacks, CF2_Fixed scaleY, CF2_ArrStack hStemHintArray, CF2_ArrStack vStemHintArray, CF2_HintMask hintMask, CF2_Fixed hintOriginY, const CF2_Blues blues, const FT_Vector *fractionalTranslation)
Definition: pshints.c:1080
static void cf2_doFlex(CF2_Stack opStack, CF2_Fixed *curX, CF2_Fixed *curY, CF2_GlyphPath glyphPath, const FT_Bool *readFromStack, FT_Bool doConditionalLastRead)
Definition: psintrp.c:335
static void cf2_doStems(const CF2_Font font, CF2_Stack opStack, CF2_ArrStack stemHintArray, CF2_Fixed *width, FT_Bool *haveWidth, CF2_Fixed hintOffset)
Definition: psintrp.c:281
#define PS_STORAGE_SIZE
static void cf2_doBlend(const CFF_Blend blend, CF2_Stack opStack, CF2_UInt numBlends)
Definition: psintrp.c:418
static void cf2_hintmask_read(CF2_HintMask hintmask, CF2_Buffer charstring, size_t bitCount)
Definition: psintrp.c:131
cf2_interpT2CharString(CF2_Font font, CF2_Buffer buf, CF2_OutlineCallbacks callbacks, const FT_Vector *translation, FT_Bool doingSeac, CF2_Fixed curX, CF2_Fixed curY, CF2_Fixed *width)
Definition: psintrp.c:471
ps_builder_check_points(PS_Builder *builder, FT_Int count)
Definition: psobjs.c:2207
FT_BEGIN_HEADER struct CF2_BufferRec_ CF2_BufferRec
FT_BEGIN_HEADER struct CF2_BufferRec_ * CF2_Buffer
cf2_stack_roll(CF2_Stack stack, CF2_Int count, CF2_Int shift)
Definition: psstack.c:242
cf2_stack_init(FT_Memory memory, FT_Error *e, FT_UInt stackSize)
Definition: psstack.c:53
Definition: pshints.h:182
Definition: pshints.h:127
Definition: pshints.h:71
Definition: psstack.h:63
Definition: ftgloadr.h:61
Definition: freetype.h:1872
Definition: ftgloadr.h:39
Definition: ftimage.h:76
Definition: t1tables.h:296
Definition: psaux.h:564
Definition: psaux.h:631
Definition: t1types.h:203
Definition: btrfs_drv.h:450
Definition: wincodecs_private.h:312
Definition: format.c:80
Definition: storages.c:44
t1_lookup_glyph_by_stdcharcode_ps(PS_Decoder *decoder, FT_Int charcode)
Definition: t1decode.c:132
Referenced by cf2_getGlyphOutline(), and cf2_interpT2CharString().
