#$@%#$%!

Ngiler SH3LL 360
: / usr / share / ghostscript / Resource / Init /

Information Server
MySQL : OFF Perl : OFF CURL : ON WGET : OFF PKEXEC : OFF

Directive	Local Value
IP Address	162.0.209.101
System	Linux premium169.web-hosting.com 4.18.0-553.50.1.lve.el8.x86_64 #1 SMP Thu Apr 17 19:10:24 UTC 2025 x86_64
User	luxeelil
PHP Version	8.0.30
Software	LiteSpeed
Doc root	Writable

Edit File : pdf_font.ps \| Size : 89.57 KB
% Copyright (C) 2001-2019 Artifex Software, Inc. % All Rights Reserved. % % This software is provided AS-IS with no warranty, either express or % implied. % % This software is distributed under license and may not be copied, % modified or distributed except as expressly authorized under the terms % of the license contained in the file LICENSE in this distribution. % % Refer to licensing information at http://www.artifex.com or contact % Artifex Software, Inc., 1305 Grant Avenue - Suite 200, Novato, % CA 94945, U.S.A., +1(415)492-9861, for further information. % % PDF font operations. % Since PDF font are not unique and can collide with external font resources % or each other, use font dictionaries obtained from PDF directly, never % register them as resources or look them up by name. Use findfont oparator % for non-embedded fonts only. CIDFont resources still use the old logic % described below. % Finding a font by name can't give a proper result when PDF font names aren't unique. % But it is only the way to obtain a font in Postscript after a font file is executed. % Therefore using a FontName (and findfont) is allowed only % immediately after a font file is executed. % In all other cases the font to be found by a pointer through PDF structures. % % This ideal logics can't work for documents, % which define a font resource with an embedded font, % and another font resource with same BaseFont but with no embedded font % (and possibly with no font descriptor). % Our testbase does contain such examples. % In this case we do find font by FontName (with findfont), % since there is no other way to get a reasonable result. /.setlanguagelevel where { pop 2 .setlanguagelevel } if .currentglobal //true .setglobal /GS_PDF_ProcSet load begin % from userdict at this point pdfdict begin % We cache the PostScript font in an additional element of the % font resource dictionary, called PSFont. % ---------------- Encodings ---------------- % /.notdefEncoding 256 { /.notdef } repeat 256 packedarray def % Apply a list of differences to an Encoding. % Note that the differences may cause the array to grow. /updateencoding { % <encoding\|null> <differences> updateencoding <enc'> % Calculate the length of the result. % in case the incoming Encoding is null, use .notdefEncoding exch dup //null eq { pop .notdefEncoding } if 0 0 3 index { dup type /nametype ne { exch pop oforce } { pop 1 add } ifelse % Differences list may not be in order, update the largest_index % stack: <Differences> <encoding> <largest_index> <at_index> 2 copy lt { exch pop dup } if % at_index is new largest } forall pop 1 index length .max array dup 0 4 -1 roll putinterval exch 0 exch { % Stack: enc' code element dup type /nametype ne { exch pop oforce } { 3 copy put pop 1 add } ifelse } forall pop } bind executeonly def /good_encoding_names << /MacRomanEncoding 0 /MacExpertEncoding 0 /WinAnsiEncoding 0 >> readonly def /known_symbolic_fonts << /Wingdings2 0 /ZapfDingbats 0 >> readonly def % Get the Encoding for a font. /getencoding % <base-encoding> <font-resource> getencoding <enc> { dup /Encoding knownoget { dup type /nametype eq { % The published PDF specification says the Encoding name % "must be" one of the 3 predefined Encodings, implying % that an error should occur if it isn't. However, Acrobat % Reader simply ignores unknown names, and since there are % some buggy applications that rely on this, we do the same. //good_encoding_names 1 index known { exch /BaseFont knownoget not { 0 } if % Ignore named encodings for known symbolic fonts. See bug 690135. //known_symbolic_fonts exch known { pop } { exch pop findencoding } ifelse } { pop pop } ifelse } { exch pop dup type /arraytype eq { exch pop ( ** Warning: Encoding is an array, not name or dictionary.\n) pdfformatwarning } { dup /BaseEncoding knownoget { %% Originally we ignored the specific invalid name '/' here from Bug #687786, however %% Bug #696942 contains an invalid BaseEncoding '/utf-8', so now we check all BaseEncoding %% against the permitted names, just as we do for Encodings. //good_encoding_names 1 index known{ findencoding 3 -1 roll pop exch }{ ( Error: Invalid BaseEncoding name ") print 256 string cvs print (" ignoring BaseEncoding.\n) pdfformaterror ( Output may be incorrect.\n) pdfformaterror }ifelse } if /Differences knownoget { updateencoding } if } ifelse } ifelse } { pop ( Error: Encoding not present.\n) pdfformaterror ( Output may be incorrect.\n) pdfformaterror } ifelse } bind executeonly def currentdict /good_encoding_names undef currentdict /known_symbolic_fonts undef /checkGlyphNames2Unicode % <dict> checkGlyphNames2Unicode - { PDFDEBUG { dup /FontInfo .knownget { /GlyphNames2Unicode .knownget { (Has GlyphNames2Unicode) = pop % { exch //== exec //== exec} forall } if } if } if pop } bind executeonly def % Define a font using it's FontName as the key. % Adjust a font according to the Encoding and Widths in the font resource. /adjustfont { % <font-resource> <font> adjustfont <font'> getfontencoding 3 copy .processToUnicode getfontmetrics 5 -1 roll pop .updatefont { %% Bug #696306 has a broken type 1 font where the eexec encrypted portion simply ends %% leaving a partial glyph description and, more importantly, the Private dictionary %% on the operand stack. Ths means the font dictonary does not contain a Private %% dictionary which causes .buildfont1 to throw an error. .completefont calls .buildfont1 %% (which is obscured by a definition in gs_type1.ps) so we need to check the reault %% of .completefont. If it fails we must discard the font dictionary and use a fallback. {.completefont} stopped { (\n * ERROR: The font ) print /FontName get 256 string cvs print ( is damaged and cannot be used. Switching to a\n) pdfformaterror ( last-ditch fallback, text may not render correctly, or at all.\n\n) pdfformaterror /Helvetica findfont }if } if } bind executeonly def % Get the (possibly modified) encoding of a font. /getfontencoding { % <font-resource> <font> getfontencoding % <font-resource> <font> <Encoding\|null> % Ignore encoding when TrueType is requested % and loaded from an embedded stream. % All other cases are left unchanged. dup /FontType get 42 eq 1 index /PathLoad known not and 2 index /Subtype get /TrueType eq and { //null } { % Acrobat appears to be always using StandardEcoding as the % default encoding for some non-symbolic fonts (rather than, % as the spec states, the encoding specified by the font). % As this is contrary to spec, and we only have a CFF % example, I've restricted this to fonts with Subtype Type1C % and that result in a Type 2 PS font. 1 index /FontDescriptor knownoget { dup % Unfortunately, Acrobat doesn't enforce the meaning of % FontFile[23] so whilst, in theory, Type1C should only % occur in FontFile3, we can't rely on that. dup /FontFile knownoget not { dup /FontFile2 knownoget not { dup /FontFile3 knownoget not {1 dict} if } if } if exch pop /Subtype knownoget {/Type1C eq}{//false} ifelse exch /Flags knownoget {4 and 4 eq not}{//false}ifelse and } {//false} ifelse 1 index /FontType get 2 eq and { 2 index /Encoding knownoget {pop StandardEncoding 2 index getencoding} { //null } ifelse } { 2 index /Encoding known { dup /Encoding knownoget { 2 index getencoding } { //null } ifelse } { //null } ifelse } ifelse } ifelse } bind executeonly def % Returns true if the current glyph is in the Differences array at % the specified index value. This is needed because the Widths % array may map to the same glyph at different positions from the % Encoding. We want to use the Width that was associated with the % one specified in the Encoding::Differences list. /match_in_diff % <Differences> <index> <glyphname> match_in_diff <bool> { //false 4 1 roll 0 4 -1 roll % stack: false index glyphname at_index==0 Differences { exch 1 index type /nametype ne { % stack: false index glyphname Diff_element at_index pop % Diff_element is new at_index } { % stack: false index glyphname Diff_element at_index exch 2 index eq { % stack: false index glyphname at_index dup 3 index eq { //true 5 1 roll % stack: true false index glyphname at_index pop exit } if } if 1 add % at_index++ stack: false index glyphname at_index' } ifelse } forall % stack: true false index glyphname % or : false index glyphname at_index pop pop pop } bind executeonly def /unique_name { % <dict> </root> unique_name </unique> % % Note : this function interacts with pdf_write_encoding in src/gdevpdtw.c % and with copied_drop_extension_glyphs in src\gxfcopy.c % by adding a reserved substring (~GS~). % .namestring % <<>> (root) 0 1 65535 { 5 string cvs % <<>> (root) (0) (~GS~) exch concatstrings 1 index exch % <<>> (root) (root) (~GS~0) concatstrings % <<>> (root) (root~GS~0) dup % <<>> (root) (root~GS~0) (root~GS~0) 3 index exch % <<>> (root) (root~GS~0) <<>> (root~GS~0) known not { exch pop exit % <<>> (root~GS~0) } if pop } for exch pop cvn % /root0 } bind executeonly def % Get the metrics of a font, if specified. /getfontmetrics { % <font-resource> <font> <Encoding\|null> getfontmetrics % <font-resource> <font> <Encoding\|null> % <Metrics\|null> <GlyphMap\|null> 2 index /Widths oknown { dup //null eq { pop dup /Encoding get } if 7 dict begin dup length dict /Metrics exch def /Encoding exch def /GlyphMap //null def exch dup /Widths oget /Widths exch def % Stack: font font-res % Note that widths are always based on a 1000-unit % character space, but the FontMatrix may specify % some other scale factor. Compensate for this here, % by scaling the Widths if necessary. 0.001 2 index /FontMatrix get 0 get dup 0 eq { % FontMatrix.xx == 0, so we cannot scale down by xx. % - FontMatrix[0] == 0 implies either FontMatrix[1] <> 0 or % FontMatrix cannot be inverted. In the 1st case we have % FontMatrixNonHV == true and will render text with cshow + xshow. % In the 2nd case, metrics in the PDF Font object cannot be enforced % [by altering metrics in PS glyph space]. % HACK: % - we scale down by FontMatrix[1]; % - given the format of Metrics entries we use, wy = 0 in glyph space; % - as a result, the cshow procedure receives as wy the value we % need for wx (all of this in PS user space). pop 2 index /FontMatrix get 1 get dup 0 eq { pop 1 } if % sorry, no way to enforce PDF metrics by altering the font } if div % Stack: font font-res mscale /FirstChar 2 index /FirstChar knownoget not { ( ** Warning: /FirstChar attribute is missing, assuming 0.\n) pdfformatwarning 0 } if def /LastChar 2 index /LastChar knownoget not { ( Warning: /LastChar attribute is missing, assuming 255.\n) pdfformatwarning 255 } if def Encoding length LastChar le { ( Warning: Font Encoding array size is smaller than character range.\n) pdfformatwarning } if 1 index /FontDescriptor knownoget { /MissingWidth knownoget not { 0 } if } { 1000 } ifelse /MissingWidth exch def Widths length LastChar FirstChar sub le { ( Warning: Font Widths array size is smaller than character range.\n) pdfformatwarning /Widths [Widths aload length LastChar FirstChar sub exch sub MissingWidth exch {dup} repeat] def } if FirstChar 0 Encoding { % Stack: font font-res mscale first-char index charname 1 index FirstChar lt { MissingWidth } { 1 index LastChar gt { MissingWidth } { Widths 2 index FirstChar sub get } ifelse } ifelse oforce % Stack: font font-res mscale first-char index charname width 4 index mul % The following 'loop' is only context for 'exit'. { % Work around a bug in pdfTeX, which can generate Encoding % vectors containing nulls : 1 index //null eq { exit } if Metrics 2 index .knownget { 1 index ne } { //false } ifelse { % Two or more Encoding elements refer same glyph name, % and Widths specify different wihts for it. % Since a Postscript font can't have different % Metrics for same glyph name, % we generate an unique name, and create a new % Charstrings entry with same glyph value. GlyphMap //null eq { /Encoding Encoding dup length array copy def /GlyphMap 4 dict def } if % To prevent too many new names, check whether % we can use one already created for same glyph. //true GlyphMap { % f r s c i n w b n1 n2 4 index eq { % f r s c i n w b n1 dup Metrics exch get % f r s c i n w b n1 w1 3 index eq { % f r s c i n w b n1 4 3 roll pop % f r s c i w b n1 3 1 roll pop % f r s c i n1 w Encoding 3 index 3 index put //false % f r s c i n1 w b exit } { pop } ifelse } { % f r s c i n w b n1 pop } ifelse } forall % f r s c i n w b { % Do create a new name. Metrics 2 index //unique_name exec % f r s c i n w nn Encoding 4 index 2 index put GlyphMap 1 index 5 -1 roll put % f r s c i w nn exch % Stack: font font-res mscale first-char index new_name width } if } if 2 copy Metrics 3 1 roll put exit } loop pop pop 1 add } forall pop pop pop exch Encoding Metrics GlyphMap end } { //null //null } ifelse } bind executeonly def currentdict /unique_name undef currentdict /match_in_diff undef /ToUnicodeCMapReader 4 dict begin /defineresource % <name> <dict> <cat-name> defineresource <dict> { pop dup userdict exch /.lastToUnicode exch put exch pop } bind executeonly def /CIDSystemInfo { ( Warning: ToUnicode CMap has invalid syntax near CIDSystemInfo.\n) pdfformatwarning /CIDSystemInfo } bind executeonly def % A work around a bug in Altona.Page_3.2002-09-27.pdf - a slash is missed. /CMapName { ( ** Warning: ToUnicode CMap has no CMapName.\n\ See the comment to revision 6201 in gs/doc/ps2pdf.htm#Problems .\n) pdfformatwarning /CMap1 % arbitrary, PDF defineresource tolerates non-unique names } bind executeonly def % A work around incorrect ToUnicode CMap generated by GS before rev. 6201. % Split large ranges into smaller chunks to stay withing the limits % of various PS% objects and speed up operand stack manipulation, % esp. "counttomatk -3 roll". Bug 691908. /beginbfrange { { pop mark 256 { currentfile token not { /endbfrange exit } if dup /endbfrange eq { exit } if currentfile token not { pop /endbfrange } if currentfile token not { pop pop /endbfrange } if dup ([) eq { pop [ { currentfile token not { exit } if dup (]) eq { pop exit } if } loop ] } if } repeat dup /endbfrange eq { pop endbfrange exit } { endbfrange mark } ifelse } loop } bind executeonly def currentdict end readonly def /string2number % <string> string2number <number> { 0 exch dup 0 exch 1 exch length 1 sub { % n () i 1 index exch get % n () v 3 2 roll 256 mul add exch % v+n256 () } for pop % N } bind executeonly def /copy&def % <key> <value> <bool> copy&def - { { //true } { currentdict gcheck { dup gcheck not } { //false } ifelse } ifelse { currentglobal currentdict gcheck setglobal exch dup length string copy exch setglobal } if def } bind executeonly def /.convert_ToUnicode-into-g2u % <GlyphNames2Unicode> <Encoding\|null> <CMap> .convert_ToUnicode-into-g2u - { CMAPDEBUG { (.convert_ToUnicode-into-g2u beg) = } if 3 2 roll begin /.CodeMapData get % About the data format see gs_cmap.ps, the comment after "CMap operators". 1 get % code maps { CMAPDEBUG { dup //== exec } if dup length 1 sub 0 exch 5 exch { % e [] i 2 copy get % e [] i (prefix) string2number % e [] i prefix 2 index 2 index 1 add get % e [] i prefix (key_size,?is_range,value_type,value_size) dup 0 get 8 mul % e [] i prefix (key_size,?is_range,value_type,value_size) key_size8 3 2 roll exch bitshift exch % e [] i prefix<<key_size8 (key_size,?is_range,value_type,value_size) dup 0 get exch 3 get % e [] i offset key_size value_size 4 index 4 index 2 add get % e [] i offset key_size value_size (keys) 5 index 5 index 3 add get % e [] i offset key_size value_size (keys) (values) CMAPDEBUG { ( offset=) print 4 index =string cvs print ( key_size=) print 3 index =string cvs print ( value_size=) print 2 index = ( keys=) print 1 index //== exec ( values=) print dup //== exec } if 1 index length 0 eq { % A single pair. exch pop exch pop exch pop exch % e [] i (values) offset 4 index //null ne { 4 index length 1 index gt { 4 index exch get } if } if % e [] i (values) cid\|name exch CMAPDEBUG { ( defined single: ) print 1 index =string cvs print ( ) print dup //== exec } if //false copy&def % e [] i pop % e [] } { % A range. % e [] i offset key_size value_size (keys) (values) dup length string copy % protect the original string from modifications below. 0 4 index 2 mul 3 index length 1 sub { % e [] i offset key_size value_size (keys) (values) j 2 index 1 index 6 index getinterval string2number % e [] i offset key_size value_size (keys) (values) j keyL CMAPDEBUG { ( keyL=) print dup =string cvs print } if 3 index 2 index 7 index add 7 index getinterval string2number % e [] i offset key_size value_size (keys) (values) j keyL keyH CMAPDEBUG { ( keyH=) print dup = } if 3 2 roll 6 index idiv 5 index mul % e [] i offset key_size value_size (keys) (values) keyL keyH J 3 index exch 6 index getinterval % e [] i offset key_size value_size (keys) (values) keyL keyH (valueL) 3 1 roll 1 exch { % e [] i offset key_size value_size (keys) (values) (value) k 9 index //null ne { 9 index exch get % e [] i offset key_size value_size (keys) (values) (value) name } if % e [] i offset key_size value_size (keys) (values) (value) cid\|name 1 index % e [] i offset key_size value_size (keys) (values) (value) cid\|name (value) CMAPDEBUG { ( defined from range: ) print 1 index =string cvs print ( ) print dup //== exec } if //true copy&def % e [] i offset key_size value_size (keys) (values) (value) %% Calculate the value from the last string dup dup length 1 sub 0 exch 0 1 3 -1 roll { % (string) value index exch 256 mul exch 2 index exch get add } for %% and increment the value for the next string 1 add %% Now convert the value into a string of bytes. 1 index length 1 sub 1 exch 0 1 3 -1 roll { % (string) value divisor index 2 index 2 index idiv 255 and % (string) value divisor index byte exch 4 index length 1 sub exch sub % (string) value divisor byte string_position 5 index % (string) value divisor byte string_position (string) exch 3 -1 roll put % (string) value divisor 256 mul } for pop pop pop } for % e [] i offset key_size value_size (keys) (values) (value) } for pop pop pop pop pop pop pop % e [] } ifelse } for pop % e } forall end pop % CMAPDEBUG { (.convert_ToUnicode-into-g2u end) = } if } bind executeonly def /.DoToUnicode? { /IgnoreToUnicode where {/IgnoreToUnicode get not} {//true} ifelse } bind executeonly def /.processToUnicode % <font-resource> <font-dict> <encoding\|null> .processToUnicode - { //.DoToUnicode? exec { currentdict count 1 sub /.stackdepth exch .forceput currentdict countdictstack /.dstackdepth exch .forceput { 1 index /FontType get 0 eq { 1 index /FDepVector get 0 get dup /FontType .knownget not { dup /CIDFontType .knownget { dup 2 eq {pop 11} if } {-1} % just some value that's not a valid font type ifelse }if 11 eq { /Path known} {pop //false} ifelse } {//false} ifelse % Currently pdfwrite is only device which can handle GlyphNames2Unicoide to % generate a ToUnicode CMaps. So don't bother with other devices. /WantsToUnicode /GetDeviceParam .special_op { exch pop }{ //false }ifelse or { PDFDEBUG { (.processToUnicode beg) = } if 2 index /ToUnicode knownoget { dup type /dicttype eq { dup /File known not } { //true } ifelse { % We undefine wrong /Length and define /File in stream dictionaries. % Bug687351.pdf defines /ToUnicode /Identity-H, what is incorrect. ( * Warning: Ignoring bad ToUnicode CMap.\n) pdfformatwarning pop } { /PDFScanRules .getuserparam dup //null eq { pop //PDFScanRules_null } { 1 dict dup /PDFScanRules 4 -1 roll put } ifelse //PDFScanRules_true setuserparams PDFfile fileposition 3 -1 roll count 1 sub countdictstack { //false resolvestream % Following Acrobat we ignore everything outside % begincodespacerange .. endcmap. dup 0 (begincodespacerange) /SubFileDecode filter flushfile /CIDInit /ProcSet findresource begin //ToUnicodeCMapReader begin 12 dict begin /CMapType 2 def mark exch % emulate 'begincodespacerange' 0 (endcmap) /SubFileDecode filter cvx /begincmap cvx exch 2 .execn endcmap userdict /.lastToUnicode currentdict put end end end } PDFSTOPONERROR { { exec } 0 get //false 5 -2 roll 5 } { { stopped } 0 get 4 2 roll 4 } ifelse array astore cvx exec countdictstack exch sub 0 .max { end } repeat count exch sub 2 sub 0 .max { exch pop } repeat 3 1 roll % Stach the stop flag. PDFfile exch setfileposition setuserparams { ( Warning: Failed to read ToUnicode CMap.\n) pdfformatwarning } { 1 index /FontInfo .knownget not { currentglobal 2 index dup gcheck setglobal /FontInfo 5 dict dup 5 1 roll .forceput setglobal } executeonly if dup /GlyphNames2Unicode .knownget not { //true % No existing G2U, make one } { dup wcheck { //false % Existing, writeable G2U, don't make new one } { pop //true % Existing read only G2U, make new one } ifelse } ifelse { currentglobal exch dup gcheck setglobal dup /GlyphNames2Unicode 100 dict dup 4 1 roll .forceput 3 2 roll setglobal } if % font-res font-dict encoding\|null font-info g2u exch pop exch % font-res font-dict g2u encoding\|null userdict /.lastToUnicode get % font-res font-dict g2u Encoding\|null CMap .convert_ToUnicode-into-g2u % font-res font-dict //null % font-res font-dict //null } ifelse } ifelse } if PDFDEBUG { (.processToUnicode end) = } executeonly if } executeonly if } executeonly stopped { .dstackdepth 1 countdictstack 1 sub {pop end} for .stackdepth 1 count 3 sub {pop pop} for } if pop pop pop currentdict /.stackdepth .forceundef currentdict /.dstackdepth .forceundef } executeonly {pop pop pop} ifelse } bind executeonly odef currentdict /.DoToUnicode? .forceundef % ---------------- Descriptors ---------------- % % Partial descriptors for the 14 built-in fonts. Note that % from PDF 1.1 to PDF 1.2, the meaning of the Flag 6 in the FontDescriptor % object has undergone a subtle change in its meaning which has serious % consequences for searching with Acrobat: % In PDF 1.1, the flag meant: Font has StandardEncoding % In PDF 1.2, the flag means: Font has (subset of) StandardRomanCharacterSet /standardfontdescriptors mark /Courier mark /Flags 16#23 .dicttomark /Courier-Oblique 1 index /Courier-Bold 1 index /Courier-BoldOblique 1 index /Helvetica mark /Flags 16#20 .dicttomark /Helvetica-Oblique 1 index /Helvetica-Bold 1 index /Helvetica-BoldOblique 1 index /Times-Roman mark /Flags 16#22 .dicttomark /Times-Bold 1 index /Times-Italic mark /Flags 16#62 .dicttomark /Times-BoldItalic 1 index /Symbol mark /Flags 16#4 .dicttomark /ZapfDingbats 1 index .dicttomark readonly def % ---------------- Utilities ---------------- % /.pdforigfontcache_g 20 dict def currentglobal //false setglobal systemdict /.pdforigfontcache_l 20 dict .forceput setglobal % Find an original font, using cache to prevent adjustfont to accumulate changes. /pdffindcachedfont { % <font_name> pdffindcachedfont <font> dup //.pdforigfontcache_g exch .knownget { exch pop } { dup .pdforigfontcache_l exch .knownget { exch pop } { dup findfont dup dup gcheck { //.pdforigfontcache_g } { .pdforigfontcache_l } ifelse % Stack : font_name font font cache 4 2 roll .growput } ifelse } ifelse } bind executeonly def % Add original font to cache to prevent adjustfont to accumulate changes. /pdfaddcachedfont { % <font_name> pdfaddcachedfont <font> dup findfont dup % name font font dup gcheck { //.pdforigfontcache_g } {.pdforigfontcache_l} ifelse 4 2 roll % font d name font put % font } bind executeonly def /.remove_font_name_prefix { % <name> .remove_font_name_prefix <name> dup .namestring (+) search { //true exch { dup 65 lt exch 90 gt or { pop //false exit } if } forall { pop exch pop cvn } { pop pop } ifelse } { pop } ifelse } bind executeonly def % Find a font (except for embedded ones), and adjust its encoding if necessary. /.pdfdfndict mark /defaultfontname /Helvetica .dicttomark readonly def /pdffindfont { % <font-resource> <fontname> pdffindfont <font> % If the font isn't available, synthesize one based on % its descriptor. dup /Font resourcestatus { pop pop pdffindcachedfont } { 1 index /FontDescriptor knownoget { % Stack: font-res fontname fontdesc dup /Flags oget dup 16#40 and -6 bitshift % 1, oblique/italic 1 index 16#40000 and -17 bitshift add % 2, bold exch 16#2 and 2 bitshift add % 8, serif % We should look at the fixed flag, too. % Stack: font-res fontname fontdesc properties % Even though /FontName is a required key in FontDescriptor dict % (As of the PDF 1.4 Reference Manual), In the case of missing % /FontName key, we substitue /BaseFont for the value of /FontName. % Yet another case of broken PDF's that Adobe Reader accepts. 1 index dup /FontName known { /FontName oget dup type /nametype ne { ( Error: /FontName in FontDescriptor is not a name.\n) pdfformaterror ( Output may be incorrect.\n) pdfformaterror cvn } if } { ( Error: FontDescriptor missing required /FontName key. BaseFont name used.\n) pdfformaterror ( Output may be incorrect.\n) pdfformaterror pop 2 index % grab the BaseFont from the stack. } ifelse .remove_font_name_prefix exch % Analyzes font name and extract "Bold" and "Narrow" properties % which are not described by the FontDescriptor Flags. % We also allow the font name analysis to override the Flags setting % for Italic/Oblique as this gives us results more consistent with % Acrobat. 0 2 index //.fontnameproperties exec 7 and or % Rebind the default font name to Helvetica so that % fonts with no properties are handled correctly. //.pdfdfndict begin .substitutefontname end % Stack: font-res fontname fontdesc substname\|null Fontmap 1 index known {//false} { .buildnativefontmap pop NativeFontmap 1 index known not} ifelse { % No available good substitution, use the standard one. pop 1 index .substitutefont } if dup 3 index ne QUIET not and { (Substituting font ) print dup =only ( for ) print 2 index =only (.) = flush } if pdffindcachedfont % Stack: font-res fontname fontdesc font % Some non-compliant files are missing FirstChar/LastChar, % despite referencing a non-base14 font 3 index /FirstChar knownoget { 0 % push an initial value for accumating the Widths 0 string % and an empty string to interrogate the font 7 index /Widths knownoget { 0 1 2 index length 1 sub { dup 2 index exch get dup type /packedarraytype eq {exec} if % Handle entries which are indirect references (seriously ? !!) dup 0 gt % We ignore entries of zero in the widths array { exch 5 index add % add FirstChar to the idx to get a char code dup 64 gt 1 index 91 lt and % we only want to consider A~Z and.... 1 index 96 gt 2 index 123 lt and or % ... a~z { exch 5 -1 roll add 4 1 roll % add the width to the accumulator on the stack 1 string dup 0 4 -1 roll put 3 -1 roll concatstrings exch % add the char code to the string } { pop pop } ifelse } { pop pop } ifelse } for pop % get rid of the Widths array 3 -1 roll pop % get rid of the FirstChar value dup length dup 0 gt { 3 -1 roll exch div % calculate an average width from the Widths array gsave 2 index 10 scalefont setfont exch dup length exch stringwidth grestore pop 100 mul exch div div % Only make the font smaller/narrower, not larger/wider dup 1.0 lt { 0 0 2 index 0 0 6 array astore exch //true .copyfontdict dup /FontMatrix get 3 -1 roll matrix concatmatrix exch dup 3 -1 roll /FontMatrix exch put % we don't need to definfont here, we can leave that to .completefont below } { pop } ifelse } { % no suitable Widths entries - carry on and hope for the best...... pop pop pop } ifelse } { % Broken file: no Widths array for non-base14 font - carry on and hope for the best...... ( Warning: Widths array missing in FontDescriptor for non-base14 font\n) pdfformatwarning pop pop pop } ifelse } { ( ** Warning: FirstChar value missing in FontDescriptor for non-base14 font\n) pdfformatwarning } ifelse % Stack: font-res fontname fontdesc font % If this is a small-caps font, replace the CharString % entries for a..z. exch /Flags oget 16#20000 and 0 ne { //true .copyfontdict dup /CharStrings 2 copy get dup length dict .copydict % stack: font-res fontname font font /CharStrings CharStringsdict 5 index /FirstChar get 97 .max 6 index /LastChar get 122 .min 1 exch { % Stack: font-res fontname font' font' /CharStrings charstrings code % Note that this only remaps a-z, not accented characters. 6 index /Widths oget 1 index 8 index /FirstChar get sub oget 1 string dup 0 5 -1 roll put % Stack: font-res font' font' /CharStrings charstrings code % width (x) 2 index exch dup cvn exch dup 0 2 copy get 32 sub put 4 -1 roll { % Stack: operand (X) width 0 setcharwidth exch pop currentfont /FontMatrix get matrix invertmatrix concat 0.7 dup scale 0 0 moveto show } /exec cvx 4 packedarray cvx put } for put } if dup /FontName get 2 index ne { //true .copyfontdict 2 copy exch /FontName exch put } if exch pop .completefont } { % No descriptor available, use the default algorithm. pdffindcachedfont } ifelse } ifelse exch pop } bind executeonly def % ---------------- Type 1 fonts ---------------- % /buildType1 % <Type1-font-resource> buildType1 <font> { dup /BaseFont get pdffindfont } bind executeonly def % Read an embedded Type 1 font. /readfontfilter { % <proc> readfontfilter <filter> 0 () /SubFileDecode filter } bind executeonly def % Adobe Acrobat doesn't skip space characters after eexec /eexec_pdf_param_dict mark .eexec_param_dict {} forall /keep_spaces //true .dicttomark readonly def % When Type 1 font reading procedure is executing, a copy of this dictionary is current. % topFontDict allows us to attempt to handle the case where a Type 1 font definition % does not start by creating it's own dictionary (i.e. a number of the keys end up in % the currentdict rather than the font dictionary). % The whole type1 stream can be executed directly. There's no need to process % Length1, 2, 3 keys. /readtype1dict 10 dict dup begin /prev_definefont /definefont load def /definefont { % if a font defines any keys outside it's own dictionary, % this attempts to cope by copying them into the font dictionary [ /FontType % in PLRM order /FontMatrix /FontName /FontInfo /WMode /Encoding /FontBBox /UniqueID /XUID /PaintType /StrokeWidth /Metrics /Metrics2 /CDevProc /CharStrings /Private /WeightVector ] { 2 copy known {pop} { dup where { 1 index get 2 index 3 1 roll put dup /MisplacedKey 0 put } {pop} ifelse } ifelse } forall dup /MisplacedKey known { ( ** Warning: Type 1 font defines some required keys outside the font dictionary.\n) pdfformatwarning } if dup /CharStrings get /.notdef known not { dup /CharStrings get /.notdef <9E35CED7FFD3622F09> put ( Warning: Type 1 font has no /.notdef entry in /CharString dictionary.\n) pdfformatwarning } if dup /UniqueID .knownget { dup dup 0 lt exch 16#ffffff gt or { ( Warning: Ignoring invalid /UniqueID = ) exch =string cvs concatstrings (\n) concatstrings pdfformatwarning dup /UniqueID undef } { pop } ifelse } if prev_definefont } bind executeonly def /undef_proc_warning { /Repaired //true store % flag that we have warnings UndefProcList exch 2 copy .knownget { 1 add } { 1 } ifelse put } bind executeonly def /missing-type1-procs 6 dict begin /-\| { string currentfile exch readstring pop /-\| //undef_proc_warning exec } executeonly bdef /RD { string currentfile exch readstring pop /RD //undef_proc_warning exec } executeonly bdef /\|- { noaccess def /\|- //undef_proc_warning exec } executeonly bdef /ND { noaccess def /ND //undef_proc_warning exec } executeonly bdef /\| { noaccess put /\| //undef_proc_warning exec } executeonly bdef /NP { noaccess put /NP //undef_proc_warning exec } executeonly bdef currentdict end readonly def /eexec { % Assume the font dictionary is directly below the file on the stack count 0 gt { /topFontDict 2 index cvlit store } if //eexec_pdf_param_dict /eexecDecode filter //missing-type1-procs begin /userdict .systemvar begin //systemdict begin readtype1dictcopy begin cvx stopped currentfile flushfile % Skip the trailer after return from eexec, bug 690701. { currentdict end //missing-type1-procs eq { exit } if } loop { stop } if } bind executeonly def /readonly-op-dict << /stringtype 0 /arraytype 0 /packedarraytype 0 /dicttype 0 >> readonly def /readonly { % bug 689617 dup type //readonly-op-dict exch known not { ( Warning: Type 1 font applies operator readonly to an invalid object type.\n) pdfformatwarning } if } bind executeonly def /prev_get /get load def /get { dup /FontName eq { % No warning, probably FontName is defined elsewhere; see definefont above. .knownget not { /Missing } if } { dup /UniqueID eq { % We don't want fonts to check /UniqueID and do 'restore'. pop pop 16#FEDCBA98 % Arbitrary and invalid value } { prev_get } ifelse } ifelse } bind executeonly def /prev_begin /begin load def /begin { dup //systemdict eq { pop 0 dict } if prev_begin } bind executeonly def { /undef_proc_warning /missing-type1-procs /readonly-op-dict } { currentdict exch undef } forall end readonly def currentdict /eexec_pdf_param_dict .undef /readtype1 { % <font-resource> <stream-dict> readtype1 <font\|null> PDFfile fileposition 3 1 roll % pos res stream dup /PFB known exch % pos res pfb? stream //true resolvestream % pos res pfb? file exch { //false /PFBDecode filter % pos res file' } if % Some buggy embedded fonts leave extra junk on the stack, % so we have to make a closure that records the stack depth % in a fail-safe way. This code also removes the mark when % the implied cleartomark is not executed, i.e. Length3 == 0. % Also restore dictstack depth. % //systemdict begin //readtype1dict dup length 5 add dict copy begin % pos res file' /file-position 4 -1 roll def % res file' /stack-count count 3 sub def 1 index /BaseFont oget /savedFontName exch def /topFontDict //null def /readtype1dictcopy currentdict def cvx stopped { currentdict /topFontDict known not { end } { exit } ifelse } loop { /topFontDict //null def } if PDFfile file-position setfileposition count stack-count sub { pop } repeat topFontDict end end } bind executeonly def % ---------------- Type 3 fonts ---------------- % /buildType3 { % <Type3-font-resource> buildType3 <font> 8 dict begin /FontType 3 def % If the font does not contain a Resources entry, then we use % the resources from our current context. Page 391 of the PDF % 1.6 spec says that the Resources dict is optional and if not % present then we should use the Resources for the page. % However we have a test file (687989) which uses a Type3 font % inside a form XObject and the desired Resources are in the % XObject dict and not in the Page dict. So we are going to % the parent object to find resources instead of only going to % the page dict when a font does not specify its required % resources. /Resources 1 index /Resources knownoget { oforce } { LocalResources } ifelse def /FontBBox 1 index /FontBBox get cvx def /FontMatrix 1 index /FontMatrix oget def /CharProcs 1 index /CharProcs oget def 1 index /Widths knownoget { /Widths exch def 1 index /FirstChar known 2 index /LastChar known and { /FirstChar 1 index /FirstChar oget def /LastChar 1 index /LastChar oget def } { ( Error: Requireed entry FirstChar or LastChar is missing from Font.\n) pdfformaterror ( Output may be incorrect.\n) pdfformaterror /FirstChar 0 def /LastChar Widths length def }ifelse } if /FontName 1 index /Name knownoget not { /PDFType3Untitled } if def /Encoding .notdefEncoding 2 index getencoding def % We have to define BuildChar rather than BuildGlyph: % there is no PDF equivalent of glyphshow, and we need % the character code to access the Widths. /BuildChar { % Stack: font charcode 1 index begin 4 dict begin /Font 3 -1 roll def /CharCode 1 index def Encoding exch get CharProcs exch knownoget { dup /Length get 0 eq { pop %% Detect a 0 length stream. If this occurs %% then we won't execute d0 or d1, and so won't adjust the %% character width. So, pretend we got a %% null d1, just so that we can adjust using the /Widths %% (Bug 697805) 0 0 0 0 0 0 pdfopdict /d1 get exec }{ { //false resolvestream % Stack: filepos stream % Don't let setgcolor set the color inside the BuildGlyph % procedure, because this causes an /undefined error. q %% This is (currently) needed to make sure that the current dictionary, which is %% 'nodict' because we did a gsave, is writeable. If we don't execute gput %% to make a writeable copy then it is a no access dicitonary and the 'def' %% below will fail. It would be nice to fix the cases of this someday, but %% we use 'nodict'[ to store other PDF state stuff that isn't gstate, and we %% probably always will, so it may well be more trouble than its worth. /Dummy //false gput Font /Resources get exch pdfopdict /BuildCharDictDepth countdictstack def .pdfruncontext countdictstack BuildCharDictDepth sub { //pdfdict /.Qqwarning_issued .knownget {not}{//true} ifelse { (\n Warning: Type 3 glyph has unbalanced q/Q operators \(too many q's\)\n Output may be incorrect.\n) pdfformatwarning //pdfdict /.Qqwarning_issued //true .forceput } executeonly if Q } executeonly repeat Q } executeonly PDFfile fileposition 2 .execn % Keep pdfcount valid. PDFfile exch setfileposition } executeonly ifelse } executeonly { % PDF Type 3 fonts don't use .notdef % d1 implementation adjusts the width as needed 0 0 0 0 0 0 pdfopdict /d1 get exec } ifelse end end } executeonly bdef dup currentdict Encoding .processToUnicode currentdict end .completefont exch pop } bind executeonly odef /.adjustcharwidth { % <wx> <wy> .adjustcharwidth <wx'> <wy'> % Enforce the metrics, in glyph space, to the values found in the PDF Font object % - force wy == 0 (assumed, and not stored in the PDF font) % Even though PDF1.3-1.7 specifications state that this must be 0, % Distiller sometimes creates Type3 fonts with non-zero wy. We set % it to 0 since this is apparently what Acrobat Reader 4 and 5 do. % PDF1.2 does not mention this restriction, it only says % "see setcharwidth/ setcachedevice in the PostScript Reference". % - get wx from the Widths array (do nothing if not present) pop 0 /Widths where { begin CharCode FirstChar ge CharCode LastChar le and { exch pop Widths CharCode FirstChar sub get exch } if end } if } bind executeonly def % ---------------- TrueType fonts ---------------- % /TTfonts mark /Arial /Helvetica /Arial,Italic /Helvetica-Oblique /Arial,Bold /Helvetica-Bold /Arial,BoldItalic /Helvetica-BoldOblique /CourierNew /Courier /CourierNew,Bold /Courier-Bold /TimesNewRoman /Times-Roman /TimesNewRoman,Italic /Times-Italic /TimesNewRoman,Bold /Times-Bold /TimesNewRoman,BoldItalic /Times-BoldItalic .dicttomark readonly def /buildTrueType { % <TrueType-font-resource> buildTrueType <font> dup /BaseFont oget dup /font_name gput 1 index /FontDescriptor knownoget { /Flags knownoget { 4 and 0 ne { //true } % symbolic { 1 index /Encoding oknown not} % no encoding => symbolic ifelse } {//false} ifelse } {//false} ifelse /is_symbolic gput 1 index /Encoding oknown { StandardEncoding 3 index getencoding } { //null } ifelse /prebuilt_encoding gput //false /.render_notdef gput % set the default dup /Font resourcestatus dup { exch pop exch pop } if not TTfonts 2 index known and { dup TTfonts exch get QUIET not { (Substituting font ) print dup =only ( for ) print 1 index =only (.) = flush } if exch 3 1 roll pdffindfont //true .copyfontdict 2 copy exch /FontName exch put exch pop .completefont } { pdffindfont } ifelse } bind executeonly def % Read an embedded TrueType font. /readtruetype { % <font-resource> <stream-dict> readtruetype <font> 1 index exch PDFfile fileposition 3 1 roll //true resolvestream readfontfilter % Stack: filepos fontres stream 1 index /CIDSystemInfo oknown { 1 index /CIDSystemInfo get dup type /packedarraytype eq {exec}if dup /Registry known not { ( Warning: a CIDFont's CIDSystemInfo is missing the required Registry entry\n) pdfformatwarning dup /Registry (Adobe) put } if dup /Ordering known not { ( Warning: a CIDFont's CIDSystemInfo is missing the required Ordering entry\n) pdfformatwarning dup /Ordering (Identity) put } if dup /Supplement known not { ( Warning: a CIDFont's CIDSystemInfo is missing the required Supplement entry\n) pdfformatwarning dup /Supplement 0 put } if 3 1 roll 1 index /Subtype knownoget { /CIDFontType2 ne { ( Error: Subtype of a TT CID font is not /CIDFontType2\n) pdfformaterror 1 index /Subtype /CIDFontType2 put ( Output may be incorrect.\n) pdfformaterror } if } { ( Error: Subtype of a TT CID font is missing.\n) pdfformaterror 1 index /Subtype /CIDFontType2 put ( Output may be incorrect.\n) pdfformaterror } ifelse 1 index /BaseFont get % Use the BaseFont name for the font. Otherwise we % would use the name table, or a manufactured name. .loadttcidfont % Stack: filepos fontres cidfont } { % filepos fontres stream 1 index /FontDescriptor oget /Flags oget 4 and 0 ne { //true % symbolic } { 1 index /Encoding oknown not % no encoding => symbolic } ifelse 2 index /Encoding oknown { StandardEncoding 3 index getencoding } { //null } ifelse dup 4 index exch % filepos fontres stream is_symbolic Encoding fontres Encoding /prebuilt_encoding exch put % filepos fontres stream is_symbolic Encoding 5 index /BaseFont get % Use the BaseFont name for the font. Otherwise we % would use the name table, or a manufactured name. .loadpdfttfont } ifelse exch pop PDFfile 3 -1 roll setfileposition % Ignore both the Encoding and the Widths. exch pop } bind executeonly def % ---------------- Type 0 fonts ---------------- % % Predefine the known CMaps, but only create them on demand. /knownCMaps mark /Identity-H { /Identity-H 0 makeIdentityCMap } /Identity-V { /Identity-V 1 makeIdentityCMap } .dicttomark def /makeIdentityCMap { % <cmapname> <wmode> .makeIdentityCMap - .currentglobal //true .setglobal 3 1 roll /CIDInit /ProcSet findresource begin 12 dict begin begincmap /WMode exch def /CMapName exch def /CIDSystemInfo 3 dict dup begin /Registry (Adobe) def /Ordering (Identity) def /Supplement 0 def end def %/CMapName (see above) /CMapVersion 1 def /CMapType 1 def %WMode (see above) % The PDF documentation says that these CMaps map CIDs % "1 to 65,536". This is a misprint for 0 to 65,535. 1 begincodespacerange % <0001> <00ff> <0100> <ffff> <0000> <ffff> endcodespacerange 1 begincidrange % <0001> <00ff> 1 <0100> <ffff> 256 <0000> <ffff> 0 endcidrange endcmap CMapName currentdict /CMap defineresource knownCMaps CMapName 2 index put end % CMap end % CIDInit ProcSet exch .setglobal } bind executeonly def /CMap_read_dict 3 dict begin /defineresource % <name> <dict> <cat-name> defineresource <dict> { pop /.last_CMap_def 1 index store exch pop } bind executeonly def /CIDSystemInfo { ( Error: CMap has invalid syntax near CIDSystemInfo.\n) pdfformaterror ( Output may be incorrect.\n) pdfformaterror /CIDSystemInfo } bind executeonly def % A work around a bug in Altona.Page_3.2002-09-27.pdf - a slash is missed. /CMapName { ( ** Error: CMap has no CMapName.\n\ See the comment to revision 6201 in gs/doc/ps2pdf.htm#Problems .\n) pdfformaterror ( Output may be incorrect.\n) pdfformaterror /CMap1 % arbitrary, PDF defineresource tolerates non-unique names } bind executeonly def % A work around incorrect ToUnicode CMap generated by GS before rev. 6201. currentdict end readonly def % Read an embedded stream that we hope is a PostScript CMap. According % to the spec, ths isn't legal, but 'Acrobat opens it'.... % /read_CMap { dup mark exch 0 (begincodespacerange) /SubFileDecode filter cvx exec cleartomark {currentdict dup /CMapType known not {end}{pop exit} ifelse} loop /CMapType 1 def mark exch % emulate 'begincodespacerange' 0 (endcmap) /SubFileDecode filter cvx /begincmap cvx exch 2 .execn endcmap currentdict end dup /CMapName get exch /CMap defineresource end } bind executeonly def % Read embedded CMap stream. % if the <wmode> parameter is null, it indicates there is no WMode, and we % should not add one. % Following Acrobat we ignore everything outside % begincodespacerange .. endcmap. /read_CMap_stream { % <info> <wmode> <name> <stream> read_CMap <CMap> dup 0 (begincodespacerange) /SubFileDecode filter flushfile //CMap_read_dict begin /CIDInit /ProcSet findresource begin 12 dict begin /o.endmapvalue /.endmapvalue load def /.endmapvalue { dup 65535 gt { ( **** Warning: CMap: CID out of valid range (0-65535).\n) pdfformatwarning pop 65535 } if o.endmapvalue } bind def 4 2 roll dup //null eq { pop } { /WMode exch def } ifelse dup //null eq { pop } { /CIDSystemInfo exch def } ifelse /CMapType 1 def /.last_CMap_def currentdict def % establish binding mark exch % emulate 'begincodespacerange' 0 (endcmap) /SubFileDecode filter cvx /begincmap cvx exch 2 .execn currentdict /o.endmapvalue undef endcmap /.last_CMap_def load { currentdict end //CMap_read_dict eq { exit } if } loop dup /.last_CMap_def undef /CMap defineresource } bind executeonly def currentdict /CMap_read_dict undef /buildType0 { % <Type0-font-resource> buildType0 <font> dup /BaseFont get % FontName 1 index /Encoding oget dup type /nametype eq { dup /CMap resourcestatus { pop pop /CMap findresource } { knownCMaps 1 index .knownget { exch pop exec } { /undefined signalerror } ifelse } ifelse } { %% Bug #696449 Acrobat will read an embedded PostScript %% CMap, whcih according to the spec is not valid, it needs %% to be a PDF CMap stream. Here we check and see if it looks like a CMap %% dictionary. If it is we proceed, if its some other kind of dictionary, %% throw an error, if its neither, treat it as a stream and hope for the best. dup /Type known { dup /Type get /CMap eq { PDFfile fileposition exch dup /CIDSystemInfo knownoget { << exch { oforce } forall >> } { //null } ifelse exch dup /WMode knownoget not {//null} if exch dup /CMapName knownoget not {/null} if exch //true resolvestream read_CMap_stream exch PDFfile exch setfileposition } { PDFSTOPONERROR { /buildType0 cvx /syntaxerror signalerror } if } ifelse }{ PDFfile fileposition exch //true resolvestream read_CMap exch PDFfile exch setfileposition } ifelse } ifelse % CMap [ 3 index /DescendantFonts oget { exec resourcefont } forall ] % subfonts .composefontdict % composefont must insert FontInfo dictionary - see gs_cmap.ps . % Stack: fontres name font 3 copy exch pop //null .processToUnicode exch pop .completefont % Stack: fontres font 1 index /FontMatrix knownoget { dup aload pop //true {0 0 1 0 0 1} {3 -1 roll eq and} forall { 1 index exch makefont exch /FontName get exch exch pop .completefont } { pop } ifelse } if exch pop } bind executeonly def % ---------------- CIDFontType0/2 fonts ---------------- % % Insert metrics into a CIDFont, by saving the PDF W, W2, DW, and DW2 % arrays and using a (currently very inefficient) CDevProc. % For detail, refer "PDF Reference" 2nd ed., p314 "5.6.3 CIDFonts". % It notes default DW is 0, but Acrobat Reader uses 1000 as default. % If DW is 0, currentpoint does not move by default in rendering text % horizontally, the result is unreadable. You can check it by Acrobat. /.pdfDefaultDW 1000 def /.pdfDefaultDW2 [ 880 -1000 ] def /addCIDmetrics { % <CIDFont-resource> <CIDFont> addCIDmetrics <fontdict> dup length 5 add dict .copydict dup /FID undef dup /UniqueID undef dup /XUID undef % Insert the widths into the font. % Stack: pdfresource newfont 1 index /DW knownoget { 1 index /DW 3 -1 roll put } { dup /DW .pdfDefaultDW put } ifelse 1 index /W knownoget { //false 1 index { xcheck or } forall { oforce_array } if dup 2 index /W 3 -1 roll put .pdfMakeInternalW 1 index /.internalW 3 -1 roll put } if 1 index /DW2 knownoget { 1 index /DW2 3 -1 roll put } { dup /DW2 .pdfDefaultDW2 put } ifelse 1 index /W2 knownoget { //false 1 index { xcheck or } forall { oforce_array } if dup 2 index /W2 3 -1 roll put .pdfMakeInternalW2 1 index /.internalW2 3 -1 roll put } if dup /CDevProc 1 index /CIDWProc load /exec load 3 packedarray cvx put exch pop } bind executeonly def /.pdfMakeInternalMTXArray { % <mtx_array> <item_size> .pdfConvertInternalW <mtx_array'> % convert /W or /W2 to internal expression % % mtx_array: original /W or /W2 array % item_size: number of metrics values per CID % % for detail of the metrics list format in PDF, % refer PDF Ref. p.317 "Glyph Metrics in CIDFonts". % % format of single entry in internal expression % % [ % [cid_begin cid_end] % value_is_varied (bool) % [ [values for cid_begin...] % [values for cid_begin + 1] % ... ] % ] % 7 dict begin /itemSize exch def /M exch def % original /W or /W2 /Msize M length def /Mi { M i get } def % W[i] /Mi1 { M i 1 add get } def % W[i + 1] /putMTXEntry << /arraytype { [ [Mi Mi Mi1 length itemSize idiv add 1 sub] //true [ 0 itemSize Mi1 length 1 sub { [ exch 1 1 index itemSize add 1 sub { Mi1 exch get } for ] } for ] ] /i i 2 add def } /integertype { [ [Mi Mi1] //false [[ i 2 add 1 i 1 add itemSize add { M exch get } for ]] ] /i i 2 add itemSize add def } >> def /i 0 def [ { putMTXEntry Mi1 type get exec i Msize ge { exit } if } loop ] end } executeonly def /.pdfMakeInternalW { dup length 0 gt { oforce_recursive 1 .pdfMakeInternalMTXArray } if } executeonly def /.pdfMakeInternalW2 { dup length 0 gt { oforce_recursive 3 .pdfMakeInternalMTXArray } if } executeonly def /.pdfGetMTXByCID { % <internalMTXArray> <cid> % .pdfGetMTXByCID % { <MTXEntry> true \| false } % get values for given CID from internal format of /W or /W2 exch { { dup 0 get {} forall % Stack: <cid> <entry> <cid_0> <cid_1> 3 index lt { pop pop //false exit } if 2 index exch sub dup 0 lt { pop pop //false exit } if 1 index 1 get not { pop 0 } if exch 2 get exch get //true exit } loop { exit } if } forall dup type /arraytype eq { exch pop //true } { pop //false } ifelse } executeonly def % Apply the [D]W[2] metrics to a character before displaying. /CIDWProc { % <w0x> <w0y> <llx> <lly> <urx> <ury> % <w1x> <w1y> <vx> <vy> <cid> <font> CIDWproc % <w0x'> ... <vy'> begin % push <font> to currentdict % <w1x> <w1y> <vx> <vy> won't be used and replaced, discard now 5 1 roll pop pop pop pop % get FontMatrix that applies to this CID % (needs to convert [D]W[2] values to glyph space) currentdict /FontMatrix get % if the currentfont is a CIDFontType 0 CIDFont, % we need FDArray font's FontMatrix too FontType 9 eq { currentdict 2 index .type9mapcid % <w0x> <w0y> <llx> <lly> <urx> <ury> <cid> <FontMatrix> (charstring) <FDArray#> exch pop currentdict /FDArray get exch get /FontMatrix get % <w0x> <w0y> <llx> <lly> <urx> <ury> <cid> <FontMatrix> <FontMatrix2> matrix concatmatrix } if % preserve this FontMatrix at bottom of the stack 8 1 roll % Stack: <FontMatrix> <w0x> <w0y> <llx> <lly> <urx> <ury> <cid> { currentdict /DW .knownget not { % no DW .pdfDefaultDW exit % replace <w0x> by defaultDW } if currentdict /.internalW .knownget not { % no W exit % use already-stacked DW } if dup length 0 eq { % W is null array pop % discard unusable W exit % use already-stacked DW } if % W is finite array, try to get W_cid 2 index .pdfGetMTXByCID { % got W, discard DW exch pop {} forall exit } if exit } loop 0 % <w0y'> % Stack: <FontMatrix> <w0x> <w0y> <llx> <lly> <urx> <ury> <cid> <w0x'> <w0y'> 9 -2 roll pop pop % discard <w0x> <w0y> 7 2 roll % put <w0x'> <w0y'> % Stack: <FontMatrix> <w0x'> <w0y'> <llx> <lly> <urx> <ury> <cid> 0 % <w1x'> exch % put <w1x'> % Stack: <FontMatrix> <w0x'> <w0y'> <llx> <lly> <urx> <ury> <w1x'> <cid> { currentdict /DW2 .knownget not { % no DW2, use defaultDW2 .pdfDefaultDW2 exit } if currentdict /.internalW2 .knownget not { % has DW2, no W2 exit % use already-stacked DW2 } if dup length 0 eq { % W2 is null array pop % discard unusable W2 exit % use already-stacked DW2 } if 2 index .pdfGetMTXByCID { % got W2_cid, discard DW2 exch pop exit } if % could not get W2_cid exit } loop exch pop % discard <cid> % Stack: <FontMatrix> <w0x'> <w0y'> <llx> <lly> <urx> <ury> % <w1x'> { [<vy'> <w1y'>] \| [<w1y'> <vx'> <vy'>] } dup length 2 eq { % this is DW2 aload pop exch 8 index 2 div % <vx'> = <w0x'> / 2 exch } { % assume W2 aload pop } ifelse % Stack: <FontMatrix> <w0x'> <w0y'> <llx> <lly> <urx> <ury> <w1x'> <w1y'> <vx'> <vy'> % now, convert each metrics valude (1000th of text space) to glyph space 10 -2 roll % Stack: <FontMatrix> <llx> <lly> <urx> <ury> <w1x'> <w1y'> <vx'> <vy'> <w0x'> <w0y'> 3 { 10 index idtransform exch 1000 div exch 1000 div 6 2 roll } repeat 10 2 roll % Stack: <FontMatrix> <w0x'> <w0y'> <llx> <lly> <urx> <ury> <w1x'> <w1y'> <vx'> <vy'> 11 -1 roll pop % Stack: <w0x'> <w0y'> <llx> <lly> <urx> <ury> <w1x'> <w1y'> <vx'> <vy'> end % recover currentdict } bind executeonly def % <string> <match> tailmatch ==> <pre> true % ==> <string> false /tailmatch { 2 copy length 1 index length .min dup 2 index length exch sub exch getinterval 1 index eq { length 1 index length exch sub 0 exch getinterval //true } { pop //false } ifelse } bind executeonly def /makeboldfont { 16 dict begin /strokewidth exch def /basecidfont exch def /FontMatrix [ 1 0 0 1 0 0 ] def /CIDFontName /.boldfont def /CIDFontType 1 def /basefont-H /.basefont-H /Identity-H [ basecidfont ] composefont def /basefont-V /.basefont-V /Identity-V [ basecidfont ] composefont def /CIDSystemInfo dup basecidfont exch get def /FontBBox [ basecidfont /FontBBox get cvx exec 4 2 roll basecidfont /FontMatrix get transform 4 2 roll basecidfont /FontMatrix get transform ] def /tmpstr 2 string def /BuildGlyph { gsave exch begin dup 256 idiv tmpstr exch 0 exch put 256 mod tmpstr exch 1 exch put rootfont /WMode known { rootfont /WMode get 1 eq } { //false } ifelse { basefont-V } { basefont-H } ifelse setfont strokewidth setlinewidth 1 setlinejoin newpath 0 0 moveto tmpstr //false charpath stroke 0 0 moveto tmpstr show currentpoint setcharwidth end grestore } bind def currentdict end dup /CIDFontName get exch /CIDFont defineresource } bind executeonly def % <CIDFont-resource> <CIDFontName> findCIDFont <CIDFont-resource> <font> % CIDFont-resource is not modified. /findCIDFont { { dup /CIDFont resourcestatus { pop pop dup /CIDFont findresource dup /Path known 1 index /ResourcePath known or { exch pop exit } { pop dup /CIDFont undefineresource } ifelse } if .remove_font_name_prefix dup dup length string cvs (,Bold) tailmatch { exch pop % If we're substituting a standard weight font for a % "Light,Bold" font, don't artificially bolden further dup (Light) tailmatch { pop cvn findCIDFont dup /FontName .knownget { (Light) tailmatch exch pop } { //true } ifelse { 0.03 makeboldfont } if } { pop cvn findCIDFont 0.03 makeboldfont } ifelse exit } if (,Italic) tailmatch { exch pop cvn findCIDFont [ 1 0 0.3 1 0 0 ] makefont exit } if (,BoldItalic) tailmatch { exch pop % see above dup (Light) tailmatch { pop cvn findCIDFont dup /FontName .knownget { (Light) tailmatch exch pop } { //true } ifelse { 0.03 makeboldfont } if } { pop cvn findCIDFont 0.03 makeboldfont } ifelse [ 1 0 0.3 1 0 0 ] makefont exit } if QUIET not { (Can't find CID font ") print dup =string cvs print (".) = flush } if pop 1 index /CIDSystemInfo oget begin Registry (-) Ordering end concatstrings concatstrings cvn QUIET not { (Attempting to substitute CID font ) print dup ==only ( for ) print 1 index ==only (, see doc/Use.htm#CIDFontSubstitution.) = flush } if exch pop dup /CIDFont resourcestatus { pop pop /CIDFont { findresource } stopped {pop}{exit} ifelse } if QUIET not { (The substitute CID font ") print dup =string cvs print (" is not provided either. ) print } if PDFNOCIDFALLBACK { PDFSTOPONERROR { (Will exit with error.) = flush } { (Will attempt to continue, but content may be missing.) = flush } ifelse exit } if QUIET not { (attempting to use fallback CIDFont.) print (See doc/Use.htm#CIDFontSubstitution.) = flush } if PDFNOCIDFALLBACK not { % This previously worked by loading the substitute font, and using that % as a "template" to create a new CIDFont dictionary with the CIDSystemInfo % dict appropriate for the requested font. % This, however, caused problems with the CIDMap and thus broke pdfwrite. % Hence, we now modify the CIDFont resource .map dictionary on the fly % so it includes an appropriate mapping, so the subsitute font is loaded % from the beginning with the correct ordering and supplement settings. /CIDFont /Category findresource /.map get dup /CIDFallBack .knownget { dup type /dicttype eq { dup /FileType get /TrueType eq { currentglobal 4 1 roll dup gcheck setglobal dup length dict copy dup 6 index /CIDSystemInfo oget dup /Ordering oget exch /Supplement get % we have to copy the string, for VM correctness exch dup length string copy exch 2 array astore /CSI exch put 2 index exch .forceput exch setglobal { % This should not execute arbitrary Postscript, so we ought to % be safe running in a stopped context, in knowledge we know how % to clean up afterwards - this would not be safe if CIDFallBack % were a "real" CIDFont. /CIDFont findresource } % if the above fails, try just using the CIDFallBack font directly stopped { pop % First, since it didn't work, remove the entry from the CIDFont category % .map dictionary. currentglobal exch /CIDFont /Category findresource /.map get dup gcheck setglobal exch undef setglobal (Warning: falling back to Identity ordering\n) print flush /CIDFallBack /CIDFont findresource } if exit } executeonly if } if } if pop pop pop /CIDFallBack QUIET not { (The fallback CID font ") print dup =string cvs print (" is not provided. ) print ( Finally attempting to use ArtifexBullet.\n) print flush }if % We'll just use Identity for this, we have only one glyph anyway. /ArtifexBullet /CIDFont resourcestatus { pop pop pop /ArtifexBullet /CIDFont findresource exit } { pop /ArtifexBullet } ifelse QUIET not { (The CID font ") print dup =string cvs print (" is not provided. ) print PDFSTOPONERROR { (Will exit with error.) = flush } { (Will continue, but content may be missing.) = flush } ifelse } if } executeonly if /findresource cvx /undefined signalerror } executeonly loop } bind executeonly odef /buildCIDType0 { % <CIDFontType0-font-resource> buildCIDType0 <font> dup /BaseFont get findCIDFont exch pop } bind executeonly def /buildCIDType2 { % <CIDFontType2-font-resource> buildCIDType2 <font> dup /BaseFont get findCIDFont exch pop } bind executeonly def /processCIDToGIDMap { % <fontres> <cidfont> processCIDToGIDMap <fontres> <cidfont> 1 index /CIDToGIDMap knownoget { PDFfile fileposition 4 1 roll dup /Identity eq { pop } { //true resolvestream % Stack: filepos fontres font mapstream [ { counttomark 1 add index 32768 string readstring not { counttomark 1 eq { exch pop dup length } { ] dup 0 exch { length add } forall } ifelse exit } if } loop 2 idiv % Stack: filepos fontres font mapstream array/string CIDCount dup 0 ne { 3 index exch /CIDCount exch put exch closefile exch dup /CIDMap 4 -1 roll put }{ % If CIDCount is zero, ignore it pop pop closefile }ifelse } ifelse 3 2 roll PDFfile exch setfileposition } if } bind executeonly def % Adjust a CIDFontType0 DW[2] in the font resource. /adjustCIDType0 { % <font-resource> <font> adjustfont <font'> dup /FontType get 1 eq { ( ** Error: Font resource has a wrong /Subtype.\n) pdfformaterror ( Output may be incorrect.\n) pdfformaterror adjustfont } { addCIDmetrics dup /CIDFontName get exch /CIDFont defineresource } ifelse } bind executeonly def % Adjust a CIDFontType2 DW[2] and CIDToGIDMap in the font resource. /adjustCIDType2 { % <font-resource> <font> adjustfont <font'> dup /FontType get 1 eq { ( Error: Font resource has a wrong /Subtype.\n) pdfformaterror ( Output may be incorrect.\n) pdfformaterror adjustfont } { addCIDmetrics dup /CIDFontType get 2 eq { % OpenType CFF font converts to CIDFontType 0 processCIDToGIDMap % that ignores CIDMap. } if dup /CIDFontName get exch /CIDFont defineresource } ifelse } bind executeonly def % ---------------- Other embedded fonts ---------------- % % Read an embedded compressed font. /readType1C { % <font-resource> <stream-dict> readType1C <font> 1 index exch PDFfile fileposition 3 1 roll dup //true resolvestream dup readfontfilter % Stack: pos resource streamdict stream filter 3 index /FontDescriptor oget /FontName oget 1 index /FontSetInit /ProcSet findresource begin //true //false ReadData %% We need to be careful not to corrupt the stack if something went wrong. %% Previously, if the dict was length 0 (an error occured) we would end up %% unable to recover the stack in the calling procedure. %% Bug #695819. dup length 0 ne { { exch pop exit } forall 7 1 roll }{ /invalidfont signalerror } ifelse closefile closefile pop PDFfile 3 -1 roll setfileposition pop pop } bind executeonly def % Read an embedded CFF CIDFont. /readCIDFontType0C { % <font-resource> <stream-dict> readCIDFontType0C <font> PDFfile fileposition 3 1 roll dup //true resolvestream dup readfontfilter % Stack: pos resource streamdict stream filter 3 index /FontDescriptor oget /FontName oget 1 index /FontSetInit /ProcSet findresource begin //true //true ReadData pop closefile closefile pop PDFfile 3 -1 roll setfileposition % Some broken Adobe software produces PDF files in which % the FontName of the CFF font and the FontName in the % FontDescriptor don't match the BaseFont in the font. % Use the FontName, rather than the BaseFont, here. dup /FontDescriptor oget /FontName oget /CIDFont findresource addCIDmetrics dup /CIDFontName get exch /CIDFont defineresource } bind executeonly def % Read an embedded OpenType font. /readOTTOfont { % <font-resource> <stream-dict> readOTTOfont <font> 1 index exch % res res strdict PDFfile fileposition 3 1 roll % res pos res strdict dup //true resolvestream % res pos res strdict stream dup readfontfilter % res pos res strdict stream filter 3 index /FontDescriptor oget /FontName oget % res pos res strdict stream filter /name 1 index .init_otto_font_file % res pos res strdict stream filter /name filter' //true 6 index /CIDSystemInfo known % res pos res strdict stream filter /name filter' bool bool ReadData % res pos res strdict stream filter fontset { exch pop exit } forall % res pos res strdict stream filter font dup /FontType get 9 eq { % OpenType may contain simple CFF font, which is accesed as a CIDFont by PDF. % The font is converted to Type 9 CIDFont resource, which ignores CIDMap attribute. % The following code just shuffles GlyphDirectory to the same effect. 4 index /CIDToGIDMap knownoget { dup type /dicttype eq { 1 index /GlyphDirectory get exch % res pos res strdict stream filter font dir c2g //true resolvestream % res pos res strdict stream filter font dir c2g_file 256 dict begin 0 2 index 0 get def % copy .notdef 0 1 16#7fffffff { 1 index read not { pop exit } if % res pos res strdict stream filter font dir c2g_file cid hi 256 mul % res pos res strdict stream filter font dir c2g_file cid hi 2 index read not { pop pop exit } if % res pos res strdict stream filter font dir c2g_file cid hi lo add % res pos res strdict stream filter font dir c2g_file cid gid dup 0 ne { dup 4 index length lt { 3 index exch get % res pos res strdict stream filter font dir c2g_file cid charstr def % res pos res strdict stream filter font dir c2g_file } { pop pop } ifelse } { pop pop } ifelse } for closefile pop % res pos res strdict stream filter font dup length dict copy % res pos res strdict stream filter font' dup /GlyphDirectory currentdict put % res pos res strdict stream filter font' end dup /GlyphDirectory get 0 exch { pop .max } forall 1 index exch /CIDCount exch 1 add put } { pop } ifelse } if } if 7 1 roll % font res pos res strdict stream filter closefile closefile pop pop % font res pos PDFfile exch setfileposition % font res pop % font } bind executeonly def % ---------------- Font lookup ---------------- % % Some PDF files mis-identify font type of the embedded font streams or % include raw PFB font streams. Length1, Length2, Length3 may be wrong or % missing. Adobe Acrobat corrects these errors transparently to the user. % % We ignore the font type keys and recognize the font type by the 1st 4 bytes % of the font stream. The PFB stream is recognized by the 1st 2 bytes. /fonttypeprocs mark % <font-resource> -proc- <font> /Type0 //buildType0 /Type1 //buildType1 /MMType1 //buildType1 /Type3 /buildType3 load /TrueType //buildTrueType /CIDFontType0 //buildCIDType0 /CIDFontType2 //buildCIDType2 .dicttomark readonly def /adjustfonttypes mark /Type1 //adjustfont /MMType1 //adjustfont /TrueType //adjustfont /CIDFontType0 //adjustCIDType0 /CIDFontType2 //adjustCIDType2 .dicttomark readonly def % Bind a proc and define n names % /name ... /name {proc} n bndef - /bndef { exch bind executeonly exch { dup 3 1 roll def } repeat pop } bind executeonly def % <res> run-fonttypeproc <font> /run-fonttypeproc { dup /Subtype knownoget not { 0 } if % res /subtype //fonttypeprocs 1 index known not { ( Error: Font /Subtype attribute is wrong or missing, /Type1 assumed.\n) pdfformaterror ( Output may be incorrect.\n) pdfformaterror pop /Type1 2 copy /Subtype exch put } if //fonttypeprocs exch get exec } bind executeonly def % Prototype for all procedures: <res> <desc> <stream> foo <font> /font_tag_dict 13 dict begin % When the font stream is absent or cannot be read we load the font by the name. /no_stream { pop pop run-fonttypeproc } bind executeonly def /bad_stream { ( ** Error: Error reading font stream, attempting to load the font using its name\n) pdfformaterror ( Output may be incorrect.\n) pdfformaterror //no_stream exec } bind executeonly def <8001> % PFB { dup /PFB //true put exch pop readtype1 } bind executeonly def (%!PS) (%!Fo) % Type1 { exch pop readtype1 } 2 bndef <01000401> <01000402> <01000403> <01000404> % Type 1C <01000C02> <01000C03> { exch pop 1 index /Subtype knownoget dup { pop /CIDFontType0 eq } if { readCIDFontType0C } { readType1C } ifelse } 6 bndef <00010000> (true) (typ1) (ttcf) % TrueType OpenType { exch pop readtruetype } 4 bndef (OTTO) { exch pop readOTTOfont } bind executeonly def currentdict end readonly def currentdict /bndef undef % Used to create a hash for the XUID, ths combines the input PDF file name and the % object number (currently the object number of the FontDescriptor). NB we must % use an object number, as otherwise all fonts will have the same % XUID and Ghostscript will think they are the same font. Ths routine must not % be used unless we have an object number which is believed to be uniqe to % a particular font instance. /.CRCHashFilenameAndObject % object_number (filename) CRCHasFilename integer { dup % object_number (filename) (filename) length % object_number (filename) length 0 exch % object_number (filename) hash length 1 sub % object_number (filename) hash length-1 0 1 3 -1 roll % object_number (filename) hash 0 1 length-1 { % object_number (filename) hash index 2 index exch get % object_number (filename) hash char exch % object_number (filename) char hash dup 16#F8000000 and % object_number (filename) char hash top5bits -27 bitshift % object_number (filename) char hash top5>>27 exch 5 bitshift % object_number (filename) char top5>>27 hash<<5 16#7FFFFFFF and xor % object_number (filename) char CRC<hash> xor % object_number (filename) newhash } for exch pop % object_number newhash dup 16#F8000000 and % object_number newhash top5bits -27 bitshift % object_number newhash top5>>27 exch 5 bitshift % object_number top5>>27 newhash<<5 16#7FFFFFFF and xor % object_number CRC<newhash> xor % final hashed value }bind executeonly def % Either patch or create a new XUID based on the existing % XUID or UniqueID and incorporating the PDF object number % so we get an XUID we can use to improve cache efficiency % in multipage documents. /patch_font_XUID % <font dict> <patch> patch_font_XUID <font dict'> { dup //null eq {pop} { //pdfdict /InputPDFFileName .knownget {.CRCHashFilenameAndObject} if exch dup /.OrigUniqueIDXUID .knownget not { dup /XUID .knownget not { dup /UniqueID .knownget {1 array astore}{ [] } ifelse } if } if dup //null eq { pop exch pop } { [ 1000000 3 -1 roll 4 index exch {exch} forall ] exch //true .copyfontdict dup 3 -1 roll /XUID exch put exch pop .completefont } ifelse } ifelse } bind executeonly def /resourcefont % <font-resource> resourcefont <font> { dup /PSFont .knownget dup { pop /FID knownoget dup { pop type /fonttype eq } if } if { /PSFont get } { dup /Subtype get /Type0 eq { % if the font was defined in-line, we won't have a object number dup /.gs.pdfobj# .knownget not { //null } if } { dup /FontDescriptor knownoget { % if the font was defined in-line, we won't have a object number dup /.gs.pdfobj# .knownget not { //null }if dup //null eq { exch pop }{ exch dup /FontFile knownoget not { dup /FontFile2 knownoget not { dup /FontFile3 knownoget not { pop pop //null } {pop pop}ifelse } {pop pop}ifelse }{pop pop}ifelse }ifelse }{ //null } ifelse } ifelse 3 1 roll % In the event we have a Type 0 dictionary with a spurious % FontDescriptor object, remove it here to prevent confusion % later on. % Bug 691589 dup /Subtype get /Type0 eq 1 index /FontDescriptor known and { dup /FontDescriptor undef }if dup /CIDSystemInfo .knownget { oforce_recursive 1 index exch /CIDSystemInfo exch put } if dup dup /FontDescriptor knownoget { % font-res font-res font-desc % The same font descriptor can be reused in a CID and non-CID contexts. % Store CID and non-CID fonts under different keys. Bug 689301 1 index /Subtype knownoget dup { pop dup /CIDFontType0 eq exch /CIDFontType2 eq or } if { /CIDFontObject } { /FontObject } ifelse % font-res font-res font-desc /key 2 index 1 index .knownget { 4 1 roll pop pop pop % font-res obj } { 4 1 roll % /key font-res font-res font-desc dup /FontFile knownoget not { dup /FontFile2 knownoget not { dup /FontFile3 knownoget not { //null } if } if } if % /key res res desc stream dup //null ne { PDFfile fileposition mark { 2 index //true resolvestream dup 4 string readstring pop exch closefile } stopped { cleartomark /bad_stream } { exch pop } ifelse PDFfile 3 -1 roll setfileposition dup length 4 lt { pop /bad_stream } if } { /no_stream } ifelse % /key res res desc stream tag //font_tag_dict 1 index known not { dup 0 2 getinterval <8001> eq { 0 2 getinterval % /key res res desc stream pfb_tag } { (12345678>\n) dup /ASCIIHexEncode filter dup 4 -1 roll writestring closefile ( ** Error: unrecognized font file starts with <) exch concatstrings pdfformaterror ( Output may be incorrect.\n) pdfformaterror /no_stream % /key res res desc stream unknown_tag } ifelse } if //font_tag_dict exch get % /key res res desc stream {proc} { stopped } 0 get % /key res res desc stream {proc} --stopped-- count % /key res res desc stream {proc} --stopped-- # countdictstack % /key res res desc stream {proc} --stopped-- # ## PDFfile fileposition % /key res res desc stream {proc} --stopped-- # ## ### 5 array astore cvx % /key res res desc stream {{proc} --stopped-- # ## ###} exec 4 -1 roll { PDFSTOPONERROR not { PDFfile exch setfileposition countdictstack exch sub 0 .max { end } repeat count 4 add exch sub 0 .max { pop } repeat //null } { /resourcefont cvx /undefinederror signalerror } ifelse } { PDFfile exch setfileposition countdictstack exch sub 0 .max { end } repeat count 3 sub exch sub 0 .max { pop } repeat } ifelse dup //null eq { PDFSTOPONERROR not { pop ( Error: can't process embedded font stream,\n attempting to load the font using its name.\n) pdfformaterror ( Output may be incorrect.\n) pdfformaterror dup run-fonttypeproc % /key res font } { /resourcefont cvx /undefinederror signalerror } ifelse } if 1 index % /key res font res 4 -1 roll 2 index % res font desc /key font put % Save pointer to the font. } ifelse } { run-fonttypeproc } ifelse % Stack: font-res font 1 index exch 1 index /Subtype get //adjustfonttypes exch .knownget { exec } { exch pop } ifelse 4 -1 roll patch_font_XUID dup 3 1 roll /PSFont exch put } ifelse dup checkGlyphNames2Unicode } bind executeonly def currentdict /font_tag_dict .undef currentdict /fonttypeprocs .undef currentdict /adjustfonttypes .undef drawopdict begin /d0 { currentcolor currentcolorspace .swapcolors setcolorspace setcolor .swapcolors .adjustcharwidth setcharwidth } bind executeonly def /d1 { 2 copy % ... llx lly urx ury \| urx ury 0 ne exch 0 ne % ... llx lly urx ury \| ury!=0 urx!=0 3 index 6 index eq and % ... llx lly urx ury \| ury!=0 (urx!=0 && llx==urx) exch 2 index 5 index eq and or { % ... llx lly urx ury \| (urx!=0 && llx==urx) \|\| (ury!=0 && lly==ury) % The bounding box is empty and likely incorrect. Don't cache. pop pop pop pop //d0 exec } { currentcolor currentcolorspace .swapcolors setcolorspace setcolor .swapcolors 6 -2 roll .adjustcharwidth 6 2 roll setcachedevice } ifelse } bind executeonly def /Tf { 1 index Page /Font rget { dup type /dicttype eq { resourcefont exch Tf pop } { PDFSTOPONERROR { /typecheck cvx signalerror } { % Bug 689450 type ( Error: Tf refers to a resource key with an invalid value type: ) pdfformaterror .namestring pdfformaterror (. Assuming resource key: ) pdfformaterror 1 index .namestring pdfformaterror ( is a font name.\n) pdfformaterror ( Output may be incorrect.\n) pdfformaterror Tf } ifelse }ifelse } { PDFSTOPONERROR { pop /undefined cvx signalerror } { % Bug 689037 ( ** Error: Tf refers to an unknown resource name: ) pdfformaterror 1 index .namestring pdfformaterror ( Assuming it's a font name.\n) pdfformaterror ( Output may be incorrect.\n) pdfformaterror Tf } ifelse } ifelse } bind executeonly def end end % pdfdict end % GS_PDF_ProcSet .setglobal Back

