home *** CD-ROM | disk | FTP | other *** search
/ Carousel Volume 2 #1 / carousel.iso / mactosh / lang / distillp.sit / still.ps < prev   
Encoding:
Text File  |  1989-04-03  |  67.0 KB  |  2,199 lines  |  [TEXT/unix]
  1. %!PS-Adobe-2.1
  2. %%Title: still.ps
  3. %%Creator: Glenn Reid, Adobe Systems <adobe!greid@decwrl.dec.com>
  4. %%CreationDate:    greid Wed Jul  6 18:02:53 1988 EDIT: Wed Mar 15 12:46:06 1989
  5. %%VMUsage: 44036 (approx)
  6. %%EndComments
  7.  
  8. % Notice: Copyright 1988 1989 Adobe Systems Incorporated.  All Rights Reserved.
  9.  
  10. /adobe_distill 155 200 add dict def    % 155 required by still.ps
  11. /adobe_still_version ((V 1.0d release 10 edit 08)) def
  12.  
  13. % options:
  14. /debug true def            % generate debugging messages
  15. /messages false def        % generate more debugging messages (verbose!)
  16. /trace true  def        % print tracing messages like "page: 3"
  17. /substitutefonts true def    % substitute fonts if guess_font fails....
  18. /includeuserfonts true def    % copy embedded user-defined fonts to output?;
  19. /printpages false def        % do you want the pages to print?
  20. /optimize true  def        % optimize "show" to "widthshow", etc.
  21. /tolerance .05 def        % for "essentially equal to" operations
  22. /cachedir 60 dict def        % how many font dicts to cache (optimization)
  23. /includeprologue true def    % output files with/without prologue
  24.  
  25. % 
  26. % HOW TO USE: [see section below]
  27. %
  28. % OVERVIEW:
  29. %    This is a meta-utility program that "distills" any PostScript
  30. %    language program into a simpler one.  The resulting program
  31. %    will print exactly the same page as the original, but all
  32. %    unnecessary execution overhead is eliminated and the file is
  33. %    clean, uniform, and fast.
  34. %
  35. % RELEASE NOTES: [recent changes and details]
  36. %    First public release: 2/10/89
  37. %    Second release (numbered release 8): 2/17/89
  38. %        - reimplemented guess_font routines
  39. %        - added support for color; not careful about RGB->CMYK->RGB
  40. %        - added selective printing of pages during distill
  41. %    Release 9: 3/2/89
  42. %        - fixed color-induced [major efficiency loss] bug
  43. %        - produces %%BoundingBox and %%PageBoundingBox info (atend)
  44. %        - works better (bugs fixed) on rotated (landscape) documents
  45. %        - fixed horrible bug related to CTM that made it resolution-
  46. %          dependent in some cases.
  47. %        - included flag to omit the prologue on output if desired
  48. %        - moved some of the flags to the beginning of the file
  49. %        - improved prologue code to simulate CMYK color with RGB
  50. %    Release 10: 3/10/89
  51. %        - fixed bug related to rotated text
  52. %        - fixed rotated charpath bug mentioned in KNOWN PROBLEMS list
  53. %        - fixed bug with "closepath" followed by "rmoveto"
  54. %        - '=' and 'print' operators now pass data through to output
  55. %        - bug fixes for and much better support of user-defined fonts
  56. %        - (edit 07) fixed "undefined" "fd" problem.
  57. %        - (edit 08) took out redefinitions of '=' and 'print'; fixed
  58. %          a different "undefined" "fd" problem!
  59. %
  60. % MANY USES:
  61. %    * If you archive documents in PostScript format, they can be
  62. %      made compact and efficient by distilling them.
  63. %    * As a development tool, you can see what your program is
  64. %      really doing, and how simple and fast the driver could be.
  65. %    * Distilled files can be used as an interchange format,
  66. %      since arbitrary PostScript files can be converted to this
  67. %      uniform representation.
  68. %    * If your program can parse these files, then any arbitrary
  69. %      PostScript program can be used as input after distilling.
  70. %    * Many others.
  71. %
  72. % FEATURES:
  73. %    * correctly distills arbitrarily complex PostScript programs
  74. %    * output is universal, simple, and in default user coordinates
  75. %    * handles "charpath", "image", "imagemask", "awidthshow", etc.
  76. %    * correctly follows "save", "restore", "gsave", "grestore"
  77. %    * re-encodes fonts automatically to match application encoding
  78. %    * reduces prologue size to only about 25-30 lines
  79. %    * For machine-generated code:
  80. %        * output files are almost always SMALLER than original files
  81. %         * output files are almost always FASTER than original files
  82. %    * optimizes "show" to use "widthshow" whenever possible.
  83. %    * uses save/restore at page boundaries
  84. %    * observes structuring conventions and page independence
  85. %    * caches font dictionaries instead of repeating "findfonts"
  86. %    * output is normally VERY fast.
  87. %
  88. % HOW TO USE:
  89. %    This program redefines a bunch of operators, and is invoked
  90. %    with the word "distill".  This file has to precede the job it is
  91. %    distilling, and you have to invoke it by calling "distill".
  92. %
  93. %    PRINTERS:
  94. %        In general, start with this file (still.ps), add the word
  95. %        "distill" at the end (to invoke the procedure), and tack
  96. %        any PostScript language file onto the end.  Send this to
  97. %        your favorite PostScript printer with an appropriate
  98. %        end-of-file indication at the end.  Results will
  99. %        be returned across communication channel, often to a log
  100. %        file somewhere (Unix: /usr/adm/printername.log)
  101. %
  102. %    INTERPRETERS: if you have an interpreter with a file system
  103. %        handy, first type "(still.ps) run" to load this file, then
  104. %        distill your file like this: "(prog.ps) distill".  It will
  105. %        write the results in "prog.psx" (appends an x to the file
  106. %        name you give it).
  107. % 
  108. %    MACINTOSH: I have written a small Mac utility that is called
  109. %        "DistillPS" (an adaptation of "SendPS") that will perform the
  110. %        above PRINTER steps for you.  If you are an Adobe registered
  111. %        developer, you can get a copy directly from Adobe (or see
  112. %        posting in USENET comp.binaries.mac group).
  113. %
  114. % BACKGROUND
  115. % The basic idea is to execute the input file completely, with all of
  116. % the painting operators redefined.  When one of these operators is
  117. % called by the client program, the distillery will write the
  118. % path the output file (with all coordinates normalized to the default
  119. % userspace coordinate system).  Note that it will usually take LONGER
  120. % to distill a file than it would to print it, because it executes the
  121. % whole program, and much of it in a redefined state (slower).  Usually
  122. % only about 20% slower than original print time to distill.
  123. % 
  124. % The routines in this file are broken down into several areas.  Most
  125. % of them are concerned with writing things to the output file,
  126. % actually, although there are two other interesting areas.  The first
  127. % are the graphics state procedures, which attempt to keep track of the
  128. % graphics state and, when a painting op is called, it writes out any
  129. % changes to the graphics state since the last time it was called.  This
  130. % keeps each painting op from having to write gstate itself.  The other
  131. % interesting procs are simply the redefinitions of the painting ops
  132. % themselves.
  133. %
  134. % KNOWN COMPATIBLE PROGRAMS
  135. % The following applications have been tested (with some version of the
  136. % driver, at least), successfully:
  137. %    Lotus Manuscript
  138. %    Macintosh "LaserPrep" (all documents, I think)
  139. %    DEC's VaxDocument
  140. %    Scribe
  141. %    PageMaker
  142. %    Frame Maker
  143. %    Adobe Illustrator
  144. %    TranScript (ditroff and enscript drivers)
  145. %
  146. % KNOWN PROBLEMS:
  147. %    Clipping isn't handled correctly.
  148. %
  149. %    I'm not convinced that the bounding box for images is right.
  150. %
  151. %    Hand-written PostScript language programs (especially those
  152. %    that take advantage of looping constructs) may get BIGGER
  153. %    when you distill them, because the Distillery unrolls all loops.
  154. %    It is really intended for machine-generated files, but it should
  155. %    still work on programs tightly coded by hand (like Cookbook
  156. %    examples).
  157. %
  158. %    Use of the "put" and "putinterval" operators to overwrite
  159. %    string bodies can confuse the optimization technique.  If you
  160. %    see strange output (wrong characters printed, especially),
  161. %    try changing "/optimize true def" to "/optimize false def"
  162. %    at the very beginning of this program.
  163. %
  164. %    Programs that use the "transform" operator to make resolution-
  165. %    rounding decisions may have the output file bound to a specific
  166. %    resolution.  The last ProcSet (called "hacks") redefines a few
  167. %    operators to try to work around this.  Output file is still
  168. %    device-independent in any case, but might look different.
  169. %
  170. %    Distillery relies on bug in save/restore related to string bodies
  171. %    to preserve some information across save/restore. It is localized
  172. %    to the "adobe_staticvar" procedure set, but may not always work.
  173. %
  174. %    In order to optimize re-encoding of fonts, the distillery takes
  175. %    an educated guess that the first re-encoded font it sees will
  176. %    have a representative encoding vector ("stdvec").  If this
  177. %    first font is not encountered before other marks are made, the encoding
  178. %    vector cannot be produced in the %%BeginSetup section, and the still
  179. %    is forced to repeat the vector every time a font is used.  Work
  180. %    is in progress on a heuristic to improve this.
  181. %
  182. %       In order to avoid building up the dictionary stack during
  183. %       execution, all definitions are made in one dictionary
  184. %       (PROLOGUE) and it is not explicitly brought to the top of
  185. %       the dictionary stack for each operation (to avoid
  186. %       "dictstackoverflow" errors).  Most of the identifiers have
  187. %       been chosen to be reasonably unique, but there could be a
  188. %       conflict if user programs use the same names.
  189. %
  190. %    Sometimes generates unnecessarily verbose code in the presence
  191. %    of lots of save/restores in original file.  Try distilling the
  192. %    output a second time to improve this (like whiskey)....
  193. %
  194. %    Some of the ProcSets depend on each other in weird ways, which
  195. %    is definitely wrong, since only the script should depend on
  196. %    the procset definitions.  Eventually this will get fixed.
  197. %
  198. %    Does not always work correctly with user-defined fonts, especially
  199. %    those defined by the standard TeX driver (unfortunately).  In
  200. %    particular, TeX bitmap fonts that are defined and have characters
  201. %    added on the fly are almost impossible to deal with reliably in this
  202. %    distillery approach.
  203.  
  204. %%BeginProcSet: originals 0.5
  205. % This dictionary contains the original definitions of native operators
  206. % that have been redefined by the Distillery.  They are needed on
  207. % occasion to permit the original program to execute operators without
  208. % having the results distilled.  The motivating factor for this is
  209. % user-defined fonts, which "draw" into the font cache, but the effects
  210. % are not wanted in the output file.
  211. %
  212. % This also serves as a list of the redbook operators that are redefined
  213. % by the distillery code.
  214.  
  215. mark
  216.   /show
  217.   /widthshow
  218.   /ashow
  219.   /awidthshow
  220.   /kshow
  221.   /fill
  222.   /eofill
  223.   /stroke
  224.   /clip
  225.   /image
  226.   /imagemask
  227.   /showpage
  228.   /pathbbox
  229.   /save
  230.   /restore
  231.   /gsave
  232.   /grestore
  233.   /charpath
  234.   /newpath
  235.   /definefont
  236.   /flushfile
  237.   /=
  238.   /print
  239. counttomark dup dict begin { dup load def } repeat pop
  240. /originals currentdict end def
  241.  
  242. %%EndProcSet: originals 0.5
  243.  
  244. %%BeginProcSet: distill_defs 1.0 0
  245. /setpacking where { pop currentpacking true setpacking } if
  246. /firstmtx matrix currentmatrix def
  247.  
  248. /bdef { bind def } bind def
  249.  
  250. /ifnotdef { %def
  251.   % only does the "def" if the key has not already been defined:
  252.     1 index where { pop pop pop }{ def } ifelse
  253. } bdef
  254.  
  255. /*flushfile /flushfile load ifnotdef
  256.  
  257. printpages not { %if
  258.     /showpage { erasepage initgraphics } bind def
  259. } if
  260.  
  261. /currentcmykcolor where { pop }{ %else
  262.     /currentcmykcolor { %def
  263.         currentrgbcolor 3 { 1 exch sub 3 1 roll } repeat 0
  264.     } bind def
  265. } ifelse
  266.  
  267. /setpacking where { pop setpacking } if
  268. %%EndProcSet
  269.  
  270. %%BeginProcSet: Adobe_staticvar 1.0 0
  271.     % this procedure set implements the "magic" stuff to hide numbers
  272.     % and other things where they will not be subject to save/restore
  273.     /magicval { 8 string } bdef
  274.     /hideval { %def    % /name int :    % "hideval" uses save/restore bug!
  275.     exch load dup 0 (\040\040\040\040\040\040\040\040) putinterval
  276.     exch (\040\040\040\040\040\040\040\040) cvs
  277.     dup length 8 exch sub exch putinterval
  278.     } bdef
  279.     /magicbool { 5 string } bdef
  280.     /hidebool { %def    % /name int :    % "hideval" uses save/restore bug!
  281.     exch load dup 0 (\040\040\040\040\040) putinterval
  282.     exch (\040\040\040\040\040) cvs 0 exch putinterval
  283.     } bdef
  284.     /cvnum { cvx exec } bdef    % makes hidden val back into an integer
  285.     /cvbool { cvx exec } bdef    % makes hidden val back into a boolean
  286.     /hidefontname { %def
  287.     % hides a font name in a string body, for use in %%DocumentFonts
  288.     scratch cvs
  289.     % look to see if it is already in the docfonts string:
  290.     % lots of hacks to search for (FontName\n), not just (FontName)
  291.     save    % cause we're using memory for temporary string
  292.         adobe_distill begin
  293.         1 index length 1 add string /tmpstring exch def
  294.         tmpstring dup length 1 sub (\040) 0 get put
  295.         tmpstring 0 3 index putinterval
  296.         pagefonts tmpstring search {pop pop pop false}{pop true} ifelse
  297.         docfonts tmpstring search {pop pop pop false}{pop true}ifelse
  298.         end
  299.     3 -1 roll restore        % roll save object past booleans
  300.  
  301.     % first deal with docfonts, then with pagefonts booleans
  302.     { %ifelse
  303.         exch    % extra boolean for page fonts
  304.         dup dfontcount cvnum 1 index length add 1 add
  305.         docfonts length lt {
  306.         dup docfonts exch dfontcount cvnum exch putinterval
  307.         length 1 add dfontcount cvnum add /dfontcount exch hideval
  308.         docfonts dfontcount cvnum 1 sub (\040) putinterval
  309.         }{ %else
  310.         pop (% No more room for fonts in document font list\n) d=
  311.         } ifelse
  312.         messages { %if
  313.         (document fonts: ) pr=
  314.         docfonts 0 dfontcount cvnum getinterval d= flush
  315.         } if
  316.         exch % page font boolean still on stack, under "dup"ed string
  317.     }{ } ifelse
  318.     { %ifelse
  319.         pfontcount cvnum 1 index length add 1 add
  320.         pagefonts length lt {
  321.         dup pagefonts exch pfontcount cvnum exch putinterval
  322.         length 1 add pfontcount cvnum add /pfontcount exch hideval
  323.         pagefonts pfontcount cvnum 1 sub (\040) putinterval
  324.         }{ %else
  325.         pop (% No more room for fonts in page font list\n) d=
  326.         } ifelse
  327.         messages { %if
  328.         (page fonts: ) pr=
  329.         pagefonts 0 pfontcount cvnum getinterval d= flush
  330.         } if
  331.     }{ pop } ifelse
  332.     } bdef
  333. %%EndProcSet: Adobe_staticvar 1.0 0
  334.  
  335. %%BeginProcSet: distill 1.0 0
  336. /setpacking where { pop currentpacking true setpacking } if
  337.  
  338. /adobe_distill dup where { pop pop }{ 165 200 add dict def } ifelse
  339.  
  340. % some variables
  341.     % magic variables depending on "hideval", not subject to save/restore
  342.     /pagecount magicval def    /pagecount 1 hideval
  343.     /beginsetup magicbool def    /beginsetup true hidebool
  344.     /lastshowpage magicbool def    /lastshowpage false hidebool
  345.     /begunpage magicbool def    /begunpage false hidebool
  346.     /?distilling magicbool def    /?distilling true hidebool
  347.  
  348.     /dfontcount magicval def     /dfontcount 0 hideval
  349.     /pfontcount magicval def    /pfontcount 0 hideval
  350.     /docfonts 40 30 mul string def        % room for 40 30-byte font names
  351.     /pagefonts 40 30 mul string def        % room for 40 30-byte font names
  352.     /LLx magicval def        /LLx 10000 hideval
  353.     /LLy magicval def        /LLy 10000 hideval
  354.     /URx magicval def        /URx -10000 hideval
  355.     /URy magicval def        /URy -10000 hideval
  356.     /docLLx magicval def    /docLLx 10000 hideval
  357.     /docLLy magicval def    /docLLy 10000 hideval
  358.     /docURx magicval def    /docURx -10000 hideval
  359.     /docURy magicval def    /docURy -10000 hideval
  360.  
  361.     /optim optimize def
  362.     /scratch 128 string def
  363.     /fontcount 0 def
  364.     /indentlevel 0 def
  365.     /ANYtype null def
  366.     /insideproc false def
  367.     /Dfont null def
  368.     /Ffont null def
  369.     /Fname null def
  370.     /lastshow false def
  371.     /imageproc null def
  372.     /imagematrix null def
  373.     /imagedepth null def
  374.     /imageheight null def
  375.     /imagewidth null def
  376.     /unames 120 dict def    % for keeping track of user-defined names
  377.  
  378. % a few of them go into userdict:
  379. /cvp {
  380.     messages { % ifelse
  381.     (                     ) cvs pr= (\040) pr=
  382.     }{ pop } ifelse
  383. } bdef
  384. /pr= { messages { rprint }{ pop } ifelse } bdef
  385. /d= { messages { r= }{ pop } ifelse } bdef
  386.  
  387. /distill {
  388.     adobe_distill begin
  389.     debug{(%!PS-Adobe-2.1 debug version ) rprint adobe_still_version == }if
  390.     userdict /orig_dictcount countdictstack put
  391.     count 0 eq { %ifelse
  392.         /INfile (%stdin) def
  393.         /OUTfile (%stdout) def
  394.         /fd (%stdout) (w) file def
  395.         initstill
  396.         writeprologue
  397.         initgstate
  398.         INfile (r) file cvx exec
  399.         writetrailer
  400.     }{ %else
  401.         dup type /stringtype ne { %if
  402.         (\n% Distill Error; invoked with bogus file name: ) print
  403.         == (\n) print flush
  404.         stop
  405.         } if
  406.         /filenameforall where { pop }{ %ifelse
  407.         (\n% Distill Error; invoked with file name: ) print == 
  408.         (% This interpreter cannot open files directly.) = 
  409.         (% Please add "distill" at end of file and concatenate with) = 
  410.         (% file to be distilled.) = (\n) print flush
  411.         stop
  412.         } ifelse
  413.         initgraphics
  414.         /saveall save def
  415.         /INfile exch def
  416.         /OUTfile INfile length 1 add string def
  417.         OUTfile 0 INfile putinterval
  418.         OUTfile dup length 1 sub (x) 0 get put
  419.         trace { (output file: ) rprint OUTfile == } if
  420.         /outfile OUTfile (w) file def
  421.         /fd /outfile load def
  422.         initstill
  423.         writeprologue
  424.         initgstate
  425.         debug { %ifelse
  426.             INfile run
  427.         }{ % else
  428.             { INfile run } stopped { % if
  429.              errordict begin $error begin
  430.                 (\n%%[Error: ) wout
  431.                 /errorname load =string cvs wout
  432.                 (; OffendingCommand: ) wout
  433.                 /command load =string cvs wout (]%%) wout writeNL
  434.                 (STACK:) writeop /ostack load type /arraytype eq {
  435.                 ostack { =string cvs writeop } forall
  436.                 } if
  437.                 fd systemdict /flushfile get exec
  438.                 handleerror
  439.             end end
  440.             } if
  441.         } ifelse
  442.         writetrailer
  443.         fd closefile
  444.         countdictstack orig_dictcount sub { end } repeat
  445.         clear
  446.         saveall { restore } stopped { %if
  447.         trace { (couldn't restore after distill.) r= } if
  448.         } if
  449.     } ifelse
  450.    end
  451. } bdef
  452.  
  453. % the rest of them go in "adobe_distill"
  454. adobe_distill begin
  455.     /setdistill { %def
  456.     /?distilling exch hidebool
  457.     } bdef
  458.  
  459.     /initstill { %def
  460.     /beginsetup true hidebool
  461.     /lastshowpage false hidebool
  462.     /begunpage false hidebool
  463.     /pagecount 1 hideval
  464.     /STDvec 0 hideval
  465.     /PAGEvec 0 hideval
  466.     /dfontcount 0 hideval
  467.     /pfontcount 0 hideval
  468.     /LLx 10000 hideval  /LLy 10000 hideval
  469.     /URx -10000 hideval /URy -10000 hideval
  470.     /docLLx 10000 hideval  /docLLy 10000 hideval
  471.     /docURx -10000 hideval /docURy -10000 hideval
  472.     /SharedFontDirectory where { %ifelse
  473.         /SharedFontDirectory get
  474.     }{ /FontDirectory load } ifelse
  475.     /FontDirectory exch def
  476.     0 1 pagefonts length 1 sub { pagefonts exch 0 put } for
  477.     0 1 docfonts length 1 sub { docfonts exch 0 put } for
  478.     } bdef
  479.     debug { %if
  480.     /BB {
  481.         debug {
  482.         (% BBox: ) pr=
  483.         LLx pr= ( ) pr= LLy pr= ( ) pr=
  484.         URx pr= ( ) pr= URy pr= (\n) pr= flush
  485.         (% DocBBox: ) pr=
  486.         docLLx pr= ( ) pr= docLLy pr= ( ) pr=
  487.         docURx pr= ( ) pr= docURy pr= () r= flush
  488.         } if
  489.     } bdef
  490.     } if
  491.     /?box { %def    % X Y
  492.     dup URy cvnum gt { dup /URy exch cvi hideval } if
  493.     dup LLy cvnum lt { dup /LLy exch cvi hideval } if pop
  494.     dup URx cvnum gt { dup /URx exch cvi hideval } if
  495.     dup LLx cvnum lt { dup /LLx exch cvi hideval } if pop
  496.     } bdef
  497.     /doc?box {
  498.     dup docURy cvnum gt { dup /docURy exch cvi hideval } if
  499.     dup docLLy cvnum lt { dup /docLLy exch cvi hideval } if pop
  500.     dup docURx cvnum gt { dup /docURx exch cvi hideval } if
  501.     dup docLLx cvnum lt { dup /docLLx exch cvi hideval } if pop
  502.     } bdef
  503.     /pageBBox-docBBox {
  504.     LLx cvnum LLy cvnum doc?box
  505.     URx cvnum URy cvnum doc?box
  506.     } bdef
  507.     /writeRmove { %def
  508.     2 copy lineY sub exch lineX sub exch
  509.     dup 0.0 eq { pop writenum (x) writeop }{ %ifelse
  510.         1 index 0.0 eq { writenum (y) writeop pop }{ %ifelse
  511.         writepair (r) writeop
  512.         } ifelse
  513.     } ifelse
  514.     2 copy ?box
  515.     /lineY exch store /lineX exch store
  516.     } bdef
  517.     /writelines { %def
  518.     counttomark REPEAT_LINETO_THRESHOLD gt { % ifelse
  519.         counttomark /lcount exch store
  520.         lcount -2 2 { %for
  521.         dup /rcount exch store
  522.         -2 roll 2 copy lineY sub exch lineX sub exch 4 -2 roll
  523.         2 copy ?box
  524.         /lineY exch store /lineX exch store
  525.         rcount 2 roll
  526.         } for
  527.         lcount 2 idiv { writepair writeNL } repeat
  528.         lcount 2 idiv writenum (R) writeop
  529.     }{ % else
  530.         counttomark -2 2 { -2 roll writeRmove } for
  531.     } ifelse
  532.     } bdef
  533.     /writepath {
  534.     /closed false store
  535.     % optimize special case of just "moveto lineto stroke"
  536.     mark
  537.     % pathforall
  538.     { counttomark 2 gt { cleartomark false exit } if thruCTM true }
  539.     { counttomark 5 gt { cleartomark false exit } if thruCTM true }
  540.     { cleartomark false exit }
  541.     { cleartomark false exit }
  542.     pathforall { %ifelse
  543.         counttomark 5 ne { %ifelse
  544.         % degenerate case...
  545.         ischarpath counttomark 2 eq and {    % just moveto
  546.             2 copy ?box
  547.             writepair (m) writeop
  548.         } if
  549.         cleartomark
  550.         }{ %else
  551.         3 -1 roll pop
  552.         /?simplepath true store
  553.         simplepath astore pop
  554.         pop %mark
  555.         } ifelse
  556.     }{ %else
  557.         /?simplepath false store
  558.         mark
  559.         { % moveto
  560.         closed { (cp ) wout /closed false store } if
  561.         counttomark 2 gt { %if
  562.             counttomark 1 add 2 roll writelines 3 1 roll
  563.         } if
  564.         2 copy thruCTM /lineY exch store /lineX exch store
  565.         /closeX lineX store  /closeY lineY store
  566.         2 copy ?box
  567.         writeTpair (m) writeop
  568.         } % moveto proc
  569.         { %lineto proc
  570.         thruCTM count 490 gt { writelines } if
  571.         } % lineto
  572.         { % curveto
  573.         counttomark 6 gt { %if
  574.             counttomark 1 add 6 roll writelines 7 1 roll
  575.         } if
  576.         2 copy thruCTM /lineY exch store /lineX exch store
  577.         3 { %repeat
  578.             6 -2 roll 2 copy thruCTM
  579.             2 copy ?box
  580.             exch writenum writenum
  581.         } repeat (c) writeop 6 {pop} repeat
  582.         } % curveto
  583.         { % closepath
  584.         counttomark 0 gt { writelines } if
  585.         /closed true store
  586.         /lineX closeX store  /lineY closeY store
  587.         } % closepath
  588.         pathforall
  589.         counttomark 0 gt { writelines } if
  590.         pop %mark
  591.     } ifelse
  592.     } bdef
  593.     /hashpath { %def
  594.       % manufacture a [fairly] unique integer to represent a path:
  595.     -1                % initial value
  596.     { .5 add add 2 div add }    % moveto
  597.     { add sub }            % lineto
  598.     { add add sub add add add }    % curveto
  599.     { 1 add }            % closepath
  600.     pathforall
  601.     dup 100 lt { 10 mul truncate 10 div } if
  602.     } bdef
  603.     /hashencoding { %def
  604.       % manufacture a [fairly] unique integer for an encoding vector,
  605.       % by alternately adding then subtracting the length of the name.
  606.       % The alternation makes reordered lists with same names still come out
  607.       % with a different hash value (the "-1 exch" and the "mul" do this)
  608.     -1 exch 0 exch            % initial value: 0
  609.     { % forall
  610.         dup type /nametype eq { length }{ pop 1 } ifelse
  611.         2 index mul add    % multiply by 1 or -1 and add
  612.         exch -1 mul exch    % flip 1 and -1
  613.     } forall
  614.     exch pop            % get rid of -1, leave hash val
  615.     } bdef
  616.     /STDvec magicval def /STDvec 0 hideval
  617.     /PAGEvec magicval def /PAGEvec 0 hideval
  618.     /enc1 null def /enc2 null def
  619.     /diffencoding { %def
  620.     % check the "top128" boolean to see if it's worth reencoding them
  621.     /enc2 exch store /enc1 exch store    % enc2 is the new one
  622.     [ 
  623.         32 1 127 { %for                % 0 1 255 ??
  624.         dup dup enc2 exch get exch enc1 exch get
  625.         1 index eq { pop pop } if
  626.         } for
  627.     ]
  628.     } bdef
  629.     /indent { indentlevel { fd (  ) writestring } repeat } bdef
  630.     /++ { dup load 1 add store } bdef
  631.     /-- { dup load dup 1 ge { 1 sub } if store } bdef
  632.  
  633. end %adobe_distill
  634. /setpacking where { pop setpacking } if
  635. %%EndProcSet
  636.  
  637. %%BeginProcSet: distill_writetofile 1.0 0
  638. /setpacking where { pop currentpacking true setpacking } if
  639. /adobe_distill dup where { pop pop }{ 165 200 add dict def } ifelse
  640. adobe_distill begin
  641.     /writetrailer { %def    % :
  642.     stackptr 0 ne { stackshow } if
  643.     begunpage cvbool { %if
  644.         lastshowpage cvbool not { %if
  645.         ( /showpage {} def) writeop
  646.         } if
  647.         pagecount cvnum scratch cvs wout ( ENDPAGE\n) wout
  648.         (%%PageTrailer) writeop
  649.         (%%PageFonts: ) wout
  650.         pfontcount cvnum 0 eq { writeNL }{ %else
  651.         pfontcount cvnum 200 lt { %ifelse
  652.             pagefonts 0 pfontcount cvnum getinterval writeop
  653.         }{ %else
  654.             pagefonts (\040) search not { writeop }{ %else
  655.             writeop    % first one without the %%+
  656.             { %loop
  657.                 search { (%%+ ) wout writeop }{ %else
  658.                 (\000) search { writeop pop pop }{ pop } ifelse
  659.                 exit
  660.                 } ifelse
  661.             } loop
  662.             } ifelse
  663.         } ifelse
  664.         0 1 pfontcount cvnum { pagefonts exch 0 put } for
  665.         /pfontcount 0 hideval
  666.         } ifelse
  667.         LLx 10000 eq LLy 10000 eq or
  668.         URx -10000 eq URy -10000 eq or or not {
  669.         (%%PageBoundingBox: ) wout
  670.           LLx cvnum writenum LLy cvnum writenum
  671.           URx cvnum writenum URy cvnum writenum writeNL
  672.         } if
  673.         pageBBox-docBBox
  674.     } if
  675.     (%%Trailer) writeop
  676.     (end %PROLOGUE) writeop
  677.     (%%Pages: ) wout pagecount cvnum writenum writeNL
  678.     (%%BoundingBox: ) wout
  679.       docLLx cvnum writenum docLLy cvnum writenum
  680.       docURx cvnum writenum docURy cvnum writenum writeNL
  681.     (%%DocumentFonts: ) wout
  682.     dfontcount cvnum 0 eq { writeNL }{ %else
  683.         dfontcount cvnum 200 lt { %ifelse
  684.         docfonts 0 dfontcount cvnum getinterval writeop
  685.         }{ %else
  686.         docfonts (\040) search not { writeop }{ %else
  687.             writeop    % first one without the %%+
  688.             { %loop
  689.             search { (%%+ ) wout writeop }{ %else
  690.                 (\000) search { writeop pop pop }{ pop } ifelse
  691.                 exit
  692.             } ifelse
  693.             } loop
  694.         } ifelse
  695.         } ifelse
  696.     } ifelse
  697.     (%%EOF) writeop
  698.     } bdef
  699.     /writecomments { %def
  700.     fd (%!PS-Adobe-2.1\n) writestring
  701.     fd (%%Title: ) writestring fd OUTfile writestring fd (\n) writestring
  702.     fd (%%Creator: Glenn Reid and still.ps ) writestring
  703.     fd adobe_still_version writestring fd (\n) writestring
  704.     fd (%%BoundingBox: (atend)\n) writestring
  705.     fd (%%Pages: (atend)\n) writestring
  706.     includeprologue { %ifelse
  707.         fd (%%DocumentProcSets: Adobe_distill 0.95\n) writestring
  708.     }{ %else
  709.         fd (%%DocumentNeededProcSets: Adobe_distill 0.95\n) writestring
  710.     } ifelse
  711.     fd (%%EndComments\n) writestring
  712.     } bdef
  713.     /writeprologue { %def    % :
  714.     writecomments
  715.     includeprologue { %ifelse
  716.         mark
  717.         (%%BeginProcSet: Adobe_distill 0.95)
  718.         (/PROLOGUE 30 40 add dict def)
  719.         ( % 30 procedure entries + room for 40 cached font dictionaries)
  720.         ( PROLOGUE begin)
  721.         ( /clip { } def    % causes problems. remove if "clip" is needed)
  722.         ( /bdef { bind def } bind def    /ldef { load def } bdef)
  723.         ( /T { moveto show } bdef    /A { moveto ashow } bdef)
  724.         ( /W { moveto widthshow } bdef    /AW { moveto awidthshow } bdef)
  725.         ( /f /fill ldef            /R { { rlineto } repeat } bdef)
  726.         ( /r /rlineto ldef        /L { { lineto } repeat } bdef)
  727.         ( /m /moveto ldef        /l { moveto lineto stroke } bdef)
  728.         ( /x { 0 rlineto } bdef        /y { 0 exch rlineto } bdef)
  729.         ( /c /curveto ldef        /cp /closepath ldef)
  730.         ( /s /stroke ldef        /w /setlinewidth ldef)
  731.         ( /g /setgray ldef        /j /setlinejoin ldef)
  732.         ( /d /setdash ldef        /F /setfont ldef)
  733.         ( /C /setcmykcolor where { /setcmykcolor get }{ %ifelse)
  734.         (   { %def)
  735.         (     1 sub 3 { 3 index add neg dup 0 lt { pop 0 } if 3 1 roll } repeat)
  736.         (     setrgbcolor)
  737.         (   } bind)
  738.         ( } ifelse def)
  739.         ( /MF { findfont exch makefont setfont } bdef)
  740.         ( /DF { findfont exch scalefont setfont currentfont def } bdef)
  741.         ( /BEGINPAGE { pop /pagesave save def } bdef)
  742.         ( /ENDPAGE { pop pagesave restore showpage } def)
  743.         ( /REMAP { %def)
  744.         (   FontDirectory 2 index known { pop pop pop } { %ifelse)
  745.         (     findfont dup length dict begin)
  746.         (       { 1 index /FID ne {def}{pop pop} ifelse } forall)
  747.         (       exch dup length 0 gt { /Encoding exch def }{ pop } ifelse)
  748.         (     currentdict end definefont pop)
  749.         (   } ifelse)
  750.         ( } bdef)
  751.         ( /RECODE { %def)
  752.         (    3 -1 roll 1 index findfont /Encoding get 256 array copy exch)
  753.         (    0 exch { %forall)
  754.         (     dup type/nametype eq)
  755.         (       { 3 {2 index} repeat put pop 1 add }{ exch pop }ifelse)
  756.         (    } forall pop 3 1 roll REMAP)
  757.         ( } bdef)
  758.         ( end %PROLOGUE)
  759.         (%%EndProcSet: Adobe_distill 0.95)
  760.         % write all the above strings to the output file:
  761.         counttomark -1 1 { %for
  762.         -1 roll fd exch writestring fd (\n) writestring
  763.         } for
  764.         fd systemdict /flushfile get exec
  765.         pop %mark
  766.     }{ %else
  767.         (%%IncludeProcSet: Adobe_distill 0.95\n) fd exch writestring
  768.     } ifelse
  769.     fd (%%EndProlog\n) writestring
  770.     fd (%%BeginSetup\n) writestring
  771.     fd (PROLOGUE begin\n) writestring
  772.     } bdef
  773.     /checksetup { %def
  774.     % called from "fontstate", "graphicstate", and "definefont"
  775.     beginsetup cvbool {
  776.         /beginsetup false hidebool
  777.         fd (\n%%EndSetup\n%%Page: 1 1\n) writestring
  778.         fd (%%PageFonts: (atend)\n) writestring
  779.         fd (%%PageBoundingBox: (atend)\n) writestring
  780.         fd (1 BEGINPAGE\n) writestring
  781.         /begunpage true hidebool
  782.         /fontcount 0 store
  783.     }{ %else
  784.         lastshowpage cvbool { %if
  785.         /lastshowpage false hidebool
  786.         /fontcount 0 store
  787.         writeNL (%%Page: ) wout
  788.         trace { (page: ) rprint pagecount cvnum == flush } if
  789.         /pagecount pagecount cvnum 1 add hideval
  790.         pagecount cvnum dup writenum writenum writeNL
  791.         (%%PageFonts: (atend)) writeop
  792.         (%%PageBoundingBox: (atend)) writeop
  793.         pagecount cvnum scratch cvs wout ( BEGINPAGE\n) wout
  794.         /begunpage true hidebool
  795.          % invalidate all remapped fonts, for page independence
  796.         FontDirectory { %forall
  797.             exch pop dup /FontInfo known { %ifelse
  798.             /FontInfo get dup /pleasemap known { %ifelse
  799.                 begin (Glenn Reid)
  800.                 pleasemap cvbool not {
  801.                     /pleasemap true hidebool
  802.                 } if pop
  803.                 end
  804.             }{ pop } ifelse
  805.             }{ pop } ifelse
  806.         } forall
  807.         % forcegstate
  808.         } if
  809.     } ifelse
  810.     } bdef
  811.     /writenamearray {        % [ /name ... ] :
  812.     fd ([) writestring
  813.     /indentlevel ++ fd (\n) writestring indent
  814.     /CNT 1 store
  815.     %| maintain CNT to count bytes.  wrap lines at a reasonable
  816.     %| place when writing out character names, to avoid long lines
  817.     { %forall
  818.         fd (/) writestring
  819.         dup type /nametype eq { scratch cvs }{ pop (.notdef) } ifelse
  820.         dup  length 1 add CNT add /CNT exch store  fd exch writestring
  821.         CNT 60 ge { /CNT 1 store fd (\n) writestring indent } if
  822.     } forall
  823.     /indentlevel -- fd (\n) writestring indent fd (]) writestring
  824.     } bdef
  825.     /writediffencoding {    % [ 32/name 37/etc ... ] :
  826.     fd ([) writestring
  827.     /indentlevel ++ fd (\n) writestring indent
  828.     /CNT 1 store
  829.     %| maintain CNT to count bytes.  wrap lines at a reasonable
  830.     %| place when writing out character names, to avoid long lines
  831.     { %forall
  832.         dup type /integertype eq { %ifelse
  833.         fd (\040) writestring
  834.         scratch cvs fd exch writestring /CNT CNT 4 add store
  835.         }{ %else
  836.         fd (/) writestring
  837.         dup type /nametype eq { scratch cvs }{ pop (.notdef) } ifelse
  838.         dup  length 1 add CNT add /CNT exch store  fd exch writestring
  839.         } ifelse
  840.         CNT 60 ge { /CNT 1 store fd (\n) writestring indent } if
  841.     } forall
  842.     /indentlevel -- fd (\n) writestring indent fd (]) writestring
  843.     } bdef
  844.  
  845.   % write numbers in various formats:
  846.  
  847.     /thruCTM { CTM transform } bdef
  848.     /dthruCTM { CTM dtransform } bdef
  849.     /XthruCTM { %def
  850.     dup CTM dtransform
  851.     rot not { pop }{ %else
  852.         2 copy gt { pop }{ exch pop } ifelse
  853.     } ifelse
  854.     } bdef
  855.  
  856.     /*writestring { %def
  857.     writestring fd *flushfile
  858.     } bdef
  859.     /shave { %def
  860.       % eliminate significant digits beyond .001; compensate for roundoff
  861.     dup type /realtype eq { %if
  862.         1000 mul truncate 1000 div
  863.     } if
  864.     } bdef
  865.     /writenum { % def        % num :
  866.     dup abs 0.001 le { pop 0 } if        % --> 0
  867.     dup dup cvi eq { cvi } if
  868.     fd exch scratch cvs writestring _space
  869.     } bdef
  870.     /writeprecisenum { % def        % num :
  871.     fd exch scratch cvs writestring _space
  872.     } bdef
  873.     /writeXnum { % def        % num :
  874.     CTM 0 get mul writenum
  875.     } bdef
  876.     /writeYnum { % def        % num :
  877.     CTM 3 get mul writenum
  878.     } bdef
  879.     /writeTpair { % def        % num1 num2 :
  880.     thruCTM exch
  881.     writenum writenum
  882.     } bdef
  883.     /writepair { % def        % num1 num2 :
  884.     exch writenum writenum
  885.     } bdef
  886.     /writenumarray {        % [ nums ] : 
  887.     fd ([) writestring
  888.     { writenum } forall
  889.     fd (] ) writestring
  890.     } bdef
  891.  
  892.   % write out names and strings:
  893.     /rprint /print load def
  894.     /r= /= load def
  895. %    /print { fd exch writestring } bind def
  896. %    /= { scratch cvs fd exch writestring writeNL } bind def
  897.  
  898.     /writeNL { fd (\n) writestring } bdef
  899.     /_space { fd (\040) writestring } bdef
  900.     /wout { % def        % (string) :
  901.      fd exch writestring
  902.     } bdef
  903.     /writestr { % def        % (string) :
  904.     fd exch writestring _space
  905.     } bdef
  906.     /writeop { %def        % (string) :
  907.     fd exch writestring writeNL
  908.     } bdef
  909.     /writePSstring { % def    % (string) :
  910.     fd (\() writestring dup length 75 gt exch
  911.     wordfix fd (\) ) writestring { writeNL } if % if length > 75 bytes
  912.     } bdef
  913.     /writename { % def        % name :
  914.     scratch cvs fd exch writestring  _space
  915.     } bdef
  916.     /writeRname { % def        % name :
  917.     (/) wout scratch cvs wout (R ) wout
  918.     } bdef
  919.     /checkusernames { %def    % array :
  920.     { % forall
  921.         dup type /nametype ne { pop }{ %ifelse
  922.         dup systemdict exch known { pop }{ % ifelse
  923.             dup xcheck not { pop }{ %ifelse
  924.             dup unames exch known { pop }{ %ifelse
  925.                 dup where not { %ifelse
  926.                 dup unames exch true put
  927.                 pop % assume it's taken care of
  928.                 }{ %else
  929.                 pop dup load dup type /arraytype eq
  930.                 1 index type /packedarraytype eq or
  931.                   { checkusernames }{ pop } ifelse
  932.                 indent (userdict /) wout dup writename
  933.                 dup unames exch true put
  934.                 load writeANY
  935.                 (put) writeop indent
  936.                 } ifelse
  937.             } ifelse
  938.             } ifelse
  939.         } ifelse
  940.         } ifelse
  941.     } forall
  942.     } bdef
  943.     /arrayusernames { %def
  944.     dup type /arraytype eq 1 index type /packedarraytype eq or { %ifelse
  945.         dup checkusernames
  946.         { arrayusernames } forall
  947.     }{ pop } ifelse
  948.     } bdef
  949.     /writeproc { %def
  950.     ({) writestr
  951.     insideproc exch /insideproc true store
  952.     dup type /arraytype eq 1 index type /packedarraytype eq or { % ifelse
  953.         dup length 20 lt { %ifelse
  954.         { writeANY } forall
  955.         }{ %else
  956.         writeNL /indentlevel ++ indent
  957.         { writeANY writeNL indent } forall
  958.         /indentlevel -- writeNL indent
  959.         } ifelse
  960.     }{ %else
  961.         writename
  962.     } ifelse
  963.     /insideproc exch store
  964.     (} ) writestr
  965.     } bdef
  966.     /typedict 12 dict def
  967.     typedict begin
  968.     /stringtype {
  969.         dup 0 get 0 eq 1 index dup length 1 sub get 0 eq or {
  970.         (<) wout fd exch writehexstring (> ) wout
  971.         }{ writePSstring } ifelse
  972.     } bdef
  973.     /arraytype { %def
  974.         % dup checkusernames
  975.         dup xcheck { %ifelse
  976.         writeproc
  977.         }{ %else
  978.         /CNT 1 store
  979.         dup length 20 lt { %ifelse
  980.             ([ ) wout { writeANY } forall (] ) wout
  981.         }{ %else
  982.             ([) writeop /indentlevel ++
  983.             { indent writeANY writeNL } forall
  984.             /indentlevel -- indent (] ) wout
  985.         } ifelse
  986.         } ifelse
  987.     } bdef
  988.     /packedarraytype /arraytype load def
  989.     /dicttype { %def
  990.               % safety: 1 add (needed for User Fonts)
  991.         dup maxlength 1 add writenum (dict begin) writeop indent
  992.         { %forall
  993.         exch writeANY writeANY (def ) writeop indent
  994.         } forall (currentdict end ) wout
  995.     } bdef
  996.     /integertype { writenum } def
  997.     /realtype { writenum } def
  998.     /nulltype { pop (null ) wout } def
  999.     /operatortype { %def
  1000.         insideproc { %ifelse
  1001.         writename
  1002.         }{ %else
  1003.         (/) wout writename (load) writestr
  1004.         } ifelse
  1005.     } bdef
  1006.     /nametype { %def
  1007.         dup xcheck not { (/) wout dup unames exch true put } if
  1008.         writename
  1009.     } bdef
  1010.     end % typedict
  1011.     /writeANY { %def 
  1012.     dup type dup typedict exch known { %ifelse
  1013.         typedict exch get exec
  1014.     }{ %else
  1015.         pop writename
  1016.     } ifelse
  1017.     } bdef
  1018.     % The following writes an escaped string that may contain special chars.
  1019.     % It regenerates the (\035string) notation.
  1020.     /wordfix { %def        % (string) :
  1021.     (\() search { %ifelse
  1022.         rparenfix (\\\() wout pop wordfix
  1023.     }{ rparenfix } ifelse
  1024.     } bdef
  1025.     /rparenfix { %def
  1026.     (\)) search { %ifelse
  1027.         binaryfix (\\\)) wout pop rparenfix
  1028.     }{ binaryfix } ifelse
  1029.     } bdef
  1030.     /str1 1 string def
  1031.     /longstr 1028 string def
  1032.     /writetomark { %def
  1033.     counttomark -1 0 { %for
  1034.         longstr exch exch put
  1035.     } for
  1036.     } bdef
  1037.     /binaryfix { %def
  1038.     dup false exch { %forall
  1039.         dup 128 gt 1 index 32 lt or { %ifelse
  1040.         str1 exch 0 exch put pop true exit
  1041.         }{ pop } ifelse
  1042.     } forall
  1043.     { %ifelse    % depending on whether num>128 was found
  1044.         str1 search {
  1045.         quotefix        % string previous to num>128
  1046.         (\\) wout        % the backslash
  1047.                     % write suspicious char as octal
  1048.         0 get 8 scratch cvrs    % padding with leading 0 as needed
  1049.         dup length 3 exch sub { (0) wout } repeat wout
  1050.         binaryfix        % recurse on rest of string
  1051.         }{
  1052.         (ERROR: search lied in "binaryfix".) r= flush stop
  1053.         } ifelse
  1054.     }{ quotefix } ifelse
  1055.     } bdef
  1056.     /quotefix { %def
  1057.     (\\) search {  %ifelse
  1058.         wout (\\\\) wout pop quotefix
  1059.     }{ wout } ifelse
  1060.     } bdef
  1061.  
  1062. end %adobe_distill
  1063. /setpacking where { pop setpacking } if
  1064. %%EndProcSet
  1065.  
  1066. %%BeginProcSet: distill_graphicstate 1.0 0
  1067. % we don't want packed arrays for all these matrices; set packing later
  1068. /adobe_distill dup where { pop pop }{ 165 200 add dict def } ifelse
  1069. adobe_distill begin
  1070.  
  1071.   % define a bunch of state variables, then use "store" subsequently
  1072.   % to write into them (to avoid currentdict problems).
  1073.     /mtx matrix def
  1074.     /tmpmtx matrix def
  1075.     /fontmtx matrix def
  1076.     /curfontmtx matrix def
  1077.     /CTM matrix currentmatrix def
  1078.     /normalCTM tmpmtx currentmatrix matrix invertmatrix def
  1079.     /compareCTM matrix currentmatrix def
  1080.     /newCTM matrix def
  1081.     /mtx1 0 def
  1082.     /mtx2 0 def
  1083.     /$normalize {
  1084.     dup tmpmtx copy normalCTM 3 -1 roll concatmatrix
  1085.     } bind def
  1086.     /rot false def
  1087.     /gray currentgray def
  1088.     currentcmykcolor
  1089.     /colK exch def /colY exch def /colM exch def /colC exch def
  1090.     /linewidth currentlinewidth def
  1091.     /linecap currentlinecap def
  1092.     /linejoin currentlinejoin def
  1093.     /miterlimit currentmiterlimit def
  1094.     /screenang null def
  1095.     /screenfreq null def
  1096.     /screenproc null def
  1097.     /closed false def
  1098.     currentdash /dashoff exch def /dasharray exch def
  1099.     /pointX -1 def /pointY -1 def
  1100.     /initfontscale { 1 0 0 1 0 0 $fontscale astore pop } bind def
  1101.     /$fontscale matrix  def
  1102.     /0a 0 def /0b 0 def
  1103.     /X1 0 def /X2 0 def
  1104.     /origfontname null def
  1105.     /currfontdict null def
  1106.     /definefontname null def
  1107.     /tempfontname /Courier def
  1108. %    /defaultfontname substitutefonts { /Courier }{ /Unknown } ifelse def
  1109.     /defaultfontname {
  1110.     /FontType where { %ifelse
  1111.         pop FontType 3 eq {
  1112.         FontInfo /realname get
  1113.         }{ substitutefonts { /Courier }{ /Unknown } ifelse } ifelse
  1114.     }{ %else
  1115.         substitutefonts { /Courier }{ /Unknown } ifelse
  1116.     } ifelse
  1117.     } def
  1118.     /ischarpath false def
  1119.     /currpath newpath hashpath def
  1120.     /pathstr () def
  1121.     /pathbool false def
  1122.     /pathX 0 def /pathY 0 def
  1123.     /lineX 0 def /lineY 0 def
  1124.     /closeX 0 def /closeY 0 def
  1125.     /lcount 0 def /rcount 0 def
  1126.     /REPEAT_LINETO_THRESHOLD 20 def    % point at which repeat loop is used
  1127.     /currX -1 def /currY -1 def
  1128.     /diffX 0 def
  1129.     /gstates 0 def
  1130.     /charpathgstate 0 def
  1131.     /CNT 0 def
  1132.     /showX null def /showY null def
  1133.     /currfont currentfont def
  1134.     /cliphash newpath hashpath def
  1135.     /?simplepath false def
  1136.     /simplepath [ 0 0 0 0 ] def
  1137.  
  1138. /setpacking where { pop currentpacking true setpacking } if
  1139.  
  1140.     /matrixeq { %def        % compares two matrices
  1141.     /mtx2 exch store
  1142.     /mtx1 exch store
  1143.     0 1 5 { %for
  1144.         dup mtx1 exch get
  1145.         exch mtx2 exch get eq
  1146.     } for
  1147.     5 { and } repeat
  1148.     } bdef
  1149.  
  1150.   % procedure definitions for state machinery ---------------
  1151.  
  1152.     /initgstate { %def
  1153.     gsave
  1154.         initgraphics
  1155.         /CTM mtx currentmatrix $normalize store
  1156.         tmpmtx currentmatrix compareCTM matrixeq not {
  1157.         .345 dup 0 dtransform pop 0 idtransform
  1158.         pop ne dup /rot exch store not optimize and /optim exch store
  1159.         } if
  1160.         compareCTM currentmatrix pop
  1161.         /gray currentgray store
  1162.         currentcmykcolor
  1163.         /colK exch store /colY exch store
  1164.         /colM exch store /colC exch store
  1165.         /linewidth currentlinewidth XthruCTM store
  1166.         /linecap currentlinecap store
  1167.         /linejoin currentlinejoin store
  1168.         /miterlimit currentmiterlimit store
  1169.         currentdash /dashoff exch store /dasharray exch store
  1170.         /origfontname /InvalidFont store
  1171.         /definefontname /InvalidFont store
  1172.         initfontscale
  1173.         /currfontdict currentfont store
  1174.         currentscreen
  1175.         /screenproc exch store
  1176.         /screenang exch store
  1177.         /screenfreq exch store
  1178.         /cliphash clippath hashpath store    % Wed Dec 28 12:41:07 1988
  1179.     grestore
  1180.     } bdef % initgstate
  1181.     /forcegstate { %def
  1182.     % after save & restore, you may have to explicitly "undo" anything
  1183.     % that was done within the saved context.  Since save & restore
  1184.     % affect all our state variables, we dump anything that is different
  1185.     % from the default graphics state:
  1186.     /CTM [1.01 0 1.01 0 .5 .5] store
  1187.     /compareCTM [1.01 0 1.01 0 .5 .5] store
  1188.     initfontscale
  1189.     /currfontdict null store
  1190.     /gray null store
  1191.     /colC null store
  1192.     % checkgstate % fontstate
  1193.     } bdef % initgstate
  1194.     /checkgstate { %def
  1195.     graphicstate
  1196.     fontstate
  1197.     } def %checkgstate
  1198.     /checkCTM { %def
  1199.     tmpmtx currentmatrix compareCTM matrixeq not {
  1200.         % /CTM mtx currentmatrix $normalize store
  1201.         CTM currentmatrix $normalize pop
  1202.         compareCTM currentmatrix $normalize pop
  1203.         .345 dup 0 dtransform pop 0 idtransform
  1204.         pop ne dup /rot exch store not optimize and /optim exch store
  1205.     } if
  1206.     } bdef
  1207.     /generalstate { %def
  1208.     stackptr 0 ne { stackshow } if
  1209.     /lastshow false store
  1210.     checkCTM
  1211.     } bdef % generalstate
  1212.     /colorstate { %def
  1213.     mark currentcmykcolor
  1214.     colC colM colY colK 4 { %repeat
  1215.         dup 5 index ne 10 1 roll 8 1 roll
  1216.     } repeat
  1217.     cleartomark or or or {
  1218.         currentcmykcolor
  1219.         /colK exch store /colY exch store
  1220.         /colM exch store /colC exch store
  1221.         colC 0 eq colM 0 eq colY 0 eq and and not { %ifelse % COLOR
  1222.         colC writenum colM writenum colY writenum colK writenum
  1223.         (C) writeop
  1224.         }{ %else                        % GRAY
  1225.         1 colK sub shave writenum (g) writeop
  1226.         } ifelse
  1227.     } if
  1228.     } bdef % colorstate
  1229.     /registerfont { %def
  1230.     dup cachedir exch 20 dict put    % allow 20 point sizes
  1231.     cachedir exch get        % ptsize dict
  1232.     exch fontcount put
  1233.     } bdef
  1234.     /addfontsize { %def
  1235.     cachedir exch get
  1236.     exch fontcount put
  1237.     } bdef
  1238.  
  1239.     /fontstate { %def
  1240.       currentfont null eq not    { %if
  1241.     currentfont dup /ScaleMatrix known not { pop }{ %ifelse
  1242.         begin
  1243.          % determine if anything has changed:
  1244.         tmpmtx currentmatrix compareCTM matrixeq not
  1245.         currfontdict currentfont ne or
  1246.         ScaleMatrix CTM tmpmtx concatmatrix $fontscale matrixeq not or
  1247.         { %if
  1248.           % get and set new font names
  1249.             /origfontname
  1250.             /FontInfo where { %ifelse
  1251.                 pop FontInfo /realname known
  1252.                 { FontInfo /realname get }{ % ifelse
  1253.                 /FontName where { pop FontName }{
  1254.                     defaultfontname
  1255.                 } ifelse
  1256.                 } ifelse
  1257.             }{ %else
  1258.                 /FontName where { pop FontName }{
  1259.                 defaultfontname
  1260.                 } ifelse
  1261.             } ifelse
  1262.             store
  1263.             /definefontname
  1264.             /FontName where { pop FontName }{
  1265.                 defaultfontname
  1266.             } ifelse
  1267.             FontDirectory { %forall
  1268.                 currentdict eq
  1269.                 { exch pop exit }
  1270.                 { pop } ifelse
  1271.             } forall
  1272.             store
  1273.             origfontname hidefontname
  1274.          % check for font reencoding:
  1275.          % The current font is the one required in the distilled
  1276.          % program.  If it is a reeconded font, we must generate
  1277.          % a call to "REMAP", but at the same time let's mark it
  1278.          % so we don't generate too may "REMAP" calls.
  1279.  
  1280.             checksetup generalstate colorstate
  1281.          % worry about reencoding:
  1282.             /FontInfo where { %ifelse
  1283.             pop FontInfo /pleasemap known { %ifelse
  1284.                 FontInfo /pleasemap get cvbool
  1285.             }{ %else
  1286.                 false  % evidently has not been reencoded...
  1287.             } ifelse % leaves a boolean
  1288.             }{ false } ifelse
  1289.             { % if remapping has not been done yet:
  1290.             Encoding hashencoding
  1291.             origfontname findfont /Encoding get hashencoding
  1292.             ne { %ifelse
  1293.                 Encoding hashencoding
  1294.                 STDvec cvnum eq { %ifelse
  1295.                 (stdvec) writestr
  1296.                 origfontname writeRname
  1297.                 origfontname (/) wout writename
  1298.                 ( REMAP) writeop
  1299.                 }{ %else
  1300.                   Encoding hashencoding PAGEvec cvnum eq {
  1301.                   (pagevec) writestr
  1302.                   origfontname writeRname
  1303.                   origfontname (/) wout writename
  1304.                   ( REMAP) writeop
  1305.                   }{ %else
  1306.                   origfontname findfont /Encoding get Encoding
  1307.                   diffencoding writediffencoding
  1308.                   origfontname writeRname
  1309.                   origfontname (/) wout writename
  1310.                   ( RECODE) writeop
  1311.                   } ifelse
  1312.                 } ifelse
  1313.                 /FontInfo where { %if
  1314.                 pop FontInfo /pleasemap known { %if
  1315.                     FontInfo begin
  1316.                         /pleasemap false hidebool
  1317.                     end
  1318.                 } if
  1319.                 } if
  1320.             } if
  1321.             } if % /pleasemap
  1322.          % check font scale change:
  1323.          % This stuff is absolutely horrible....
  1324.             ScaleMatrix CTM $fontscale concatmatrix
  1325.              aload pop                % Xscale 0a 0b Yscale 0 0
  1326.             pop pop 3 1 roll            % X Y 0b 0a
  1327.            % if 0a and 0b are really both 0 ...
  1328.            % and X Y are equal and positive, then you can use
  1329.            % "scalefont", else you have to use "makefont"
  1330.             /0a exch store /0b exch store
  1331.             /X1 exch store /X2 exch store
  1332.              X1 X2            % leave on stack
  1333.             0a 0b eq 0b 0 eq and    % make sure 0's are 0
  1334.              X1 X2 EQ and        % X1 and X2 are equal
  1335.              X1 dup abs eq X2 dup abs eq and    % and positive
  1336.             and
  1337.             { %ifelse
  1338.             pop dup dup round EQ { round } if
  1339.              % if you find it in the "font dict cache"....
  1340.             cachedir definefontname known { %ifelse
  1341.                 cachedir definefontname get dup 2 index known {
  1342.                 exch get (F) wout writenum
  1343.                 (F) writeop
  1344.                 }{ %else
  1345.                 pop
  1346.                 /fontcount ++
  1347.                 dup definefontname addfontsize
  1348.                 (/F) wout fontcount writenum %+ cvnum writenum
  1349.                 writenum
  1350.                 origfontname
  1351.                 /FontInfo where { %ifelse
  1352.                     pop FontInfo /pleasemap known { %ifelse
  1353.                     FontInfo /pleasemap get cvbool
  1354.                     }{ false } ifelse % leaves a boolean
  1355.                 }{ false } ifelse
  1356.                 Encoding hashencoding
  1357.                 origfontname findfont /Encoding get
  1358.                 hashencoding ne and
  1359.                 { %ifelse
  1360.                     writeRname
  1361.                 }{ (/) wout writename } ifelse
  1362.                 (DF) writeop
  1363.                 } ifelse
  1364.             }{ %else if you DON'T find the name in the cache
  1365.                 /fontcount ++
  1366.                 dup definefontname registerfont
  1367.                 (/F) wout fontcount writenum
  1368.                 writenum
  1369.                 origfontname
  1370.                 /FontInfo where { %ifelse
  1371.                 pop FontInfo /pleasemap known { %ifelse
  1372.                     FontInfo /pleasemap get cvbool not
  1373.                 }{ false } ifelse % leaves a boolean
  1374.                 }{ false } ifelse
  1375.                 Encoding hashencoding
  1376.                 origfontname findfont /Encoding get
  1377.                 hashencoding ne and
  1378.                 { %ifelse
  1379.                 writeRname
  1380.                 }{ (/) wout writename } ifelse
  1381.                 (DF) writeop
  1382.             } ifelse
  1383.             }{ %else
  1384.              % need either "makefont" or rotated coordinate system
  1385.             pop pop $fontscale aload pop curfontmtx astore
  1386.             dup 4 ScaleMatrix 4 get put
  1387.             dup 5 ScaleMatrix 5 get put  % no translate
  1388.             writenumarray
  1389.             origfontname
  1390.             /FontInfo where {
  1391.                 pop FontInfo /pleasemap known
  1392.             }{ false } ifelse { %ifelse
  1393.                 writeRname
  1394.             }{ (/) wout writename } ifelse
  1395.             (MF) writeop
  1396.             } ifelse
  1397.             /currfontdict currentfont store
  1398.         } if % anything has changed
  1399.         end
  1400.     } ifelse
  1401.     beginsetup cvbool not {
  1402.         generalstate
  1403.         colorstate
  1404.     } if
  1405.       } if
  1406.     } bdef %fontstate
  1407.  
  1408.     /graphicstate { %def
  1409.     checksetup
  1410.     generalstate
  1411.     colorstate
  1412.     linewidth currentlinewidth XthruCTM ne {
  1413.         /linewidth currentlinewidth XthruCTM store
  1414.         linewidth shave writenum (w) writeop
  1415.     } if
  1416.     linecap currentlinecap ne {
  1417.         /linecap currentlinecap store
  1418.         linecap writenum (setlinecap) writeop
  1419.     } if
  1420.     linejoin currentlinejoin ne {
  1421.         /linejoin currentlinejoin store
  1422.         linejoin writenum (j) writeop
  1423.     } if
  1424.     miterlimit currentmiterlimit ne {
  1425.         /miterlimit currentmiterlimit store
  1426.         miterlimit shave writenum (setmiterlimit) writeop
  1427.     } if
  1428.     currentdash dashoff ne exch dasharray ne or {
  1429.         currentdash /dashoff exch store /dasharray exch store
  1430.         fd ([) writestring
  1431.         dasharray { XthruCTM writenum } forall
  1432.         fd (] ) writestring
  1433.         dashoff XthruCTM writenum (d) writeop
  1434.     } if
  1435.     gsave
  1436.       % don't clip to degenerate paths of any kind:
  1437.         newpath clippath hashpath cliphash ne { %if
  1438.         mark { pathbbox } stopped not {
  1439.             exch 4 -1 roll sub abs 1 gt
  1440.             3 1 roll sub abs 1 gt and { % if
  1441.             writepath
  1442.             (clip newpath) writeop
  1443.             /cliphash hashpath store
  1444.             } if
  1445.         } if cleartomark
  1446.         } if
  1447.     grestore
  1448.     currentscreen
  1449.     /screenproc load ne exch screenang ne or exch screenfreq ne or { %if
  1450.         currentscreen
  1451.         /screenproc exch store
  1452.         /screenang exch store
  1453.         /screenfreq exch store
  1454.         screenfreq writenum screenang writenum writeNL
  1455.         /screenproc load
  1456.         dup type /arraytype eq
  1457.         1 index type /packedarraytype eq or { %ifelse
  1458.         checkusernames
  1459.         }{ pop } ifelse
  1460.         /screenproc load writeproc
  1461.         (setscreen) writeop
  1462.     } if
  1463.     } bdef %graphicstate
  1464.  
  1465. end %adobe_distill
  1466. /setpacking where { pop setpacking } if
  1467. %%EndProcSet
  1468.  
  1469. %%BeginProcSet: distill_optimize 1.0 0
  1470. /adobe_distill dup where { pop pop }{ 165 200 add dict def } ifelse
  1471. adobe_distill begin
  1472.   % These procedures implement an optimization scheme for recognizing
  1473.   % sequences of "show" operations that could be optimized into calls
  1474.   % to "widthshow" (or just "show" with a longer string body).  In
  1475.   % order to accomplish this, we have implemented a stack to store
  1476.   % string bodies until they are flushed by a font change, a change
  1477.   % in Y coordinate, or an inter-string space that is inconsistent.
  1478.   % When comparing coordinates for equality, anything with the given
  1479.   % tolerance is accepted as being equal (to combat roundoff error).
  1480.     /tolerance .05 ifnotdef
  1481.     /EQ { sub abs tolerance le } bdef
  1482.     /stack 250 array def
  1483.     /stackptr 0 def
  1484. /setpacking where { pop currentpacking true setpacking } if
  1485.     /push { %def
  1486.     stackptr 0 eq { % if
  1487.         currentpoint thruCTM
  1488.         /showY exch store /showX exch store
  1489.     } if
  1490.     /stackptr stackptr 1 add store
  1491.       stackptr 249 ge { (STACK OVERFLOW!) r= flush exit } if
  1492.     stack stackptr 3 -1 roll put
  1493.     } bdef
  1494.     /pull { %def
  1495.     stack stackptr get
  1496.     /stackptr stackptr dup 0 gt { 1 sub } if store
  1497.     } bdef
  1498.  
  1499.     /*save systemdict /save get def
  1500.     /save { % def
  1501.     stackshow    % in case there's anything pending....
  1502.     *save
  1503.     } bdef
  1504.  
  1505.     /*restore systemdict /restore get def
  1506.     /restore { % def
  1507.     % after save & restore, you may have to explicitly "undo" anything
  1508.     % that was done within the saved context.  Since save & restore
  1509.     % affect all distillery state variables, we dump anything different
  1510.     % from the default graphics state:
  1511.     stackshow    % in case there's anything pending....
  1512.       currentlinecap    % 5
  1513.       currentlinewidth    % 4
  1514.       currentgray        % 3
  1515.       currentmiterlimit    % 2
  1516.       currentlinejoin    % 1
  1517.         6 -1 roll *restore
  1518.       setlinejoin        % 1
  1519.       setmiterlimit        % 2
  1520.       setgray        % 3
  1521.       setlinewidth        % 4
  1522.       setlinecap        % 5
  1523.     forcegstate % checkgstate %graphicstate
  1524.     } bdef
  1525.  
  1526.     /stackshow { %def
  1527.     stackptr 0 ne { %if
  1528.         messages {
  1529.         (stackshow: ) d=
  1530.         1 1 stackptr { (  ) pr= stack exch get == } for
  1531.         } if
  1532. %         currfont /FontType known {
  1533. %         currfont /FontType get 3 eq {
  1534. %             ?distilling false setdistill
  1535. %         } if
  1536. %         } if
  1537.         stackptr 1 eq { %ifelse
  1538.         %- if there is only one string, use "show":
  1539.         pull writePSstring
  1540.         showX showY writepair (T) writeop
  1541.         }{ %else
  1542.         %- otherwise, build single string (with \b to use W):
  1543.         diffX 0 EQ not { % if
  1544.             gsave        % figure out widthshow value
  1545.             currfont setfont
  1546.             diffX (\b) stringwidth CTM dtransform pop sub
  1547.             grestore
  1548.             writenum (0) writestr (\b) 0 get writenum
  1549.             (\\b)    % padding character
  1550.         }{ % else
  1551.             ()        % empty padding character
  1552.         } ifelse
  1553.         (\() wout
  1554.         1 1 stackptr 1 sub { % for
  1555.             stack exch get wordfix dup wout
  1556.         } for
  1557.         pop        % padding character
  1558.         pull wordfix
  1559.         (\)) wout writeNL
  1560.         showX showY writepair
  1561.         %- if diffX is 0, don't use "widthshow":
  1562.         diffX 0 EQ { (T) }{ (W) } ifelse writeop
  1563.         } ifelse
  1564.         /stackptr 0 store
  1565. %         currfont /FontType known {
  1566. %         currfont /FontType get 3 eq { setdistill } if
  1567. %         } if
  1568.     } if
  1569.     } bdef
  1570.  
  1571.     /setcurrpoint { %def
  1572.     currentpoint thruCTM
  1573.     /currY exch store /currX exch store
  1574.     } bdef % setcurrpoint
  1575.  
  1576. end %adobe_distill
  1577. /setpacking where { pop setpacking } if
  1578. %%EndProcSet
  1579.  
  1580. %%BeginProcSet: distill_paintops 1.0 0
  1581. /setpacking where { pop currentpacking true setpacking } if
  1582. /adobe_distill dup where { pop pop }{ 165 200 add dict def } ifelse
  1583. adobe_distill begin
  1584.  
  1585.   % text operators
  1586.     /sameYcoords { %def
  1587.       % this is pulled out of the "show" proc for readability; it is
  1588.       % not used anywhere else
  1589.     currentfont currfont ne { %ifelse
  1590.         stackshow fontstate push
  1591.     }{ %else
  1592.         currentpoint thruCTM pop
  1593.         currX sub dup diffX EQ { %ifelse
  1594.         pop     % dup'ed value
  1595.         push
  1596.         }{ %else
  1597.         diffX -1 eq { %ifelse
  1598.             /diffX exch store push
  1599.         }{ % else
  1600.             pop stackshow fontstate
  1601.             /diffX -1 store push
  1602.         } ifelse
  1603.         } ifelse
  1604.     } ifelse
  1605.     } bdef
  1606.  
  1607.     /*stringwidth /stringwidth load def
  1608.     /stringwidth { %def
  1609.     false setdistill *stringwidth true setdistill
  1610.     } bdef
  1611.     /show { %def
  1612.     checkCTM currentpoint thruCTM ?box
  1613.     optim { %ifelse
  1614.         dup length 0 eq { pop } { %ifelse
  1615.         dup            % save string for use at the end
  1616.         lastshow not { %ifelse
  1617.             stackshow fontstate
  1618.             /currfont currentfont store
  1619.             push
  1620.             /diffX -1 store
  1621.         }{ % else
  1622.           % don't optimize if matrix is different...
  1623.             tmpmtx currentmatrix compareCTM matrixeq
  1624.             currentpoint thruCTM exch pop
  1625.             currY eq and { %ifelse        Y = Y
  1626.             sameYcoords
  1627.             }{ %else currY ne
  1628.             stackshow    % flush the pending show stack
  1629.             fontstate
  1630.             push        % the string (and set showX, showY)
  1631.             /diffX -1 store
  1632.             } ifelse
  1633.             /currfont currentfont store
  1634.         } ifelse %lastshow
  1635.         currentfont /FontType known {
  1636.             currentfont /FontType get 3 eq {
  1637.             false setdistill show true setdistill
  1638.             }{ show } ifelse
  1639.         }{ false setdistill show true setdistill } ifelse
  1640.         setcurrpoint
  1641.         /lastshow true store
  1642.         } ifelse % if length is not 0
  1643.     }{ % else
  1644.         dup length 0 eq { pop } { %ifelse
  1645.         fontstate
  1646.         dup writePSstring currentpoint writeTpair
  1647.         (T) writeop
  1648.         currentfont /FontType known {
  1649.             currentfont /FontType get 3 eq {
  1650.             false setdistill show true setdistill
  1651.             }{ show } ifelse
  1652.         }{ false setdistill show true setdistill } ifelse
  1653.         } ifelse % if operand is not null string
  1654.     } ifelse
  1655.     currentpoint thruCTM ?box
  1656.     } bdef
  1657.  
  1658.     /widthshow { %def
  1659.     checkCTM currentpoint thruCTM ?box
  1660.     optim { %ifelse
  1661.         dup length 0 eq { 4{pop}repeat } { %ifelse
  1662.         4 copy pop pop
  1663.         1 index EQ exch 0.0 EQ and { % ifelse
  1664.             fontstate
  1665.             4 1 roll pop pop pop
  1666.             show    % make sure it's not "bound"
  1667.         }{ %else
  1668.             fontstate
  1669.             4 copy
  1670.             4 2 roll dthruCTM writepair %exch writeXnum writeYnum
  1671.             exch writenum writePSstring currentpoint writeTpair
  1672.             (W) writeop
  1673.             currentfont /FontType known {
  1674.             currentfont /FontType get 3 eq {
  1675.                 false setdistill widthshow true setdistill
  1676.             }{ widthshow } ifelse
  1677.             }{ false setdistill widthshow true setdistill } ifelse
  1678.         } ifelse
  1679.         } ifelse
  1680.     }{ %else
  1681.         % Cx Cy char (string) widthshow
  1682.         dup length 0 eq { 4{pop}repeat } { %ifelse
  1683.         fontstate
  1684.         4 copy
  1685.         % 4 -2 roll exch writeXnum writeYnum exch writenum
  1686.         4 -2 roll dthruCTM writepair exch writenum
  1687.         writePSstring currentpoint writeTpair
  1688.         (W) writeop
  1689.         currentfont /FontType known {
  1690.             currentfont /FontType get 3 eq {
  1691.             false setdistill widthshow true setdistill
  1692.             }{ widthshow } ifelse
  1693.         }{ false setdistill widthshow true setdistill } ifelse
  1694.         } ifelse
  1695.     } ifelse
  1696.     currentpoint thruCTM ?box
  1697.     } bdef
  1698.  
  1699.     /ashow { %bdef
  1700.     checkCTM currentpoint thruCTM ?box
  1701.     optim { %ifelse
  1702.         dup length 0 eq { pop pop pop } { %ifelse
  1703.         3 copy pop
  1704.         1 index EQ exch 0.0 EQ and { % ifelse
  1705.             fontstate
  1706.             3 1 roll pop pop
  1707.             show    % make sure it's not "bound"
  1708.         }{ %else
  1709.             fontstate
  1710.             3 copy
  1711.             3 1 roll dthruCTM writepair
  1712.             writePSstring currentpoint writeTpair
  1713.             (A) writeop
  1714.             currentfont /FontType known {
  1715.             currentfont /FontType get 3 eq {
  1716.                 false setdistill ashow true setdistill
  1717.             }{ ashow } ifelse
  1718.             }{ false setdistill ashow true setdistill } ifelse
  1719.         } ifelse
  1720.         } ifelse
  1721.     }{ %else
  1722.         dup length 0 eq { pop pop pop } { %ifelse
  1723.         fontstate
  1724.         3 copy
  1725.         3 1 roll dthruCTM writepair % exch writeXnum writeYnum
  1726.         writePSstring currentpoint writeTpair
  1727.         (A) writeop
  1728.         currentfont /FontType known {
  1729.             currentfont /FontType get 3 eq {
  1730.             false setdistill ashow true setdistill
  1731.             }{ ashow } ifelse
  1732.         }{ false setdistill ashow true setdistill } ifelse
  1733.         } ifelse
  1734.     } ifelse
  1735.     currentpoint thruCTM ?box
  1736.     } bdef
  1737.  
  1738.     /awidthshow { %def
  1739.     % Cx Cy 32 Ax Ay (string) awidthshow
  1740.     checkCTM currentpoint thruCTM ?box
  1741.     optim { %def
  1742.         dup length 0 eq { 6{pop}repeat } { %ifelse
  1743.         fontstate
  1744.         6 copy 6 1 roll
  1745.         1 index EQ exch 0.0 EQ and { %ifelse
  1746.             4 1 roll 1 index eq exch 0.0 eq and { %leaves 32 (str)
  1747.             8 1 roll 7 { pop } repeat
  1748.             show    % make sure it's not "bound"
  1749.             }{ %else
  1750.             pop pop 3 1 roll pop pop
  1751.             widthshow    % make sure it's not "bound"
  1752.             } ifelse
  1753.         }{ %else
  1754.             pop pop pop pop 6 copy 6 -3 roll pop
  1755.             1 index EQ exch 0.0 EQ and { % ifelse
  1756.             9 3 roll 6 { pop } repeat
  1757.             ashow    % make sure it's not "bound"
  1758.             }{ %else
  1759.             pop pop pop 6 copy
  1760.             6 -2 roll dthruCTM writepair
  1761.             4 -1 roll writenum 3 1 roll dthruCTM writepair
  1762.             writePSstring currentpoint writeTpair
  1763.             (AW) writeop
  1764.             currentfont /FontType known {
  1765.                 currentfont /FontType get 3 eq {
  1766.                 false setdistill awidthshow true setdistill
  1767.                 }{ awidthshow } ifelse
  1768.             }{ false setdistill awidthshow true setdistill } ifelse
  1769.             } ifelse
  1770.         } ifelse
  1771.         } ifelse
  1772.     }{ %else
  1773.         dup length 0 eq { 6{pop}repeat } { %ifelse
  1774.         fontstate
  1775.         6 copy
  1776.         % 6 -2 roll exch writeXnum writeYnum
  1777.         % 4 -1 roll writenum 3 -1 roll writeXnum exch writeYnum
  1778.         6 -2 roll dthruCTM writepair
  1779.         4 -1 roll writenum 3 1 roll dthruCTM writepair
  1780.         writePSstring currentpoint writeTpair
  1781.         (AW) writeop
  1782.             currentfont /FontType known {
  1783.             currentfont /FontType get 3 eq {
  1784.                 false setdistill awidthshow true setdistill
  1785.             }{ awidthshow } ifelse
  1786.             }{ false setdistill awidthshow true setdistill } ifelse
  1787.         } ifelse
  1788.     } ifelse
  1789.     currentpoint thruCTM ?box
  1790.     } bdef
  1791.  
  1792.     /kshow { %def
  1793.     (%AAAAAH: kshow) writeop
  1794.     kshow
  1795.     } bdef
  1796.  
  1797.    % graphics operators
  1798.     /fillguts { %def
  1799.     (starting fill) d=
  1800.     generalstate
  1801.     graphicstate
  1802.     writepath
  1803.     ischarpath { % if
  1804.         pathstr length 0 gt {
  1805.         pathX writenum pathY writenum (m) writeop
  1806.         pathstr writePSstring (false charpath) writeop
  1807.         } if
  1808.         gstates 0 le {
  1809.         /ischarpath false store
  1810.         /closed false store
  1811.         } if
  1812.     } if
  1813.     } bdef
  1814.  
  1815.     /fill { %def
  1816.     ?distilling cvbool { %if
  1817.         fillguts
  1818.         ?simplepath {
  1819.         simplepath aload pop
  1820.         4 2 roll writepair (moveto) writeop writepair (lineto) writeop
  1821.         /?simplepath false store
  1822.         } if
  1823.         (f) writeop
  1824.     } if
  1825.     fill
  1826.     } bdef
  1827.     /eofill { %def
  1828.     ?distilling cvbool { %if
  1829.         fillguts
  1830.         ?simplepath { %ifelse
  1831.         simplepath aload pop
  1832.         4 2 roll writepair (moveto) writeop writepair (lineto) writeop
  1833.         /?simplepath false store
  1834.         } if
  1835.         (eofill) writeop
  1836.     } if
  1837.     eofill
  1838.     } bdef
  1839.  
  1840.     /stroke { %def
  1841.     ?distilling cvbool { %if
  1842.         fillguts
  1843.         ?simplepath { %ifelse
  1844.         generalstate graphicstate
  1845.         simplepath aload pop writepair writepair (l) writeop
  1846.         /?simplepath false store
  1847.         }{ % else
  1848.         closed { (cp ) wout } if
  1849.         (s) writeop
  1850.         } ifelse
  1851.     } if
  1852.     stroke
  1853.     } bdef
  1854.  
  1855.     /clip { %def
  1856.     ?distilling cvbool { %if
  1857.         /lastshow false store
  1858.     } if
  1859.     clip
  1860.     } bdef
  1861.     /eoclip /clip load def
  1862.     /imageguts { % def
  1863.     graphicstate
  1864.     /imageproc exch store
  1865.     /imagematrix exch store
  1866.     /imagedepth exch store
  1867.     /imageheight exch store
  1868.     /imagewidth exch store
  1869.      % set up the call to "image" in the output file:
  1870.     (/imagesave save def) writeop
  1871.     CTM writenumarray (concat) writeop
  1872.     0 0 thruCTM ?box
  1873.     imagewidth imagedepth dup type /booleantype eq { pop 1 } if
  1874.     div imageheight imagematrix itransform thruCTM ?box
  1875.     (/imagebuff) writestr
  1876.     imagedepth dup type /booleantype eq { pop 1 } if
  1877.     imagewidth mul dup dup 8 idiv 8 mul eq {8 idiv}{8 idiv 1 add} ifelse
  1878.     writenum ( string def) writeop
  1879.      % invoke "image" with correct args in output file:
  1880.     imagewidth writenum imageheight writenum
  1881.     imagedepth (     ) cvs writestr
  1882.     imagematrix writenumarray
  1883.     } bdef
  1884.     /image { %def    % width height depth matrix { proc } :
  1885.     ?distilling cvbool { %ifelse
  1886.         imageguts
  1887.         ({ currentfile imagebuff readhexstring pop } image) writeop
  1888.         imagewidth imageheight imagedepth imagematrix
  1889.         { imageproc dup fd exch writehexstring writeNL } image
  1890.         (imagesave restore) writeop
  1891.     }{ image } ifelse
  1892.     } bdef
  1893.     /imagemask { % def    % width height depth matrix { proc } :
  1894.     ?distilling cvbool { %ifelse
  1895.         imageguts
  1896.         ({ currentfile imagebuff readhexstring pop } imagemask) writeop
  1897.         imagewidth imageheight imagedepth imagematrix
  1898.         { imageproc dup fd exch writehexstring writeNL } imagemask
  1899.         (imagesave restore) writeop
  1900.     }{ imagemask } ifelse
  1901.     } bdef
  1902.     % don't actually print the pages...   Fri Feb 17 13:13:10 1989
  1903.     % /*showpage systemdict /showpage get def
  1904.     /*showpage where { pop }{ %ifelse
  1905.     /*showpage /showpage load def
  1906.     } ifelse
  1907.     /showpage { %def
  1908.     stackshow
  1909.     pagecount cvnum scratch cvs wout ( ENDPAGE\n) wout
  1910.     /lastshowpage true hidebool
  1911.     /begunpage false hidebool
  1912.     /PAGEvec 0 hideval
  1913.     *showpage
  1914.     (%%PageTrailer) writeop
  1915.     (%%PageFonts: ) wout
  1916.     pfontcount cvnum 0 eq { writeNL }{ %else
  1917.         pfontcount cvnum 200 lt { %ifelse
  1918.         pagefonts 0 pfontcount cvnum getinterval writeop
  1919.         }{ %else
  1920.         pagefonts (\040) search not { writeop }{ %else
  1921.             writeop    % first one without the %%+
  1922.             { %loop
  1923.             search { (%%+ ) wout writeop }{ %else
  1924.                 (\000) search { writeop pop pop }{ pop } ifelse
  1925.                 exit
  1926.             } ifelse
  1927.             } loop
  1928.         } ifelse
  1929.         } ifelse
  1930.     } ifelse
  1931.     0 1 pfontcount cvnum { pagefonts exch 0 put } for
  1932.     /pfontcount 0 hideval
  1933.     LLx 10000 eq LLy 10000 eq or URx -10000 eq URy -10000 eq or or not {
  1934.         (%%PageBoundingBox: ) wout
  1935.           LLx cvnum writenum LLy cvnum writenum
  1936.           URx cvnum writenum URy cvnum writenum writeNL
  1937.         pageBBox-docBBox
  1938.     } if
  1939.     /LLx 10000 hideval  /LLy 10000 hideval
  1940.     /URx -10000 hideval /URy -10000 hideval
  1941.     % checksetup
  1942.     } bdef
  1943.     /*pathbbox systemdict /pathbbox get def
  1944.     /pathbbox { %def
  1945.     ?distilling cvbool { %if
  1946.         ischarpath { %ifelse
  1947.         gsave
  1948.             { currentpoint } stopped { 0 0 } if
  1949.             systemdict /moveto get exec
  1950.             pathstr false charpath flattenpath *pathbbox
  1951.         grestore
  1952.         }{ %else
  1953.         *pathbbox
  1954.         } ifelse
  1955.     } if
  1956.     } bdef
  1957.     /gsave { % def
  1958.     ?distilling cvbool { /gstates gstates 1 add store } if
  1959.     gsave
  1960.     } bdef
  1961.     /grestore { % def
  1962.     ?distilling cvbool { %if
  1963.         gstates 0 gt { %if
  1964.         /gstates gstates 1 sub store
  1965.         gstates charpathgstate lt { /ischarpath false store } if
  1966.         } if
  1967.     } if
  1968.     grestore
  1969.     } bdef
  1970.     /charpath { %def
  1971.     % need to make sure that when "stroke" or "fill" comes along
  1972.     % that the "charpath" elements are in the right place in the path...
  1973.     %- writepath
  1974.     ?distilling cvbool { %if
  1975.         checkgstate
  1976.         /ischarpath true store
  1977.         /charpathgstate gstates store
  1978.         /pathbool exch store
  1979.         /pathstr exch store
  1980.         { currentpoint } stopped { 0 0 } if thruCTM
  1981.         /pathY exch store /pathX exch store
  1982.         pathstr stringwidth rmoveto
  1983.     } if
  1984.     } bdef
  1985.     /newpath { %def
  1986.     ?distilling cvbool { gstates 0 le { /ischarpath false store } if } if
  1987.     newpath
  1988.     } bdef
  1989.  
  1990. end %adobe_distill
  1991. /setpacking where { pop setpacking } if
  1992. %%EndProcSet: distill_paintops 1.0
  1993.  
  1994. %%BeginProcSet: distill_guessfont 1.0
  1995. /setpacking where { pop currentpacking true setpacking } if
  1996. /adobe_distill dup where { pop pop }{ 165 200 add dict def } ifelse
  1997. adobe_distill begin
  1998.     /*definefont systemdict /definefont get def
  1999.     /definefont { %def
  2000.     % make a dictionary into which to put things
  2001.     % put the ORIGINAL name of the font into that dictionary
  2002.     % put the original FID in that dictionary, for easy comparison
  2003.     dup /FontType known {
  2004.         dup /FontType get 3 eq { %ifelse
  2005.         dup begin
  2006.             includeuserfonts { %if
  2007.             (%%BeginFont: ) wout 1 index writename writeNL
  2008.             currentdict maxlength writenum (dict begin) writeop
  2009.             save
  2010.                 /indentlevel ++
  2011.                 unames /Encoding true put
  2012.                 currentdict { %forall
  2013.                 exch dup /Encoding eq { %ifelse
  2014.                     indent (/) wout writename
  2015.                     writenamearray ( def) writeop indent
  2016.                 }{ %else
  2017.                     % dup unames exch true put
  2018.                     ( /) wout writename writeANY
  2019.                     (def) writeop indent
  2020.                 } ifelse
  2021.                 } forall
  2022.                 currentdict { pop unames exch true put } forall
  2023.                 currentdict { exch pop arrayusernames } forall
  2024.             restore
  2025.             indent (currentdict end\n) wout
  2026.             1 index writeANY (exch definefont pop) writeop
  2027.             (%%EndFont: ) wout 1 index writename writeNL
  2028.             } if
  2029.             currentdict /FontInfo known not
  2030.             currentdict dup length 2 add exch maxlength ge and { %if
  2031.             % make slightly bigger version of current dictionary
  2032.             pop currentdict end
  2033.             dup maxlength 1 add dict begin
  2034.             { def } forall currentdict
  2035.             } if
  2036.             /FontInfo 5 dict def
  2037.             FontInfo begin
  2038.             /realname 2 index def
  2039.             /pleasemap magicbool def
  2040.             /pleasemap false hidebool
  2041.             end
  2042.         end
  2043.         false
  2044.         }{ true } ifelse
  2045.     }{ true } ifelse
  2046.     % previous code leaves either true or false on stack
  2047.     { %if
  2048.         /Dfont exch store
  2049.      % This might be the first time we've ever seen a new
  2050.      % encoding.  If so, let's guess that we'll see lots
  2051.      % more of the vector, and give it the name "stdvec".
  2052.          Dfont begin
  2053.         %gcr FontType 1 eq STDvec cvnum 0 eq and
  2054.             STDvec cvnum 0 eq
  2055.         Encoding StandardEncoding ne and { %if
  2056.             /STDvec Encoding hashencoding hideval
  2057.             fd (/stdvec\n) *writestring
  2058.             STDvec
  2059.             StandardEncoding hashencoding eq { %ifelse
  2060.             fd (StandardEncoding ) *writestring
  2061.             }{ %else
  2062.             Encoding writenamearray
  2063.             } ifelse
  2064.             fd (def\n) *writestring
  2065.             checksetup
  2066.         }{ %else
  2067.             %gcr FontType 1 eq STDvec cvnum 0 eq and
  2068.             STDvec cvnum 0 eq
  2069.             Encoding StandardEncoding ne and { %if
  2070.             /PAGEvec Encoding hashencoding hideval
  2071.             fd (/pagevec\n) *writestring
  2072.             PAGEvec
  2073.             StandardEncoding hashencoding eq { %ifelse
  2074.                 fd (StandardEncoding ) *writestring
  2075.             }{ %else
  2076.                 Encoding writenamearray
  2077.             } ifelse
  2078.             fd (def\n) *writestring
  2079.             checksetup
  2080.             } if
  2081.         } ifelse
  2082.         end
  2083.      % try to find the "real" font in FontDirectory from which this
  2084.      % font was derived, assuming it was reencoded....
  2085.         /tempfontname /Courier store
  2086.         /tempfontname /UnKnownFont store
  2087.         FontDirectory { %forall
  2088.         /Ffont exch store /Fname exch store
  2089.         % if the font was already touched, ignore it:
  2090.         Ffont /FontInfo known { %ifelse
  2091.             Ffont /FontInfo get /realname known not
  2092.         }{ true } ifelse    % leaves boolean
  2093.         { % if
  2094.             % if UniqueID's match, grab it!
  2095.             Dfont /UniqueID known Ffont /UniqueID known and {
  2096.             Dfont /UniqueID get Ffont /UniqueID get eq {
  2097.                 /tempfontname Fname store exit
  2098.             } if
  2099.             } if
  2100.         } if % /realname is not there
  2101.         } forall
  2102.         tempfontname /UnKnownFont eq { %if
  2103.           Dfont begin
  2104.         FontDirectory { %forall
  2105.           /Ffont exch store /Fname exch store
  2106.           % if CharStrings match, then compare FontMatrix.  If
  2107.           % FontMatrix matches or the *second* elements match,
  2108.           % (it might be oblique), then grab it.
  2109.           Dfont /FontType known {
  2110.             FontType 1 eq {
  2111.               Dfont/CharStrings known Ffont/CharStrings known and {
  2112.             Dfont/CharStrings get Ffont/CharStrings get eq {
  2113.               Dfont/FontMatrix known Ffont/FontMatrix known and {
  2114.                 Dfont/FontMatrix get Ffont/FontMatrix get
  2115.                 2 copy eq  3 1 roll
  2116.                 2 get exch 2 get eq or {
  2117.                 /tempfontname Fname store exit
  2118.                 } if
  2119.               } if
  2120.             } if
  2121.               } if
  2122.             } if
  2123.           } if
  2124.         } forall
  2125.           end
  2126.         } if
  2127.         tempfontname /UnKnownFont eq { %if
  2128.           FontDirectory { %forall
  2129.         /Ffont exch store /Fname exch store
  2130.           % if everything matches but some keys, grab it
  2131.           true    % start with "true" on stack
  2132.           Dfont { %forall
  2133.             exch dup /Encoding eq 1 index /FID eq or { %ifelse
  2134.             pop pop
  2135.             }{ % else
  2136.             dup Ffont exch known {
  2137.                 Ffont exch get ne { pop false exit } if
  2138.             }{ pop pop } ifelse
  2139.             } ifelse
  2140.           } forall
  2141.           % use either "true" that was there, or "false" from loop
  2142.           { %if
  2143.               /tempfontname Fname store exit
  2144.           } if
  2145.           } forall
  2146.         } if
  2147.          tempfontname /UnKnownFont eq {
  2148.         Dfont /Encoding get StandardEncoding eq
  2149.         substitutefonts or { %ifelse
  2150.           % If there is no comparable fontdict already there, and
  2151.           % if this is of FontType 1 and has StandardEncoding,
  2152.           % we guess that this is a downloadable font, and ignore it
  2153.             Dfont /FontName known {
  2154.             /tempfontname Dfont /FontName get store
  2155.             }{
  2156.             /tempfontname /Courier store
  2157.             } ifelse
  2158.             (%substituting ) wout tempfontname writename writeNL
  2159.             messages {
  2160.             (substituting: ) pr= tempfontname ==
  2161.             } if
  2162.             Dfont    % needed by *definefont below...
  2163.         }{ %else
  2164.             (ERROR: Couldn't find original fontdict to match: ) print
  2165.             Dfont /FontName get == flush
  2166.             (Fonts in FontDirectory include:) r=
  2167.             FontDirectory { pop (\040) print == } forall flush
  2168.             stop
  2169.         } ifelse
  2170.         } if
  2171.         Dfont dup begin
  2172.         /FontInfo 5 dict def
  2173.         FontInfo begin
  2174.             /realname tempfontname def
  2175.             /pleasemap magicbool def
  2176.             /pleasemap
  2177.             tempfontname findfont /Encoding get
  2178.             StandardEncoding eq
  2179.             hidebool
  2180.         end
  2181.         end
  2182.     } if
  2183.     *definefont
  2184.     } bdef
  2185.  
  2186. end %adobe_distill
  2187. /setpacking where { pop setpacking } if
  2188. %%EndProcSet: distill_guessfont 1.0
  2189.  
  2190. %%BeginProcSet: hacks 0.5
  2191.   % defeat the "transform round exch round exch itransform" trick:
  2192.     /round { } bdef
  2193.     /transform { dup type /arraytype eq { pop } if } bdef
  2194.     /itransform { dup type /arraytype eq { pop } if } bdef
  2195.   % redefine control-D:
  2196.     (\004) { (\n%%EOF) writeop } bdef
  2197. %%EndProcSet: hacks 0.5
  2198.  
  2199.