psinterpreter

Documentation

Overview

Package psinterpreter implement a Postscript interpreter required to parse .CFF files, and Type1 and Type2 Charstrings. This package provides the low-level mechanisms needed to read such formats; the data is consumed in higher level packages, which implement `PsOperatorHandler`. It also provides helpers to interpret glyph outline descriptions, shared between Type1 and CFF font formats.

Index

• Variables
• type ArgStack
  • func (a *ArgStack) Clear()
  • func (a *ArgStack) Float() float32
  • func (a *ArgStack) Pop() int32
  • func (a *ArgStack) PopN(numPop int32) error
  • func (a *ArgStack) Uint16() uint16
• type Machine
  • func (p *Machine) CallSubroutine(index int32, isLocal bool) error
  • func (p *Machine) Return() error
  • func (p *Machine) Run(instructions []byte, localSubrs, globalSubrs [][]byte, ...) error
  • func (p *Machine) SkipBytes(count int32)
• type PsContext
• type PsOperator
  • func (p PsOperator) String() string
• type PsOperatorHandler

Variables

var (

	// ErrInterrupt signals the interpreter to stop early, without erroring.
	ErrInterrupt = errors.New("interruption")
)

Types

type ArgStack

type ArgStack struct {
	Vals [psArgStackSize]int32
	// Effecive size currently in use. The first value to
	// pop is at index Top-1
	Top int32
}

func (*ArgStack) Clear

func (a *ArgStack) Clear()

Clear clears the stack

func (*ArgStack) Float

func (a *ArgStack) Float() float32

Float return the top level value as a real number (which is stored as its binary representation), without popping the stack.

func (*ArgStack) Pop

func (a *ArgStack) Pop() int32

Pop returns the top level value and decrease `Top` It will panic if the stack is empty.

func (*ArgStack) PopN

func (a *ArgStack) PopN(numPop int32) error

PopN check and remove the n top levels entries. Passing a negative `numPop` clears all the stack.

func (*ArgStack) Uint16

func (a *ArgStack) Uint16() uint16

Uint16 returns the top level value as uint16, without popping the stack.

type Machine

type Machine struct {
	ArgStack ArgStack
	// contains filtered or unexported fields
}

Machine is a PostScript interpreter. A same interpreter may be re-used using muliples `Run` calls.

func (*Machine) CallSubroutine

func (p *Machine) CallSubroutine(index int32, isLocal bool) error

CallSubroutine calls the subroutine, identified by its index, as found in the instructions (that is, before applying the subroutine biased). `isLocal` controls whether the local or global subroutines are used. No argument stack modification is performed.

func (*Machine) Return

func (p *Machine) Return() error

Return returns from a subroutine call.

func (*Machine) Run

func (p *Machine) Run(instructions []byte, localSubrs, globalSubrs [][]byte, handler PsOperatorHandler) error

Run runs the instructions in the PostScript context asked by `handler`. `localSubrs` and `globalSubrs` contains the subroutines that may be called in the instructions.

func (*Machine) SkipBytes

func (p *Machine) SkipBytes(count int32)

SkipBytes skips the next `count` bytes from the instructions, and clears the argument stack. It does nothing if `count` exceed the length of the instructions.

type PsContext

type PsContext uint32

PsContext is the flavour of the Postcript language.

const (
	TopDict         PsContext = iota // Top dict in CFF files
	PrivateDict                      // Private dict in CFF files
	Type2Charstring                  // Charstring in CFF files
	Type1Charstring                  // Charstring in Type1 font files
)

type PsOperator

type PsOperator struct {
	Operator  byte
	IsEscaped bool
}

PsOperator is a postcript command, which may be escaped.

func (PsOperator) String

func (p PsOperator) String() string

type PsOperatorHandler

type PsOperatorHandler interface {
	// Context defines the precise behaviour of the interpreter,
	// which has small nuances depending on the context.
	Context() PsContext

	// Apply implements the operator defined by `operator` (which is the second byte if `escaped` is true).
	//
	// Returning `ErrInterrupt` stop the parsing of the instructions, without reporting an error.
	// It can be used as an optimization.
	Apply(operator PsOperator, state *Machine) error
}

PsOperatorHandler defines the behaviour of an operator.