Edit File : pdf_font.ps | Size : 89.57 KB

% Copyright (C) 2001-2019 Artifex Software, Inc.
% All Rights Reserved.
%
% This software is provided AS-IS with no warranty, either express or
% implied.
%
% This software is distributed under license and may not be copied,
% modified or distributed except as expressly authorized under the terms
% of the license contained in the file LICENSE in this distribution.
%
% Refer to licensing information at http://www.artifex.com or contact
% Artifex Software, Inc.,  1305 Grant Avenue - Suite 200, Novato,
% CA 94945, U.S.A., +1(415)492-9861, for further information.
%

% PDF font operations.

% Since PDF font are not unique and can collide with external font resources
% or each other, use font dictionaries obtained from PDF directly, never
% register them as resources or look them up by name. Use findfont oparator
% for non-embedded fonts only. CIDFont resources still use the old logic
% described below.

% Finding a font by name can't give a proper result when PDF font names aren't unique.
% But it is only the way to obtain a font in Postscript after a font file is executed.
% Therefore using a FontName (and findfont) is allowed only
% immediately after a font file is executed.
% In all other cases the font to be found by a pointer through PDF structures.
%
% This ideal logics can't work for documents,
% which define a font resource with an embedded font,
% and another font resource with same BaseFont but with no embedded font
% (and possibly with no font descriptor).
% Our testbase does contain such examples.
% In this case we do find font by FontName (with findfont),
% since there is no other way to get a reasonable result.

