[ Avaa Bypassed ]

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

% Initialization file for Display PostScript functions.

% ------ Errors ------ %

% These errors are only defined in DPS.
{ /invalidcontext /invalidid } { .registererror } forall

% ------ 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.
  //systemdict /savedinitialgstate gstate readonly .forceput
  .setglobal
} .bind executeonly odef % must be bound and hidden for .forceput

% 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 } executeonly forall
                % Set the user parameters.
  userparams readonly .setuserparams
                % Establish the initial gstate(s).
  /savedinitialgstate .systemvar setgstate gsave
                % Wrap up.
  end .setglobal
} bind executeonly 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 .systemvar /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 .systemvar /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>
  0 .currentscreenphase
} 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 {
    0 le
    { 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