[comp.lang.postscript] Esoterica

CXT105@psuvm.psu.edu (Christopher Tate) (04/17/91)

There seem to be all manner of interesting things floating around in the
internaldict, such as the FlxProc array and the superexec operator.  But
does anyone know (or is anyone allowed to tell?) what operators such as
ErodeSW, CCRun, xlck, or ylck do?

I don't necessarily care whether they're actually *useful*; I'm just
curious about the innards of my LaserWriter....

I'm also assuming that the operators such as @repeat, @rfor, @loop, @ifor,
etc. have to do with low-level implementation of the interpreter.  Is this
even close to right?

-------
Christopher Tate                   | "Excuse me, is this your bag?"
                                   | "No."
cxt105@psuvm.psu.edu               | "Are you sure?  Do take your time."
{...}!psuvax1!psuvm.bitnet!cxt105  | "This is definitely *not* my bag."
cxt105@psuvm.bitnet                | "Just as we thought...."

andrew@visix.com (Andrew Bernard) (04/18/91)

In article <91106.223204CXT105@psuvm.psu.edu> CXT105@psuvm.psu.edu (Christopher Tate) writes:
>There seem to be all manner of interesting things floating around in the
>internaldict, such as the FlxProc array and the superexec operator.  But
>does anyone know (or is anyone allowed to tell?) what operators such as
>ErodeSW, CCRun, xlck, or ylck do?
>

Some of these sound like hinting operators/procedures.  Check out the
Adobe Type 1 Font Format documentation.  I don't know the others.

>I don't necessarily care whether they're actually *useful*; I'm just
>curious about the innards of my LaserWriter....
>
>I'm also assuming that the operators such as @repeat, @rfor, @loop, @ifor,
>etc. have to do with low-level implementation of the interpreter.  Is this
>even close to right?
>

These are the run-time forms of the looping operators.  Basically, when you
execute certain control operators (_repeat_, _for_, etc) they push some state
information and your procedure onto the execution stack followed by one 
of the @ operators.  The @ operator is then responsible for executing the
procedure and generating the next iteration of the loop.  This makes it
possible for the interpreter to implement control structures without having
to re-enter itself, which can be very expensive (though it does do this
during things like _pathforall_).  Using @ operators also makes recovery
from things like _stop_ somewhat cleaner.  I suspect it also helps a little
when you want to implement multiple threads ala DPS.

-- 
     andrew bernard              ring the doorbell on your mind  
    software engineer            but it's locked from the outside
     visix software                                 -dinosaur jr.
    andrew@visix.com

woody@chinacat.Unicom.COM (Woody Baker @ Eagle Signal) (04/18/91)

In article <91106.223204CXT105@psuvm.psu.edu>, CXT105@psuvm.psu.edu (Christopher Tate) writes:
> ErodeSW, CCRun, xlck, or ylck do?
> 
The Type 1 Font book (the Black Book) explains most of these details.
it does not cover superexec.  Superexec is just like exec, except that it
bypasses a majority of the invalid access errors.  The simplest way
to use it is to enclose a sequence of operations in { } and feed that
to superexec.  Nearly everything that will raise an invalid access error
will work.
> 
> -------
> Christopher Tate                   | "Excuse me, is this your bag?"
>                                    | "No."
> cxt105@psuvm.psu.edu               | "Are you sure?  Do take your time."
> {...}!psuvax1!psuvm.bitnet!cxt105  | "This is definitely *not* my bag."
> cxt105@psuvm.bitnet                | "Just as we thought...."