.\" Automatically generated by Pod::Man 2.28 (Pod::Simple 3.28)
.\"
.\" Standard preamble:
.\" ========================================================================
.de Sp \" Vertical space (when we can't use .PP)
.if t .sp .5v
.if n .sp
..
.de Vb \" Begin verbatim text
.ft CW
.nf
.ne \\$1
..
.de Ve \" End verbatim text
.ft R
.fi
..
.\" Set up some character translations and predefined strings.  \*(-- will
.\" give an unbreakable dash, \*(PI will give pi, \*(L" will give a left
.\" double quote, and \*(R" will give a right double quote.  \*(C+ will
.\" give a nicer C++.  Capital omega is used to do unbreakable dashes and
.\" therefore won't be available.  \*(C` and \*(C' expand to `' in nroff,
.\" nothing in troff, for use with C<>.
.tr \(*W-
.ds C+ C\v'-.1v'\h'-1p'\s-2+\h'-1p'+\s0\v'.1v'\h'-1p'
.ie n \{\
.    ds -- \(*W-
.    ds PI pi
.    if (\n(.H=4u)&(1m=24u) .ds -- \(*W\h'-12u'\(*W\h'-12u'-\" diablo 10 pitch
.    if (\n(.H=4u)&(1m=20u) .ds -- \(*W\h'-12u'\(*W\h'-8u'-\"  diablo 12 pitch
.    ds L" ""
.    ds R" ""
.    ds C` ""
.    ds C' ""
'br\}
.el\{\
.    ds -- \|\(em\|
.    ds PI \(*p
.    ds L" ``
.    ds R" ''
.    ds C`
.    ds C'
'br\}
.\"
.\" Escape single quotes in literal strings from groff's Unicode transform.
.ie \n(.g .ds Aq \(aq
.el       .ds Aq '
.\"
.\" If the F register is turned on, we'll generate index entries on stderr for
.\" titles (.TH), headers (.SH), subsections (.SS), items (.Ip), and index
.\" entries marked with X<> in POD.  Of course, you'll have to process the
.\" output yourself in some meaningful fashion.
.\"
.\" Avoid warning from groff about undefined register 'F'.
.de IX
..
.nr rF 0
.if \n(.g .if rF .nr rF 1
.if (\n(rF:(\n(.g==0)) \{
.    if \nF \{
.        de IX
.        tm Index:\\$1\t\\n%\t"\\$2"
..
.        if !\nF==2 \{
.            nr % 0
.            nr F 2
.        \}
.    \}
.\}
.rr rF
.\"
.\" Accent mark definitions (@(#)ms.acc 1.5 88/02/08 SMI; from UCB 4.2).
.\" Fear.  Run.  Save yourself.  No user-serviceable parts.
.    \" fudge factors for nroff and troff
.if n \{\
.    ds #H 0
.    ds #V .8m
.    ds #F .3m
.    ds #[ \f1
.    ds #] \fP
.\}
.if t \{\
.    ds #H ((1u-(\\\\n(.fu%2u))*.13m)
.    ds #V .6m
.    ds #F 0
.    ds #[ \&
.    ds #] \&
.\}
.    \" simple accents for nroff and troff
.if n \{\
.    ds ' \&
.    ds ` \&
.    ds ^ \&
.    ds , \&
.    ds ~ ~
.    ds /
.\}
.if t \{\
.    ds ' \\k:\h'-(\\n(.wu*8/10-\*(#H)'\'\h"|\\n:u"
.    ds ` \\k:\h'-(\\n(.wu*8/10-\*(#H)'\`\h'|\\n:u'
.    ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'^\h'|\\n:u'
.    ds , \\k:\h'-(\\n(.wu*8/10)',\h'|\\n:u'
.    ds ~ \\k:\h'-(\\n(.wu-\*(#H-.1m)'~\h'|\\n:u'
.    ds / \\k:\h'-(\\n(.wu*8/10-\*(#H)'\z\(sl\h'|\\n:u'
.\}
.    \" troff and (daisy-wheel) nroff accents
.ds : \\k:\h'-(\\n(.wu*8/10-\*(#H+.1m+\*(#F)'\v'-\*(#V'\z.\h'.2m+\*(#F'.\h'|\\n:u'\v'\*(#V'
.ds 8 \h'\*(#H'\(*b\h'-\*(#H'
.ds o \\k:\h'-(\\n(.wu+\w'\(de'u-\*(#H)/2u'\v'-.3n'\*(#[\z\(de\v'.3n'\h'|\\n:u'\*(#]
.ds d- \h'\*(#H'\(pd\h'-\w'~'u'\v'-.25m'\f2\(hy\fP\v'.25m'\h'-\*(#H'
.ds D- D\\k:\h'-\w'D'u'\v'-.11m'\z\(hy\v'.11m'\h'|\\n:u'
.ds th \*(#[\v'.3m'\s+1I\s-1\v'-.3m'\h'-(\w'I'u*2/3)'\s-1o\s+1\*(#]
.ds Th \*(#[\s+2I\s-2\h'-\w'I'u*3/5'\v'-.3m'o\v'.3m'\*(#]
.ds ae a\h'-(\w'a'u*4/10)'e
.ds Ae A\h'-(\w'A'u*4/10)'E
.    \" corrections for vroff
.if v .ds ~ \\k:\h'-(\\n(.wu*9/10-\*(#H)'\s-2\u~\d\s+2\h'|\\n:u'
.if v .ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'\v'-.4m'^\v'.4m'\h'|\\n:u'
.    \" for low resolution devices (crt and lpr)
.if \n(.H>23 .if \n(.V>19 \
\{\
.    ds : e
.    ds 8 ss
.    ds o a
.    ds d- d\h'-1'\(ga
.    ds D- D\h'-1'\(hy
.    ds th \o'bp'
.    ds Th \o'LP'
.    ds ae ae
.    ds Ae AE
.\}
.rm #[ #] #H #V #F C
.\" ========================================================================
.\"
.IX Title "Imager::Expr 3pm"
.TH Imager::Expr 3pm "2014-01-10" "perl v5.20.1" "User Contributed Perl Documentation"
.\" For nroff, turn off justification.  Always turn off hyphenation; it makes
.\" way too many mistakes in technical documents.
.if n .ad l
.nh
.SH "NAME"
Imager::Expr \- implements expression parsing and compilation for the 
expression evaluation engine used by Imager::transform2()
.SH "SYNOPSIS"
.IX Header "SYNOPSIS"
my \f(CW$code\fR = Imager::Expr\->new({rpnexpr=>$someexpr})
  or die \*(L"Cannot compile \f(CW$someexpr:\fR \*(R",\fIImager::Expr::error()\fR;
.SH "DESCRIPTION"
.IX Header "DESCRIPTION"
This module is used internally by the \fIImager::transform2()\fR function.
You shouldn't have much need to use it directly, but you may want to
extend it.
.PP
To create a new Imager::Expr object, call:
.PP
.Vb 3
\& my %options;
\& my $expr = Imager::Expr\->new(\e%options)
\&   or die Imager::Expr::error();
.Ve
.PP
You will need to set an expression value and you may set any of the
following:
.IP "\(bu" 4
constants
.Sp
A hashref defining extra constants for expression parsing.  The names
of the constants must be valid identifiers (/[^\eW\ed]\ew*/) and the
values must be valid numeric constants (that Perl recognizes in
scalars).
.Sp
Imager::Expr may define it's own constants (currently just pi.)
.IP "\(bu" 4
variables
.Sp
A reference to an array of variable names.  These are allocated
numeric registers starting from register zero.
.PP
By default you can define a \f(CW\*(C`rpnexpr\*(C'\fR key (which emulates \s-1RPN\s0) or
\&\f(CW\*(C`expr\*(C'\fR (an infix expression).  It's also possible to write other
expression parsers that will use other keys.  Only one expression key
should be defined.
.SS "Instance methods"
.IX Subsection "Instance methods"
The \fIImager::Expr::error()\fR method is used to retrieve the error if the
expression object cannot be created.
.SS "Methods"
.IX Subsection "Methods"
Imager::Expr provides only a few simple methods meant for external use:
.IP "Imager::Expr\->type_registered($keyword)" 4
.IX Item "Imager::Expr->type_registered($keyword)"
Returns true if the given expression type is available.  The parameter
is the key supplied to the \fInew()\fR method.
.Sp
.Vb 3
\&  if (Imager::Expr\->type_registered(\*(Aqexpr\*(Aq)) {
\&    # use infix expressions
\&  }
.Ve
.ie n .IP "$expr\->\fIcode()\fR" 4
.el .IP "\f(CW$expr\fR\->\fIcode()\fR" 4
.IX Item "$expr->code()"
Returns the compiled code.
.ie n .IP "$expr\->\fInregs()\fR" 4
.el .IP "\f(CW$expr\fR\->\fInregs()\fR" 4
.IX Item "$expr->nregs()"
Returns a reference to the array of numeric registers.
.ie n .IP "$expr\->\fIcregs()\fR" 4
.el .IP "\f(CW$expr\fR\->\fIcregs()\fR" 4
.IX Item "$expr->cregs()"
Returns a reference to the array of color registers.
.ie n .IP "$expr\->\fIdumpops()\fR" 4
.el .IP "\f(CW$expr\fR\->\fIdumpops()\fR" 4
.IX Item "$expr->dumpops()"
Returns a string with the generated \s-1VM \s0\*(L"machine code\*(R".
.ie n .IP "$expr\->\fIdumpcode()\fR" 4
.el .IP "\f(CW$expr\fR\->\fIdumpcode()\fR" 4
.IX Item "$expr->dumpcode()"
Returns a string with the disassembled \s-1VM \s0\*(L"machine code\*(R".
.SS "Creating a new parser"
.IX Subsection "Creating a new parser"
I'll write this one day.
.PP
Methods used by parsers:
.IP "compile" 4
.IX Item "compile"
This is the main method you'll need to implement in a parser.  See the
existing parsers for a guide.
.Sp
It's supplied the following parameters:
.RS 4
.IP "\(bu" 4
\&\f(CW$expr\fR \- the expression to be parsed
.IP "\(bu" 4
\&\f(CW$options\fR \- the options hash supplied to transform2.
.RE
.RS 4
.Sp
Return an array ref of array refs containing opcodes and operands.
.RE
.ie n .IP "@vars = $self\->\fI_variables()\fR" 4
.el .IP "\f(CW@vars\fR = \f(CW$self\fR\->\fI_variables()\fR" 4
.IX Item "@vars = $self->_variables()"
A list (not a reference) of the input variables.  This should be used
to allocate as many registers as there are variable as input
registers.
.ie n .IP "$self\->error($message)" 4
.el .IP "\f(CW$self\fR\->error($message)" 4
.IX Item "$self->error($message)"
Set the return value of \fIImager::Expr::error()\fR
.ie n .IP "@ops = $self\->stack_to_reg(@stack_ops)" 4
.el .IP "\f(CW@ops\fR = \f(CW$self\fR\->stack_to_reg(@stack_ops)" 4
.IX Item "@ops = $self->stack_to_reg(@stack_ops)"
Converts marginally parsed \s-1RPN\s0 to register code.
.IP "\fIassemble()\fR" 4
.IX Item "assemble()"
Called to convert op codes into byte code.
.IP "\fInumre()\fR" 4
.IX Item "numre()"
Returns a regular expression that matches floating point numbers.
.IP "\fIoptimize()\fR" 4
.IX Item "optimize()"
Optimizes the assembly code, including attempting common subexpression
elimination and strength reducing division by a constant into
multiplication by a constant.
.IP "\fIregister_type()\fR" 4
.IX Item "register_type()"
Called by a new expression parser implementation to register itself,
call as:
.Sp
.Vb 1
\&  YourClassName\->register_type(\*(Aqtype code\*(Aq);
.Ve
.Sp
where type code is the parameter that will accept the expression.
.SS "Future compatibility"
.IX Subsection "Future compatibility"
Try to avoid doing your own optimization beyond literal folding \- if
we add some sort of jump, the existing optimizer will need to be
rewritten, and any optimization you perform may well be broken too
(well, your code generation will probably be broken anyway <sigh>).
.SH "AUTHOR"
.IX Header "AUTHOR"
Tony Cook <tonyc@cpan.org>, Arnar M. Hrafnkelsson