psintrp.c File Reference
#include "psft.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 }
1443 &component,
1444 callbacks,
1445 translation,
1446 TRUE,
1447 0,
1448 0,
1449 &dummyWidth );
1451
1452 /* save the left bearing and width of the base */
1453 /* character as they will be erased by the next load */
1454
1455 left_bearing = *decoder->builder.left_bearing;
1457
1458 decoder->builder.left_bearing->x = 0;
1459 decoder->builder.left_bearing->y = 0;
1460
1461 /* Now load `achar' on top of */
1462 /* the base outline */
1463
1465 (FT_UInt)achar_index,
1466 &component );
1468 {
1471 }
1473 &component,
1474 callbacks,
1475 translation,
1476 TRUE,
1477 adx - asb,
1478 ady,
1479 &dummyWidth );
1481
1482 /* restore the left side bearing and */
1483 /* advance width of the base character */
1484
1485 *decoder->builder.left_bearing = left_bearing;
1487
1489 }
1490 break;
1491
1495 else
1496 {
1497 CF2_Fixed lsb_x, lsb_y;
1498 PS_Builder* builder;
1499
1500
1502
1503 builder = &decoder->builder;
1504
1507
1508 lsb_y = cf2_stack_popFixed( opStack );
1509 lsb_x = cf2_stack_popFixed( opStack );
1510
1515
1516 haveWidth = TRUE;
1517
1518 /* the `metrics_only' indicates that we only want */
1519 /* to compute the glyph's metrics (lsb + advance */
1520 /* width), not load the rest of it; so exit */
1521 /* immediately */
1524
1525 if ( initial_map_ready )
1526 {
1527 curX = ADD_INT32( curX, lsb_x );
1528 curY = ADD_INT32( curY, lsb_y );
1529 }
1530 }
1531 break;
1532
1534 {
1536
1537
1539
1541
1544 else
1546 }
1547 continue; /* do not clear the stack */
1548
1550 {
1551 CF2_F16Dot16 summand1;
1552 CF2_F16Dot16 summand2;
1553
1554
1556
1557 summand2 = cf2_stack_popFixed( opStack );
1558 summand1 = cf2_stack_popFixed( opStack );
1559
1560 cf2_stack_pushFixed( opStack,
1561 ADD_INT32( summand1,
1562 summand2 ) );
1563 }
1564 continue; /* do not clear the stack */
1565
1567 {
1568 CF2_F16Dot16 minuend;
1569 CF2_F16Dot16 subtrahend;
1570
1571
1573
1574 subtrahend = cf2_stack_popFixed( opStack );
1575 minuend = cf2_stack_popFixed( opStack );
1576
1577 cf2_stack_pushFixed( opStack,
1578 SUB_INT32( minuend, subtrahend ) );
1579 }
1580 continue; /* do not clear the stack */
1581
1583 {
1584 CF2_F16Dot16 dividend;
1586
1587
1589
1591 {
1594
1595 large_int = FALSE;
1596 }
1597 else
1598 {
1600 dividend = cf2_stack_popFixed( opStack );
1601 }
1602
1603 cf2_stack_pushFixed( opStack,
1605
1606 }
1607 continue; /* do not clear the stack */
1608
1610 {
1612
1613
1615
1617
1620 else
1622 }
1623 continue; /* do not clear the stack */
1624
1626 {
1629
1630
1632
1635
1637 }
1638 continue; /* do not clear the stack */
1639
1643 else
1644 {
1645 CF2_Int subr_no;
1648 CF2_UInt opIdx = 0;
1649
1650
1652
1653 subr_no = cf2_stack_popInt( opStack );
1655
1656 /********************************************************
1657 *
1658 * remove all operands to callothersubr from the stack
1659 *
1660 * for handled othersubrs, where we know the number of
1661 * arguments, we increase the stack by the value of
1662 * known_othersubr_result_cnt
1663 *
1664 * for unhandled othersubrs the following pops adjust
1665 * the stack pointer as necessary
1666 */
1667
1670
1672
1673 known_othersubr_result_cnt = 0;
1674 result_cnt = 0;
1675
1676 /* XXX TODO: The checks to `arg_count == <whatever>' */
1677 /* might not be correct; an othersubr expects a */
1678 /* certain number of operands on the PostScript stack */
1679 /* (as opposed to the T1 stack) but it doesn't have to */
1680 /* put them there by itself; previous othersubrs might */
1681 /* have left the operands there if they were not */
1682 /* followed by an appropriate number of pops */
1683 /* */
1684 /* On the other hand, Adobe Reader 7.0.8 for Linux */
1685 /* doesn't accept a font that contains charstrings */
1686 /* like */
1687 /* */
1688 /* 100 200 2 20 callothersubr */
1689 /* 300 1 20 callothersubr pop */
1690 /* */
1691 /* Perhaps this is the reason why BuildCharArray */
1692 /* exists. */
1693
1694 switch ( subr_no )
1695 {
1696 case 0: /* end flex feature */
1698 goto Unexpected_OtherSubr;
1699
1700 if ( initial_map_ready &&
1701 ( !decoder->flex_state ||
1702 decoder->num_flex_vectors != 7 ) )
1703 {
1705 " unexpected flex end\n" ));
1706 lastError = FT_THROW( Invalid_Glyph_Format );
1708 }
1709
1710 /* the two `results' are popped */
1711 /* by the following setcurrentpoint */
1712 cf2_stack_pushFixed( opStack, curX );
1713 cf2_stack_pushFixed( opStack, curY );
1714 known_othersubr_result_cnt = 2;
1715 break;
1716
1717 case 1: /* start flex feature */
1719 goto Unexpected_OtherSubr;
1720
1721 if ( !initial_map_ready )
1722 break;
1723
1726
1727 decoder->flex_state = 1;
1728 decoder->num_flex_vectors = 0;
1729 break;
1730
1731 case 2: /* add flex vectors */
1732 {
1734 FT_Int idx2;
1735
1736
1738 goto Unexpected_OtherSubr;
1739
1740 if ( !initial_map_ready )
1741 break;
1742
1744 {
1746 " missing flex start\n" ));
1747 lastError = FT_THROW( Invalid_Glyph_Format );
1749 }
1750
1751 /* note that we should not add a point for */
1752 /* index 0; this will move our current position */
1753 /* to the flex point without adding any point */
1754 /* to the outline */
1757 {
1758 /* in malformed fonts it is possible to have */
1759 /* other opcodes in the middle of a flex (which */
1760 /* don't increase `num_flex_vectors'); we thus */
1761 /* have to check whether we can add a point */
1762
1764 1 ) )
1765 {
1766 lastError = FT_THROW( Invalid_Glyph_Format );
1768 }
1769
1770 /* map: 1->2 2->4 3->6 4->2 5->4 6->6 */
1772
1773 flexStore[idx2 - 2] = curX;
1774 flexStore[idx2 - 1] = curY;
1775
1777 cf2_glyphpath_curveTo( &glyphPath,
1778 flexStore[0],
1779 flexStore[1],
1780 flexStore[2],
1781 flexStore[3],
1782 flexStore[4],
1783 flexStore[5] );
1784 }
1785 }
1786 break;
1787
1788 case 3: /* change hints */
1790 goto Unexpected_OtherSubr;
1791
1792 if ( initial_map_ready )
1793 {
1794 /* do not clear hints if initial hintmap */
1795 /* is not ready - we need to collate all */
1796 cf2_arrstack_clear( &vStemHintArray );
1797 cf2_arrstack_clear( &hStemHintArray );
1798
1802 }
1803
1804 known_othersubr_result_cnt = 1;
1805 break;
1806
1807 case 12:
1808 case 13:
1809 /* counter control hints, clear stack */
1810 cf2_stack_clear( opStack );
1811 break;
1812
1813 case 14:
1814 case 15:
1815 case 16:
1816 case 17:
1817 case 18: /* multiple masters */
1818 {
1820 FT_UInt num_points, nn, mm;
1821 CF2_UInt delta;
1823
1824
1825 if ( !blend )
1826 {
1827 FT_ERROR((
1828 "cf2_interpT2CharString:"
1829 " unexpected multiple masters operator\n" ));
1830 lastError = FT_THROW( Invalid_Glyph_Format );
1832 }
1833
1834 num_points = (FT_UInt)subr_no - 13 +
1835 ( subr_no == 18 );
1837 blend->num_designs ) )
1838 {
1839 FT_ERROR((
1840 "cf2_interpT2CharString:"
1841 " incorrect number of multiple masters arguments\n" ));
1842 lastError = FT_THROW( Invalid_Glyph_Format );
1844 }
1845
1846 /* We want to compute */
1847 /* */
1848 /* a0*w0 + a1*w1 + ... + ak*wk */
1849 /* */
1850 /* but we only have a0, a1-a0, a2-a0, ..., ak-a0. */
1851 /* */
1852 /* However, given that w0 + w1 + ... + wk == 1, we */
1853 /* can rewrite it easily as */
1854 /* */
1855 /* a0 + (a1-a0)*w1 + (a2-a0)*w2 + ... + (ak-a0)*wk */
1856 /* */
1857 /* where k == num_designs-1. */
1858 /* */
1859 /* I guess that's why it's written in this `compact' */
1860 /* form. */
1861 /* */
1862 delta = opIdx + num_points;
1863 values = opIdx;
1864 for ( nn = 0; nn < num_points; nn++ )
1865 {
1867 values );
1868
1869
1871 tmp = ADD_INT32( tmp,
1872 FT_MulFix(
1873 cf2_stack_getReal( opStack,
1874 delta++ ),
1875 blend->weight_vector[mm] ) );
1876
1878 }
1879 cf2_stack_pop( opStack,
1881
1882 known_othersubr_result_cnt = (FT_Int)num_points;
1883 break;
1884 }
1885
1886 case 19:
1887 /* <idx> 1 19 callothersubr */
1888 /* ==> replace elements starting from index */
1889 /* cvi( <idx> ) of BuildCharArray with */
1890 /* WeightVector */
1891 {
1894
1895
1897 goto Unexpected_OtherSubr;
1898
1900
1903 decoder->len_buildchar )
1904 goto Unexpected_OtherSubr;
1905
1907 blend->weight_vector,
1908 blend->num_designs *
1910 }
1911 break;
1912
1913 case 20:
1914 /* <arg1> <arg2> 2 20 callothersubr pop */
1915 /* ==> push <arg1> + <arg2> onto T1 stack */
1916 {
1917 CF2_F16Dot16 summand1;
1918 CF2_F16Dot16 summand2;
1919
1920
1922 goto Unexpected_OtherSubr;
1923
1924 summand2 = cf2_stack_popFixed( opStack );
1925 summand1 = cf2_stack_popFixed( opStack );
1926
1927 cf2_stack_pushFixed( opStack,
1928 ADD_INT32( summand1,
1929 summand2 ) );
1930 known_othersubr_result_cnt = 1;
1931 }
1932 break;
1933
1934 case 21:
1935 /* <arg1> <arg2> 2 21 callothersubr pop */
1936 /* ==> push <arg1> - <arg2> onto T1 stack */
1937 {
1938 CF2_F16Dot16 minuend;
1939 CF2_F16Dot16 subtrahend;
1940
1941
1943 goto Unexpected_OtherSubr;
1944
1945 subtrahend = cf2_stack_popFixed( opStack );
1946 minuend = cf2_stack_popFixed( opStack );
1947
1948 cf2_stack_pushFixed( opStack,
1949 SUB_INT32( minuend,
1950 subtrahend ) );
1951 known_othersubr_result_cnt = 1;
1952 }
1953 break;
1954
1955 case 22:
1956 /* <arg1> <arg2> 2 22 callothersubr pop */
1957 /* ==> push <arg1> * <arg2> onto T1 stack */
1958 {
1959 CF2_F16Dot16 factor1;
1960 CF2_F16Dot16 factor2;
1961
1962
1964 goto Unexpected_OtherSubr;
1965
1966 factor2 = cf2_stack_popFixed( opStack );
1967 factor1 = cf2_stack_popFixed( opStack );
1968
1969 cf2_stack_pushFixed( opStack,
1970 FT_MulFix( factor1, factor2 ) );
1971 known_othersubr_result_cnt = 1;
1972 }
1973 break;
1974
1975 case 23:
1976 /* <arg1> <arg2> 2 23 callothersubr pop */
1977 /* ==> push <arg1> / <arg2> onto T1 stack */
1978 {
1979 CF2_F16Dot16 dividend;
1981
1982
1984 goto Unexpected_OtherSubr;
1985
1987 dividend = cf2_stack_popFixed( opStack );
1988
1990 goto Unexpected_OtherSubr;
1991
1992 cf2_stack_pushFixed( opStack,
1993 FT_DivFix( dividend,
1994 divisor ) );
1995 known_othersubr_result_cnt = 1;
1996 }
1997 break;
1998
1999 case 24:
2000 /* <val> <idx> 2 24 callothersubr */
2001 /* ==> set BuildCharArray[cvi( <idx> )] = <val> */
2002 {
2005
2006
2008 goto Unexpected_OtherSubr;
2009
2011
2014 goto Unexpected_OtherSubr;
2015
2017 cf2_stack_popFixed( opStack );
2018 }
2019 break;
2020
2021 case 25:
2022 /* <idx> 1 25 callothersubr pop */
2023 /* ==> push BuildCharArray[cvi( idx )] */
2024 /* onto T1 stack */
2025 {
2028
2029
2031 goto Unexpected_OtherSubr;
2032
2034
2037 goto Unexpected_OtherSubr;
2038
2039 cf2_stack_pushFixed( opStack,
2041 known_othersubr_result_cnt = 1;
2042 }
2043 break;
2044
2045#if 0
2046 case 26:
2047 /* <val> mark <idx> */
2048 /* ==> set BuildCharArray[cvi( <idx> )] = <val>, */
2049 /* leave mark on T1 stack */
2050 /* <val> <idx> */
2051 /* ==> set BuildCharArray[cvi( <idx> )] = <val> */
2054 break;
2055#endif
2056
2057 case 27:
2058 /* <res1> <res2> <val1> <val2> 4 27 callothersubr pop */
2059 /* ==> push <res1> onto T1 stack if <val1> <= <val2>, */
2060 /* otherwise push <res2> */
2061 {
2064 CF2_F16Dot16 cond1;
2065 CF2_F16Dot16 cond2;
2066
2067
2069 goto Unexpected_OtherSubr;
2070
2071 cond2 = cf2_stack_popFixed( opStack );
2072 cond1 = cf2_stack_popFixed( opStack );
2075
2076 cf2_stack_pushFixed( opStack,
2078 known_othersubr_result_cnt = 1;
2079 }
2080 break;
2081
2082 case 28:
2083 /* 0 28 callothersubr pop */
2084 /* ==> push random value from interval [0, 1) */
2085 /* onto stack */
2086 {
2088
2089
2091 goto Unexpected_OtherSubr;
2092
2093 /* only use the lower 16 bits of `random' */
2094 /* to generate a number in the range (0;1] */
2096 ( ( decoder->current_subfont->random & 0xFFFF ) + 1 );
2097
2098 decoder->current_subfont->random =
2100
2102 known_othersubr_result_cnt = 1;
2103 }
2104 break;
2105
2106 default:
2108 {
2110
2111
2112 FT_ERROR((
2113 "cf2_interpT2CharString (Type 1 mode):"
2114 " unknown othersubr [%d %d], wish me luck\n",
2115 arg_cnt, subr_no ));
2116
2117 /* store the unused args */
2118 /* for this unhandled OtherSubr */
2119
2122 result_cnt = arg_cnt;
2123
2126 cf2_stack_popFixed( opStack );
2127
2128 break;
2129 }
2130 /* fall through */
2131
2132 Unexpected_OtherSubr:
2134 " invalid othersubr [%d %d]\n",
2135 arg_cnt, subr_no ));
2136 lastError = FT_THROW( Invalid_Glyph_Format );
2138 }
2139 }
2140 continue; /* do not clear the stack */
2141
2145 else
2146 {
2148
2149 if ( known_othersubr_result_cnt > 0 )
2150 {
2151 known_othersubr_result_cnt--;
2152 /* ignore, we pushed the operands ourselves */
2153 continue;
2154 }
2155
2156 if ( result_cnt == 0 )
2157 {
2159 " no more operands for othersubr\n" ));
2160 lastError = FT_THROW( Invalid_Glyph_Format );
2162 }
2163
2164 result_cnt--;
2166 }
2167 continue; /* do not clear the stack */
2168
2171
2173 continue; /* do not clear the stack */
2174
2176 {
2179
2180
2182
2185
2188 }
2189 continue; /* do not clear the stack */
2190
2192 {
2194
2195
2197
2199
2202 }
2203 continue; /* do not clear the stack */
2204
2206 {
2209 CF2_F16Dot16 cond1;
2210 CF2_F16Dot16 cond2;
2211
2212
2214
2215 cond2 = cf2_stack_popFixed( opStack );
2216 cond1 = cf2_stack_popFixed( opStack );
2219
2220 cf2_stack_pushFixed( opStack,
2222 }
2223 continue; /* do not clear the stack */
2224
2226 {
2228
2229
2231
2232 /* only use the lower 16 bits of `random' */
2233 /* to generate a number in the range (0;1] */
2235 ( ( decoder->current_subfont->random & 0xFFFF ) + 1 );
2236
2237 decoder->current_subfont->random =
2239
2241 }
2242 continue; /* do not clear the stack */
2243
2245 {
2246 CF2_F16Dot16 factor1;
2247 CF2_F16Dot16 factor2;
2248
2249
2251
2252 factor2 = cf2_stack_popFixed( opStack );
2253 factor1 = cf2_stack_popFixed( opStack );
2254
2255 cf2_stack_pushFixed( opStack,
2256 FT_MulFix( factor1, factor2 ) );
2257 }
2258 continue; /* do not clear the stack */
2259
2261 {
2263
2264
2266
2269 {
2270 /* use a start value that doesn't make */
2271 /* the algorithm's addition overflow */
2273 FT_Fixed new_root;
2274
2275
2276 /* Babylonian method */
2277 for (;;)
2278 {
2281 break;
2282 root = new_root;
2283 }
2284 arg = new_root;
2285 }
2286 else
2287 arg = 0;
2288
2290 }
2291 continue; /* do not clear the stack */
2292
2294 {
2296
2297
2299
2301
2304 }
2305 continue; /* do not clear the stack */
2306
2308 {
2311
2312
2314
2317
2320 }
2321 continue; /* do not clear the stack */
2322
2324 {
2327
2328
2330
2333
2335 {
2336 /* for `cf2_stack_getReal', */
2337 /* index 0 is bottom of stack */
2338 CF2_UInt gr_idx;
2339
2340
2342 gr_idx = size - 1;
2344 gr_idx = 0;
2345 else
2347
2348 cf2_stack_pushFixed( opStack,
2349 cf2_stack_getReal( opStack,
2350 gr_idx ) );
2351 }
2352 }
2353 continue; /* do not clear the stack */
2354
2356 {
2359
2360
2362
2365
2367 }
2368 continue; /* do not clear the stack */
2369
2373 else
2374 {
2376
2377 if ( !initial_map_ready )
2378 break;
2379
2380 /* From the T1 specification, section 6.4: */
2381 /* */
2382 /* The setcurrentpoint command is used only in */
2383 /* conjunction with results from OtherSubrs */
2384 /* procedures. */
2385
2386 /* known_othersubr_result_cnt != 0 is already handled */
2387 /* above. */
2388
2389 /* Note, however, that both Ghostscript and Adobe */
2390 /* Distiller handle this situation by silently */
2391 /* ignoring the inappropriate `setcurrentpoint' */
2392 /* instruction. So we do the same. */
2393#if 0
2394
2396 {
2398 " unexpected `setcurrentpoint'\n" ));
2399 goto Syntax_Error;
2400 }
2401 else
2402 ...
2403#endif
2404
2405 curY = cf2_stack_popFixed( opStack );
2406 curX = cf2_stack_popFixed( opStack );
2407
2408 decoder->flex_state = 0;
2409 }
2410 break;
2411
2412 } /* end of 2nd switch checking op2 */
2413 }
2414 }
2415 } /* end of 1st switch checking op2 */
2416 } /* case cf2_cmdESC */
2417
2418 break;
2419
2423 else
2424 {
2425 CF2_Fixed lsb_x;
2426 PS_Builder* builder;
2427
2428
2430
2431 builder = &decoder->builder;
2432
2435
2436 lsb_x = cf2_stack_popFixed( opStack );
2437
2439 lsb_x );
2440
2441 haveWidth = TRUE;
2442
2443 /* the `metrics_only' indicates that we only want to compute */
2444 /* the glyph's metrics (lsb + advance width), not load the */
2445 /* rest of it; so exit immediately */
2448
2449 if ( initial_map_ready )
2450 curX = ADD_INT32( curX, lsb_x );
2451 }
2452 break;
2453
2456
2458 {
2460 "Build initial hintmap, rewinding...\n" ));
2461
2462 /* trigger initial hintmap build */
2463 cf2_glyphpath_moveTo( &glyphPath, curX, curY );
2464
2465 initial_map_ready = TRUE;
2466
2467 /* change hints routine - clear for rewind */
2468 cf2_arrstack_clear( &vStemHintArray );
2469 cf2_arrstack_clear( &hStemHintArray );
2470
2474
2475 /* rewind charstring */
2476 /* some charstrings use endchar from a final subroutine call */
2477 /* without returning, detect these and exit to the top level */
2478 /* charstring */
2479 while ( charstringIndex > 0 )
2480 {
2482
2483 /* restore position in previous charstring */
2484 charstring = (CF2_Buffer)
2485 cf2_arrstack_getPointer(
2486 &subrStack,
2487 (CF2_UInt)--charstringIndex );
2488 }
2489 charstring->ptr = charstring->start;
2490
2491 break;
2492 }
2493
2495 cf2_stack_count( opStack ) == 5 )
2496 {
2497 if ( !haveWidth )
2499 nominalWidthX );
2500 }
2501
2502 /* width is defined or default after this */
2503 haveWidth = TRUE;
2504
2507
2508 /* close path if still open */
2509 cf2_glyphpath_closeOpenPath( &glyphPath );
2510
2511 /* disable seac for CFF2 and Type1 */
2512 /* (charstring ending with args on stack) */
2514 {
2515 /* must be either 4 or 5 -- */
2516 /* this is a (deprecated) implied `seac' operator */
2517
2518 CF2_Int achar;
2519 CF2_Int bchar;
2520 CF2_BufferRec component;
2523
2524
2525 if ( doingSeac )
2526 {
2527 lastError = FT_THROW( Invalid_Glyph_Format );
2529 }
2530
2531 achar = cf2_stack_popInt( opStack );
2532 bchar = cf2_stack_popInt( opStack );
2533
2534 curY = cf2_stack_popFixed( opStack );
2535 curX = cf2_stack_popFixed( opStack );
2536
2539 {
2542 }
2544 &component,
2545 callbacks,
2546 translation,
2547 TRUE,
2548 curX,
2549 curY,
2550 &dummyWidth );
2552
2555 {
2558 }
2560 &component,
2561 callbacks,
2562 translation,
2563 TRUE,
2564 0,
2565 0,
2566 &dummyWidth );
2568 }
2570
2573 /* the final \n in the tracing message gets added in */
2574 /* `cf2_hintmask_read' (which also traces the mask bytes) */
2576
2577 /* never add hints after the mask is computed */
2579 cf2_hintmask_isValid( &hintMask ) )
2580 {
2582 break;
2583 }
2584
2585 /* if there are arguments on the stack, there this is an */
2586 /* implied cf2_cmdVSTEMHM */
2588 opStack,
2589 &vStemHintArray,
2590 width,
2591 &haveWidth,
2592 0 );
2593
2596
2598 {
2599 /* consume the hint mask bytes which follow the operator */
2600 cf2_hintmask_read( &hintMask,
2601 charstring,
2602 cf2_arrstack_size( &hStemHintArray ) +
2603 cf2_arrstack_size( &vStemHintArray ) );
2604 }
2605 else
2606 {
2607 /*
2608 * Consume the counter mask bytes which follow the operator:
2609 * Build a temporary hint map, just to place and lock those
2610 * stems participating in the counter mask. These are most
2611 * likely the dominant hstems, and are grouped together in a
2612 * few counter groups, not necessarily in correspondence
2613 * with the hint groups. This reduces the chances of
2614 * conflicts between hstems that are initially placed in
2615 * separate hint groups and then brought together. The
2616 * positions are copied back to `hStemHintArray', so we can
2617 * discard `counterMask' and `counterHintMap'.
2618 *
2619 */
2620#ifdef __REACTOS__
2622 CF2_HintMaskRec counterMask;
2623 if (!counterHintMap_allocated)
2624 {
2625 lastError = FT_Err_Out_Of_Memory;
2627 }
2628/* Ugly but it allows us to reduce the diff */
2629#define counterHintMap (*counterHintMap_allocated)
2630#else
2631 CF2_HintMapRec counterHintMap;
2632 CF2_HintMaskRec counterMask;
2633#endif
2634
2635
2636 cf2_hintmap_init( &counterHintMap,
2637 font,
2638 &glyphPath.initialHintMap,
2639 &glyphPath.hintMoves,
2640 scaleY );
2642
2643 cf2_hintmask_read( &counterMask,
2644 charstring,
2645 cf2_arrstack_size( &hStemHintArray ) +
2646 cf2_arrstack_size( &vStemHintArray ) );
2647 cf2_hintmap_build( &counterHintMap,
2648 &hStemHintArray,
2649 &vStemHintArray,
2650 &counterMask,
2651 0,
2652 FALSE );
2653#ifdef __REACTOS__
2654 free(counterHintMap_allocated);
2655#undef counterHintMap
2656#endif
2657 }
2658 break;
2659
2662
2665 " No width. Use hsbw/sbw as first op\n" ));
2666
2669 nominalWidthX );
2670
2671 /* width is defined or default after this */
2672 haveWidth = TRUE;
2673
2676
2679
2681 cf2_glyphpath_moveTo( &glyphPath, curX, curY );
2682
2683 break;
2684
2687
2690 " No width. Use hsbw/sbw as first op\n" ));
2691
2694 nominalWidthX );
2695
2696 /* width is defined or default after this */
2697 haveWidth = TRUE;
2698
2701
2703
2705 cf2_glyphpath_moveTo( &glyphPath, curX, curY );
2706
2707 break;
2708
2710 {
2713
2714
2716
2718 {
2720 idx + 0 ) );
2722 idx + 1 ) );
2723
2724 cf2_glyphpath_lineTo( &glyphPath, curX, curY );
2725 idx += 2;
2726 }
2727
2729 {
2731
2732
2739
2741
2742 curX = x3;
2743 curY = y3;
2744 idx += 6;
2745 }
2746
2747 cf2_stack_clear( opStack );
2748 }
2749 continue; /* no need to clear stack again */
2750
2752 {
2755
2756
2757 /* if `cf2_stack_count' isn't of the form 4n or 4n+1, */
2758 /* we enforce it by clearing the second bit */
2759 /* (and sorting the stack indexing to suit) */
2760 count = count1 & ~2U;
2762
2764
2766 {
2768
2769
2771 {
2773
2774 idx++;
2775 }
2776 else
2777 x1 = curX;
2778
2782 x3 = x2;
2784
2786
2787 curX = x3;
2788 curY = y3;
2789 idx += 4;
2790 }
2791
2792 cf2_stack_clear( opStack );
2793 }
2794 continue; /* no need to clear stack again */
2795
2797 {
2800
2801
2802 /* if `cf2_stack_count' isn't of the form 4n or 4n+1, */
2803 /* we enforce it by clearing the second bit */
2804 /* (and sorting the stack indexing to suit) */
2805 count = count1 & ~2U;
2807
2809
2811 {
2813
2814
2816 {
2818
2819 idx++;
2820 }
2821 else
2822 y1 = curY;
2823
2828 y3 = y2;
2829
2831
2832 curX = x3;
2833 curY = y3;
2834 idx += 4;
2835 }
2836
2837 cf2_stack_clear( opStack );
2838 }
2839 continue; /* no need to clear stack again */
2840
2843 {
2846
2848
2849
2850 /* if `cf2_stack_count' isn't of the form 8n, 8n+1, */
2851 /* 8n+4, or 8n+5, we enforce it by clearing the */
2852 /* second bit */
2853 /* (and sorting the stack indexing to suit) */
2854 count = count1 & ~2U;
2856
2858
2860 {
2862
2863
2864 if ( alternate )
2865 {
2867 y1 = curY;
2871
2873 {
2875
2876 idx++;
2877 }
2878 else
2879 x3 = x2;
2880
2881 alternate = FALSE;
2882 }
2883 else
2884 {
2885 x1 = curX;
2890
2892 {
2894
2895 idx++;
2896 }
2897 else
2898 y3 = y2;
2899
2900 alternate = TRUE;
2901 }
2902
2904
2905 curX = x3;
2906 curY = y3;
2907 idx += 4;
2908 }
2909
2910 cf2_stack_clear( opStack );
2911 }
2912 continue; /* no need to clear stack again */
2913
2915 {
2917
2920
2921
2923 byte2 );
2924
2926
2928 }
2929 continue;
2930
2931 default:
2932 /* numbers */
2933 {
2934 if ( /* op1 >= 32 && */ op1 <= 246 )
2935 {
2937
2938
2939 v = op1 - 139;
2940
2942
2943 /* -107 .. 107 */
2945 }
2946
2947 else if ( /* op1 >= 247 && */ op1 <= 250 )
2948 {
2950
2951
2952 v = op1;
2953 v -= 247;
2954 v *= 256;
2956 v += 108;
2957
2959
2960 /* 108 .. 1131 */
2962 }
2963
2964 else if ( /* op1 >= 251 && */ op1 <= 254 )
2965 {
2967
2968
2969 v = op1;
2970 v -= 251;
2971 v *= 256;
2974
2976
2977 /* -1131 .. -108 */
2979 }
2980
2981 else /* op1 == 255 */
2982 {
2984
2985 FT_UInt32 byte1 = (FT_UInt32)cf2_buf_readByte( charstring );
2986 FT_UInt32 byte2 = (FT_UInt32)cf2_buf_readByte( charstring );
2987 FT_UInt32 byte3 = (FT_UInt32)cf2_buf_readByte( charstring );
2988 FT_UInt32 byte4 = (FT_UInt32)cf2_buf_readByte( charstring );
2989
2990
2992 ( byte2 << 16 ) |
2993 ( byte3 << 8 ) |
2994 byte4 );
2995
2996 /*
2997 * For Type 1:
2998 *
2999 * According to the specification, values > 32000 or < -32000
3000 * must be followed by a `div' operator to make the result be
3001 * in the range [-32000;32000]. We expect that the second
3002 * argument of `div' is not a large number. Additionally, we
3003 * don't handle stuff like `<large1> <large2> <num> div <num>
3004 * div' or <large1> <large2> <num> div div'. This is probably
3005 * not allowed anyway.
3006 *
3007 * <large> <num> <num>+ div is not checked but should not be
3008 * allowed as the large value remains untouched.
3009 *
3010 */
3012 {
3014 {
3015 if ( large_int )
3017 " no `div' after large integer\n" ));
3018 else
3019 large_int = TRUE;
3020 }
3021
3023
3025 }
3026 else
3027 {
3029
3031 }
3032 }
3033 }
3034 continue; /* don't clear stack */
3035
3036 } /* end of switch statement checking `op1' */
3037
3038 cf2_stack_clear( opStack );
3039
3040 } /* end of main interpreter loop */
3041
3042 /* we get here if the charstring ends without cf2_cmdENDCHAR */
3044 " charstring ends without ENDCHAR\n" ));
3045
3046 exit:
3047 /* check whether last error seen is also the first one */
3049
3052
3053 /* free resources from objects we've used */
3054 cf2_glyphpath_finalize( &glyphPath );
3055 cf2_arrstack_finalize( &vStemHintArray );
3056 cf2_arrstack_finalize( &hStemHintArray );
3057 cf2_arrstack_finalize( &subrStack );
3058 cf2_stack_free( opStack );
3059
3061
3062#ifdef __REACTOS__
3063 free(glyphPath_allocated);
3064#undef glyphPath
3065#endif
3066
3067 return;
3068 }
_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:3962
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:281
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:2208
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:62
Definition: ftgloadr.h:62
Definition: freetype.h:1878
Definition: ftgloadr.h:40
Definition: ftimage.h:77
Definition: t1tables.h:297
Definition: psaux.h:565
Definition: psaux.h:632
Definition: t1types.h:204
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:133
Referenced by cf2_getGlyphOutline(), and cf2_interpT2CharString().
