ref: a15863b8ae23a26a2f825daf6107ab92e53c2669
dir: /sys/lib/ghostscript/pdf_ops.ps/
% Copyright (C) 1994, 2000 Aladdin Enterprises. 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.
%
% For more information about licensing, please refer to
% http://www.ghostscript.com/licensing/. For information on
% commercial licensing, go to http://www.artifex.com/licensing/ or
% contact Artifex Software, Inc., 101 Lucas Valley Road #110,
% San Rafael, CA 94903, U.S.A., +1(415)492-9861.
% $Id: pdf_ops.ps,v 1.41 2005/09/28 04:33:27 dan Exp $
% Definitions for most of the PDF operators.
.currentglobal true .setglobal
% Define pdfmark. Don't allow it to be bound in.
% Also don't define it in systemdict, because this leads some Adobe code
% to think this interpreter is a distiller.
% (If this interpreter really is a distiller, don't do this.)
systemdict /pdfmark known not
{ userdict /pdfmark { cleartomark } bind put } if
userdict /GS_PDF_ProcSet 127 dict dup begin
% ---------------- Abbreviations ---------------- %
/bdef { bind def } bind def
% ---------------- Graphics state stack ---------------- %
% PDF adds a number of parameters to the graphics state.
% We implement this by pushing and popping a dictionary
% each time we do a PDF gsave or grestore.
% The keys in this dictionary are as follows:
% self % identifies the dictionary as one of ours
% ClipRect % (optional)
% Show
% TextSaveMatrix % matrix at time of BT (iff within BT/ET)
% (The following correspond directly to PDF state parameters.)
% AlphaIsShape
% FillConstantAlpha
% FillColor
% FillColorSpace
% FillOverprint
% SoftMask
% StrokeConstantAlpha
% StrokeColor
% StrokeColorSpace
% StrokeOverprint
% TextSpacing
% TextHScaling
% Leading
% TextFont
% TextLineMatrix
% TextMatrix
% TextRise
% TextRenderingMode
% WordSpacing
/nodict 1 dict def
nodict /self { //nodict } executeonly put
nodict readonly pop
/dictbeginpage { % <initialdict> dictbeginpage -
//nodict 20 dict .copydict begin { def } forall
graphicsbeginpage textbeginpage
} bdef
/endpage { % - endpage -
showpage end
} bdef
/graphicsbeginpage {
initgraphics
currentdict /ClipRect knownoget { aload pop rectclip } if
0 g 0 G false op false OP 0 OPM
1 ca 1 CA null SMask false AIS /Compatible BM true TK
} bdef
/gput % <value> <key> gput -
{ exch currentdict //nodict eq { /self dup load end 5 dict begin def } if
% If we're in a Level 1 system, we need to grow the
% dictionary explicitly.
currentdict length currentdict maxlength ge %eq
{ currentdict dup length 3 mul 2 idiv 1 add dict .copydict end begin
}
if def
} bdef
% Restore graphics state, but do not modify path. Paths are not part
% of the PDF graphics state; see 4.4.1 of PDF reference 3rd ed.
/grestore_nopath {
% Collect the upath with an identity CTM
{ matrix setmatrix //false upath } stopped {
pop grestore newpath
} {
% Save the CTM, set identity during the uappend, then set the CTM
grestore matrix currentmatrix matrix setmatrix
exch newpath uappend setmatrix
} ifelse
} bdef
/q {
gsave //nodict begin
} bdef
% Some PDF files have excess Q operators!
/Q {
currentdict /self .knownget {
exec //nodict eq { end grestore_nopath false } { true } ifelse
} {
true % formaterror -- not a gsave dict
} ifelse
{ (\n **** File has imbalanced q/Q operators \(too many Q's\) ****\n)
pdfformaterror
} if
} bdef
% Save PDF gstate
/qstate { % - qstate <qstate>
gstate
} bdef
% Set PDF gstate
/setqstate { % <qstate> setqstate -
{ matrix setmatrix //false upath } stopped {
pop setgstate newpath
} {
% Save the CTM, set identity during the uappend, then set the CTM
exch setgstate matrix currentmatrix matrix setmatrix
exch newpath uappend setmatrix
} ifelse
} bdef
% ---------------- Color setting ---------------- %
/fcput % <color> <colorspace> fcput -
{ /FillColorSpace gput /FillColor gput
} bdef
/scput % <color> <colorspace> scput -
{ /StrokeColorSpace gput /StrokeColor gput
} bdef
/csput % <colorspace> csput -
{ csset 2 copy fcput scput
} bdef
/csdevgray [/DeviceGray] readonly def
/csdevrgb [/DeviceRGB] readonly def
/csdevcmyk [/DeviceCMYK] readonly def
/cspattern [/Pattern] readonly def
/nullpattern1 mark
/PatternType 1 /PaintType 1 /TilingType 3 /BBox [0 0 0 0]
/XStep 1 /YStep 1 /PaintProc { }
.dicttomark readonly def
/nullpattern2 nullpattern1 dup length dict copy readonly def
% Each entry in the color space dictionary is a procedure of the form
% <cspace> -proc- <cspace> <initial-color>
/CSdict mark
/DeviceGray { pop //csdevgray 0 } bind
/DeviceRGB { pop //csdevrgb [0 0 0] cvx } bind
/DeviceCMYK { pop //csdevcmyk [0 0 0 1] cvx } bind
/CIEBasedA { 0 } bind
/CIEBasedABC { [0 0 0] cvx } bind
/ICCBased { [ 1 index 1 oget /N get { 0 } repeat ] cvx } bind
/Separation { 1 } bind
/DeviceN { % What is the correct value??
[ 1 index 1 get length { 1 } repeat ] cvx
} bind
/Indexed { 0 } bind
/Pattern {
dup type /nametype eq 1 index length 1 eq or {
pop //cspattern //nullpattern1 matrix makepattern
} {
//nullpattern2 matrix makepattern 1 index 1 get csset
% Stack: patternspace nullpattern basecolor basespace
pop [ 3 1 roll dup type /arraytype eq { aload pop } if
counttomark -1 roll ] cvx
} ifelse
} bind
.dicttomark readonly def
/csset % <cspace> csset <color> <cspace>
{ dup dup type /nametype ne { 0 get } if //CSdict exch get exec exch
} bdef
/g { //csdevgray fcput } bdef
/G { //csdevgray scput } bdef
/rg { 3 array astore cvx //csdevrgb fcput } bdef
/RG { 3 array astore cvx //csdevrgb scput } bdef
/k { 4 array astore cvx //csdevcmyk fcput } bdef
/K { 4 array astore cvx //csdevcmyk scput } bdef
/cs { csset fcput } bdef
/CS { csset scput } bdef
/ri { pop } bdef
% We have to break up sc according to the number of operands.
/sc1 { /FillColor gput } bdef
/SC1 { /StrokeColor gput } bdef
% We have to avoid storing into a color array associated with an outer
% gsave level, so we do a kind of "copy on write".
/sc* {
currentdict /FillColor .knownget {
astore pop
} {
/FillColor load
% FillColor may contain either a single value or an array.
dup type /arraytype eq { length }{ pop 1 } ifelse
array astore cvx /FillColor gput
} ifelse
} bdef
/SC* {
currentdict /StrokeColor .knownget {
astore pop
} {
/StrokeColor load
% StrokeColor may contain either a single value or an array.
dup type /arraytype eq { length }{ pop 1 } ifelse
array astore cvx /StrokeColor gput
} ifelse
} bdef
% ---------------- Overprint/transparency setting ---------------- %
/op { /FillOverprint gput } bdef
/OP { /StrokeOverprint gput } bdef
/OPM {
/.setoverprintmode where { pop .setoverprintmode } { pop } ifelse
} bdef
/ca { /FillConstantAlpha gput } bdef
/CA { /StrokeConstantAlpha gput } bdef
/SMask { /SoftMask gput } bdef
/AIS { /AlphaIsShape gput } bdef
/BM {
/.setblendmode where {
pop [ exch dup type /nametype ne { aload pop } if /Normal ] {
{ .setblendmode } .internalstopped not { exit } if pop
} forall
} {
pop
} ifelse
} bdef
/TK {
/.settextknockout where { pop .settextknockout } { pop } ifelse
} bdef
% ---------------- Color installation ---------------- %
% Establish a given color (and color space) as current.
/.settransparencyparams { % <alpha> <smask> .settransparencyparams -
/.inittransparencymask where {
pop AlphaIsShape {
1 .setopacityalpha 0 .inittransparencymask exch .setshapealpha 1
} {
1 .setshapealpha 1 .inittransparencymask exch .setopacityalpha 0
} ifelse
% Set the soft mask by rendering the XObject. Doing this every time
% is obviously very inefficient; we'll improve it later.
.settransparencymask
} {
pop pop
} ifelse
} bdef
/.settransparencymask { % <paramdict> <masknum> .settransparencymask -
exch dup null eq {
pop .inittransparencymask
} {
dup /Draw get exec
} ifelse
} bdef
% (Non-mask) images must execute setfillblend.
/setfillblend {
FillOverprint setoverprint
FillConstantAlpha SoftMask .settransparencyparams
} def
/setfillstate {
FillColor FillColorSpace setgcolor setfillblend
} def
/setstrokestate {
StrokeColor StrokeColorSpace setgcolor StrokeOverprint setoverprint
StrokeConstantAlpha SoftMask .settransparencyparams
} def
/Cdict 15 dict dup begin % <color...> <colorspace> -proc- -
/DeviceGray { pop setgray } bdef
/DeviceRGB { pop setrgbcolor } bdef
/DeviceCMYK { pop setcmykcolor } bdef
/CIEBasedA { setgcolorspace setcolor } bdef
/CIEBasedABC /CIEBasedA load def
/CIEBasedDEF /CIEBasedA load def
/CIEBasedDEFG /CIEBasedA load def
/ICCBased /CIEBasedA load def
/Separation /CIEBasedA load def
/DeviceN /CIEBasedA load def
/Indexed /CIEBasedA load def
/Pattern
{ setgcolorspace
% Since multiple patterns may share
% same data stream, we need to ensure
% that the stream is at 0 position.
% Making this consistently with resolveshading,
% which applies ReusableStreamDecode filter
% to the PS stream, which represents the
% PDF stream in dynamics.
dup /Shading knownoget {
dup /ShadingType oget 4 ge {
/DataSource knownoget {
dup type /filetype eq {
0 setfileposition
} {
pop
} ifelse
} if
} {
pop
} ifelse
} if
dup /Matrix knownoget not { matrix } if
gsave DefaultQstate setqstate makepattern grestore setcolor
} bdef
end def
/setgcolor % (null | <color...>) <colorspace> setgcolor -
{ 1 index null eq
{ pop pop }
{ dup 0 get //Cdict exch get exec }
ifelse
} bdef
% Compare the old and new color spaces in an attempt to avoid expensive
% reloads of CIEBased color spaces.
/PCSdict 15 dict dup begin % <colorspace> -proc- <colorspace|pdfcspace>
/CIEBasedA { dup 1 get /PDFColorSpace .knownget { exch pop } if } bdef
/CIEBasedABC /CIEBasedA load def
/CIEBasedDEF /CIEBasedA load def
/CIEBasedDEFG /CIEBasedA load def
/Indexed {
dup 1 get dup pdfcolorspace 2 copy ne { 3 1 roll } if pop pop
} bdef
end def
/pdfcolorspace { % <colorspace> pdfcolorspace <colorspace|pdfcspace>
dup type /arraytype eq {
//PCSdict 1 index 0 get .knownget { exec } if
} if
} bdef
/setgcolorspace { % <colorspace> setgcolorspace -
dup pdfcolorspace currentcolorspace pdfcolorspace eq {
pop
} {
setcolorspace
} ifelse
} bdef
/fsexec % <fillop|strokeop> fsexec -
{ % Preserve the current point, if any.
{ currentpoint } stopped
{ $error /newerror false put cvx exec }
{ 3 -1 roll cvx exec moveto }
ifelse
} bdef
% ---------------- Path painting and clipping ---------------- %
/S { setstrokestate /stroke fsexec } bdef
/f { setfillstate /fill fsexec } bdef
/f* { setfillstate /eofill fsexec } bdef
/n { newpath } bdef % don't allow n to get bound in
/s { closepath S } bdef
/B { gsave setfillstate fill grestore S } bdef
/b { closepath B } bdef
/B* { gsave setfillstate eofill grestore S } bdef
/b* { closepath B* } bdef
% Clipping:
/Wdict 4 dict dup begin
/S { gsave setstrokestate stroke grestore n } bdef
/f { gsave setfillstate fill grestore n } bdef
/f* { gsave setfillstate eofill grestore n } bdef
/n { end clip newpath } bdef
end readonly def
/W { //Wdict begin } bdef
/W*dict 4 dict dup begin
Wdict { def } forall
/n { end eoclip newpath } bdef
end readonly def
/W* { //W*dict begin } bdef
% ---------------- Text control ---------------- %
/textbeginpage
{ /TextSpacing 0 def % 0 Tc
/TextLeading 0 def % 0 TL
/TextRenderingMode 0 def % 0 Tr
/TextRise 0 def % 0 Ts
/WordSpacing 0 def % 0 Tw
/TextHScaling 1.0 def % 100 Tz
/TextFont null def
/Show { showfirst } def
} bdef
% Contrary to the statement in the PDF manual, BT and ET *can* be nested,
% if the CharProc for a Type 3 font does a BT/ET itself.
% Since we always call the CharProc inside a q/Q, we simply ensure that
% the text state is saved and restored like the rest of the extended
% graphics state.
/settextmatrix {
TextMatrix concat
TextHScaling 1 ne { TextHScaling 1 scale } if
TextRise 0 ne { 0 TextRise translate } if
TextFont dup null eq { pop } { setfont } ifelse
} bdef
/settextstate {
% The text state can be set even outside BT/ET.
currentdict /TextSaveMatrix known {
TextSaveMatrix setmatrix settextmatrix
} if
} bdef
/settextposition {
% Update the TextMatrix translation.
gsave TextSaveMatrix setmatrix
currentpoint TextRise sub TextMatrix 4 2 getinterval astore pop
% We would like to do "grestore currentpoint translate"
% here, but some PDF files set a singular text matrix
% (0 0 0 0 <x> <y> Tm), so we can't do this.
TextTempMatrix identmatrix setmatrix currentpoint
grestore
TextTempMatrix currentmatrix 4 2 getinterval astore pop
TextTempMatrix setmatrix
} bdef
/BT {
currentdict /TextLineMatrix .knownget
{ identmatrix pop TextMatrix identmatrix pop }
{ matrix /TextLineMatrix gput matrix /TextMatrix gput }
ifelse
{ showfirst } /Show gput
currentdict /TextSaveMatrix .knownget not {
matrix dup /TextSaveMatrix gput
} if currentmatrix pop settextmatrix
matrix /TextTempMatrix gput % see settextposition
} bdef
/ET {
TextRenderingMode 4 ge { clip newpath } if
TextSaveMatrix setmatrix
currentdict /TextSaveMatrix undef
} bdef
/Tc { /TextSpacing gput { showfirst } /Show gput } bdef
/TL { /TextLeading gput } bdef
/Tr { dup .settextrenderingmode /TextRenderingMode gput { showfirst } /Show gput } bdef
/Ts { /TextRise gput settextstate } bdef
/Tw { /WordSpacing gput { showfirst } /Show gput } bdef
/Tz { 100 div /TextHScaling gput settextstate} bdef
% ---------------- Font control ---------------- %
/Tf { % <font> <scale> Tf -
dup 0 eq {
(\n **** Warning: Invalid 0.0 font scale given for Tf ****\n)
pdfformaterror
pop 0.00000001 % handle invalid scale by using a really small value
} if
dup 1 eq { pop } { scalefont } ifelse
/TextFont gput settextstate
} bdef
% Read a CFF font.
/FRD % <resname> <file> FRD -
{ /FontSetInit /ProcSet findresource begin //true ReadData
} bdef
% Copy a font, removing its FID. If changed is true, also remove
% the UniqueID and XUID, if any. If the original dictionary doesn't have
% the keys being removed, don't copy it.
/.copyfontdict % <font> <changed> .copyfontdict <dict>
{ 1 index /FID known
1 index { 2 index /UniqueID known or 2 index /XUID known or } if
{ % We add 1 to the length just in case the original
% didn't have a FID.
exch dup length 1 add dict exch
{ % Stack: changed newfont key value
1 index /FID eq 4 index
{ 2 index /UniqueID eq or 2 index /XUID eq or }
if not { 3 copy put } if pop pop
}
forall exch
}
if pop
} bdef
% Insert a new Encoding or Metrics into a font if necessary.
% Return a possibly updated font, and a flag to indicate whether
% the font was actually copied.
/.updatefontmetrics { % <font> <Metrics|null> .updatefontmetrics
% <font'> <copied>
dup //null ne {
exch //true .copyfontdict dup /Metrics 4 -1 roll put //true
} {
pop //false
} ifelse
} bdef
/.updatefontencoding { % <font> <Encoding|null> .updatefontencoding
% <font'> <copied>
dup //null ne { dup 2 index /Encoding get ne } { //false } ifelse {
exch //false .copyfontdict dup /Encoding 4 -1 roll put //true
} {
pop //false
} ifelse
} bdef
% Duplicate keys in CharString dictionary according to GlyphMap: <</new_glyph /old_glyph>>
% We have to do this because PDF fonts can associate multiple widths with the same glyph
% but Metrics dictionary works by the glyph name.
/.update_charstring { % <font> <GlyphMap> .update_charstring <font'> <copied>
dup //null ne {
exch //true .copyfontdict % map font
dup dup /CharStrings get % map font font cstr
dup length % map font font cstr len
4 index length add % map font font cstr len+map_len
dict copy dup begin % map font font cstr'
/CharStrings exch put % map font
exch { % font /new /old
currentdict exch .knownget {
def
} {
currentdict /.notdef .knownget {
def
} {
pop
% The font has no .notdef.
% Could not resolve the conflict,
% but either the font is invalid or the glyph name is never used.
} ifelse
} ifelse
} forall
end //true
} {
pop //false
} ifelse
} bdef
/.updatefont { % <font> <Encoding|null> <Metrics|null> <GlyphMap|null>
% .updatefont <font'> <copied>
4 2 roll % <Metrics|null> <GlyphMap> <font> <Encoding|null>
.updatefontencoding % <Metrics|null> <GlyphMap> <font> bool
4 1 roll exch % bool <Metrics|null> <font> <GlyphMap>
.update_charstring % bool <Metrics|null> <font> bool
3 1 roll exch % bool bool <font> <Metrics|null>
.updatefontmetrics % bool bool <font> bool
4 2 roll or or % <font> is_copied
} bdef
% ---------------- Text positioning ---------------- %
/Td {
TextLineMatrix transform TextLineMatrix 4 2 getinterval astore pop
TextLineMatrix TextMatrix copy pop settextstate
} bdef
/TD { dup neg /TextLeading gput Td } bdef
/T* { 0 TextLeading neg Td } bdef
/Tm {
TextLineMatrix astore TextMatrix copy pop settextstate
} bdef
% ---------------- Text painting ---------------- %
/Vexch {
rootfont /WMode knownoget { 1 eq { exch } if } if
} bind def
/textrenderingprocs [ % (0 is handled specially)
% Painting-only modes
{ tf } { tS } { tB } { tn }
% Clipping modes
{ gsave tf grestore tW }
{ gsave tS grestore tW }
{ gsave tB grestore tW }
{ tW }
] readonly def
/setshowstate
{ WordSpacing 0 eq TextSpacing 0 eq and
{ TextRenderingMode 0 eq {
{ setfillstate show }
} {
TextRenderingMode 3 eq {
% Some PDF files execute 'tm' with a singular matrix,
% and then use the text rendering mode 3.
% The graphics library currently cannot handle text
% operations when the CTM is singular.
% Work around this here.
{
matrix currentmatrix dup
dup 0 get 0 eq 1 index 1 get 0 eq and {
dup dup 2 get 0 eq { 0 }{ 1 } ifelse 1 put
} if
dup 2 get 0 eq 1 index 3 get 0 eq and {
dup dup 1 get 0 eq { 3 }{ 2 } ifelse 1 put
} if
setmatrix
1 index setfillstate show % Tr was set to graphic state.
setmatrix
% now set the currentpoint using the original matrix
false charpath currentpoint newpath moveto
}
} {
{ false charpath textrenderingprocs TextRenderingMode get exec }
} ifelse
} ifelse
}
{ TextRenderingMode 0 eq TextRenderingMode 3 eq or
% Tr was set to graphic state.
{ WordSpacing 0 eq
{ { setfillstate TextSpacing 0 Vexch 3 -1 roll ashow } }
{ TextSpacing 0 eq
{ { setfillstate WordSpacing 0 Vexch 32 4 -1 roll widthshow } }
{ { setfillstate WordSpacing 0 Vexch 32
TextSpacing 0 Vexch 6 -1 roll awidthshow } }
ifelse
}
ifelse
}
{ { WordSpacing TextSpacing
% Implement the combination of t3 and false charpath.
% Note that we must use cshow for this, because we
% can't parse multi-byte strings any other way.
% Stack: string xword xchar
{ pop pop (x) dup 0 3 index put false charpath
% Stack: xword xchar ccode
3 copy 32 eq { add } { exch pop } ifelse 0 Vexch rmoveto pop
}
4 -1 roll cshow pop pop
textrenderingprocs TextRenderingMode get exec
}
}
ifelse
}
ifelse /Show gput
} bdef
/showfirst { setshowstate Show } def
/Tj {
0 0 moveto Show settextposition
} bdef
/' { T* Tj } bdef
/" { exch Tc exch Tw T* Tj } bdef
/TJ {
0 0 moveto {
dup type /stringtype eq {
Show
} { -1000 div
currentfont /ScaleMatrix .knownget { 0 get mul } if
0 Vexch rmoveto
} ifelse
} forall settextposition
} bdef
/tf { setfillstate currentpoint fill moveto } bdef
/tn { currentpoint newpath moveto } bdef % Obsolete, never used.
% For stroking characters, temporarily restore the graphics CTM so that
% the line width will be transformed properly.
/Tmatrix matrix def
/tS
{ setstrokestate
currentpoint //Tmatrix currentmatrix TextSaveMatrix setmatrix stroke
setmatrix moveto
} bdef
/tB { gsave tf grestore tS } bdef
% This does the wrong thing if there have been multiple text operations
% within a single BT/ET pair, but it's a start.
/tW { } bdef
end readonly put % GS_PDF_ProcSet
.setglobal