/.setlanguagelevel where { pop 2 .setlanguagelevel } if
.currentglobal //true .setglobal
/GS_PDF_ProcSet load begin	% from userdict at this point
pdfdict begin

% We cache the PostScript font in an additional element of the
% font resource dictionary, called PSFont.

% ---------------- Encodings ---------------- %

/.notdefEncoding 256 { /.notdef } repeat 256 packedarray def

% Apply a list of differences to an Encoding.
% Note that the differences may cause the array to grow.
/updateencoding {	% <encoding|null> <differences> updateencoding <enc'>
 % Calculate the length of the result.
 % in case the incoming Encoding is null, use .notdefEncoding
 exch dup //null eq { pop .notdefEncoding } if
 0 0 3 index {
 dup type /nametype ne { exch pop oforce } { pop 1 add } ifelse
 % Differences list may not be in order, update the largest_index
 % stack: <Differences> <encoding> <largest_index> <at_index>
 2 copy lt { exch pop dup } if	% at_index is new largest
 } forall
 pop 1 index length .max array dup 0 4 -1 roll putinterval
 exch 0 exch {
 % Stack: enc' code element
 dup type /nametype ne
 { exch pop oforce }
 { 3 copy put pop 1 add }
 ifelse
 } forall pop
} bind executeonly def

