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 trace_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:1817
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) return;
531/* Ugly but it allows us to reduce the diff */
532#define glyphPath (*glyphPath)
533#else
534 CF2_GlyphPathRec glyphPath;
535#endif
536
537 FT_ZERO( &storage );
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
622
623 charstringIndex = 0; /* entry is valid now */
624
625 /* catch errors so far */
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. */
672 cf2_stack_clear( opStack );
673 continue;
674 }
675
676 if ( result_cnt > 0 &&
677 !( op1 == cf2_cmdCALLSUBR ||
678 op1 == cf2_cmdRETURN ||
679 op1 == cf2_cmdESC ||
680 op1 >= 32 /* Numbers */ ) )
681 {
682 /* all operands have been transferred by previous pops */
683 result_cnt = 0;
684 }
685
687 {
689 " no `div' after large integer\n" ));
690
691 large_int = FALSE;
692 }
693 }
694
695 /* check for errors once per loop */
698
699 instructionLimit--;
700 if ( instructionLimit == 0 )
701 {
702 lastError = FT_THROW( Invalid_Glyph_Format );
704 }
705
706 switch( op1 )
707 {
711 /* we may get here if we have a prior error */
713 break;
714
717
719 break; /* clear stack & ignore */
720
722 {
723 /* vsindex not allowed after blend */
724 lastError = FT_THROW( Invalid_Glyph_Format );
726 }
727
728 {
730
731
734 }
735 break;
736
738 {
739 FT_UInt numBlends;
740
741
743
745 break; /* clear stack & ignore */
746
747 /* do we have a `blend' op in a non-variant font? */
749 {
750 lastError = FT_THROW( Invalid_Glyph_Format );
752 }
753
754 /* check cached blend vector */
756 font->vsindex,
757 font->lenNDV,
758 font->NDV ) )
759 {
761 font->vsindex,
762 font->lenNDV,
763 font->NDV );
764 if ( lastError )
766 }
767
768 /* do the blend */
770 if ( numBlends > stackSize )
771 {
772 lastError = FT_THROW( Invalid_Glyph_Format );
774 }
775
777
779 }
780 continue; /* do not clear the stack */
781
785
787 {
788 /* never add hints after the mask is computed */
789 /* except if in Type 1 mode (no hintmask op) */
791 {
793 " invalid horizontal hint mask\n" ));
794 break;
795 }
796 }
797
798 /* add left-sidebearing correction in Type 1 mode */
800 opStack,
801 &hStemHintArray,
802 width,
803 &haveWidth,
805 : 0 );
806
809
810 break;
811
815
817 {
818 /* never add hints after the mask is computed */
819 /* except if in Type 1 mode (no hintmask op) */
821 {
823 " invalid vertical hint mask\n" ));
824 break;
825 }
826 }
827
828 /* add left-sidebearing correction in Type 1 mode */
830 opStack,
831 &vStemHintArray,
832 width,
833 &haveWidth,
835 : 0 );
836
839
840 break;
841
844
847 " No width. Use hsbw/sbw as first op\n" ));
848
851 nominalWidthX );
852
853 /* width is defined or default after this */
854 haveWidth = TRUE;
855
858
860
861 cf2_glyphpath_moveTo( &glyphPath, curX, curY );
862
863 break;
864
866 {
869
870
872
874 {
876 idx + 0 ) );
878 idx + 1 ) );
879
880 cf2_glyphpath_lineTo( &glyphPath, curX, curY );
881 }
882
883 cf2_stack_clear( opStack );
884 }
885 continue; /* no need to clear stack again */
886
889 {
892
894
895
897
899 {
901
902
903 if ( isX )
905 else
907
908 isX = !isX;
909
910 cf2_glyphpath_lineTo( &glyphPath, curX, curY );
911 }
912
913 cf2_stack_clear( opStack );
914 }
915 continue;
916
919 {
922
923
925 : " rrcurveto\n" ));
926
928 {
930
931
938
940
941 curX = x3;
942 curY = y3;
943 idx += 6;
944 }
945
947 {
949 idx + 0 ) );
951 idx + 1 ) );
952
953 cf2_glyphpath_lineTo( &glyphPath, curX, curY );
954 }
955
956 cf2_stack_clear( opStack );
957 }
958 continue; /* no need to clear stack again */
959
963 else
964 {
966
967 /* if there is no path, `closepath' is a no-op */
969
970 haveWidth = TRUE;
971 }
972 break;
973
976 {
977 CF2_Int subrNum;
978
979
981 : " callsubr" ));
982
985 {
986 /* max subr plus one for charstring */
987 lastError = FT_THROW( Invalid_Glyph_Format );
989 }
990
991 /* push our current CFF charstring region on subrStack */
992 charstring = (CF2_Buffer)
994 &subrStack,
995 (size_t)charstringIndex + 1 );
996
997 /* set up the new CFF region and pointer */
998 subrNum = cf2_stack_popInt( opStack );
999
1001 {
1003 decoder->locals_hash );
1004
1005
1007 subrNum = *val;
1008 else
1009 subrNum = -1;
1010 }
1011
1012 switch ( op1 )
1013 {
1016 subrNum + decoder->globals_bias,
1017 charstringIndex + 1 ));
1018
1020 subrNum,
1021 charstring ) )
1022 {
1023 lastError = FT_THROW( Invalid_Glyph_Format );
1025 }
1026 break;
1027
1028 default:
1029 /* cf2_cmdCALLSUBR */
1031 subrNum + decoder->locals_bias,
1032 charstringIndex + 1 ));
1033
1035 subrNum,
1036 charstring ) )
1037 {
1038 lastError = FT_THROW( Invalid_Glyph_Format );
1040 }
1041 }
1042
1043 charstringIndex += 1; /* entry is valid now */
1044 }
1045 continue; /* do not clear the stack */
1046
1049
1050 if ( charstringIndex < 1 )
1051 {
1052 /* Note: cannot return from top charstring */
1053 lastError = FT_THROW( Invalid_Glyph_Format );
1055 }
1056
1057 /* restore position in previous charstring */
1058 charstring = (CF2_Buffer)
1059 cf2_arrstack_getPointer(
1060 &subrStack,
1061 (CF2_UInt)--charstringIndex );
1062 continue; /* do not clear the stack */
1063
1065 {
1067
1068
1069 /* first switch for 2-byte operators handles CFF2 */
1070 /* and opcodes that are reserved for both CFF and CFF2 */
1071 switch ( op2 )
1072 {
1074 {
1076 {
1083 };
1084
1085
1087
1088 cf2_doFlex( opStack,
1089 &curX,
1090 &curY,
1091 &glyphPath,
1092 readFromStack,
1094 }
1095 continue;
1096
1098 {
1100 {
1107 };
1108
1109
1111
1112 cf2_doFlex( opStack,
1113 &curX,
1114 &curY,
1115 &glyphPath,
1116 readFromStack,
1118 }
1119 break; /* TODO: why is this not a continue? */
1120
1122 {
1124 {
1131 };
1132
1133
1135
1136 cf2_doFlex( opStack,
1137 &curX,
1138 &curY,
1139 &glyphPath,
1140 readFromStack,
1142 }
1143 continue;
1144
1146 {
1148 {
1155 };
1156
1157
1159
1160 cf2_doFlex( opStack,
1161 &curX,
1162 &curY,
1163 &glyphPath,
1164 readFromStack,
1166 }
1167 continue;
1168
1169 /* these opcodes are always reserved */
1177 break;
1178
1179 default:
1180 {
1184 {
1185 /* all operands have been transferred by previous pops */
1186 result_cnt = 0;
1187 }
1188 else
1189 {
1190 /* second switch for 2-byte operators handles */
1191 /* CFF and Type 1 */
1192 switch ( op2 )
1193 {
1194
1196 /* something about `flip type of locking' -- ignore it */
1198
1199 break;
1200
1203 /*
1204 * Type 1: Type 2:
1205 * x0 dx0 x1 dx1 x2 dx2 vstem3 x dx {dxa dxb}* vstem
1206 * y0 dy0 y1 dy1 y2 dy2 hstem3 y dy {dya dyb}* hstem
1207 * relative to lsb point relative to zero
1208 *
1209 */
1210 {
1213 else
1214 {
1216
1218
1219
1221 : " hstem3\n" ));
1222
1224
1228
1229 cf2_stack_setReal(
1230 opStack, 2,
1232 cf2_stack_getReal( opStack, 1 ) ) );
1233 cf2_stack_setReal(
1234 opStack, 4,
1236 cf2_stack_getReal( opStack, 3 ) ) );
1237
1238 /* add left-sidebearing correction */
1240 opStack,
1241 isV ? &vStemHintArray : &hStemHintArray,
1242 width,
1243 &haveWidth,
1246
1249 }
1250 }
1251 break;
1252
1254 {
1257
1258
1260
1263
1265 }
1266 continue; /* do not clear the stack */
1267
1269 {
1272
1273
1275
1278
1280 }
1281 continue; /* do not clear the stack */
1282
1284 {
1286
1287
1289
1291
1293 }
1294 continue; /* do not clear the stack */
1295
1299 else
1300 {
1302 CF2_Int bchar_index, achar_index;
1304
1305#ifdef FT_CONFIG_OPTION_INCREMENTAL
1307#endif
1308 CF2_BufferRec component;
1309 CF2_Fixed dummyWidth;
1310
1313
1317
1318
1320
1321 if ( doingSeac )
1322 {
1324 lastError = FT_THROW( Invalid_Glyph_Format );
1326 }
1327
1329 {
1331 lastError = FT_THROW( Invalid_Glyph_Format );
1333 }
1334
1335 /* `glyph_names' is set to 0 for CID fonts which do */
1336 /* not include an encoding. How can we deal with */
1337 /* these? */
1338#ifdef FT_CONFIG_OPTION_INCREMENTAL
1340 !face->root.internal->incremental_interface )
1341#else
1343#endif /* FT_CONFIG_OPTION_INCREMENTAL */
1344 {
1345 FT_ERROR((
1346 "cf2_interpT2CharString: (Type 1 seac)"
1347 " glyph names table not available in this font\n" ));
1348 lastError = FT_THROW( Invalid_Glyph_Format );
1350 }
1351
1352 /* seac weirdness */
1354
1355#ifdef FT_CONFIG_OPTION_INCREMENTAL
1357 {
1358 /* the caller must handle the font encoding also */
1359 bchar_index = bchar;
1360 achar_index = achar;
1361 }
1362 else
1363#endif
1364 {
1365 bchar_index = t1_lookup_glyph_by_stdcharcode_ps(
1366 decoder, bchar );
1367 achar_index = t1_lookup_glyph_by_stdcharcode_ps(
1368 decoder, achar );
1369 }
1370
1371 if ( bchar_index < 0 || achar_index < 0 )
1372 {
1373 FT_ERROR((
1374 "cf2_interpT2CharString: (Type 1 seac)"
1375 " invalid seac character code arguments\n" ));
1376 lastError = FT_THROW( Invalid_Glyph_Format );
1378 }
1379
1380 /* if we are trying to load a composite glyph, */
1381 /* do not load the accent character and return */
1382 /* the array of subglyphs. */
1384 {
1387 FT_SubGlyph subg;
1388
1389
1390 /* reallocate subglyph array if necessary */
1393 {
1396 }
1397
1398 subg = loader->current.subglyphs;
1399
1400 /* subglyph 0 = base character */
1401 subg->index = bchar_index;
1402 subg->flags = FT_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES |
1404 subg->arg1 = 0;
1405 subg->arg2 = 0;
1406 subg++;
1407
1408 /* subglyph 1 = accent character */
1409 subg->index = achar_index;
1410 subg->flags = FT_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES;
1413
1414 /* set up remaining glyph fields */
1415 glyph->num_subglyphs = 2;
1416 glyph->subglyphs = loader->base.subglyphs;
1417 glyph->format = FT_GLYPH_FORMAT_COMPOSITE;
1418
1419 loader->current.num_subglyphs = 2;
1420
1422 }
1423
1424 /* First load `bchar' in builder */
1425 /* now load the unscaled outline */
1426
1427 /* prepare loader */
1429
1431 (FT_UInt)bchar_index,
1432 &component );
1434 {
1437 }
1439 &component,
1440 callbacks,
1441 translation,
1442 TRUE,
1443 0,
1444 0,
1445 &dummyWidth );
1446 cf2_freeT1SeacComponent( decoder, &component );
1447
1448 /* save the left bearing and width of the base */
1449 /* character as they will be erased by the next load */
1450
1453
1456
1457 /* Now load `achar' on top of */
1458 /* the base outline */
1459
1461 (FT_UInt)achar_index,
1462 &component );
1464 {
1467 }
1469 &component,
1470 callbacks,
1471 translation,
1472 TRUE,
1473 adx - asb,
1474 ady,
1475 &dummyWidth );
1476 cf2_freeT1SeacComponent( decoder, &component );
1477
1478 /* restore the left side bearing and */
1479 /* advance width of the base character */
1480
1483
1485 }
1486 break;
1487
1491 else
1492 {
1493 CF2_Fixed lsb_x, lsb_y;
1494 PS_Builder* builder;
1495
1496
1498
1499 builder = &decoder->builder;
1500
1503
1504 lsb_y = cf2_stack_popFixed( opStack );
1505 lsb_x = cf2_stack_popFixed( opStack );
1506
1511
1512 haveWidth = TRUE;
1513
1514 /* the `metrics_only' indicates that we only want */
1515 /* to compute the glyph's metrics (lsb + advance */
1516 /* width), not load the rest of it; so exit */
1517 /* immediately */
1520
1521 if ( initial_map_ready )
1522 {
1523 curX = ADD_INT32( curX, lsb_x );
1524 curY = ADD_INT32( curY, lsb_y );
1525 }
1526 }
1527 break;
1528
1530 {
1532
1533
1535
1537
1540 else
1542 }
1543 continue; /* do not clear the stack */
1544
1546 {
1547 CF2_F16Dot16 summand1;
1548 CF2_F16Dot16 summand2;
1549
1550
1552
1553 summand2 = cf2_stack_popFixed( opStack );
1554 summand1 = cf2_stack_popFixed( opStack );
1555
1556 cf2_stack_pushFixed( opStack,
1557 ADD_INT32( summand1,
1558 summand2 ) );
1559 }
1560 continue; /* do not clear the stack */
1561
1563 {
1564 CF2_F16Dot16 minuend;
1565 CF2_F16Dot16 subtrahend;
1566
1567
1569
1570 subtrahend = cf2_stack_popFixed( opStack );
1571 minuend = cf2_stack_popFixed( opStack );
1572
1573 cf2_stack_pushFixed( opStack,
1574 SUB_INT32( minuend, subtrahend ) );
1575 }
1576 continue; /* do not clear the stack */
1577
1579 {
1580 CF2_F16Dot16 dividend;
1582
1583
1585
1587 {
1590
1591 large_int = FALSE;
1592 }
1593 else
1594 {
1596 dividend = cf2_stack_popFixed( opStack );
1597 }
1598
1599 cf2_stack_pushFixed( opStack,
1601
1602 }
1603 continue; /* do not clear the stack */
1604
1606 {
1608
1609
1611
1613
1616 else
1618 }
1619 continue; /* do not clear the stack */
1620
1622 {
1625
1626
1628
1631
1633 }
1634 continue; /* do not clear the stack */
1635
1639 else
1640 {
1641 CF2_Int subr_no;
1644 CF2_UInt opIdx = 0;
1645
1646
1648
1649 subr_no = cf2_stack_popInt( opStack );
1651
1652 /*******************************************************/
1653 /* */
1654 /* remove all operands to callothersubr from the stack */
1655 /* */
1656 /* for handled othersubrs, where we know the number of */
1657 /* arguments, we increase the stack by the value of */
1658 /* known_othersubr_result_cnt */
1659 /* */
1660 /* for unhandled othersubrs the following pops adjust */
1661 /* the stack pointer as necessary */
1662
1665
1667
1668 known_othersubr_result_cnt = 0;
1669 result_cnt = 0;
1670
1671 /* XXX TODO: The checks to `arg_count == <whatever>' */
1672 /* might not be correct; an othersubr expects a */
1673 /* certain number of operands on the PostScript stack */
1674 /* (as opposed to the T1 stack) but it doesn't have to */
1675 /* put them there by itself; previous othersubrs might */
1676 /* have left the operands there if they were not */
1677 /* followed by an appropriate number of pops */
1678 /* */
1679 /* On the other hand, Adobe Reader 7.0.8 for Linux */
1680 /* doesn't accept a font that contains charstrings */
1681 /* like */
1682 /* */
1683 /* 100 200 2 20 callothersubr */
1684 /* 300 1 20 callothersubr pop */
1685 /* */
1686 /* Perhaps this is the reason why BuildCharArray */
1687 /* exists. */
1688
1689 switch ( subr_no )
1690 {
1691 case 0: /* end flex feature */
1693 goto Unexpected_OtherSubr;
1694
1695 if ( initial_map_ready &&
1696 ( !decoder->flex_state ||
1697 decoder->num_flex_vectors != 7 ) )
1698 {
1700 " unexpected flex end\n" ));
1701 lastError = FT_THROW( Invalid_Glyph_Format );
1703 }
1704
1705 /* the two `results' are popped */
1706 /* by the following setcurrentpoint */
1707 cf2_stack_pushFixed( opStack, curX );
1708 cf2_stack_pushFixed( opStack, curY );
1709 known_othersubr_result_cnt = 2;
1710 break;
1711
1712 case 1: /* start flex feature */
1714 goto Unexpected_OtherSubr;
1715
1716 if ( !initial_map_ready )
1717 break;
1718
1721
1722 decoder->flex_state = 1;
1723 decoder->num_flex_vectors = 0;
1724 break;
1725
1726 case 2: /* add flex vectors */
1727 {
1729 FT_Int idx2;
1730
1731
1733 goto Unexpected_OtherSubr;
1734
1735 if ( !initial_map_ready )
1736 break;
1737
1739 {
1741 " missing flex start\n" ));
1742 lastError = FT_THROW( Invalid_Glyph_Format );
1744 }
1745
1746 /* note that we should not add a point for */
1747 /* index 0; this will move our current position */
1748 /* to the flex point without adding any point */
1749 /* to the outline */
1752 {
1753 /* in malformed fonts it is possible to have */
1754 /* other opcodes in the middle of a flex (which */
1755 /* don't increase `num_flex_vectors'); we thus */
1756 /* have to check whether we can add a point */
1757
1759 1 ) )
1760 {
1761 lastError = FT_THROW( Invalid_Glyph_Format );
1763 }
1764
1765 /* map: 1->2 2->4 3->6 4->2 5->4 6->6 */
1767
1768 flexStore[idx2 - 2] = curX;
1769 flexStore[idx2 - 1] = curY;
1770
1772 cf2_glyphpath_curveTo( &glyphPath,
1773 flexStore[0],
1774 flexStore[1],
1775 flexStore[2],
1776 flexStore[3],
1777 flexStore[4],
1778 flexStore[5] );
1779 }
1780 }
1781 break;
1782
1783 case 3: /* change hints */
1785 goto Unexpected_OtherSubr;
1786
1787 if ( initial_map_ready )
1788 {
1789 /* do not clear hints if initial hintmap */
1790 /* is not ready - we need to collate all */
1791 cf2_arrstack_clear( &vStemHintArray );
1792 cf2_arrstack_clear( &hStemHintArray );
1793
1797 }
1798
1799 known_othersubr_result_cnt = 1;
1800 break;
1801
1802 case 12:
1803 case 13:
1804 /* counter control hints, clear stack */
1805 cf2_stack_clear( opStack );
1806 break;
1807
1808 case 14:
1809 case 15:
1810 case 16:
1811 case 17:
1812 case 18: /* multiple masters */
1813 {
1815 FT_UInt num_points, nn, mm;
1816 CF2_UInt delta;
1818
1819
1820 if ( !blend )
1821 {
1822 FT_ERROR((
1823 "cf2_interpT2CharString:"
1824 " unexpected multiple masters operator\n" ));
1825 lastError = FT_THROW( Invalid_Glyph_Format );
1827 }
1828
1829 num_points = (FT_UInt)subr_no - 13 +
1830 ( subr_no == 18 );
1832 blend->num_designs ) )
1833 {
1834 FT_ERROR((
1835 "cf2_interpT2CharString:"
1836 " incorrect number of multiple masters arguments\n" ));
1837 lastError = FT_THROW( Invalid_Glyph_Format );
1839 }
1840
1841 /* We want to compute */
1842 /* */
1843 /* a0*w0 + a1*w1 + ... + ak*wk */
1844 /* */
1845 /* but we only have a0, a1-a0, a2-a0, ..., ak-a0. */
1846 /* */
1847 /* However, given that w0 + w1 + ... + wk == 1, we */
1848 /* can rewrite it easily as */
1849 /* */
1850 /* a0 + (a1-a0)*w1 + (a2-a0)*w2 + ... + (ak-a0)*wk */
1851 /* */
1852 /* where k == num_designs-1. */
1853 /* */
1854 /* I guess that's why it's written in this `compact' */
1855 /* form. */
1856 /* */
1857 delta = opIdx + num_points;
1858 values = opIdx;
1859 for ( nn = 0; nn < num_points; nn++ )
1860 {
1862 values );
1863
1864
1866 tmp = ADD_INT32( tmp,
1867 FT_MulFix(
1868 cf2_stack_getReal( opStack,
1869 delta++ ),
1870 blend->weight_vector[mm] ) );
1871
1873 }
1874 cf2_stack_pop( opStack,
1876
1877 known_othersubr_result_cnt = (FT_Int)num_points;
1878 break;
1879 }
1880
1881 case 19:
1882 /* <idx> 1 19 callothersubr */
1883 /* ==> replace elements starting from index */
1884 /* cvi( <idx> ) of BuildCharArray with */
1885 /* WeightVector */
1886 {
1889
1890
1892 goto Unexpected_OtherSubr;
1893
1895
1898 decoder->len_buildchar )
1899 goto Unexpected_OtherSubr;
1900
1902 blend->weight_vector,
1903 blend->num_designs *
1905 }
1906 break;
1907
1908 case 20:
1909 /* <arg1> <arg2> 2 20 callothersubr pop */
1910 /* ==> push <arg1> + <arg2> onto T1 stack */
1911 {
1912 CF2_F16Dot16 summand1;
1913 CF2_F16Dot16 summand2;
1914
1915
1917 goto Unexpected_OtherSubr;
1918
1919 summand2 = cf2_stack_popFixed( opStack );
1920 summand1 = cf2_stack_popFixed( opStack );
1921
1922 cf2_stack_pushFixed( opStack,
1923 ADD_INT32( summand1,
1924 summand2 ) );
1925 known_othersubr_result_cnt = 1;
1926 }
1927 break;
1928
1929 case 21:
1930 /* <arg1> <arg2> 2 21 callothersubr pop */
1931 /* ==> push <arg1> - <arg2> onto T1 stack */
1932 {
1933 CF2_F16Dot16 minuend;
1934 CF2_F16Dot16 subtrahend;
1935
1936
1938 goto Unexpected_OtherSubr;
1939
1940 subtrahend = cf2_stack_popFixed( opStack );
1941 minuend = cf2_stack_popFixed( opStack );
1942
1943 cf2_stack_pushFixed( opStack,
1944 SUB_INT32( minuend,
1945 subtrahend ) );
1946 known_othersubr_result_cnt = 1;
1947 }
1948 break;
1949
1950 case 22:
1951 /* <arg1> <arg2> 2 22 callothersubr pop */
1952 /* ==> push <arg1> * <arg2> onto T1 stack */
1953 {
1954 CF2_F16Dot16 factor1;
1955 CF2_F16Dot16 factor2;
1956
1957
1959 goto Unexpected_OtherSubr;
1960
1961 factor2 = cf2_stack_popFixed( opStack );
1962 factor1 = cf2_stack_popFixed( opStack );
1963
1964 cf2_stack_pushFixed( opStack,
1965 FT_MulFix( factor1, factor2 ) );
1966 known_othersubr_result_cnt = 1;
1967 }
1968 break;
1969
1970 case 23:
1971 /* <arg1> <arg2> 2 23 callothersubr pop */
1972 /* ==> push <arg1> / <arg2> onto T1 stack */
1973 {
1974 CF2_F16Dot16 dividend;
1976
1977
1979 goto Unexpected_OtherSubr;
1980
1982 dividend = cf2_stack_popFixed( opStack );
1983
1985 goto Unexpected_OtherSubr;
1986
1987 cf2_stack_pushFixed( opStack,
1988 FT_DivFix( dividend,
1989 divisor ) );
1990 known_othersubr_result_cnt = 1;
1991 }
1992 break;
1993
1994 case 24:
1995 /* <val> <idx> 2 24 callothersubr */
1996 /* ==> set BuildCharArray[cvi( <idx> )] = <val> */
1997 {
2000
2001
2003 goto Unexpected_OtherSubr;
2004
2006
2009 goto Unexpected_OtherSubr;
2010
2012 cf2_stack_popFixed( opStack );
2013 }
2014 break;
2015
2016 case 25:
2017 /* <idx> 1 25 callothersubr pop */
2018 /* ==> push BuildCharArray[cvi( idx )] */
2019 /* onto T1 stack */
2020 {
2023
2024
2026 goto Unexpected_OtherSubr;
2027
2029
2032 goto Unexpected_OtherSubr;
2033
2034 cf2_stack_pushFixed( opStack,
2036 known_othersubr_result_cnt = 1;
2037 }
2038 break;
2039
2040#if 0
2041 case 26:
2042 /* <val> mark <idx> */
2043 /* ==> set BuildCharArray[cvi( <idx> )] = <val>, */
2044 /* leave mark on T1 stack */
2045 /* <val> <idx> */
2046 /* ==> set BuildCharArray[cvi( <idx> )] = <val> */
2049 break;
2050#endif
2051
2052 case 27:
2053 /* <res1> <res2> <val1> <val2> 4 27 callothersubr pop */
2054 /* ==> push <res1> onto T1 stack if <val1> <= <val2>, */
2055 /* otherwise push <res2> */
2056 {
2059 CF2_F16Dot16 cond1;
2060 CF2_F16Dot16 cond2;
2061
2062
2064 goto Unexpected_OtherSubr;
2065
2066 cond2 = cf2_stack_popFixed( opStack );
2067 cond1 = cf2_stack_popFixed( opStack );
2070
2071 cf2_stack_pushFixed( opStack,
2073 known_othersubr_result_cnt = 1;
2074 }
2075 break;
2076
2077 case 28:
2078 /* 0 28 callothersubr pop */
2079 /* ==> push random value from interval [0, 1) */
2080 /* onto stack */
2081 {
2083
2084
2086 goto Unexpected_OtherSubr;
2087
2088 /* only use the lower 16 bits of `random' */
2089 /* to generate a number in the range (0;1] */
2092
2095
2097 known_othersubr_result_cnt = 1;
2098 }
2099 break;
2100
2101 default:
2103 {
2105
2106
2107 FT_ERROR((
2108 "cf2_interpT2CharString (Type 1 mode):"
2109 " unknown othersubr [%d %d], wish me luck\n",
2110 arg_cnt, subr_no ));
2111
2112 /* store the unused args */
2113 /* for this unhandled OtherSubr */
2114
2117 result_cnt = arg_cnt;
2118
2121 cf2_stack_popFixed( opStack );
2122
2123 break;
2124 }
2125 /* fall through */
2126
2127 Unexpected_OtherSubr:
2129 " invalid othersubr [%d %d]\n",
2130 arg_cnt, subr_no ));
2131 lastError = FT_THROW( Invalid_Glyph_Format );
2133 }
2134 }
2135 continue; /* do not clear the stack */
2136
2140 else
2141 {
2143
2144 if ( known_othersubr_result_cnt > 0 )
2145 {
2146 known_othersubr_result_cnt--;
2147 /* ignore, we pushed the operands ourselves */
2148 continue;
2149 }
2150
2151 if ( result_cnt == 0 )
2152 {
2154 " no more operands for othersubr\n" ));
2155 lastError = FT_THROW( Invalid_Glyph_Format );
2157 }
2158
2159 result_cnt--;
2161 }
2162 continue; /* do not clear the stack */
2163
2166
2168 continue; /* do not clear the stack */
2169
2171 {
2174
2175
2177
2180
2183 }
2184 continue; /* do not clear the stack */
2185
2187 {
2189
2190
2192
2194
2197 }
2198 continue; /* do not clear the stack */
2199
2201 {
2204 CF2_F16Dot16 cond1;
2205 CF2_F16Dot16 cond2;
2206
2207
2209
2210 cond2 = cf2_stack_popFixed( opStack );
2211 cond1 = cf2_stack_popFixed( opStack );
2214
2215 cf2_stack_pushFixed( opStack,
2217 }
2218 continue; /* do not clear the stack */
2219
2221 {
2223
2224
2226
2227 /* only use the lower 16 bits of `random' */
2228 /* to generate a number in the range (0;1] */
2231
2234
2236 }
2237 continue; /* do not clear the stack */
2238
2240 {
2241 CF2_F16Dot16 factor1;
2242 CF2_F16Dot16 factor2;
2243
2244
2246
2247 factor2 = cf2_stack_popFixed( opStack );
2248 factor1 = cf2_stack_popFixed( opStack );
2249
2250 cf2_stack_pushFixed( opStack,
2251 FT_MulFix( factor1, factor2 ) );
2252 }
2253 continue; /* do not clear the stack */
2254
2256 {
2258
2259
2261
2264 {
2265 /* use a start value that doesn't make */
2266 /* the algorithm's addition overflow */
2268 FT_Fixed new_root;
2269
2270
2271 /* Babylonian method */
2272 for (;;)
2273 {
2276 break;
2277 root = new_root;
2278 }
2279 arg = new_root;
2280 }
2281 else
2282 arg = 0;
2283
2285 }
2286 continue; /* do not clear the stack */
2287
2289 {
2291
2292
2294
2296
2299 }
2300 continue; /* do not clear the stack */
2301
2303 {
2306
2307
2309
2312
2315 }
2316 continue; /* do not clear the stack */
2317
2319 {
2322
2323
2325
2328
2330 {
2331 /* for `cf2_stack_getReal', */
2332 /* index 0 is bottom of stack */
2333 CF2_UInt gr_idx;
2334
2335
2337 gr_idx = size - 1;
2339 gr_idx = 0;
2340 else
2342
2343 cf2_stack_pushFixed( opStack,
2344 cf2_stack_getReal( opStack,
2345 gr_idx ) );
2346 }
2347 }
2348 continue; /* do not clear the stack */
2349
2351 {
2354
2355
2357
2360
2362 }
2363 continue; /* do not clear the stack */
2364
2368 else
2369 {
2371
2372 if ( !initial_map_ready )
2373 break;
2374
2375 /* From the T1 specification, section 6.4: */
2376 /* */
2377 /* The setcurrentpoint command is used only in */
2378 /* conjunction with results from OtherSubrs */
2379 /* procedures. */
2380
2381 /* known_othersubr_result_cnt != 0 is already handled */
2382 /* above. */
2383
2384 /* Note, however, that both Ghostscript and Adobe */
2385 /* Distiller handle this situation by silently */
2386 /* ignoring the inappropriate `setcurrentpoint' */
2387 /* instruction. So we do the same. */
2388#if 0
2389
2391 {
2393 " unexpected `setcurrentpoint'\n" ));
2394 goto Syntax_Error;
2395 }
2396 else
2397 ...
2398#endif
2399
2400 curY = cf2_stack_popFixed( opStack );
2401 curX = cf2_stack_popFixed( opStack );
2402
2403 decoder->flex_state = 0;
2404 }
2405 break;
2406
2407 } /* end of 2nd switch checking op2 */
2408 }
2409 }
2410 } /* end of 1st switch checking op2 */
2411 } /* case cf2_cmdESC */
2412
2413 break;
2414
2418 else
2419 {
2420 CF2_Fixed lsb_x;
2421 PS_Builder* builder;
2422
2423
2425
2426 builder = &decoder->builder;
2427
2430
2431 lsb_x = cf2_stack_popFixed( opStack );
2432
2434 lsb_x );
2435
2436 haveWidth = TRUE;
2437
2438 /* the `metrics_only' indicates that we only want to compute */
2439 /* the glyph's metrics (lsb + advance width), not load the */
2440 /* rest of it; so exit immediately */
2443
2444 if ( initial_map_ready )
2445 curX = ADD_INT32( curX, lsb_x );
2446 }
2447 break;
2448
2451
2453 {
2455 "Build initial hintmap, rewinding...\n" ));
2456
2457 /* trigger initial hintmap build */
2458 cf2_glyphpath_moveTo( &glyphPath, curX, curY );
2459
2460 initial_map_ready = TRUE;
2461
2462 /* change hints routine - clear for rewind */
2463 cf2_arrstack_clear( &vStemHintArray );
2464 cf2_arrstack_clear( &hStemHintArray );
2465
2469
2470 /* rewind charstring */
2471 /* some charstrings use endchar from a final subroutine call */
2472 /* without returning, detect these and exit to the top level */
2473 /* charstring */
2474 while ( charstringIndex > 0 )
2475 {
2477
2478 /* restore position in previous charstring */
2479 charstring = (CF2_Buffer)
2480 cf2_arrstack_getPointer(
2481 &subrStack,
2482 (CF2_UInt)--charstringIndex );
2483 }
2484 charstring->ptr = charstring->start;
2485
2486 break;
2487 }
2488
2490 cf2_stack_count( opStack ) == 5 )
2491 {
2492 if ( !haveWidth )
2494 nominalWidthX );
2495 }
2496
2497 /* width is defined or default after this */
2498 haveWidth = TRUE;
2499
2502
2503 /* close path if still open */
2504 cf2_glyphpath_closeOpenPath( &glyphPath );
2505
2506 /* disable seac for CFF2 and Type1 */
2507 /* (charstring ending with args on stack) */
2509 {
2510 /* must be either 4 or 5 -- */
2511 /* this is a (deprecated) implied `seac' operator */
2512
2513 CF2_Int achar;
2514 CF2_Int bchar;
2515 CF2_BufferRec component;
2518
2519
2520 if ( doingSeac )
2521 {
2522 lastError = FT_THROW( Invalid_Glyph_Format );
2524 }
2525
2526 achar = cf2_stack_popInt( opStack );
2527 bchar = cf2_stack_popInt( opStack );
2528
2529 curY = cf2_stack_popFixed( opStack );
2530 curX = cf2_stack_popFixed( opStack );
2531
2534 {
2537 }
2539 &component,
2540 callbacks,
2541 translation,
2542 TRUE,
2543 curX,
2544 curY,
2545 &dummyWidth );
2546 cf2_freeSeacComponent( decoder, &component );
2547
2550 {
2553 }
2555 &component,
2556 callbacks,
2557 translation,
2558 TRUE,
2559 0,
2560 0,
2561 &dummyWidth );
2562 cf2_freeSeacComponent( decoder, &component );
2563 }
2565
2568 /* the final \n in the tracing message gets added in */
2569 /* `cf2_hintmask_read' (which also traces the mask bytes) */
2571
2572 /* never add hints after the mask is computed */
2574 cf2_hintmask_isValid( &hintMask ) )
2575 {
2577 break;
2578 }
2579
2580 /* if there are arguments on the stack, there this is an */
2581 /* implied cf2_cmdVSTEMHM */
2583 opStack,
2584 &vStemHintArray,
2585 width,
2586 &haveWidth,
2587 0 );
2588
2591
2593 {
2594 /* consume the hint mask bytes which follow the operator */
2595 cf2_hintmask_read( &hintMask,
2596 charstring,
2597 cf2_arrstack_size( &hStemHintArray ) +
2598 cf2_arrstack_size( &vStemHintArray ) );
2599 }
2600 else
2601 {
2602 /*
2603 * Consume the counter mask bytes which follow the operator:
2604 * Build a temporary hint map, just to place and lock those
2605 * stems participating in the counter mask. These are most
2606 * likely the dominant hstems, and are grouped together in a
2607 * few counter groups, not necessarily in correspondence
2608 * with the hint groups. This reduces the chances of
2609 * conflicts between hstems that are initially placed in
2610 * separate hint groups and then brought together. The
2611 * positions are copied back to `hStemHintArray', so we can
2612 * discard `counterMask' and `counterHintMap'.
2613 *
2614 */
2615#ifdef __REACTOS__
2617 CF2_HintMaskRec counterMask;
2618 if (!counterHintMap)
2619 {
2620 lastError = FT_Err_Out_Of_Memory;
2622 }
2623/* Ugly but it allows us to reduce the diff */
2624#define counterHintMap (*counterHintMap)
2625#else
2626 CF2_HintMapRec counterHintMap;
2627 CF2_HintMaskRec counterMask;
2628#endif
2629
2630
2631 cf2_hintmap_init( &counterHintMap,
2632 font,
2633 &glyphPath.initialHintMap,
2634 &glyphPath.hintMoves,
2635 scaleY );
2637
2638 cf2_hintmask_read( &counterMask,
2639 charstring,
2640 cf2_arrstack_size( &hStemHintArray ) +
2641 cf2_arrstack_size( &vStemHintArray ) );
2642 cf2_hintmap_build( &counterHintMap,
2643 &hStemHintArray,
2644 &vStemHintArray,
2645 &counterMask,
2646 0,
2647 FALSE );
2648#ifdef __REACTOS__
2649 free(&counterHintMap);
2650#endif
2651 }
2652 break;
2653
2656
2659 " No width. Use hsbw/sbw as first op\n" ));
2660
2663 nominalWidthX );
2664
2665 /* width is defined or default after this */
2666 haveWidth = TRUE;
2667
2670
2673
2675 cf2_glyphpath_moveTo( &glyphPath, curX, curY );
2676
2677 break;
2678
2681
2684 " No width. Use hsbw/sbw as first op\n" ));
2685
2688 nominalWidthX );
2689
2690 /* width is defined or default after this */
2691 haveWidth = TRUE;
2692
2695
2697
2698 cf2_glyphpath_moveTo( &glyphPath, curX, curY );
2699
2700 break;
2701
2703 {
2706
2707
2709
2711 {
2713 idx + 0 ) );
2715 idx + 1 ) );
2716
2717 cf2_glyphpath_lineTo( &glyphPath, curX, curY );
2718 idx += 2;
2719 }
2720
2722 {
2724
2725
2732
2734
2735 curX = x3;
2736 curY = y3;
2737 idx += 6;
2738 }
2739
2740 cf2_stack_clear( opStack );
2741 }
2742 continue; /* no need to clear stack again */
2743
2745 {
2748
2749
2750 /* if `cf2_stack_count' isn't of the form 4n or 4n+1, */
2751 /* we enforce it by clearing the second bit */
2752 /* (and sorting the stack indexing to suit) */
2753 count = count1 & ~2U;
2755
2757
2759 {
2761
2762
2764 {
2766
2767 idx++;
2768 }
2769 else
2770 x1 = curX;
2771
2775 x3 = x2;
2777
2779
2780 curX = x3;
2781 curY = y3;
2782 idx += 4;
2783 }
2784
2785 cf2_stack_clear( opStack );
2786 }
2787 continue; /* no need to clear stack again */
2788
2790 {
2793
2794
2795 /* if `cf2_stack_count' isn't of the form 4n or 4n+1, */
2796 /* we enforce it by clearing the second bit */
2797 /* (and sorting the stack indexing to suit) */
2798 count = count1 & ~2U;
2800
2802
2804 {
2806
2807
2809 {
2811
2812 idx++;
2813 }
2814 else
2815 y1 = curY;
2816
2821 y3 = y2;
2822
2824
2825 curX = x3;
2826 curY = y3;
2827 idx += 4;
2828 }
2829
2830 cf2_stack_clear( opStack );
2831 }
2832 continue; /* no need to clear stack again */
2833
2836 {
2839
2841
2842
2843 /* if `cf2_stack_count' isn't of the form 8n, 8n+1, */
2844 /* 8n+4, or 8n+5, we enforce it by clearing the */
2845 /* second bit */
2846 /* (and sorting the stack indexing to suit) */
2847 count = count1 & ~2U;
2849
2851
2853 {
2855
2856
2857 if ( alternate )
2858 {
2860 y1 = curY;
2864
2866 {
2868
2869 idx++;
2870 }
2871 else
2872 x3 = x2;
2873
2874 alternate = FALSE;
2875 }
2876 else
2877 {
2878 x1 = curX;
2883
2885 {
2887
2888 idx++;
2889 }
2890 else
2891 y3 = y2;
2892
2893 alternate = TRUE;
2894 }
2895
2897
2898 curX = x3;
2899 curY = y3;
2900 idx += 4;
2901 }
2902
2903 cf2_stack_clear( opStack );
2904 }
2905 continue; /* no need to clear stack again */
2906
2908 {
2910
2913
2914
2916 byte2 );
2917
2919
2921 }
2922 continue;
2923
2924 default:
2925 /* numbers */
2926 {
2927 if ( /* op1 >= 32 && */ op1 <= 246 )
2928 {
2930
2931
2932 v = op1 - 139;
2933
2935
2936 /* -107 .. 107 */
2938 }
2939
2940 else if ( /* op1 >= 247 && */ op1 <= 250 )
2941 {
2943
2944
2945 v = op1;
2946 v -= 247;
2947 v *= 256;
2949 v += 108;
2950
2952
2953 /* 108 .. 1131 */
2955 }
2956
2957 else if ( /* op1 >= 251 && */ op1 <= 254 )
2958 {
2960
2961
2962 v = op1;
2963 v -= 251;
2964 v *= 256;
2967
2969
2970 /* -1131 .. -108 */
2972 }
2973
2974 else /* op1 == 255 */
2975 {
2977
2978 FT_UInt32 byte1 = (FT_UInt32)cf2_buf_readByte( charstring );
2979 FT_UInt32 byte2 = (FT_UInt32)cf2_buf_readByte( charstring );
2980 FT_UInt32 byte3 = (FT_UInt32)cf2_buf_readByte( charstring );
2981 FT_UInt32 byte4 = (FT_UInt32)cf2_buf_readByte( charstring );
2982
2983
2985 ( byte2 << 16 ) |
2986 ( byte3 << 8 ) |
2987 byte4 );
2988
2989 /*
2990 * For Type 1:
2991 *
2992 * According to the specification, values > 32000 or < -32000
2993 * must be followed by a `div' operator to make the result be
2994 * in the range [-32000;32000]. We expect that the second
2995 * argument of `div' is not a large number. Additionally, we
2996 * don't handle stuff like `<large1> <large2> <num> div <num>
2997 * div' or <large1> <large2> <num> div div'. This is probably
2998 * not allowed anyway.
2999 *
3000 * <large> <num> <num>+ div is not checked but should not be
3001 * allowed as the large value remains untouched.
3002 *
3003 */
3005 {
3007 {
3008 if ( large_int )
3010 " no `div' after large integer\n" ));
3011 else
3012 large_int = TRUE;
3013 }
3014
3016
3018 }
3019 else
3020 {
3022
3024 }
3025 }
3026 }
3027 continue; /* don't clear stack */
3028
3029 } /* end of switch statement checking `op1' */
3030
3031 cf2_stack_clear( opStack );
3032
3033 } /* end of main interpreter loop */
3034
3035 /* we get here if the charstring ends without cf2_cmdENDCHAR */
3037 " charstring ends without ENDCHAR\n" ));
3038
3039 exit:
3040 /* check whether last error seen is also the first one */
3042
3045
3046 /* free resources from objects we've used */
3047 cf2_glyphpath_finalize( &glyphPath );
3048 cf2_arrstack_finalize( &vStemHintArray );
3049 cf2_arrstack_finalize( &hStemHintArray );
3050 cf2_arrstack_finalize( &subrStack );
3051 cf2_stack_free( opStack );
3052
3054
3055#ifdef __REACTOS__
3056 free(&glyphPath);
3057#undef counterHintMap
3058#undef glyphPath
3059#endif
3060
3061 return;
3062 }
_STLP_MOVE_TO_STD_NAMESPACE void _STLP_CALL advance(_InputIterator &__i, _Distance __n)
Definition: _iterator_base.h:515
Definition: _stack.h:55
#define FT_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES
Definition: freetype.h:3923
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:791
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:1681
cf2_hintmap_build(CF2_HintMap hintmap, CF2_ArrStack hStemHintArray, CF2_ArrStack vStemHintArray, CF2_HintMask hintMask, CF2_Fixed hintOrigin, FT_Bool initialMap)
Definition: pshints.c:808
cf2_glyphpath_closeOpenPath(CF2_GlyphPath glyphpath)
Definition: pshints.c:1907
cf2_glyphpath_lineTo(CF2_GlyphPath glyphpath, CF2_Fixed x, CF2_Fixed y)
Definition: pshints.c:1711
cf2_hintmap_init(CF2_HintMap hintmap, CF2_Font font, CF2_HintMap initialMap, CF2_ArrStack hintMoves, CF2_Fixed scale)
Definition: pshints.c:277
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:1083
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:2145
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:1909
Definition: ftgloadr.h:40
Definition: ftimage.h:75
Definition: t1tables.h:299
Definition: psaux.h:533
Definition: psaux.h:600
Definition: t1types.h:201
Definition: btrfs_drv.h:450
t1_lookup_glyph_by_stdcharcode_ps(PS_Decoder *decoder, FT_Int charcode)
Definition: t1decode.c:131
Referenced by cf2_getGlyphOutline(), and cf2_interpT2CharString().
