Subversion Repositories planix.SVN

%    Copyright (C) 1997, 2000 Aladdin Enterprises.  All rights reserved.

% 

% This software is provided AS-IS with no warranty, either express or

% implied.

% 

% This software is distributed under license and may not be copied,

% modified or distributed except as expressly authorized under the terms

% of the license contained in the file LICENSE in this distribution.

% 

% For more information about licensing, please refer to

% http://www.ghostscript.com/licensing/. For information on

% commercial licensing, go to http://www.artifex.com/licensing/ or

% contact Artifex Software, Inc., 101 Lucas Valley Road #110,

% San Rafael, CA  94903, U.S.A., +1(415)492-9861.

% $Id: gs_dps.ps,v 1.8 2002/11/14 17:24:00 raph Exp $

% Initialization file for Display PostScript functions.

% ------ Contexts ------ %

% To create a context with private local VM, we use the .localfork

% operator to actually create the context, the new VM, and an empty

% userdict, and then we call the .initlocaldicts procedure to make

% local copies of the initial contents of the dictionaries in local VM.

% savedlocaldicts in systemdict is a global read-only dictionary whose

% elements are global read-only copies of these initial contents;

% we just copy its elements into local VM and install them in systemdict.

% userdict and internaldict require special handling.

% Switching between contexts with different local VMs requires

% changing the bindings in systemdict that reference local objects.

% For this purpose, each userdict has an entry called localdicts

% which holds the local copies of the elements of savedlocaldicts,

% plus internaldict.  The context switching code in the interpreter

% effectively copies this dictionary into systemdict.

% NOTE: the name localdicts is known to the interpreter.

% Switching between contexts also requires resetting the user parameters.

% The interpreter records the value of userparams (a local dictionary

% referenced from systemdict) for each context, and uses it for this.

% See gs_lev2.ps for more details.

% NOTE: the name userparams is known to the interpreter.

% Save copies of local dictionaries at the end of system initialization.

% Also save the initial gstate.

/.savelocalstate {

  .currentglobal true .setglobal

  //systemdict /savedlocaldicts mark //systemdict {

    dup gcheck {

      pop pop

    } {

      dup type /dicttype eq {

		% Save a copy of this dictionary in global VM.

	dup maxlength dict .copydict readonly

      } {

	pop pop

      } ifelse

    } ifelse

  } forall .dicttomark readonly put

		% Create localdicts for the current context.

  false .setglobal

  userdict /localdicts mark savedlocaldicts {

    pop dup load

  } forall /internaldict dup load

  .dicttomark readonly put

		% Save a copy of the initial gstate.

  true .setglobal

  //systemdict /savedinitialgstate gstate readonly put

  .setglobal

} .bind def

% Initialize local dictionaries and gstate when creating a new context.

% Note that until this completes, we are in the anomalous situation of

% having systemdict point to dictionaries that are in a non-current

% local VM.  Because of this, we turn off garbage collection temporarily.

/.copylocal {		% <name> <dict> .copylocal <name> <dict'>

		% Copy a dictionary to the current (local) VM,

		% and make it read-only if its current definition is.

  dup maxlength dict .copydict

  1 index load wcheck not { readonly } if

} .bind def

% When this is called, the dictionary stack is in its initial state,

% and there is (anomalously) only one gstate on the gstate stack.