/good_encoding_names <<
 /MacRomanEncoding 0 /MacExpertEncoding 0 /WinAnsiEncoding 0
>> readonly def

/known_symbolic_fonts <<
 /Wingdings2 0
 /ZapfDingbats 0
>> readonly def

% Get the Encoding for a font.
/getencoding		% <base-encoding> <font-resource> getencoding <enc>
 { dup /Encoding knownoget
 { dup type /nametype eq
 {
 % The published PDF specification says the Encoding name
 % "must be" one of the 3 predefined Encodings, implying
 % that an error should occur if it isn't. However, Acrobat
 % Reader simply ignores unknown names, and since there are
 % some buggy applications that rely on this, we do the same.

//good_encoding_names 1 index known {
           exch /BaseFont knownoget not { 0 } if
           % Ignore named encodings for known symbolic fonts. See bug 690135.
           //known_symbolic_fonts exch known {
             pop
           } {
             exch pop findencoding
           } ifelse
         } {
           pop pop
         } ifelse
       }
       { exch pop
         dup type /arraytype eq
         { exch pop
           (   **** Warning: Encoding is an array, not name or dictionary.\n)  pdfformatwarning
         }
         { dup /BaseEncoding knownoget
             {
               %% Originally we ignored the specific invalid name '/' here from Bug #687786, however
               %% Bug #696942 contains an invalid BaseEncoding '/utf-8', so now we check all BaseEncoding
               %% against the permitted names, just as we do for Encodings.
               //good_encoding_names 1 index known{
                 findencoding 3 -1 roll pop exch
               }{
                 (   **** Error: Invalid BaseEncoding name ") print 256 string cvs print (" ignoring BaseEncoding.\n)  pdfformaterror
                 (               Output may be incorrect.\n) pdfformaterror
               }ifelse
             } if
           /Differences knownoget { updateencoding } if
         }
         ifelse
       }
       ifelse
     } {
       pop
       (   **** Error: Encoding not present.\n)  pdfformaterror
       (                 Output may be incorrect.\n) pdfformaterror
     }
     ifelse
 } bind executeonly def

currentdict /good_encoding_names undef
currentdict /known_symbolic_fonts undef