/.initlocaldicts {		% - .initlocaldicts -

  -2 vmreclaim

  .currentglobal //systemdict begin

  false .setglobal

		% Since localdicts doesn't exist yet, references from

		% systemdict to local objects won't get restored if

		% a context switch happens in this code.  Therefore,

		% until localdicts is defined, we have to keep all our

		% state on the operand stack.

		% Acquire userdict.

		%****** WRONG IF NON-STANDARD INITIAL DSTACK ******

  countdictstack array dictstack

   { dup gcheck not { exit } if pop } forall

		% Create localdicts with a local copy of each dictionary,

		% except for userdict and userparams, which just need

		% to be filled in.

  mark savedlocaldicts {

    1 index /userdict eq {

		% Stack: userdict mark ... /userdict inituserdict

      counttomark 1 add index .copydict

    } {

      1 index /userparams eq {

		% Stack: userdict mark ... /userparams inituserparams

	userparams .copydict

      } {

	.copylocal

      } ifelse

    } ifelse

  } forall /internaldict dup .makeinternaldict .makeoperator

  .dicttomark readonly /localdicts exch put

		% localdicts is now defined in userdict.

		% Copy the definitions into systemdict.

  localdicts { .forcedef } forall

		% Set the user parameters.

  userparams readonly .setuserparams

		% Establish the initial gstate(s).

  /savedinitialgstate .systemvar setgstate gsave

		% Wrap up.

  end .setglobal

} odef

% Check whether an object is a procedure.

/.proccheck {			% <obj> .proccheck <bool>

  dup xcheck

  exch type dup /arraytype eq exch /packedarraytype eq or and

} bind def

% Create a context with private local VM.

% The .localfork operator does all the work, but we must ensure that

% .initlocaldicts gets called when the new context starts up.

/localfork {			% <mark> <obj1> ... <objN> <proc>

				%   <stdin|null> <stdout|null>

				%   localfork <context>

  .currentglobal true .setglobal 3 index

  dup .proccheck not {

    pop .setglobal /localfork cvx /typecheck signalerror

  } if

  {exec .initlocaldicts} aload pop

  3 1 roll 3 packedarray cvx

  4 1 roll 5 -1 roll pop .setglobal .localfork

} odef

% Fork a context that shares VM.  The .fork operator creates an empty

% userparams dictionary for the context, but we still need to initialize

% this dictionary when the new context starts up.

/.postfork {		% - .postfork -

	% Initialize the user parameters.

  savedlocaldicts /userparams get userparams .copydict readonly pop

} odef

/fork {			% <mark> <obj1> ... <objN> <proc> fork <context>

  .currentglobal false .setglobal 1 index

  dup .proccheck not {

    pop .setglobal /fork cvx /typecheck signalerror

  } if

  {exec .postfork} aload pop

  3 1 roll 3 packedarray cvx

  3 1 roll exch pop .setglobal .fork

} odef

% ------ Halftone phase ------ %

/sethalftonephase {		% <x> <y> sethalftonephase -

  -1 2 index 2 index .setscreenphase pop pop

} odef

/currenthalftonephase {		% - currenthalftonephase <x> <y>

} odef

% ------ Device-source images ------ */

.imagetypes 2 /.image2 load put

% ------ Device information ------ %

/.deviceinfodict mark

  /Colors null /GrayValues null /RedValues null /GreenValues null

  /BlueValues null /ColorValues null

.dicttomark readonly def

/deviceinfo {			% - deviceinfo <dict>

  currentdevice //.deviceinfodict .getdeviceparams .dicttomark

  dup begin

  /ColorValues .knownget {

    { currentdict /ColorValues undef }

    {

      % hack around devices that incorrect set GrayValues

      Colors 3 eq { 1 } { GrayValues } ifelse

      RedValues mul GreenValues mul BlueValues mul ColorValues ne

      { currentdict /GrayValues undef

        currentdict /RedValues undef

        currentdict /GreenValues undef

        currentdict /BlueValues undef

      } if

    }

    ifelse

  } if

  currentdict end readonly

} odef

% The current implementation allocates a 2-element array each time.

% Perhaps we should change this to 2 separate parameters for X and Y?

/.wtdict mark

  /wtranslation null

.dicttomark readonly def

/wtranslation {			% - wtranslation <x> <y>

  currentdevice //.wtdict .getdeviceparams exch pop exch pop aload pop

} odef

currentdict /.wtdict .undef

% ------ View clipping ------ %

/rectviewclip {			% <x> <y> <width> <height> rectviewclip -

				% <numarray|numstring> rectviewclip -

  newpath .rectappend viewclip

} odef