/checkGlyphNames2Unicode % <dict> checkGlyphNames2Unicode -
{
 PDFDEBUG {
 dup /FontInfo .knownget {
 /GlyphNames2Unicode .knownget {
 (Has GlyphNames2Unicode) =
 pop % { exch //== exec //== exec} forall
 } if
 } if
 } if
 pop
} bind executeonly def

% Define a font using it's FontName as the key.
% Adjust a font according to the Encoding and Widths in the font resource.
/adjustfont {		% <font-resource> adjustfont <font'>
 getfontencoding
 3 copy .processToUnicode
 getfontmetrics 5 -1 roll pop .updatefont {
 %% Bug #696306 has a broken type 1 font where the eexec encrypted portion simply ends
 %% leaving a partial glyph description and, more importantly, the Private dictionary
 %% on the operand stack. Ths means the font dictonary does not contain a Private
 %% dictionary which causes .buildfont1 to throw an error. .completefont calls .buildfont1
 %% (which is obscured by a definition in gs_type1.ps) so we need to check the reault
 %% of .completefont. If it fails we must discard the font dictionary and use a fallback.
 {.completefont} stopped {
 (\n *** ERROR: The font ) print /FontName get 256 string cvs print ( is damaged and cannot be used. Switching to a\n) pdfformaterror
 ( last-ditch fallback, text may not render correctly, or at all.\n\n) pdfformaterror
 /Helvetica findfont
 }if
 } if
} bind executeonly def

% Get the (possibly modified) encoding of a font.
/getfontencoding {	% <font-resource> getfontencoding
 % <font-resource> <Encoding|null>
 % Ignore encoding when TrueType is requested
 % and loaded from an embedded stream.
 % All other cases are left unchanged.
 dup /FontType get 42 eq 1 index /PathLoad known not and
 2 index /Subtype get /TrueType eq and {
 //null
 } {
 % Acrobat appears to be always using StandardEcoding as the
 % default encoding for some non-symbolic fonts (rather than,
 % as the spec states, the encoding specified by the font).
 % As this is contrary to spec, and we only have a CFF
 % example, I've restricted this to fonts with Subtype Type1C
 % *and* that result in a Type 2 PS font.
 1 index /FontDescriptor knownoget
 {
 dup
 % Unfortunately, Acrobat doesn't enforce the meaning of
 % FontFile[23] so whilst, in theory, Type1C should only
 % occur in FontFile3, we can't rely on that.
 dup /FontFile knownoget not
 {
 dup /FontFile2 knownoget not
 {
 dup /FontFile3 knownoget not {1 dict} if
 } if
 } if
 exch pop /Subtype knownoget {/Type1C eq}{//false} ifelse
 exch /Flags knownoget {4 and 4 eq not}{//false}ifelse and
 } {//false} ifelse

1 index /FontType get 2 eq and
    {
        2 index /Encoding knownoget {pop StandardEncoding 2 index getencoding} { //null } ifelse
    }
    {
      2 index /Encoding known {
        dup /Encoding knownoget { 2 index getencoding } { //null } ifelse
      } {
        //null
      } ifelse
    } ifelse
  } ifelse
} bind executeonly def

% Returns true if the current glyph is in the Differences array at
% the specified index value. This is needed because the Widths
% array may map to the same glyph at different positions from the
% Encoding. We want to use the Width that was associated with the
% one specified in the Encoding::Differences list.
/match_in_diff % <Differences> <index> <glyphname> match_in_diff <bool>
{ //false 4 1 roll 0 4 -1 roll	% stack: false index glyphname at_index==0 Differences
 { exch 1 index type /nametype ne {
 % stack: false index glyphname Diff_element at_index
 pop	% Diff_element is new at_index
 } {
 % stack: false index glyphname Diff_element at_index
 exch 2 index eq {
 % stack: false index glyphname at_index
 dup 3 index eq {
 //true 5 1 roll % stack: true false index glyphname at_index
 pop exit
 } if
 } if
 1 add		% at_index++ stack: false index glyphname at_index'
 } ifelse
 } forall
 % stack: true false index glyphname
 % or : false index glyphname at_index
 pop pop pop
} bind executeonly def

/unique_name { % <dict> </root> unique_name </unique>
 %
 % Note : this function interacts with pdf_write_encoding in src/gdevpdtw.c
 % and with copied_drop_extension_glyphs in src\gxfcopy.c
 % by adding a reserved substring (~GS~).
 %
 .namestring % <<>> (root)
 0 1 65535 {
 5 string cvs % <<>> (root) (0)
 (~GS~) exch concatstrings
 1 index exch % <<>> (root) (root) (~GS~0)
 concatstrings % <<>> (root) (root~GS~0)
 dup % <<>> (root) (root~GS~0) (root~GS~0)
 3 index exch % <<>> (root) (root~GS~0) <<>> (root~GS~0)
 known not {
 exch pop exit % <<>> (root~GS~0)
 } if
 pop
 } for
 exch pop cvn % /root0
} bind executeonly def

% Get the metrics of a font, if specified.
/getfontmetrics { % <font-resource> <Encoding|null> getfontmetrics
 % <font-resource> <Encoding|null>
 % <Metrics|null> <GlyphMap|null>
 2 index /Widths oknown {
 dup //null eq { pop dup /Encoding get } if
 7 dict begin
 dup length dict
 /Metrics exch def
 /Encoding exch def
 /GlyphMap //null def
 exch
 dup /Widths oget /Widths exch def
 % Stack: font font-res
 % Note that widths are always based on a 1000-unit
 % character space, but the FontMatrix may specify
 % some other scale factor. Compensate for this here,
 % by scaling the Widths if necessary.
 0.001 2 index /FontMatrix get 0 get
 dup 0 eq {
 % FontMatrix.xx == 0, so we cannot scale down by xx.
 % - FontMatrix[0] == 0 implies either FontMatrix[1] <> 0 or
 % FontMatrix cannot be inverted. In the 1st case we have
 % FontMatrixNonHV == true and will render text with cshow + xshow.
 % In the 2nd case, metrics in the PDF Font object cannot be enforced
 % [by altering metrics in PS glyph space].
 % HACK:
 % - we scale down by FontMatrix[1];
 % - given the format of Metrics entries we use, wy = 0 in glyph space;
 % - as a result, the cshow procedure receives as wy the value we
 % need for wx (all of this in PS user space).
 pop
 2 index /FontMatrix get 1 get
 dup 0 eq { pop 1 } if % sorry, no way to enforce PDF metrics by altering the font
 } if
 div
 % Stack: font font-res mscale
 /FirstChar 2 index /FirstChar knownoget not {
 ( **** Warning: /FirstChar attribute is missing, assuming 0.\n) pdfformatwarning
 0
 } if def
 /LastChar 2 index /LastChar knownoget not {
 ( **** Warning: /LastChar attribute is missing, assuming 255.\n) pdfformatwarning
 255
 } if def

Encoding length LastChar le {
         (   **** Warning: Font Encoding array size is smaller than character range.\n)
         pdfformatwarning
      } if

1 index /FontDescriptor knownoget {
           /MissingWidth knownoget not { 0 } if
        }
        { 1000
        }
      ifelse /MissingWidth exch def

Widths length LastChar FirstChar sub le {
         (   **** Warning: Font Widths array size is smaller than character range.\n)
         pdfformatwarning
         /Widths [Widths aload length LastChar FirstChar sub exch sub MissingWidth exch {dup} repeat] def
      } if
      FirstChar

0 Encoding
       {        % Stack: font font-res mscale first-char index charname

1 index FirstChar lt { MissingWidth } {
           1 index LastChar gt { MissingWidth } { Widths 2 index FirstChar sub get } ifelse
         } ifelse
         oforce

% Stack: font font-res mscale first-char index charname width
         4 index mul
                % The following 'loop' is only context for 'exit'.
         {
                % Work around a bug in pdfTeX, which can generate Encoding
                % vectors containing nulls :
           1 index //null eq { exit } if
           Metrics 2 index .knownget {
             1 index ne
           } {
             //false
           } ifelse {
             % Two or more Encoding elements refer same glyph name,
             % and Widths specify different wihts for it.
             % Since a Postscript font can't have different
             % Metrics for same glyph name,
             % we generate an unique name, and create a new
             % Charstrings entry with same glyph value.
             GlyphMap //null eq {
               /Encoding Encoding dup length array copy def
               /GlyphMap 4 dict def
             } if
             % To prevent too many new names, check whether
             % we can use one already created for same glyph.
             //true
             GlyphMap {                           % f r s c i n w b n1 n2
               4 index eq {                       % f r s c i n w b n1
                 dup Metrics exch get             % f r s c i n w b n1 w1
                 3 index eq {                     % f r s c i n w b n1
                   4 3 roll pop                   % f r s c i w b n1
                   3 1 roll pop                   % f r s c i n1 w
                   Encoding 3 index 3 index put
                   //false                        % f r s c i n1 w b
                   exit
                 } {
                   pop
                 } ifelse
               } {                                % f r s c i n w b n1
                 pop
               } ifelse
             } forall                             % f r s c i n w b
             { % Do create a new name.
               Metrics 2 index //unique_name exec % f r s c i n w nn
               Encoding 4 index 2 index put
               GlyphMap 1 index 5 -1 roll put     % f r s c i w nn
               exch
                  % Stack: font font-res mscale first-char index new_name width
             } if
           } if
           2 copy Metrics 3 1 roll put
           exit
         } loop
         pop pop
         1 add
       }
     forall pop pop pop
     exch Encoding Metrics GlyphMap end
  } {
    //null //null
  } ifelse
} bind executeonly def

currentdict /unique_name undef
currentdict /match_in_diff undef

/ToUnicodeCMapReader 4 dict begin
 /defineresource % <name> <dict> <cat-name> defineresource <dict>
 {
 pop
 dup userdict exch /.lastToUnicode exch put
 exch pop
 } bind executeonly def

/CIDSystemInfo
  {
    (   **** Warning: ToUnicode CMap has invalid syntax near CIDSystemInfo.\n)  pdfformatwarning
    /CIDSystemInfo
  } bind executeonly def % A work around a bug in Altona.Page_3.2002-09-27.pdf - a slash is missed.

/CMapName
  {
    (   **** Warning: ToUnicode CMap has no CMapName.\n\
        See the comment to revision 6201 in gs/doc/ps2pdf.htm#Problems .\n) pdfformatwarning
    /CMap1   % arbitrary, PDF defineresource tolerates non-unique names
  } bind executeonly def % A work around incorrect ToUnicode CMap generated by GS before rev. 6201.

% Split large ranges into smaller chunks to stay withing the limits
  % of various PS% objects and speed up operand stack manipulation,
  %  esp. "counttomatk -3 roll". Bug 691908.
  /beginbfrange {
    { pop
      mark
       256 {
        currentfile token not { /endbfrange exit } if
        dup /endbfrange eq { exit } if
        currentfile token not { pop /endbfrange } if
        currentfile token not { pop pop /endbfrange } if
        dup ([) eq {
          pop [
          { currentfile token not { exit } if
            dup (]) eq { pop exit } if
          } loop ]
        } if
      } repeat
      dup /endbfrange eq {
        pop endbfrange exit
      } {
        endbfrange
        mark
      } ifelse
    } loop
  } bind executeonly def
currentdict end readonly def

/string2number % <string> string2number <number>
{ 0 exch dup 0 exch 1 exch length 1 sub { % n () i
 1 index exch get % n () v
 3 2 roll 256 mul add exch % v+n*256 ()
 } for
 pop % N
} bind executeonly def

/copy&def % <key> <value> <bool> copy&def -
{
 { //true
 } {
 currentdict gcheck {
 dup gcheck not
 } {
 //false
 } ifelse
 } ifelse
 { currentglobal currentdict gcheck setglobal
 exch dup length string copy exch
 setglobal
 } if
 def
} bind executeonly def

/.convert_ToUnicode-into-g2u % <GlyphNames2Unicode> <Encoding|null> <CMap> .convert_ToUnicode-into-g2u -
{
 CMAPDEBUG {
 (.convert_ToUnicode-into-g2u beg) =
 } if
 3 2 roll begin
 /.CodeMapData get % About the data format see gs_cmap.ps, the comment after "CMap operators".
 1 get % code maps
 {
 CMAPDEBUG {
 dup //== exec
 } if
 dup length 1 sub 0 exch 5 exch { % e [] i
 2 copy get % e [] i (prefix)
 string2number % e [] i prefix
 2 index 2 index 1 add get % e [] i prefix (key_size,?is_range,value_type,value_size)
 dup 0 get 8 mul % e [] i prefix (key_size,?is_range,value_type,value_size) key_size*8
 3 2 roll exch bitshift exch % e [] i prefix<<key_size*8 (key_size,?is_range,value_type,value_size)
 dup 0 get exch 3 get % e [] i offset key_size value_size
 4 index 4 index 2 add get % e [] i offset key_size value_size (keys)
 5 index 5 index 3 add get % e [] i offset key_size value_size (keys) (values)
 CMAPDEBUG {
 ( offset=) print 4 index =string cvs print
 ( key_size=) print 3 index =string cvs print
 ( value_size=) print 2 index =
 ( keys=) print 1 index //== exec
 ( values=) print dup //== exec
 } if
 1 index length 0 eq {
 % A single pair.
 exch pop exch pop exch pop exch % e [] i (values) offset
 4 index //null ne {
 4 index length 1 index gt {
 4 index exch get
 } if
 } if % e [] i (values) cid|name
 exch
 CMAPDEBUG {
 ( defined single: ) print 1 index =string cvs print ( ) print dup //== exec
 } if
 //false copy&def % e [] i
 pop % e []
 } {
 % A range. % e [] i offset key_size value_size (keys) (values)
 dup length string copy % protect the original string from modifications below.
 0 4 index 2 mul 3 index length 1 sub { % e [] i offset key_size value_size (keys) (values) j
 2 index 1 index 6 index getinterval
 string2number % e [] i offset key_size value_size (keys) (values) j keyL
 CMAPDEBUG {
 ( keyL=) print dup =string cvs print
 } if
 3 index 2 index 7 index add 7 index getinterval
 string2number % e [] i offset key_size value_size (keys) (values) j keyL keyH
 CMAPDEBUG {
 ( keyH=) print dup =
 } if
 3 2 roll 6 index idiv 5 index mul % e [] i offset key_size value_size (keys) (values) keyL keyH J
 3 index exch 6 index getinterval % e [] i offset key_size value_size (keys) (values) keyL keyH (valueL)
 3 1 roll 1 exch { % e [] i offset key_size value_size (keys) (values) (value) k
 9 index //null ne {
 9 index exch get % e [] i offset key_size value_size (keys) (values) (value) name
 } if % e [] i offset key_size value_size (keys) (values) (value) cid|name
 1 index % e [] i offset key_size value_size (keys) (values) (value) cid|name (value)
 CMAPDEBUG {
 ( defined from range: ) print 1 index =string cvs print ( ) print dup //== exec
 } if
 //true copy&def % e [] i offset key_size value_size (keys) (values) (value)

%% Calculate the value from the last string
            dup dup length 1 sub 0 exch 0 1 3 -1 roll
            {
              % (string) value index
              exch 256 mul exch
              2 index exch get add
            } for

%% and increment the value for the next string
            1 add

%% Now convert the value into a string of bytes.
            1 index length 1 sub 1 exch 0 1 3 -1 roll
            {
              % (string) value divisor index
              2 index 2 index idiv 255 and % (string) value divisor index byte
              exch 4 index length 1 sub exch sub % (string) value divisor byte string_position
              5 index                      % (string) value divisor byte string_position (string)
              exch 3 -1 roll put           % (string) value divisor
              256 mul
            } for
            pop pop pop
          } for                                % e [] i offset key_size value_size (keys) (values) (value)
        } for
        pop pop pop pop pop pop pop            % e []
      } ifelse
    } for
    pop                                        % e
  } forall
  end
  pop                                          %
  CMAPDEBUG {
    (.convert_ToUnicode-into-g2u end) =
  } if
} bind executeonly def

/.DoToUnicode?
{
  /IgnoreToUnicode where
  {/IgnoreToUnicode get not}
  {//true} ifelse
} bind executeonly def

/.processToUnicode % <font-resource> <font-dict> <encoding|null> .processToUnicode -
{
 //.DoToUnicode? exec
 {
 currentdict count 1 sub /.stackdepth exch .forceput
 currentdict countdictstack /.dstackdepth exch .forceput
 {
 1 index /FontType get 0 eq
 {
 1 index /FDepVector get 0 get
 dup /FontType .knownget not
 {
 dup /CIDFontType .knownget
 { dup 2 eq {pop 11} if }
 {-1} % just some value that's not a valid font type
 ifelse
 }if
 11 eq
 { /Path known}
 {pop //false}
 ifelse
 }
 {//false} ifelse
 % Currently pdfwrite is only device which can handle GlyphNames2Unicoide to
 % generate a ToUnicode CMaps. So don't bother with other devices.
 /WantsToUnicode /GetDeviceParam .special_op {
 exch pop
 }{
 //false
 }ifelse
 or
 {
 PDFDEBUG {
 (.processToUnicode beg) =
 } if
 2 index /ToUnicode knownoget {
 dup type /dicttype eq { dup /File known not } { //true } ifelse {
 % We undefine wrong /Length and define /File in stream dictionaries.
 % Bug687351.pdf defines /ToUnicode /Identity-H, what is incorrect.
 ( **** Warning: Ignoring bad ToUnicode CMap.\n) pdfformatwarning
 pop
 } {
 /PDFScanRules .getuserparam dup //null eq {
 pop //PDFScanRules_null
 } {
 1 dict dup /PDFScanRules 4 -1 roll put
 } ifelse
 //PDFScanRules_true setuserparams
 PDFfile fileposition
 3 -1 roll
 count 1 sub
 countdictstack
 { //false resolvestream
 % Following Acrobat we ignore everything outside
 % begincodespacerange .. endcmap.
 dup 0 (begincodespacerange) /SubFileDecode filter flushfile
 /CIDInit /ProcSet findresource begin
 //ToUnicodeCMapReader begin
 12 dict begin
 /CMapType 2 def
 mark exch % emulate 'begincodespacerange'
 0 (endcmap) /SubFileDecode filter cvx /begincmap cvx exch 2 .execn
 endcmap
 userdict /.lastToUnicode currentdict put
 end end end
 }

PDFSTOPONERROR {
              { exec } 0 get
              //false
              5 -2 roll
              5
            } {
              { stopped } 0 get
              4 2 roll
              4
            } ifelse
            array astore cvx exec

countdictstack exch sub 0 .max { end } repeat
            count exch sub 2 sub 0 .max { exch pop } repeat
            3 1 roll                     % Stach the stop flag.
            PDFfile exch setfileposition
            setuserparams
            {
              (   **** Warning: Failed to read ToUnicode CMap.\n)  pdfformatwarning
            } {
              1 index /FontInfo .knownget not {
                currentglobal 2 index dup gcheck setglobal
                /FontInfo 5 dict dup 5 1 roll .forceput
                setglobal
              } executeonly if
              dup /GlyphNames2Unicode .knownget not {
                //true                        % No existing G2U, make one
              } {
                dup wcheck {
                  //false                     % Existing, writeable G2U, don't make new one
                } {
                  pop //true                          % Existing read only G2U, make new one
                } ifelse
              } ifelse
              {
                currentglobal exch dup gcheck setglobal
                dup /GlyphNames2Unicode 100 dict dup 4 1 roll .forceput
                3 2 roll setglobal
              } if                                 % font-res font-dict encoding|null font-info g2u
              exch pop exch                        % font-res font-dict g2u encoding|null
              userdict /.lastToUnicode get         % font-res font-dict g2u Encoding|null CMap
              .convert_ToUnicode-into-g2u          % font-res font-dict
              //null                               % font-res font-dict //null
            } ifelse
          } ifelse
        } if
        PDFDEBUG {
          (.processToUnicode end) =
        } executeonly if
      } executeonly if
    } executeonly stopped
    {
      .dstackdepth 1 countdictstack 1 sub
      {pop end} for
      .stackdepth 1 count 3 sub
      {pop pop} for
    } if
    pop pop pop
    currentdict /.stackdepth .forceundef
    currentdict /.dstackdepth .forceundef
  } executeonly
  {pop pop pop}
  ifelse

} bind executeonly odef

currentdict /.DoToUnicode? .forceundef

% ---------------- Descriptors ---------------- %

% Partial descriptors for the 14 built-in fonts.  Note that
% from PDF 1.1 to PDF 1.2, the meaning of the Flag 6 in the FontDescriptor
% object has undergone a subtle change in its meaning which has serious
% consequences for searching with Acrobat:
% In PDF 1.1, the flag meant: Font has StandardEncoding
% In PDF 1.2, the flag means: Font has (subset of) StandardRomanCharacterSet
/standardfontdescriptors mark
  /Courier mark /Flags 16#23 .dicttomark
  /Courier-Oblique 1 index
  /Courier-Bold 1 index
  /Courier-BoldOblique 1 index
  /Helvetica mark /Flags 16#20 .dicttomark
  /Helvetica-Oblique 1 index
  /Helvetica-Bold 1 index
  /Helvetica-BoldOblique 1 index
  /Times-Roman mark /Flags 16#22 .dicttomark
  /Times-Bold 1 index
  /Times-Italic mark /Flags 16#62 .dicttomark
  /Times-BoldItalic 1 index
  /Symbol mark /Flags 16#4 .dicttomark
  /ZapfDingbats 1 index
.dicttomark readonly def

% ---------------- Utilities ---------------- %

/.pdforigfontcache_g 20 dict def
currentglobal //false setglobal
systemdict /.pdforigfontcache_l 20 dict .forceput
setglobal

% Find an original font, using cache to prevent adjustfont to accumulate changes.
/pdffindcachedfont { % <font_name> pdffindcachedfont 
 dup //.pdforigfontcache_g exch .knownget {
 exch pop
 } {
 dup .pdforigfontcache_l exch .knownget {
 exch pop
 } {
 dup findfont dup
 dup gcheck { //.pdforigfontcache_g } { .pdforigfontcache_l } ifelse
 % Stack : font_name font font cache
 4 2 roll .growput
 } ifelse
 } ifelse
} bind executeonly def

% Add original font to cache to prevent adjustfont to accumulate changes.
/pdfaddcachedfont { % <font_name> pdfaddcachedfont 
 dup findfont dup % name font font
 dup gcheck { //.pdforigfontcache_g } {.pdforigfontcache_l} ifelse
 4 2 roll % font d name font
 put % font
} bind executeonly def

/.remove_font_name_prefix { % <name> .remove_font_name_prefix <name>
 dup .namestring (+) search {
 //true exch
 { dup 65 lt exch 90 gt or {
 pop //false exit
 } if
 } forall
 { pop exch pop cvn
 } {
 pop pop
 } ifelse
 } {
 pop
 } ifelse
} bind executeonly def

% Find a font (except for embedded ones), and adjust its encoding if necessary.
/.pdfdfndict mark
 /defaultfontname /Helvetica
.dicttomark readonly def
/pdffindfont {		% <font-resource> <fontname> pdffindfont 
 % If the font isn't available, synthesize one based on
 % its descriptor.
 dup /Font resourcestatus {
 pop pop pdffindcachedfont
 } {
 1 index /FontDescriptor knownoget {
 % Stack: font-res fontname fontdesc
 dup /Flags oget
 dup 16#40 and -6 bitshift		% 1, oblique/italic
 1 index 16#40000 and -17 bitshift add	% 2, bold
 exch 16#2 and 2 bitshift add	% 8, serif
 % We should look at the fixed flag, too.
 % Stack: font-res fontname fontdesc properties

% Even though /FontName is a required key in FontDescriptor dict
                % (As of the PDF 1.4 Reference Manual), In the case of missing
                % /FontName key, we substitue /BaseFont for the value of /FontName.
                % Yet another case of broken PDF's that Adobe Reader accepts.
      1 index dup /FontName known {
        /FontName oget
        dup type /nametype ne {
          (   **** Error: /FontName in FontDescriptor is not a name.\n)
          pdfformaterror
          (               Output may be incorrect.\n) pdfformaterror
          cvn
        } if
      } {
        (   **** Error: FontDescriptor missing required /FontName key. BaseFont name used.\n)
        pdfformaterror
        (               Output may be incorrect.\n) pdfformaterror
        pop 2 index		% grab the BaseFont from the stack.
      } ifelse
      .remove_font_name_prefix
      exch
                % Analyzes font name and extract "Bold" and "Narrow" properties
                % which are not described by the FontDescriptor Flags.
                % We also allow the font name analysis to override the Flags setting
                % for Italic/Oblique as this gives us results more consistent with
                % Acrobat.
      0 2 index //.fontnameproperties exec 7 and or
                % Rebind the default font name to Helvetica so that
                % fonts with no properties are handled correctly.
      //.pdfdfndict begin .substitutefontname end
                % Stack: font-res fontname fontdesc substname|null
      Fontmap 1 index known
      {//false}
      { .buildnativefontmap pop NativeFontmap 1 index known not} ifelse

{
                % No available good substitution, use the standard one.
        pop 1 index .substitutefont
      } if
      dup 3 index ne QUIET not and {
        (Substituting font ) print dup =only
        ( for ) print 2 index =only (.) = flush
      } if
      pdffindcachedfont
                % Stack: font-res fontname fontdesc font

% Some non-compliant files are missing FirstChar/LastChar,
      % despite referencing a non-base14 font
      3 index /FirstChar knownoget
      {
        0                                       % push an initial value for accumating the Widths
        0 string                                % and an empty string to interrogate the font
        7 index /Widths knownoget
        {
          0 1 2 index length 1 sub
          {
            dup 2 index exch get
            dup type /packedarraytype eq {exec} if % Handle entries which are indirect references (seriously ? !!)
            dup 0 gt                              % We ignore entries of zero in the widths array
            {
              exch 5 index add                    % add FirstChar to the idx to get a char code
              dup 64 gt 1 index 91 lt and         % we only want to consider A~Z and....
              1 index 96 gt 2 index 123 lt and or % ... a~z
              {
                exch
                5 -1 roll add 4 1 roll            % add the width to the accumulator on the stack
                1 string dup 0 4 -1 roll put
                3 -1 roll concatstrings exch      % add the char code to the string
              }
              {
                pop pop
              } ifelse
            }
            {
               pop pop
            } ifelse
          } for
          pop           % get rid of the Widths array
          3 -1 roll pop % get rid of the FirstChar value
          dup length dup 0 gt
          {
            3 -1 roll exch div % calculate an average width from the Widths array

gsave
            2 index 10 scalefont setfont
            exch dup length exch stringwidth
            grestore
            pop 100 mul exch div div
            % Only make the font smaller/narrower, not larger/wider
            dup 1.0 lt
            {
              0 0 2 index 0 0 6 array astore
              exch //true .copyfontdict
              dup /FontMatrix get 3 -1 roll matrix concatmatrix
              exch dup 3 -1 roll /FontMatrix exch put
              % we don't need to definfont here, we can leave that to .completefont below
            }
            {
              pop
            } ifelse
          }
          {
            % no suitable Widths entries - carry on and hope for the best......
            pop pop pop
          } ifelse
        }
        {
          % Broken file: no Widths array for non-base14 font - carry on and hope for the best......
          (   **** Warning: Widths array missing in FontDescriptor for non-base14 font\n)
          pdfformatwarning
          pop pop pop
        } ifelse
      }
      {
        (   **** Warning: FirstChar value missing in FontDescriptor for non-base14 font\n)
        pdfformatwarning
      } ifelse
                % Stack: font-res fontname fontdesc font
                % If this is a small-caps font, replace the CharString
                % entries for a..z.

exch /Flags oget 16#20000 and 0 ne {
        //true .copyfontdict
        dup /CharStrings 2 copy get dup length dict .copydict
        % stack: font-res fontname font font /CharStrings CharStringsdict
        5 index /FirstChar get 97 .max
        6 index /LastChar get 122 .min 1 exch {
                % Stack: font-res fontname font' font' /CharStrings charstrings code
                % Note that this only remaps a-z, not accented characters.
          6 index /Widths oget 1 index 8 index /FirstChar get sub oget
          1 string dup 0 5 -1 roll put
                % Stack: font-res font' font' /CharStrings charstrings code
                %   width (x)
          2 index exch dup cvn exch
          dup 0 2 copy get 32 sub put 4 -1 roll {
                        % Stack: operand (X) width
            0 setcharwidth exch pop
            currentfont /FontMatrix get matrix invertmatrix concat
            0.7 dup scale 0 0 moveto show
          } /exec cvx 4 packedarray cvx put
        } for put
      } if
      dup /FontName get 2 index ne {
        //true .copyfontdict
        2 copy exch /FontName exch put
      } if
      exch pop .completefont
    } {
                % No descriptor available, use the default algorithm.
      pdffindcachedfont
    } ifelse
  } ifelse
  exch pop
} bind executeonly def

% ---------------- Type 1 fonts ---------------- %

/buildType1		% <Type1-font-resource> buildType1 
 { dup /BaseFont get pdffindfont
 } bind executeonly def

% Read an embedded Type 1 font.
/readfontfilter {	% <proc> readfontfilter <filter>
 0 () /SubFileDecode filter
} bind executeonly def

% Adobe Acrobat doesn't skip space characters after eexec
/eexec_pdf_param_dict mark
  .eexec_param_dict {} forall
  /keep_spaces //true
.dicttomark readonly def

% When Type 1 font reading procedure is executing, a copy of this dictionary is current.
% topFontDict allows us to *attempt* to handle the case where a Type 1 font definition
% does not start by creating it's own dictionary (i.e. a number of the keys end up in
% the currentdict rather than the font dictionary).
% The whole type1 stream can be executed directly. There's no need to process
% Length1, 2, 3 keys.

/readtype1dict 10 dict dup begin
  /prev_definefont /definefont load def

/definefont {
    % if a font defines any keys outside it's own dictionary,
    % this attempts to cope by copying them into the font dictionary
    [
      /FontType    % in PLRM order
      /FontMatrix
      /FontName
      /FontInfo
      /WMode
      /Encoding
      /FontBBox
      /UniqueID
      /XUID
      /PaintType
      /StrokeWidth
      /Metrics
      /Metrics2
      /CDevProc
      /CharStrings
      /Private
      /WeightVector
    ]
    {
      2 copy known
      {pop}
      {
        dup where
        {
          1 index get
          2 index
          3 1 roll put
          dup /MisplacedKey 0 put
        }
        {pop} ifelse
      } ifelse
    } forall
    dup /MisplacedKey known {
      (   **** Warning: Type 1 font defines some required keys outside the font dictionary.\n)
      pdfformatwarning
    } if

dup /CharStrings get /.notdef known not {
 dup /CharStrings get
 /.notdef <9E35CED7FFD3622F09> put
 ( **** Warning: Type 1 font has no /.notdef entry in /CharString dictionary.\n)
 pdfformatwarning
 } if
 dup /UniqueID .knownget {
 dup dup 0 lt exch 16#ffffff gt or {
 ( **** Warning: Ignoring invalid /UniqueID = ) exch =string cvs
 concatstrings (\n) concatstrings pdfformatwarning
 dup /UniqueID undef
 } {
 pop
 } ifelse
 } if
 prev_definefont
 } bind executeonly def

/undef_proc_warning {
    /Repaired //true store     % flag that we have warnings
    UndefProcList exch 2 copy .knownget { 1 add } { 1 } ifelse put
  } bind executeonly def

/missing-type1-procs 6 dict begin
    /-| { string currentfile exch readstring pop /-| //undef_proc_warning exec } executeonly bdef
    /RD { string currentfile exch readstring pop /RD //undef_proc_warning exec } executeonly bdef
    /|- { noaccess def /|- //undef_proc_warning exec } executeonly bdef
    /ND { noaccess def /ND //undef_proc_warning exec } executeonly bdef
    /|  { noaccess put /|  //undef_proc_warning exec } executeonly bdef
    /NP { noaccess put /NP //undef_proc_warning exec } executeonly bdef
  currentdict end readonly def

/eexec {
        % Assume the font dictionary is directly below the file on the stack
    count 0 gt { /topFontDict 2 index cvlit store } if
    //eexec_pdf_param_dict /eexecDecode filter

//missing-type1-procs begin
    /userdict .systemvar begin
    //systemdict begin
    readtype1dictcopy begin cvx stopped

currentfile flushfile % Skip the trailer after return from eexec, bug 690701.
    { currentdict end //missing-type1-procs eq { exit } if } loop
    { stop } if
  } bind executeonly def

/readonly-op-dict <<
 /stringtype 0
 /arraytype 0
 /packedarraytype 0
 /dicttype 0
 >> readonly def

/readonly { % bug 689617
    dup type //readonly-op-dict exch known not {
      (   **** Warning: Type 1 font applies operator readonly to an invalid object type.\n)
      pdfformatwarning
    } if
  } bind executeonly def

/prev_get /get load def

/get {
    dup /FontName eq {
      % No warning, probably FontName is defined elsewhere; see definefont above.
      .knownget not { /Missing } if
    } {
      dup /UniqueID eq {
        % We don't want fonts to check /UniqueID and do 'restore'.
        pop pop 16#FEDCBA98  % Arbitrary and invalid value
      } {
        prev_get
      } ifelse
    } ifelse
  } bind executeonly def

/prev_begin /begin load def

/begin {
    dup //systemdict eq { pop 0 dict } if
    prev_begin
  } bind executeonly def

{ /undef_proc_warning /missing-type1-procs /readonly-op-dict }
  { currentdict exch undef } forall

end readonly def

currentdict /eexec_pdf_param_dict .undef

/readtype1 {		% <font-resource> <stream-dict> readtype1 <font|null>
 PDFfile fileposition 3 1 roll % pos res stream
 dup /PFB known exch % pos res pfb? stream
 //true resolvestream % pos res pfb? file
 exch {
 //false /PFBDecode filter % pos res file'
 } if
 % Some buggy embedded fonts leave extra junk on the stack,
 % so we have to make a closure that records the stack depth
 % in a fail-safe way. This code also removes the mark when
 % the implied cleartomark is not executed, i.e. Length3 == 0.
 % Also restore dictstack depth.
 %
 //systemdict begin
 //readtype1dict dup length 5 add dict copy begin % pos res file'
 /file-position 4 -1 roll def % res file'
 /stack-count count 3 sub def
 1 index /BaseFont oget /savedFontName exch def
 /topFontDict //null def
 /readtype1dictcopy currentdict def
 cvx stopped
 { currentdict /topFontDict known not { end } { exit } ifelse } loop
 { /topFontDict //null def } if
 PDFfile file-position setfileposition
 count stack-count sub { pop } repeat
 topFontDict end end
 } bind executeonly def

% ---------------- Type 3 fonts ---------------- %

/buildType3 {		% <Type3-font-resource> buildType3 
 8 dict begin
 /FontType 3 def
 % If the font does not contain a Resources entry, then we use
 % the resources from our current context. Page 391 of the PDF
 % 1.6 spec says that the Resources dict is optional and if not
 % present then we should use the Resources for the page.
 % However we have a test file (687989) which uses a Type3 font
 % inside a form XObject and the desired Resources are in the
 % XObject dict and not in the Page dict. So we are going to
 % the parent object to find resources instead of only going to
 % the page dict when a font does not specify its required
 % resources.
 /Resources 1 index /Resources knownoget {
 oforce
 } {
 LocalResources
 } ifelse def
 /FontBBox 1 index /FontBBox get cvx def
 /FontMatrix 1 index /FontMatrix oget def
 /CharProcs 1 index /CharProcs oget def
 1 index /Widths knownoget {
 /Widths exch def
 1 index /FirstChar known 2 index /LastChar known and {
 /FirstChar 1 index /FirstChar oget def
 /LastChar 1 index /LastChar oget def
 } {
 ( **** Error: Requireed entry FirstChar or LastChar is missing from Font.\n)
 pdfformaterror
 ( Output may be incorrect.\n) pdfformaterror
 /FirstChar 0 def
 /LastChar Widths length def
 }ifelse
 } if
 /FontName 1 index /Name knownoget not { /PDFType3Untitled } if def
 /Encoding .notdefEncoding 2 index getencoding def
 % We have to define BuildChar rather than BuildGlyph:
 % there is no PDF equivalent of glyphshow, and we need
 % the character code to access the Widths.
 /BuildChar {
 % Stack: font charcode
 1 index begin 4 dict begin
 /Font 3 -1 roll def /CharCode 1 index def
 Encoding exch get CharProcs exch knownoget {
 dup /Length get 0 eq {
 pop
 %% Detect a 0 length stream. If this occurs
 %% then we won't execute d0 or d1, and so won't adjust the
 %% character width. So, pretend we got a
 %% null d1, just so that we can adjust using the /Widths
 %% (Bug 697805)
 0 0 0 0 0 0
 pdfopdict /d1 get exec
 }{
 { //false resolvestream
 % Stack: filepos stream
 % Don't let setgcolor set the color inside the BuildGlyph
 % procedure, because this causes an /undefined error.
 q
 %% This is (currently) needed to make sure that the current dictionary, which is
 %% 'nodict' because we did a gsave, is writeable. If we don't execute gput
 %% to make a writeable copy then it is a no access dicitonary and the 'def'
 %% below will fail. It would be nice to fix the cases of this someday, but
 %% we use 'nodict'[ to store other PDF state stuff that isn't gstate, and we
 %% probably always will, so it may well be more trouble than its worth.
 /Dummy //false gput
 Font /Resources get exch pdfopdict
 /BuildCharDictDepth countdictstack def
 .pdfruncontext
 countdictstack BuildCharDictDepth sub
 {
 //pdfdict /.Qqwarning_issued .knownget {not}{//true} ifelse
 {
 (\n **** Warning: Type 3 glyph has unbalanced q/Q operators $too many q's$\n Output may be incorrect.\n)
 pdfformatwarning
 //pdfdict /.Qqwarning_issued //true .forceput
 } executeonly if
 Q
 } executeonly repeat
 Q
 } executeonly PDFfile fileposition 2 .execn % Keep pdfcount valid.
 PDFfile exch setfileposition
 } executeonly ifelse
 } executeonly
 {
 % PDF Type 3 fonts don't use .notdef
 % d1 implementation adjusts the width as needed
 0 0 0 0 0 0
 pdfopdict /d1 get exec
 } ifelse
 end end
 } executeonly bdef
 dup currentdict Encoding .processToUnicode
 currentdict end .completefont exch pop
} bind executeonly odef
/.adjustcharwidth {	% <wx> <wy> .adjustcharwidth <wx'> <wy'>
 % Enforce the metrics, in glyph space, to the values found in the PDF Font object
 % - force wy == 0 (assumed, and not stored in the PDF font)
 % Even though PDF1.3-1.7 specifications state that this must be 0,
 % Distiller sometimes creates Type3 fonts with non-zero wy. We set
 % it to 0 since this is apparently what Acrobat Reader 4 and 5 do.
 % PDF1.2 does not mention this restriction, it only says
 % "see setcharwidth/ setcachedevice in the PostScript Reference".
 % - get wx from the Widths array (do nothing if not present)
 pop 0
 /Widths where {
 begin
 CharCode FirstChar ge CharCode LastChar le and {
 exch pop Widths CharCode FirstChar sub get exch
 } if end
 } if
} bind executeonly def

% ---------------- TrueType fonts ---------------- %

/TTfonts mark
  /Arial /Helvetica
  /Arial,Italic /Helvetica-Oblique
  /Arial,Bold /Helvetica-Bold
  /Arial,BoldItalic /Helvetica-BoldOblique
  /CourierNew /Courier
  /CourierNew,Bold /Courier-Bold
  /TimesNewRoman /Times-Roman
  /TimesNewRoman,Italic /Times-Italic
  /TimesNewRoman,Bold /Times-Bold
  /TimesNewRoman,BoldItalic /Times-BoldItalic
.dicttomark readonly def

/buildTrueType {	% <TrueType-font-resource> buildTrueType 
 dup /BaseFont oget
 dup /font_name gput

1 index /FontDescriptor knownoget
  {
    /Flags knownoget
    {
      4 and 0 ne
      { //true } %  symbolic
      { 1 index /Encoding oknown not}  % no encoding => symbolic
      ifelse
    }
    {//false}
    ifelse
  }
  {//false}
  ifelse

/is_symbolic gput
  1 index /Encoding oknown {
    StandardEncoding
    3 index getencoding
  } {
    //null
  } ifelse
  /prebuilt_encoding gput
  //false /.render_notdef gput % set the default

dup /Font resourcestatus dup { exch pop exch pop } if not
  TTfonts 2 index known and {
    dup TTfonts exch get
    QUIET not {
      (Substituting font ) print dup =only
      ( for ) print 1 index =only (.) = flush
    } if
    exch 3 1 roll pdffindfont
    //true .copyfontdict
    2 copy exch /FontName exch put
    exch pop .completefont
  } {
    pdffindfont
  } ifelse
} bind executeonly def

% Read an embedded TrueType font.
/readtruetype {		% <font-resource> <stream-dict> readtruetype 
 1 index exch
 PDFfile fileposition 3 1 roll
 //true resolvestream readfontfilter
 % Stack: filepos fontres stream
 1 index /CIDSystemInfo oknown {
 1 index /CIDSystemInfo get dup type /packedarraytype eq {exec}if
 dup /Registry known not {
 ( **** Warning: a CIDFont's CIDSystemInfo is missing the required Registry entry\n) pdfformatwarning
 dup /Registry (Adobe) put
 } if
 dup /Ordering known not {
 ( **** Warning: a CIDFont's CIDSystemInfo is missing the required Ordering entry\n) pdfformatwarning
 dup /Ordering (Identity) put
 } if
 dup /Supplement known not {
 ( **** Warning: a CIDFont's CIDSystemInfo is missing the required Supplement entry\n) pdfformatwarning
 dup /Supplement 0 put
 } if
 3 1 roll
 1 index /Subtype knownoget {
 /CIDFontType2 ne {
 ( **** Error: Subtype of a TT CID font is not /CIDFontType2\n) pdfformaterror
 1 index /Subtype /CIDFontType2 put
 ( Output may be incorrect.\n) pdfformaterror
 } if
 } {
 ( **** Error: Subtype of a TT CID font is missing.\n) pdfformaterror
 1 index /Subtype /CIDFontType2 put
 ( Output may be incorrect.\n) pdfformaterror
 } ifelse

1 index /BaseFont get                 % Use the BaseFont name for the font. Otherwise we
                                          % would use the name table, or a manufactured name.
    .loadttcidfont
                                          % Stack: filepos fontres cidfont
  } {
                                          % filepos fontres stream
    1 index /FontDescriptor oget
    /Flags oget 4 and 0 ne {
       //true  %  symbolic
    } {
       1 index /Encoding oknown not  % no encoding => symbolic
    } ifelse

2 index /Encoding oknown {
      StandardEncoding
      3 index getencoding
    } {
      //null
    } ifelse

dup 4 index exch                      % filepos fontres stream is_symbolic Encoding fontres Encoding
    /prebuilt_encoding exch put           % filepos fontres stream is_symbolic Encoding
    5 index /BaseFont get                 % Use the BaseFont name for the font. Otherwise we
                                          % would use the name table, or a manufactured name.
    .loadpdfttfont
  } ifelse
  exch pop
  PDFfile 3 -1 roll setfileposition
                % Ignore both the Encoding and the Widths.
  exch pop
} bind executeonly def

% ---------------- Type 0 fonts ---------------- %

% Predefine the known CMaps, but only create them on demand.
/knownCMaps mark
  /Identity-H { /Identity-H 0 makeIdentityCMap }
  /Identity-V { /Identity-V 1 makeIdentityCMap }
.dicttomark def

/makeIdentityCMap {		% <cmapname> <wmode> .makeIdentityCMap -
 .currentglobal //true .setglobal 3 1 roll
 /CIDInit /ProcSet findresource begin
 12 dict begin
 begincmap
 /WMode exch def
 /CMapName exch def
 /CIDSystemInfo 3 dict dup begin
 /Registry (Adobe) def
 /Ordering (Identity) def
 /Supplement 0 def
 end def
 %/CMapName (see above)
 /CMapVersion 1 def
 /CMapType 1 def
 %WMode (see above)
 % The PDF documentation says that these CMaps map CIDs
 % "1 to 65,536". This is a misprint for 0 to 65,535.
 1 begincodespacerange
 % <0001> <00ff> <0100> <ffff>
 <0000> <ffff>
 endcodespacerange
 1 begincidrange
 % <0001> <00ff> 1 <0100> <ffff> 256
 <0000> <ffff> 0
 endcidrange
 endcmap
 CMapName currentdict /CMap defineresource
 knownCMaps CMapName 2 index put
 end		% CMap
 end		% CIDInit ProcSet
 exch .setglobal
} bind executeonly def

/CMap_read_dict 3 dict begin
 /defineresource % <name> <dict> <cat-name> defineresource <dict>
 {
 pop
 /.last_CMap_def 1 index store
 exch pop
 } bind executeonly def
 /CIDSystemInfo
 {
 ( **** Error: CMap has invalid syntax near CIDSystemInfo.\n) pdfformaterror
 ( Output may be incorrect.\n) pdfformaterror
 /CIDSystemInfo
 } bind executeonly def % A work around a bug in Altona.Page_3.2002-09-27.pdf - a slash is missed.
 /CMapName
 {
 ( **** Error: CMap has no CMapName.\n\
 See the comment to revision 6201 in gs/doc/ps2pdf.htm#Problems .\n) pdfformaterror
 ( Output may be incorrect.\n) pdfformaterror
 /CMap1 % arbitrary, PDF defineresource tolerates non-unique names
 } bind executeonly def % A work around incorrect ToUnicode CMap generated by GS before rev. 6201.
currentdict end readonly def

% Read an embedded stream that we *hope* is a PostScript CMap. According
% to the spec, ths isn't legal, but 'Acrobat opens it'....
%
/read_CMap {
  dup mark exch 0 (begincodespacerange) /SubFileDecode filter cvx exec
  cleartomark
  {currentdict dup /CMapType known not {end}{pop exit} ifelse} loop
  /CMapType 1 def
  mark exch % emulate 'begincodespacerange'
  0 (endcmap) /SubFileDecode filter cvx /begincmap cvx exch 2 .execn
  endcmap
  currentdict end
  dup /CMapName get exch
  /CMap defineresource end
} bind executeonly def

% Read embedded CMap stream.
% if the <wmode> parameter is null, it indicates there is no WMode, and we
% should not add one.
% Following Acrobat we ignore everything outside
% begincodespacerange .. endcmap.
/read_CMap_stream { % <info> <wmode> <name> <stream> read_CMap <CMap>
 dup 0 (begincodespacerange) /SubFileDecode filter flushfile
 //CMap_read_dict begin
 /CIDInit /ProcSet findresource begin
 12 dict begin
 /o.endmapvalue /.endmapvalue load def
 /.endmapvalue
 {
 dup 65535 gt
 {
 ( **** Warning: CMap: CID out of valid range (0-65535).\n) pdfformatwarning
 pop 65535
 } if
 o.endmapvalue
 } bind def
 4 2 roll
 dup //null eq { pop } { /WMode exch def } ifelse
 dup //null eq { pop } { /CIDSystemInfo exch def } ifelse
 /CMapType 1 def
 /.last_CMap_def currentdict def % establish binding
 mark exch % emulate 'begincodespacerange'
 0 (endcmap) /SubFileDecode filter cvx /begincmap cvx exch 2 .execn
 currentdict /o.endmapvalue undef
 endcmap
 /.last_CMap_def load
 { currentdict end //CMap_read_dict eq { exit } if } loop
 dup /.last_CMap_def undef
 /CMap defineresource
} bind executeonly def

currentdict /CMap_read_dict undef

/buildType0 {		% <Type0-font-resource> buildType0 
 dup /BaseFont get	% FontName
 1 index /Encoding oget
 dup type /nametype eq {
 dup /CMap resourcestatus {
 pop pop /CMap findresource
 } {
 knownCMaps 1 index .knownget
 { exch pop exec } { /undefined signalerror } ifelse
 } ifelse
 } {
 %% Bug #696449 Acrobat will read an embedded PostScript
 %% CMap, whcih according to the spec is not valid, it needs
 %% to be a PDF CMap stream. Here we check and see if it looks like a CMap
 %% dictionary. If it is we proceed, if its some other kind of dictionary,
 %% throw an error, if its neither, treat it as a stream and hope for the best.
 dup /Type known {
 dup /Type get /CMap eq {
 PDFfile fileposition exch
 dup /CIDSystemInfo knownoget {
 << exch { oforce } forall >>
 } {
 //null
 } ifelse exch
 dup /WMode knownoget not {//null} if exch
 dup /CMapName knownoget not {/null} if exch
 //true resolvestream
 read_CMap_stream
 exch PDFfile exch setfileposition
 } {
 PDFSTOPONERROR {
 /buildType0 cvx /syntaxerror signalerror
 } if
 } ifelse
 }{
 PDFfile fileposition exch
 //true resolvestream
 read_CMap
 exch PDFfile exch setfileposition
 } ifelse
 } ifelse		% CMap
 [
 3 index /DescendantFonts oget { exec resourcefont } forall
 ]			% subfonts
 .composefontdict % composefont must insert FontInfo dictionary - see gs_cmap.ps .
 % Stack: fontres name font
 3 copy exch pop //null .processToUnicode
 exch pop .completefont % Stack: fontres font

1 index /FontMatrix knownoget {
    dup aload pop //true {0 0 1 0 0 1} {3 -1 roll eq and} forall {
      1 index exch makefont exch /FontName get exch
      exch pop .completefont
    } {
      pop
    } ifelse
  } if exch pop
} bind executeonly def

% ---------------- CIDFontType0/2 fonts ---------------- %

% Insert metrics into a CIDFont, by saving the PDF W, W2, DW, and DW2
% arrays and using a (currently very inefficient) CDevProc.
% For detail, refer "PDF Reference" 2nd ed., p314 "5.6.3 CIDFonts".
% It notes default DW is 0, but Acrobat Reader uses 1000 as default.
% If DW is 0, currentpoint does not move by default in rendering text
% horizontally, the result is unreadable. You can check it by Acrobat.

/.pdfDefaultDW  1000 def
/.pdfDefaultDW2 [ 880 -1000 ] def

/addCIDmetrics {	% <CIDFont-resource> <CIDFont> addCIDmetrics <fontdict>
 dup length 5 add dict .copydict
 dup /FID undef
 dup /UniqueID undef
 dup /XUID undef
 % Insert the widths into the font.

% Stack: pdfresource newfont

1 index /DW knownoget {
    1 index /DW 3 -1 roll put
  } {
    dup /DW .pdfDefaultDW put
  } ifelse

1 index /W knownoget {
    //false 1 index { xcheck or } forall {
      oforce_array
    } if
    dup 2 index /W 3 -1 roll put
    .pdfMakeInternalW 1 index /.internalW 3 -1 roll put
  } if

1 index /DW2 knownoget {
    1 index /DW2 3 -1 roll put
  } {
    dup /DW2 .pdfDefaultDW2 put
  } ifelse

1 index /W2 knownoget {
    //false 1 index { xcheck or } forall {
      oforce_array
    } if
    dup 2 index /W2 3 -1 roll put
    .pdfMakeInternalW2 1 index /.internalW2 3 -1 roll put
  } if

dup /CDevProc 1 index /CIDWProc load /exec load 3 packedarray cvx put
  exch pop
} bind executeonly def

/.pdfMakeInternalMTXArray { % <mtx_array> <item_size> .pdfConvertInternalW <mtx_array'>
 % convert /W or /W2 to internal expression
 %
 % mtx_array: original /W or /W2 array
 % item_size: number of metrics values per CID
 %
 % for detail of the metrics list format in PDF,
 % refer PDF Ref. p.317 "Glyph Metrics in CIDFonts".
 %
 % format of single entry in internal expression
 %
 % [
 % [cid_begin cid_end]
 % value_is_varied (bool)
 % [ [values for cid_begin...]
 % [values for cid_begin + 1]
 % ... ]
 % ]
 %

7 dict
 begin
 /itemSize exch def
 /M exch def			% original /W or /W2
 /Msize M length def
 /Mi { M i get } def		% W[i]
 /Mi1 { M i 1 add get } def	% W[i + 1]
 /putMTXEntry <<
 /arraytype {
 [
 [Mi Mi Mi1 length itemSize idiv add 1 sub]
 //true
 [
 0 itemSize Mi1 length 1 sub {
 [ exch 1 1 index itemSize add 1 sub { Mi1 exch get } for ]
 } for
 ]
 ]
 /i i 2 add def
 }
 /integertype {
 [
 [Mi Mi1]
 //false
 [[ i 2 add 1 i 1 add itemSize add { M exch get } for ]]
 ]
 /i i 2 add itemSize add def
 }
 >> def

/i 0 def

[ { putMTXEntry Mi1 type get exec i Msize ge { exit } if } loop ]
  end
} executeonly def

/.pdfMakeInternalW  { dup length 0 gt { oforce_recursive 1 .pdfMakeInternalMTXArray } if } executeonly def
/.pdfMakeInternalW2 { dup length 0 gt { oforce_recursive 3 .pdfMakeInternalMTXArray } if } executeonly def

/.pdfGetMTXByCID { % <internalMTXArray> <cid>
 % .pdfGetMTXByCID
 % { <MTXEntry> true | false }

% get values for given CID from internal format of /W or /W2

exch
 {
 {
 dup 0 get {} forall % Stack: <cid> <entry> <cid_0> <cid_1>
 3 index lt { pop pop //false exit } if
 2 index exch sub dup 0 lt { pop pop //false exit } if
 1 index 1 get not { pop 0 } if
 exch 2 get exch get //true exit
 } loop
 { exit } if
 } forall
 dup type /arraytype eq { exch pop //true } { pop //false } ifelse
} executeonly def

% Apply the [D]W[2] metrics to a character before displaying.
/CIDWProc {		% <w0x> <w0y> <llx> <lly> <urx> <ury>
 % <w1x> <w1y> <vx> <vy> <cid> CIDWproc
 % <w0x'> ... <vy'>
 begin % push to currentdict
 % <w1x> <w1y> <vx> <vy> won't be used and replaced, discard now
 5 1 roll pop pop pop pop

% get FontMatrix that applies to this CID
 % (needs to convert [D]W[2] values to glyph space)
 currentdict /FontMatrix get
 % if the currentfont is a CIDFontType 0 CIDFont,
 % we need FDArray font's FontMatrix too
 FontType 9 eq {
 currentdict 2 index .type9mapcid
 % <w0x> <w0y> <llx> <lly> <urx> <ury> <cid> <FontMatrix> (charstring) <FDArray#>
 exch pop currentdict /FDArray get exch get /FontMatrix get
 % <w0x> <w0y> <llx> <lly> <urx> <ury> <cid> <FontMatrix> <FontMatrix2>
 matrix concatmatrix
 } if
 % preserve this FontMatrix at bottom of the stack
 8 1 roll
 % Stack: <FontMatrix> <w0x> <w0y> <llx> <lly> <urx> <ury> <cid>

{
 currentdict /DW .knownget not { % no DW
 .pdfDefaultDW exit % replace <w0x> by defaultDW
 } if

currentdict /.internalW .knownget not {    % no W
        exit                            % use already-stacked DW
      } if

dup length 0 eq {                 % W is null array
        pop                             % discard unusable W
        exit                            % use already-stacked DW
      } if

% W is finite array, try to get W_cid
      2 index .pdfGetMTXByCID {           % got W, discard DW
        exch pop {} forall
        exit
      } if

exit
 } loop
 0 % <w0y'>

% Stack: <FontMatrix> <w0x> <w0y> <llx> <lly> <urx> <ury> <cid> <w0x'> <w0y'>
 9 -2 roll pop pop % discard <w0x> <w0y>
 7 2 roll % put <w0x'> <w0y'>

% Stack: <FontMatrix> <w0x'> <w0y'> <llx> <lly> <urx> <ury> <cid>
 0 % <w1x'>
 exch % put <w1x'>

% Stack: <FontMatrix> <w0x'> <w0y'> <llx> <lly> <urx> <ury> <w1x'> <cid>
 {
 currentdict /DW2 .knownget not { % no DW2, use defaultDW2
 .pdfDefaultDW2 exit
 } if

currentdict /.internalW2 .knownget not {   % has DW2, no W2
        exit                            % use already-stacked DW2
      } if

dup length 0 eq {                 % W2 is null array
        pop                             % discard unusable W2
        exit                            % use already-stacked DW2
      } if

2 index .pdfGetMTXByCID {		% got W2_cid, discard DW2
        exch pop
        exit
      } if

% could not get W2_cid
      exit

} loop

exch pop % discard <cid>

% Stack: <FontMatrix> <w0x'> <w0y'> <llx> <lly> <urx> <ury>
 % <w1x'> { [<vy'> <w1y'>] | [<w1y'> <vx'> <vy'>] }
 dup length 2 eq { % this is DW2
 aload pop
 exch 8 index 2 div % <vx'> = <w0x'> / 2
 exch
 } { % assume W2
 aload pop
 } ifelse
 % Stack: <FontMatrix> <w0x'> <w0y'> <llx> <lly> <urx> <ury> <w1x'> <w1y'> <vx'> <vy'>

% now, convert each metrics valude (1000th of text space) to glyph space
 10 -2 roll
 % Stack: <FontMatrix> <llx> <lly> <urx> <ury> <w1x'> <w1y'> <vx'> <vy'> <w0x'> <w0y'>
 3 {
 10 index idtransform exch 1000 div exch 1000 div
 6 2 roll
 } repeat
 10 2 roll
 % Stack: <FontMatrix> <w0x'> <w0y'> <llx> <lly> <urx> <ury> <w1x'> <w1y'> <vx'> <vy'>
 11 -1 roll pop
 % Stack: <w0x'> <w0y'> <llx> <lly> <urx> <ury> <w1x'> <w1y'> <vx'> <vy'>
 end % recover currentdict
} bind executeonly def

% <string> <match> tailmatch ==> <pre> true
% ==> <string> false
/tailmatch {
 2 copy length 1 index length .min
 dup 2 index length exch sub exch getinterval
 1 index eq {
 length 1 index length exch sub
 0 exch getinterval //true
 } {
 pop //false
 } ifelse
} bind executeonly def

/makeboldfont {
  16 dict begin
    /strokewidth exch def
    /basecidfont exch def
    /FontMatrix [ 1 0 0 1 0 0 ] def

/CIDFontName /.boldfont def
    /CIDFontType 1 def

/basefont-H /.basefont-H /Identity-H [ basecidfont ] composefont def
    /basefont-V /.basefont-V /Identity-V [ basecidfont ] composefont def

/CIDSystemInfo dup basecidfont exch get def
    /FontBBox [ basecidfont /FontBBox get cvx exec
      4 2 roll basecidfont /FontMatrix get transform
      4 2 roll basecidfont /FontMatrix get transform
    ] def

/tmpstr 2 string def
    /BuildGlyph {
      gsave
      exch begin
        dup 256 idiv tmpstr exch 0 exch put
        256 mod tmpstr exch 1 exch put
        rootfont /WMode known { rootfont /WMode get 1 eq } { //false } ifelse
        { basefont-V } { basefont-H } ifelse setfont
        strokewidth setlinewidth
        1 setlinejoin
        newpath
        0 0 moveto tmpstr //false charpath stroke
        0 0 moveto tmpstr show
        currentpoint setcharwidth
      end
      grestore
    } bind def

currentdict
  end
  dup /CIDFontName get exch /CIDFont defineresource
} bind executeonly def

% <CIDFont-resource> <CIDFontName> findCIDFont <CIDFont-resource> 
% CIDFont-resource is not modified.
/findCIDFont {
 {
 dup /CIDFont resourcestatus {
 pop pop dup /CIDFont findresource
 dup /Path known
 1 index /ResourcePath known or
 { exch pop exit }
 { pop dup /CIDFont undefineresource }
 ifelse
 } if
 .remove_font_name_prefix
 dup dup length string cvs

(,Bold) tailmatch {
      exch pop
      % If we're substituting a standard weight font for a
      % "Light,Bold" font, don't artificially bolden further
      dup (Light) tailmatch
      {
        pop cvn findCIDFont dup /FontName .knownget
        {
          (Light) tailmatch exch pop
        }
        {
          //true
        } ifelse

{
          0.03 makeboldfont
        } if
      }
      {
        pop
        cvn findCIDFont 0.03 makeboldfont
      } ifelse
      exit
    } if
    (,Italic) tailmatch {
      exch pop
      cvn findCIDFont
      [ 1 0 0.3 1 0 0 ] makefont
      exit
    } if
    (,BoldItalic) tailmatch {
      exch pop
      % see above
      dup (Light) tailmatch
      {
        pop cvn findCIDFont dup /FontName .knownget
        {
          (Light) tailmatch exch pop
        }
        {
          //true
        } ifelse

{
          0.03 makeboldfont
        } if
      }
      {
        pop
        cvn findCIDFont 0.03 makeboldfont
      } ifelse
      [ 1 0 0.3 1 0 0 ] makefont
      exit
    } if
    QUIET not {
      (Can't find CID font ") print dup =string cvs print (".) = flush
    } if
    pop

1 index /CIDSystemInfo oget begin Registry (-) Ordering end
    concatstrings concatstrings
    cvn
    QUIET not {
      (Attempting to substitute CID font ) print dup ==only
      ( for ) print 1 index ==only (, see doc/Use.htm#CIDFontSubstitution.) = flush
    } if
    exch pop
    dup /CIDFont resourcestatus {
      pop pop /CIDFont { findresource } stopped
      {pop}{exit} ifelse
    } if
    QUIET not {
      (The substitute CID font ") print dup =string cvs print
      (" is not provided either. ) print
    } if

PDFNOCIDFALLBACK {
      PDFSTOPONERROR {
        (Will exit with error.) = flush
      }
      {
        (Will attempt to continue, but content may be missing.) = flush
      } ifelse
      exit
    } if

QUIET not {
      (attempting to use fallback CIDFont.) print
      (See doc/Use.htm#CIDFontSubstitution.) = flush
    } if

PDFNOCIDFALLBACK not {
      % This previously worked by loading the substitute font, and using that
      % as a "template" to create a new CIDFont dictionary with the CIDSystemInfo
      % dict appropriate for the requested font.
      % This, however, caused problems with the CIDMap and thus broke pdfwrite.
      % Hence, we now modify the CIDFont resource .map dictionary on the fly
      % so it includes an appropriate mapping, so the subsitute font is loaded
      % from the beginning with the correct ordering and supplement settings.
      /CIDFont /Category findresource /.map get dup /CIDFallBack .knownget {
        dup type /dicttype eq {
          dup /FileType get /TrueType eq {
            currentglobal
            4 1 roll
            dup gcheck setglobal
            dup length dict copy dup
            6 index /CIDSystemInfo oget dup /Ordering oget exch /Supplement get
            % we have to copy the string, for VM correctness
            exch dup length string copy exch 2 array astore
            /CSI exch put 2 index exch .forceput
            exch setglobal
            {
              % This *should* not execute arbitrary Postscript, so we ought to
              % be safe running in a stopped context, in knowledge we know how
              % to clean up afterwards - this would not be safe if CIDFallBack
              % were a "real" CIDFont.
              /CIDFont findresource
            }
            % if the above fails, try just using the CIDFallBack font directly
            stopped
            {
              pop
              % First, since it didn't work, remove the entry from the CIDFont category
              % .map dictionary.
              currentglobal exch
              /CIDFont /Category findresource /.map get
              dup gcheck setglobal
              exch undef
              setglobal

(Warning: falling back to Identity ordering\n) print flush
              /CIDFallBack /CIDFont findresource
            } if
            exit
          } executeonly if
        } if
      } if

pop pop pop
      /CIDFallBack

QUIET not {
        (The fallback CID font ") print dup =string cvs print
        (" is not provided. ) print
        ( Finally attempting to use ArtifexBullet.\n) print flush
      }if

% We'll just use Identity for this, we have only one glyph anyway.
      /ArtifexBullet /CIDFont resourcestatus {
        pop pop pop
        /ArtifexBullet /CIDFont findresource
        exit
      }
      {
        pop /ArtifexBullet
      } ifelse

QUIET not {
        (The CID font ") print dup =string cvs print
        (" is not provided. ) print
        PDFSTOPONERROR
        {
          (Will exit with error.) = flush
        }
        {
          (Will continue, but content may be missing.) = flush
        } ifelse
      } if
    } executeonly if
    /findresource cvx /undefined signalerror
  } executeonly loop
} bind executeonly odef

/buildCIDType0 {	% <CIDFontType0-font-resource> buildCIDType0 
 dup /BaseFont get findCIDFont exch pop
} bind executeonly def

/buildCIDType2 {	% <CIDFontType2-font-resource> buildCIDType2 
 dup /BaseFont get findCIDFont exch pop
} bind executeonly def

/processCIDToGIDMap { % <fontres> <cidfont> processCIDToGIDMap <fontres> <cidfont>
 1 index /CIDToGIDMap knownoget {
 PDFfile fileposition 4 1 roll
 dup /Identity eq {
 pop
 } {
 //true resolvestream
 % Stack: filepos fontres font mapstream
 [
 { counttomark 1 add index 32768 string readstring not {
 counttomark 1 eq {
 exch pop dup length
 } {
 ] dup 0 exch { length add } forall
 } ifelse
 exit
 } if
 } loop
 2 idiv
 % Stack: filepos fontres font mapstream array/string CIDCount
 dup 0 ne {
 3 index exch /CIDCount exch put
 exch closefile exch
 dup /CIDMap 4 -1 roll put
 }{
 % If CIDCount is zero, ignore it
 pop pop closefile
 }ifelse
 } ifelse
 3 2 roll PDFfile exch setfileposition
 } if
} bind executeonly def

% Adjust a CIDFontType0 DW[2] in the font resource.
/adjustCIDType0 {		% <font-resource> adjustfont <font'>
 dup /FontType get 1 eq {
 ( **** Error: Font resource has a wrong /Subtype.\n) pdfformaterror
 ( Output may be incorrect.\n) pdfformaterror
 adjustfont
 } {
 addCIDmetrics
 dup /CIDFontName get exch /CIDFont defineresource
 } ifelse
} bind executeonly def

% Adjust a CIDFontType2 DW[2] and CIDToGIDMap in the font resource.
/adjustCIDType2 {		% <font-resource> adjustfont <font'>
 dup /FontType get 1 eq {
 ( **** Error: Font resource has a wrong /Subtype.\n) pdfformaterror
 ( Output may be incorrect.\n) pdfformaterror
 adjustfont
 } {
 addCIDmetrics
 dup /CIDFontType get 2 eq { % OpenType CFF font converts to CIDFontType 0
 processCIDToGIDMap % that ignores CIDMap.
 } if
 dup /CIDFontName get exch /CIDFont defineresource
 } ifelse
} bind executeonly def

% ---------------- Other embedded fonts ---------------- %

% Read an embedded compressed font.
/readType1C {		% <font-resource> <stream-dict> readType1C 
 1 index exch
 PDFfile fileposition 3 1 roll
 dup //true resolvestream dup readfontfilter
 % Stack: pos resource streamdict stream filter
 3 index /FontDescriptor oget /FontName oget
 1 index
 /FontSetInit /ProcSet findresource begin //true //false ReadData
 %% We need to be careful not to corrupt the stack if something went wrong.
 %% Previously, if the dict was length 0 (an error occured) we would end up
 %% unable to recover the stack in the calling procedure.
 %% Bug #695819.
 dup length 0 ne {
 { exch pop exit } forall
 7 1 roll
 }{
 /invalidfont signalerror
 } ifelse
 closefile closefile pop
 PDFfile 3 -1 roll setfileposition
 pop pop
} bind executeonly def

% Read an embedded CFF CIDFont.
/readCIDFontType0C { % <font-resource> <stream-dict> readCIDFontType0C 
 PDFfile fileposition 3 1 roll
 dup //true resolvestream dup readfontfilter
 % Stack: pos resource streamdict stream filter
 3 index /FontDescriptor oget /FontName oget
 1 index
 /FontSetInit /ProcSet findresource begin //true //true ReadData pop
 closefile closefile pop
 PDFfile 3 -1 roll setfileposition
 % Some broken Adobe software produces PDF files in which
 % the FontName of the CFF font and the FontName in the
 % FontDescriptor don't match the BaseFont in the font.
 % Use the FontName, rather than the BaseFont, here.
 dup /FontDescriptor oget /FontName oget /CIDFont findresource
 addCIDmetrics dup /CIDFontName get exch /CIDFont defineresource
} bind executeonly def

% Read an embedded OpenType font.
/readOTTOfont {		% <font-resource> <stream-dict> readOTTOfont 
 1 index exch % res res strdict
 PDFfile fileposition 3 1 roll % res pos res strdict
 dup //true resolvestream % res pos res strdict stream
 dup readfontfilter % res pos res strdict stream filter
 3 index /FontDescriptor oget
 /FontName oget % res pos res strdict stream filter /name
 1 index .init_otto_font_file % res pos res strdict stream filter /name filter'
 //true
 6 index /CIDSystemInfo known % res pos res strdict stream filter /name filter' bool bool
 ReadData % res pos res strdict stream filter fontset
 { exch pop exit } forall % res pos res strdict stream filter font
 dup /FontType get 9 eq {
 % OpenType may contain simple CFF font, which is accesed as a CIDFont by PDF.
 % The font is converted to Type 9 CIDFont resource, which ignores CIDMap attribute.
 % The following code just shuffles GlyphDirectory to the same effect.
 4 index /CIDToGIDMap knownoget {
 dup type /dicttype eq {
 1 index /GlyphDirectory get exch % res pos res strdict stream filter font dir c2g
 //true resolvestream % res pos res strdict stream filter font dir c2g_file
 256 dict begin
 0 2 index 0 get def % copy .notdef
 0 1 16#7fffffff {
 1 index read not { pop exit } if % res pos res strdict stream filter font dir c2g_file cid hi
 256 mul % res pos res strdict stream filter font dir c2g_file cid hi
 2 index read not { pop pop exit } if % res pos res strdict stream filter font dir c2g_file cid hi lo
 add % res pos res strdict stream filter font dir c2g_file cid gid
 dup 0 ne {
 dup 4 index length lt {
 3 index exch get % res pos res strdict stream filter font dir c2g_file cid charstr
 def % res pos res strdict stream filter font dir c2g_file
 } {
 pop pop
 } ifelse
 } {
 pop pop
 } ifelse
 } for
 closefile pop % res pos res strdict stream filter font
 dup length dict copy % res pos res strdict stream filter font'
 dup /GlyphDirectory currentdict put % res pos res strdict stream filter font'
 end
 dup /GlyphDirectory get 0 exch {
 pop .max
 } forall
 1 index exch /CIDCount exch 1 add put
 } {
 pop
 } ifelse
 } if
 } if
 7 1 roll % font res pos res strdict stream filter
 closefile closefile pop pop % font res pos
 PDFfile exch setfileposition % font res
 pop % font
} bind executeonly def

% ---------------- Font lookup ---------------- %

% Some PDF files mis-identify font type of the embedded font streams or
% include raw PFB font streams. Length1, Length2, Length3 may be wrong or
% missing. Adobe Acrobat corrects these errors transparently to the user.
%
% We ignore the font type keys and recognize the font type by the 1st 4 bytes
% of the font stream. The PFB stream is recognized by the 1st 2 bytes.

/fonttypeprocs mark		% <font-resource> -proc- 
 /Type0 //buildType0
 /Type1 //buildType1
 /MMType1 //buildType1
 /Type3 /buildType3 load
 /TrueType //buildTrueType
 /CIDFontType0 //buildCIDType0
 /CIDFontType2 //buildCIDType2
.dicttomark readonly def

/adjustfonttypes mark
  /Type1 //adjustfont
  /MMType1 //adjustfont
  /TrueType //adjustfont
  /CIDFontType0 //adjustCIDType0
  /CIDFontType2 //adjustCIDType2
.dicttomark readonly def

% Bind a proc and define n names
% /name ... /name {proc} n bndef -
/bndef
  { exch bind executeonly exch
    { dup 3 1 roll def } repeat
    pop
  } bind executeonly def

% <res> run-fonttypeproc 
/run-fonttypeproc {
 dup /Subtype knownoget not { 0 } if % res /subtype
 //fonttypeprocs 1 index known not {
 ( **** Error: Font /Subtype attribute is wrong or missing, /Type1 assumed.\n)
 pdfformaterror
 ( Output may be incorrect.\n) pdfformaterror
 pop /Type1
 2 copy /Subtype exch put
 } if
 //fonttypeprocs exch get exec
} bind executeonly def

% Prototype for all procedures: <res> <desc> <stream> foo 
/font_tag_dict 13 dict begin

% When the font stream is absent or cannot be read we load the font by the name.
  /no_stream
    { pop pop
      run-fonttypeproc
    } bind executeonly def

/bad_stream
    { (   **** Error: Error reading font stream, attempting to load the font using its name\n)
      pdfformaterror
      (               Output may be incorrect.\n) pdfformaterror
      //no_stream exec
    } bind executeonly def

<8001> % PFB
 { dup /PFB //true put
 exch pop readtype1
 } bind executeonly def

(%!PS) (%!Fo)   % Type1
    { exch pop readtype1
    } 2 bndef

<01000401> <01000402> <01000403> <01000404> % Type 1C
 <01000C02> <01000C03>
 { exch pop
 1 index /Subtype knownoget dup { pop /CIDFontType0 eq } if {
 readCIDFontType0C
 } {
 readType1C
 } ifelse
 } 6 bndef

<00010000> (true) (typ1) (ttcf) % TrueType OpenType
 { exch pop readtruetype
 } 4 bndef

(OTTO)
    { exch pop
      readOTTOfont
    } bind executeonly def

currentdict end readonly def
currentdict /bndef undef

% Used to create a hash for the XUID, ths combines the input PDF file name and the
% object number (currently the object number of the FontDescriptor). NB we *must*
% use an object number, as otherwise all fonts will have the same
% XUID and Ghostscript will think they are the same font. Ths routine must not
% be used unless we have an object number which is believed to be uniqe to
% a particular font instance.
/.CRCHashFilenameAndObject % object_number (filename) CRCHasFilename integer
{
 dup % object_number (filename) (filename)
 length % object_number (filename) length
 0 exch % object_number (filename) hash length
 1 sub % object_number (filename) hash length-1
 0 1 3 -1 roll % object_number (filename) hash 0 1 length-1
 { % object_number (filename) hash index
 2 index exch get % object_number (filename) hash char
 exch % object_number (filename) char hash
 dup 16#F8000000 and % object_number (filename) char hash top5bits
 -27 bitshift % object_number (filename) char hash top5>>27
 exch 5 bitshift % object_number (filename) char top5>>27 hash<<5
 16#7FFFFFFF and
 xor % object_number (filename) char CRC<hash>
 xor % object_number (filename) newhash
 } for
 exch pop % object_number newhash
 dup 16#F8000000 and % object_number newhash top5bits
 -27 bitshift % object_number newhash top5>>27
 exch 5 bitshift % object_number top5>>27 newhash<<5
 16#7FFFFFFF and
 xor % object_number CRC<newhash>
 xor % final hashed value
}bind executeonly def

% Either patch or create a new XUID based on the existing
% XUID or UniqueID and incorporating the PDF object number
% so we get an XUID we can use to improve cache efficiency
% in multipage documents.
/patch_font_XUID % <patch> patch_font_XUID 
{
 dup //null eq
 {pop}
 {
 //pdfdict /InputPDFFileName .knownget {.CRCHashFilenameAndObject} if
 exch dup /.OrigUniqueIDXUID .knownget not
 {
 dup /XUID .knownget not
 {
 dup /UniqueID .knownget
 {1 array astore}{ [] } ifelse
 } if
 } if

dup //null eq
    {
          pop exch pop
    }
    {
      [ 1000000 3 -1 roll 4 index exch {exch} forall ]
      exch //true .copyfontdict
      dup 3 -1 roll /XUID exch put
      exch pop
      .completefont
    } ifelse
  } ifelse
} bind executeonly def

/resourcefont % <font-resource> resourcefont 
{
 dup /PSFont .knownget dup {
 pop /FID knownoget dup { pop type /fonttype eq } if
 } if {
 /PSFont get
 } {

dup /Subtype get /Type0 eq {
      % if the font was defined in-line, we won't have a object number
      dup /.gs.pdfobj# .knownget not { //null } if
    } {
        dup /FontDescriptor knownoget {
          % if the font was defined in-line, we won't have a object number
          dup /.gs.pdfobj# .knownget not { //null }if
          dup //null eq {
            exch pop
          }{
            exch dup /FontFile knownoget not {
             dup /FontFile2 knownoget not {
                dup /FontFile3 knownoget not {
                  pop pop //null
                } {pop pop}ifelse
              } {pop pop}ifelse
            }{pop pop}ifelse
          }ifelse
        }{
          //null
        } ifelse
    } ifelse
    3 1 roll

% In the event we have a Type 0 dictionary with a spurious
    % FontDescriptor object, remove it here to prevent confusion
    % later on.
    % Bug 691589
    dup /Subtype get /Type0 eq 1 index /FontDescriptor known and
    {
        dup /FontDescriptor undef
    }if
    dup /CIDSystemInfo .knownget
    {
      oforce_recursive
      1 index exch /CIDSystemInfo exch put
    } if

dup dup /FontDescriptor knownoget {
                                          % font-res font-res font-desc
      % The same font descriptor can be reused in a CID and non-CID contexts.
      % Store CID and non-CID fonts under different keys. Bug 689301
      1 index /Subtype knownoget dup {
        pop dup /CIDFontType0 eq exch /CIDFontType2 eq or
      } if { /CIDFontObject } { /FontObject } ifelse
                                          % font-res font-res font-desc /key
      2 index 1 index .knownget {
        4 1 roll pop pop pop              % font-res obj
      } {
        4 1 roll                          % /key font-res font-res font-desc

dup /FontFile knownoget not {
          dup /FontFile2 knownoget not {
            dup /FontFile3 knownoget not {
              //null
            } if
          } if
        } if
                                          % /key res res desc stream
        dup //null ne {
          PDFfile fileposition
          mark {
            2 index //true resolvestream dup
            4 string readstring pop
            exch closefile
          } stopped {
            cleartomark /bad_stream
          } {
            exch pop
          } ifelse
          PDFfile 3 -1 roll setfileposition
          dup length 4 lt { pop /bad_stream } if
        } {
          /no_stream
        } ifelse
                                          % /key res res desc stream tag

//font_tag_dict 1 index known not {
 dup 0 2 getinterval <8001> eq {
 0 2 getinterval % /key res res desc stream pfb_tag
 } {
 (12345678>\n) dup /ASCIIHexEncode filter dup 4 -1 roll writestring closefile
 ( **** Error: unrecognized font file starts with <) exch concatstrings
 pdfformaterror
 ( Output may be incorrect.\n) pdfformaterror
 /no_stream % /key res res desc stream unknown_tag
 } ifelse
 } if
 //font_tag_dict exch get % /key res res desc stream {proc}
 { stopped } 0 get % /key res res desc stream {proc} --stopped--
 count % /key res res desc stream {proc} --stopped-- #
 countdictstack % /key res res desc stream {proc} --stopped-- # ##
 PDFfile fileposition % /key res res desc stream {proc} --stopped-- # ## ###
 5 array astore cvx % /key res res desc stream {{proc} --stopped-- # ## ###}
 exec
 4 -1 roll {
 PDFSTOPONERROR not {
 PDFfile exch setfileposition
 countdictstack exch sub 0 .max { end } repeat
 count 4 add exch sub 0 .max { pop } repeat
 //null
 } {
 /resourcefont cvx /undefinederror signalerror
 } ifelse
 } {
 PDFfile exch setfileposition
 countdictstack exch sub 0 .max { end } repeat
 count 3 sub exch sub 0 .max { pop } repeat
 } ifelse
 dup //null eq {
 PDFSTOPONERROR not {
 pop
 ( **** Error: can't process embedded font stream,\n attempting to load the font using its name.\n)
 pdfformaterror
 ( Output may be incorrect.\n) pdfformaterror
 dup run-fonttypeproc % /key res font
 } {
 /resourcefont cvx /undefinederror signalerror
 } ifelse
 } if
 1 index % /key res font res
 4 -1 roll 2 index % res font desc /key font
 put % Save pointer to the font.
 } ifelse
 } {
 run-fonttypeproc
 } ifelse
 % Stack: font-res font
 1 index exch
 1 index /Subtype get
 //adjustfonttypes exch .knownget { exec } { exch pop } ifelse
 4 -1 roll patch_font_XUID
 dup 3 1 roll /PSFont exch put
 } ifelse
 dup checkGlyphNames2Unicode
} bind executeonly def

currentdict /font_tag_dict .undef
currentdict /fonttypeprocs .undef
currentdict /adjustfonttypes .undef

drawopdict begin
  /d0 {
    currentcolor currentcolorspace .swapcolors setcolorspace setcolor .swapcolors
    .adjustcharwidth setcharwidth
  } bind executeonly def
  /d1 {
    2 copy                           % ... llx lly urx ury | urx ury
    0 ne exch 0 ne                   % ... llx lly urx ury | ury!=0 urx!=0
    3 index 6 index eq and           % ... llx lly urx ury | ury!=0 (urx!=0 && llx==urx)
    exch 2 index 5 index eq and or { % ... llx lly urx ury | (urx!=0 && llx==urx) || (ury!=0 && lly==ury)
      % The bounding box is empty and likely incorrect. Don't cache.
      pop pop pop pop
      //d0 exec
    } {
      currentcolor currentcolorspace .swapcolors setcolorspace setcolor .swapcolors
      6 -2 roll .adjustcharwidth 6 2 roll setcachedevice
    } ifelse
  } bind executeonly def
  /Tf {
    1 index Page /Font rget {
      dup type /dicttype eq {
        resourcefont exch
        Tf pop
      }
      {
        PDFSTOPONERROR
        {
          /typecheck cvx signalerror
        }
        {
          % Bug 689450
          type
          (   **** Error: Tf refers to a resource key with an invalid value type: ) pdfformaterror
          .namestring pdfformaterror
          (. Assuming resource key: ) pdfformaterror
          1 index .namestring pdfformaterror
          ( is a font name.\n) pdfformaterror
          (               Output may be incorrect.\n) pdfformaterror
         Tf
        } ifelse
      }ifelse
    }
    {
      PDFSTOPONERROR
      {
          pop /undefined cvx signalerror
      }
      {
        % Bug 689037
        (   **** Error: Tf refers to an unknown resource name: ) pdfformaterror
        1 index .namestring pdfformaterror
        ( Assuming it's a font name.\n) pdfformaterror
        (               Output may be incorrect.\n) pdfformaterror
        Tf
      } ifelse
    } ifelse
  } bind executeonly def
end

end			% pdfdict
end			% GS_PDF_ProcSet
.setglobal

Back