unipdf/ps/ps.go

//
// Copyright 2020 FoxyUtils ehf. All rights reserved.
//
// This is a commercial product and requires a license to operate.
// A trial license can be obtained at https://unidoc.io
//
// DO NOT EDIT: generated by unitwist Go source code obfuscator.
//
// Use of this source code is governed by the UniDoc End User License Agreement
// terms that can be accessed at https://unidoc.io/eula/

// Package ps implements various functionalities needed for handling Postscript for PDF uses, in particular
// for PDF function type 4.
//
// Package ps implements various functionalities needed for handling Postscript for PDF uses, in particular
// for PDF function type 4.
package ps ;import (_bf "bufio";_ge "bytes";_b "errors";_f "fmt";_gd "github.com/unidoc/unipdf/v3/common";_ab "github.com/unidoc/unipdf/v3/core";_bd "io";_a "math";);

// PSProgram defines a Postscript program which is a series of PS objects (arguments, commands, programs etc).
type PSProgram []PSObject ;

// MakeReal returns a new PSReal object initialized with `val`.
func MakeReal (val float64 )*PSReal {_dgdg :=PSReal {};_dgdg .Val =val ;return &_dgdg };var ErrTypeCheck =_b .New ("\u0074\u0079p\u0065\u0020\u0063h\u0065\u0063\u006b\u0020\u0065\u0072\u0072\u006f\u0072");

// Append appends an object to the PSProgram.
func (_ac *PSProgram )Append (obj PSObject ){*_ac =append (*_ac ,obj )};func (_gcd *PSOperand )roll (_cbdg *PSStack )error {_caef ,_aedfa :=_cbdg .Pop ();if _aedfa !=nil {return _aedfa ;};_fdc ,_aedfa :=_cbdg .Pop ();if _aedfa !=nil {return _aedfa ;};_dde ,_deae :=_caef .(*PSInteger );
if !_deae {return ErrTypeCheck ;};_aebd ,_deae :=_fdc .(*PSInteger );if !_deae {return ErrTypeCheck ;};if _aebd .Val < 0{return ErrRangeCheck ;};if _aebd .Val ==0||_aebd .Val ==1{return nil ;};if _aebd .Val > len (*_cbdg ){return ErrStackUnderflow ;};for _edfa :=0;
_edfa < _gaf (_dde .Val );_edfa ++{var _aebe []PSObject ;_aebe =(*_cbdg )[len (*_cbdg )-(_aebd .Val ):len (*_cbdg )];if _dde .Val > 0{_fdcg :=_aebe [len (_aebe )-1];_aebe =append ([]PSObject {_fdcg },_aebe [0:len (_aebe )-1]...);}else {_gga :=_aebe [len (_aebe )-_aebd .Val ];
_aebe =append (_aebe [1:],_gga );};_aff :=append ((*_cbdg )[0:len (*_cbdg )-_aebd .Val ],_aebe ...);_cbdg =&_aff ;};return nil ;};var ErrStackOverflow =_b .New ("\u0073\u0074\u0061\u0063\u006b\u0020\u006f\u0076\u0065r\u0066\u006c\u006f\u0077");func (_ca *PSReal )Duplicate ()PSObject {_fc :=PSReal {};
_fc .Val =_ca .Val ;return &_fc };

// NewPSProgram returns an empty, initialized PSProgram.
func NewPSProgram ()*PSProgram {return &PSProgram {}};func (_fga *PSParser )skipSpaces ()(int ,error ){_egbff :=0;for {_ccf ,_cdgg :=_fga ._efd .Peek (1);if _cdgg !=nil {return 0,_cdgg ;};if _ab .IsWhiteSpace (_ccf [0]){_fga ._efd .ReadByte ();_egbff ++;
}else {break ;};};return _egbff ,nil ;};func (_fb *PSOperand )String ()string {return string (*_fb )};const _fd =0.000001;func (_bde *PSOperand )lt (_beef *PSStack )error {_bec ,_accf :=_beef .PopNumberAsFloat64 ();if _accf !=nil {return _accf ;};_cdf ,_accf :=_beef .PopNumberAsFloat64 ();
if _accf !=nil {return _accf ;};if _a .Abs (_cdf -_bec )< _fd {_ede :=_beef .Push (MakeBool (false ));return _ede ;}else if _cdf < _bec {_cba :=_beef .Push (MakeBool (true ));return _cba ;}else {_adga :=_beef .Push (MakeBool (false ));return _adga ;};};


// PopNumberAsFloat64 pops and return the numeric value of the top of the stack as a float64.
// Real or integer only.
func (_edc *PSStack )PopNumberAsFloat64 ()(float64 ,error ){_ggae ,_cdcc :=_edc .Pop ();if _cdcc !=nil {return 0,_cdcc ;};if _bbae ,_bfe :=_ggae .(*PSReal );_bfe {return _bbae .Val ,nil ;}else if _ccd ,_ffbfb :=_ggae .(*PSInteger );_ffbfb {return float64 (_ccd .Val ),nil ;
}else {return 0,ErrTypeCheck ;};};func (_abg *PSProgram )String ()string {_cf :="\u007b\u0020";for _ ,_bdb :=range *_abg {_cf +=_bdb .String ();_cf +="\u0020";};_cf +="\u007d";return _cf ;};func (_aaf *PSOperand )ifelse (_edac *PSStack )error {_gea ,_cag :=_edac .Pop ();
if _cag !=nil {return _cag ;};_eccfa ,_cag :=_edac .Pop ();if _cag !=nil {return _cag ;};_efac ,_cag :=_edac .Pop ();if _cag !=nil {return _cag ;};_bad ,_dfed :=_gea .(*PSProgram );if !_dfed {return ErrTypeCheck ;};_eee ,_dfed :=_eccfa .(*PSProgram );if !_dfed {return ErrTypeCheck ;
};_efgb ,_dfed :=_efac .(*PSBoolean );if !_dfed {return ErrTypeCheck ;};if _efgb .Val {_fbcg :=_eee .Exec (_edac );return _fbcg ;};_cag =_bad .Exec (_edac );return _cag ;};func (_ggca *PSParser )parseOperand ()(*PSOperand ,error ){var _gaa []byte ;for {_edgb ,_gefeb :=_ggca ._efd .Peek (1);
if _gefeb !=nil {if _gefeb ==_bd .EOF {break ;};return nil ,_gefeb ;};if _ab .IsDelimiter (_edgb [0]){break ;};if _ab .IsWhiteSpace (_edgb [0]){break ;};_dabf ,_ :=_ggca ._efd .ReadByte ();_gaa =append (_gaa ,_dabf );};if len (_gaa )==0{return nil ,_b .New ("\u0069\u006e\u0076al\u0069\u0064\u0020\u006f\u0070\u0065\u0072\u0061\u006e\u0064\u0020\u0028\u0065\u006d\u0070\u0074\u0079\u0029");
};return MakeOperand (string (_gaa )),nil ;};func (_abge *PSOperand )copy (_cfb *PSStack )error {_cea ,_ada :=_cfb .PopInteger ();if _ada !=nil {return _ada ;};if _cea < 0{return ErrRangeCheck ;};if _cea > len (*_cfb ){return ErrRangeCheck ;};*_cfb =append (*_cfb ,(*_cfb )[len (*_cfb )-_cea :]...);
return nil ;};func (_abgg *PSOperand )pop (_eed *PSStack )error {_ ,_dad :=_eed .Pop ();if _dad !=nil {return _dad ;};return nil ;};

// NewPSExecutor returns an initialized PSExecutor for an input `program`.
func NewPSExecutor (program *PSProgram )*PSExecutor {_bg :=&PSExecutor {};_bg .Stack =NewPSStack ();_bg ._e =program ;return _bg ;};func (_ace *PSOperand )div (_gfd *PSStack )error {_fdge ,_efc :=_gfd .Pop ();if _efc !=nil {return _efc ;};_bge ,_efc :=_gfd .Pop ();
if _efc !=nil {return _efc ;};_gcbf ,_ggd :=_fdge .(*PSReal );_bba ,_ccec :=_fdge .(*PSInteger );if !_ggd &&!_ccec {return ErrTypeCheck ;};if _ggd &&_gcbf .Val ==0{return ErrUndefinedResult ;};if _ccec &&_bba .Val ==0{return ErrUndefinedResult ;};_acde ,_cab :=_bge .(*PSReal );
_gbgd ,_dd :=_bge .(*PSInteger );if !_cab &&!_dd {return ErrTypeCheck ;};var _eg float64 ;if _cab {_eg =_acde .Val ;}else {_eg =float64 (_gbgd .Val );};if _ggd {_eg /=_gcbf .Val ;}else {_eg /=float64 (_bba .Val );};_efc =_gfd .Push (MakeReal (_eg ));return _efc ;
};func (_eea *PSOperand )neg (_faeb *PSStack )error {_gdd ,_bgeg :=_faeb .Pop ();if _bgeg !=nil {return _bgeg ;};if _eaf ,_fdb :=_gdd .(*PSReal );_fdb {_bgeg =_faeb .Push (MakeReal (-_eaf .Val ));return _bgeg ;}else if _aefg ,_egbd :=_gdd .(*PSInteger );
_egbd {_bgeg =_faeb .Push (MakeInteger (-_aefg .Val ));return _bgeg ;}else {return ErrTypeCheck ;};};

// PSStack defines a stack of PSObjects. PSObjects can be pushed on or pull from the stack.
type PSStack []PSObject ;func _gaf (_bac int )int {if _bac < 0{return -_bac ;};return _bac ;};

// PSInteger represents an integer.
type PSInteger struct{Val int ;};func (_cec *PSOperand )mod (_dcdb *PSStack )error {_fbca ,_aac :=_dcdb .Pop ();if _aac !=nil {return _aac ;};_cfgca ,_aac :=_dcdb .Pop ();if _aac !=nil {return _aac ;};_ebd ,_ceee :=_fbca .(*PSInteger );if !_ceee {return ErrTypeCheck ;
};if _ebd .Val ==0{return ErrUndefinedResult ;};_cge ,_ceee :=_cfgca .(*PSInteger );if !_ceee {return ErrTypeCheck ;};_effb :=_cge .Val %_ebd .Val ;_aac =_dcdb .Push (MakeInteger (_effb ));return _aac ;};func (_ece *PSOperand )add (_aeb *PSStack )error {_edf ,_gac :=_aeb .Pop ();
if _gac !=nil {return _gac ;};_ad ,_gac :=_aeb .Pop ();if _gac !=nil {return _gac ;};_bc ,_ag :=_edf .(*PSReal );_gee ,_db :=_edf .(*PSInteger );if !_ag &&!_db {return ErrTypeCheck ;};_bcb ,_feg :=_ad .(*PSReal );_cdc ,_ba :=_ad .(*PSInteger );if !_feg &&!_ba {return ErrTypeCheck ;
};if _db &&_ba {_deb :=_gee .Val +_cdc .Val ;_dfd :=_aeb .Push (MakeInteger (_deb ));return _dfd ;};var _gce float64 ;if _ag {_gce =_bc .Val ;}else {_gce =float64 (_gee .Val );};if _feg {_gce +=_bcb .Val ;}else {_gce +=float64 (_cdc .Val );};_gac =_aeb .Push (MakeReal (_gce ));
return _gac ;};func (_ed *PSInteger )String ()string {return _f .Sprintf ("\u0025\u0064",_ed .Val )};var ErrRangeCheck =_b .New ("\u0072\u0061\u006e\u0067\u0065\u0020\u0063\u0068\u0065\u0063\u006b\u0020e\u0072\u0072\u006f\u0072");

// PSBoolean represents a boolean value.
type PSBoolean struct{Val bool ;};

// MakeBool returns a new PSBoolean object initialized with `val`.
func MakeBool (val bool )*PSBoolean {_ffg :=PSBoolean {};_ffg .Val =val ;return &_ffg };func (_ef *PSBoolean )Duplicate ()PSObject {_eca :=PSBoolean {};_eca .Val =_ef .Val ;return &_eca };func (_aa *PSOperand )cvi (_afd *PSStack )error {_cbd ,_dac :=_afd .Pop ();
if _dac !=nil {return _dac ;};if _gdg ,_bcd :=_cbd .(*PSReal );_bcd {_fcd :=int (_gdg .Val );_dac =_afd .Push (MakeInteger (_fcd ));}else if _be ,_dced :=_cbd .(*PSInteger );_dced {_bff :=_be .Val ;_dac =_afd .Push (MakeInteger (_bff ));}else {return ErrTypeCheck ;
};return _dac ;};

// PSOperand represents a Postscript operand (text string).
type PSOperand string ;func (_fg *PSInteger )Duplicate ()PSObject {_dg :=PSInteger {};_dg .Val =_fg .Val ;return &_dg };func (_gf *PSOperand )abs (_gbd *PSStack )error {_abc ,_fge :=_gbd .Pop ();if _fge !=nil {return _fge ;};if _fee ,_cfg :=_abc .(*PSReal );
_cfg {_cc :=_fee .Val ;if _cc < 0{_fge =_gbd .Push (MakeReal (-_cc ));}else {_fge =_gbd .Push (MakeReal (_cc ));};}else if _fgf ,_eda :=_abc .(*PSInteger );_eda {_cd :=_fgf .Val ;if _cd < 0{_fge =_gbd .Push (MakeInteger (-_cd ));}else {_fge =_gbd .Push (MakeInteger (_cd ));
};}else {return ErrTypeCheck ;};return _fge ;};var ErrUnsupportedOperand =_b .New ("\u0075\u006e\u0073\u0075pp\u006f\u0072\u0074\u0065\u0064\u0020\u006f\u0070\u0065\u0072\u0061\u006e\u0064");

// PSReal represents a real number.
type PSReal struct{Val float64 ;};func (_gb *PSReal )DebugString ()string {return _f .Sprintf ("\u0072e\u0061\u006c\u003a\u0025\u002e\u0035f",_gb .Val );};func (_fde *PSOperand )bitshift (_bcbc *PSStack )error {_def ,_cg :=_bcbc .PopInteger ();if _cg !=nil {return _cg ;
};_fad ,_cg :=_bcbc .PopInteger ();if _cg !=nil {return _cg ;};var _dab int ;if _def >=0{_dab =_fad <<uint (_def );}else {_dab =_fad >>uint (-_def );};_cg =_bcbc .Push (MakeInteger (_dab ));return _cg ;};func (_bbe *PSOperand )sqrt (_gda *PSStack )error {_bgda ,_bdbb :=_gda .PopNumberAsFloat64 ();
if _bdbb !=nil {return _bdbb ;};if _bgda < 0{return ErrRangeCheck ;};_edeb :=_a .Sqrt (_bgda );_bdbb =_gda .Push (MakeReal (_edeb ));return _bdbb ;};func (_adg *PSOperand )ceiling (_gfc *PSStack )error {_dgec ,_dbe :=_gfc .Pop ();if _dbe !=nil {return _dbe ;
};if _cdg ,_efg :=_dgec .(*PSReal );_efg {_dbe =_gfc .Push (MakeReal (_a .Ceil (_cdg .Val )));}else if _cce ,_ggc :=_dgec .(*PSInteger );_ggc {_dbe =_gfc .Push (MakeInteger (_cce .Val ));}else {_dbe =ErrTypeCheck ;};return _dbe ;};func (_aafe *PSOperand )index (_bda *PSStack )error {_geb ,_dgd :=_bda .Pop ();
if _dgd !=nil {return _dgd ;};_cdgf ,_gdfa :=_geb .(*PSInteger );if !_gdfa {return ErrTypeCheck ;};if _cdgf .Val < 0{return ErrRangeCheck ;};if _cdgf .Val > len (*_bda )-1{return ErrStackUnderflow ;};_afcg :=(*_bda )[len (*_bda )-1-_cdgf .Val ];_dgd =_bda .Push (_afcg .Duplicate ());
return _dgd ;};func (_accc *PSOperand )le (_dba *PSStack )error {_daf ,_dfa :=_dba .PopNumberAsFloat64 ();if _dfa !=nil {return _dfa ;};_cacd ,_dfa :=_dba .PopNumberAsFloat64 ();if _dfa !=nil {return _dfa ;};if _a .Abs (_cacd -_daf )< _fd {_cfcd :=_dba .Push (MakeBool (true ));
return _cfcd ;}else if _cacd < _daf {_gbda :=_dba .Push (MakeBool (true ));return _gbda ;}else {_feb :=_dba .Push (MakeBool (false ));return _feb ;};};func (_fegg *PSOperand )idiv (_aebb *PSStack )error {_ceaf ,_afa :=_aebb .Pop ();if _afa !=nil {return _afa ;
};_egc ,_afa :=_aebb .Pop ();if _afa !=nil {return _afa ;};_dcf ,_bcac :=_ceaf .(*PSInteger );if !_bcac {return ErrTypeCheck ;};if _dcf .Val ==0{return ErrUndefinedResult ;};_bdg ,_bcac :=_egc .(*PSInteger );if !_bcac {return ErrTypeCheck ;};_faf :=_bdg .Val /_dcf .Val ;
_afa =_aebb .Push (MakeInteger (_faf ));return _afa ;};

// NewPSStack returns an initialized PSStack.
func NewPSStack ()*PSStack {return &PSStack {}};func (_adcg *PSParser )parseBool ()(*PSBoolean ,error ){_aab ,_cbac :=_adcg ._efd .Peek (4);if _cbac !=nil {return MakeBool (false ),_cbac ;};if (len (_aab )>=4)&&(string (_aab [:4])=="\u0074\u0072\u0075\u0065"){_adcg ._efd .Discard (4);
return MakeBool (true ),nil ;};_aab ,_cbac =_adcg ._efd .Peek (5);if _cbac !=nil {return MakeBool (false ),_cbac ;};if (len (_aab )>=5)&&(string (_aab [:5])=="\u0066\u0061\u006cs\u0065"){_adcg ._efd .Discard (5);return MakeBool (false ),nil ;};return MakeBool (false ),_b .New ("\u0075n\u0065\u0078\u0070\u0065c\u0074\u0065\u0064\u0020\u0062o\u006fl\u0065a\u006e\u0020\u0073\u0074\u0072\u0069\u006eg");
};

// PSObject represents a postscript object.
type PSObject interface{

// Duplicate makes a fresh copy of the PSObject.
Duplicate ()PSObject ;

// DebugString returns a descriptive representation of the PSObject with more information than String()
// for debugging purposes.
DebugString ()string ;

// String returns a string representation of the PSObject.
String ()string ;};

// Exec executes the program, typically leaving output values on the stack.
func (_ae *PSProgram )Exec (stack *PSStack )error {for _ ,_ecad :=range *_ae {var _eefb error ;switch _fca :=_ecad .(type ){case *PSInteger :_dce :=_fca ;_eefb =stack .Push (_dce );case *PSReal :_aea :=_fca ;_eefb =stack .Push (_aea );case *PSBoolean :_gdb :=_fca ;
_eefb =stack .Push (_gdb );case *PSProgram :_dge :=_fca ;_eefb =stack .Push (_dge );case *PSOperand :_edg :=_fca ;_eefb =_edg .Exec (stack );default:return ErrTypeCheck ;};if _eefb !=nil {return _eefb ;};};return nil ;};func (_fgg *PSOperand )not (_edfb *PSStack )error {_cgeg ,_fcbe :=_edfb .Pop ();
if _fcbe !=nil {return _fcbe ;};if _aefc ,_gfcb :=_cgeg .(*PSBoolean );_gfcb {_fcbe =_edfb .Push (MakeBool (!_aefc .Val ));return _fcbe ;}else if _edd ,_ceb :=_cgeg .(*PSInteger );_ceb {_fcbe =_edfb .Push (MakeInteger (^_edd .Val ));return _fcbe ;}else {return ErrTypeCheck ;
};};func (_bfg *PSBoolean )String ()string {return _f .Sprintf ("\u0025\u0076",_bfg .Val )};func (_acd *PSOperand )atan (_dae *PSStack )error {_gge ,_geg :=_dae .PopNumberAsFloat64 ();if _geg !=nil {return _geg ;};_gfa ,_geg :=_dae .PopNumberAsFloat64 ();
if _geg !=nil {return _geg ;};if _gge ==0{var _ceg error ;if _gfa < 0{_ceg =_dae .Push (MakeReal (270));}else {_ceg =_dae .Push (MakeReal (90));};return _ceg ;};_cb :=_gfa /_gge ;_eeb :=_a .Atan (_cb )*180/_a .Pi ;_geg =_dae .Push (MakeReal (_eeb ));return _geg ;
};func (_gad *PSOperand )dup (_bbg *PSStack )error {_cgc ,_fdf :=_bbg .Pop ();if _fdf !=nil {return _fdf ;};_fdf =_bbg .Push (_cgc );if _fdf !=nil {return _fdf ;};_fdf =_bbg .Push (_cgc .Duplicate ());return _fdf ;};func (_cfe *PSOperand )cos (_agd *PSStack )error {_eb ,_fec :=_agd .PopNumberAsFloat64 ();
if _fec !=nil {return _fec ;};_gde :=_a .Cos (_eb *_a .Pi /180.0);_fec =_agd .Push (MakeReal (_gde ));return _fec ;};func (_dca *PSOperand )exp (_gcf *PSStack )error {_dga ,_dcc :=_gcf .PopNumberAsFloat64 ();if _dcc !=nil {return _dcc ;};_bgfc ,_dcc :=_gcf .PopNumberAsFloat64 ();
if _dcc !=nil {return _dcc ;};if _a .Abs (_dga )< 1&&_bgfc < 0{return ErrUndefinedResult ;};_ecac :=_a .Pow (_bgfc ,_dga );_dcc =_gcf .Push (MakeReal (_ecac ));return _dcc ;};

// Push pushes an object on top of the stack.
func (_afdb *PSStack )Push (obj PSObject )error {if len (*_afdb )> 100{return ErrStackOverflow ;};*_afdb =append (*_afdb ,obj );return nil ;};

// PSExecutor has its own execution stack and is used to executre a PS routine (program).
type PSExecutor struct{Stack *PSStack ;_e *PSProgram ;};

// Empty empties the stack.
func (_gfcg *PSStack )Empty (){*_gfcg =[]PSObject {}};func (_fefd *PSOperand )or (_egbf *PSStack )error {_ggdg ,_afge :=_egbf .Pop ();if _afge !=nil {return _afge ;};_acdg ,_afge :=_egbf .Pop ();if _afge !=nil {return _afge ;};if _dea ,_aaa :=_ggdg .(*PSBoolean );
_aaa {_fadaa ,_gacb :=_acdg .(*PSBoolean );if !_gacb {return ErrTypeCheck ;};_afge =_egbf .Push (MakeBool (_dea .Val ||_fadaa .Val ));return _afge ;};if _cdd ,_eafc :=_ggdg .(*PSInteger );_eafc {_adb ,_ecae :=_acdg .(*PSInteger );if !_ecae {return ErrTypeCheck ;
};_afge =_egbf .Push (MakeInteger (_cdd .Val |_adb .Val ));return _afge ;};return ErrTypeCheck ;};func (_gg *PSBoolean )DebugString ()string {return _f .Sprintf ("\u0062o\u006f\u006c\u003a\u0025\u0076",_gg .Val );};func (_dgf *PSOperand )cvr (_abf *PSStack )error {_fcb ,_ggee :=_abf .Pop ();
if _ggee !=nil {return _ggee ;};if _dace ,_eag :=_fcb .(*PSReal );_eag {_ggee =_abf .Push (MakeReal (_dace .Val ));}else if _ebc ,_gcb :=_fcb .(*PSInteger );_gcb {_ggee =_abf .Push (MakeReal (float64 (_ebc .Val )));}else {return ErrTypeCheck ;};return _ggee ;
};func (_ga *PSOperand )Duplicate ()PSObject {_ea :=*_ga ;return &_ea };func (_bcc *PSOperand )mul (_gbac *PSStack )error {_gff ,_cfa :=_gbac .Pop ();if _cfa !=nil {return _cfa ;};_cgg ,_cfa :=_gbac .Pop ();if _cfa !=nil {return _cfa ;};_egdb ,_acg :=_gff .(*PSReal );
_ccg ,_beca :=_gff .(*PSInteger );if !_acg &&!_beca {return ErrTypeCheck ;};_fef ,_ccc :=_cgg .(*PSReal );_daee ,_aee :=_cgg .(*PSInteger );if !_ccc &&!_aee {return ErrTypeCheck ;};if _beca &&_aee {_efe :=_ccg .Val *_daee .Val ;_gdbf :=_gbac .Push (MakeInteger (_efe ));
return _gdbf ;};var _fagf float64 ;if _acg {_fagf =_egdb .Val ;}else {_fagf =float64 (_ccg .Val );};if _ccc {_fagf *=_fef .Val ;}else {_fagf *=float64 (_daee .Val );};_cfa =_gbac .Push (MakeReal (_fagf ));return _cfa ;};

// DebugString returns a descriptive string representation of the stack - intended for debugging.
func (_aace *PSStack )DebugString ()string {_dgff :="\u005b\u0020";for _ ,_dcae :=range *_aace {_dgff +=_dcae .DebugString ();_dgff +="\u0020";};_dgff +="\u005d";return _dgff ;};func (_dbg *PSOperand )gt (_eff *PSStack )error {_eccf ,_eebg :=_eff .PopNumberAsFloat64 ();
if _eebg !=nil {return _eebg ;};_ecb ,_eebg :=_eff .PopNumberAsFloat64 ();if _eebg !=nil {return _eebg ;};if _a .Abs (_ecb -_eccf )< _fd {_bbde :=_eff .Push (MakeBool (false ));return _bbde ;}else if _ecb > _eccf {_dfg :=_eff .Push (MakeBool (true ));return _dfg ;
}else {_afg :=_eff .Push (MakeBool (false ));return _afg ;};};var ErrUndefinedResult =_b .New ("\u0075\u006e\u0064\u0065fi\u006e\u0065\u0064\u0020\u0072\u0065\u0073\u0075\u006c\u0074\u0020\u0065\u0072\u0072o\u0072");func (_bgeea *PSParser )parseNumber ()(PSObject ,error ){_gbgg ,_fff :=_ab .ParseNumber (_bgeea ._efd );
if _fff !=nil {return nil ,_fff ;};switch _cged :=_gbgg .(type ){case *_ab .PdfObjectFloat :return MakeReal (float64 (*_cged )),nil ;case *_ab .PdfObjectInteger :return MakeInteger (int (*_cged )),nil ;};return nil ,_f .Errorf ("\u0075n\u0068\u0061\u006e\u0064\u006c\u0065\u0064\u0020\u006e\u0075\u006db\u0065\u0072\u0020\u0074\u0079\u0070\u0065\u0020\u0025\u0054",_gbgg );
};

// MakeOperand returns a new PSOperand object based on string `val`.
func MakeOperand (val string )*PSOperand {_abd :=PSOperand (val );return &_abd };func (_dbgf *PSOperand )truncate (_edb *PSStack )error {_becg ,_ggb :=_edb .Pop ();if _ggb !=nil {return _ggb ;};if _abeaa ,_ggg :=_becg .(*PSReal );_ggg {_feeb :=int (_abeaa .Val );
_ggb =_edb .Push (MakeReal (float64 (_feeb )));}else if _gefe ,_gbb :=_becg .(*PSInteger );_gbb {_ggb =_edb .Push (MakeInteger (_gefe .Val ));}else {return ErrTypeCheck ;};return _ggb ;};func (_dfb *PSProgram )DebugString ()string {_fgd :="\u007b\u0020";
for _ ,_gbg :=range *_dfb {_fgd +=_gbg .DebugString ();_fgd +="\u0020";};_fgd +="\u007d";return _fgd ;};

// Execute executes the program for an input parameters `objects` and returns a slice of output objects.
func (_d *PSExecutor )Execute (objects []PSObject )([]PSObject ,error ){for _ ,_dc :=range objects {_ec :=_d .Stack .Push (_dc );if _ec !=nil {return nil ,_ec ;};};_df :=_d ._e .Exec (_d .Stack );if _df !=nil {_gd .Log .Debug ("\u0045x\u0065c\u0020\u0066\u0061\u0069\u006c\u0065\u0064\u003a\u0020\u0025\u0076",_df );
return nil ,_df ;};_af :=[]PSObject (*_d .Stack );_d .Stack .Empty ();return _af ,nil ;};

// NewPSParser returns a new instance of the PDF Postscript parser from input data.
func NewPSParser (content []byte )*PSParser {_egcb :=PSParser {};_cga :=_ge .NewBuffer (content );_egcb ._efd =_bf .NewReader (_cga );return &_egcb ;};

// PSObjectArrayToFloat64Array converts []PSObject into a []float64 array. Each PSObject must represent a number,
// otherwise a ErrTypeCheck error occurs.
func PSObjectArrayToFloat64Array (objects []PSObject )([]float64 ,error ){var _bdc []float64 ;for _ ,_ff :=range objects {if _ee ,_bdd :=_ff .(*PSInteger );_bdd {_bdc =append (_bdc ,float64 (_ee .Val ));}else if _bgf ,_eef :=_ff .(*PSReal );_eef {_bdc =append (_bdc ,_bgf .Val );
}else {return nil ,ErrTypeCheck ;};};return _bdc ,nil ;};func (_gdad *PSOperand )xor (_gfaa *PSStack )error {_geba ,_eccc :=_gfaa .Pop ();if _eccc !=nil {return _eccc ;};_adcd ,_eccc :=_gfaa .Pop ();if _eccc !=nil {return _eccc ;};if _dbc ,_fagd :=_geba .(*PSBoolean );
_fagd {_cfba ,_cbdge :=_adcd .(*PSBoolean );if !_cbdge {return ErrTypeCheck ;};_eccc =_gfaa .Push (MakeBool (_dbc .Val !=_cfba .Val ));return _eccc ;};if _fdeb ,_acgf :=_geba .(*PSInteger );_acgf {_bgg ,_cad :=_adcd .(*PSInteger );if !_cad {return ErrTypeCheck ;
};_eccc =_gfaa .Push (MakeInteger (_fdeb .Val ^_bgg .Val ));return _eccc ;};return ErrTypeCheck ;};func (_cgec *PSOperand )round (_agdf *PSStack )error {_afb ,_gbae :=_agdf .Pop ();if _gbae !=nil {return _gbae ;};if _bfa ,_ddd :=_afb .(*PSReal );_ddd {_gbae =_agdf .Push (MakeReal (_a .Floor (_bfa .Val +0.5)));
}else if _agf ,_ccgb :=_afb .(*PSInteger );_ccgb {_gbae =_agdf .Push (MakeInteger (_agf .Val ));}else {return ErrTypeCheck ;};return _gbae ;};

// Parse parses the postscript and store as a program that can be executed.
func (_bdbe *PSParser )Parse ()(*PSProgram ,error ){_bdbe .skipSpaces ();_fbcge ,_cdcd :=_bdbe ._efd .Peek (2);if _cdcd !=nil {return nil ,_cdcd ;};if _fbcge [0]!='{'{return nil ,_b .New ("\u0069\u006e\u0076\u0061\u006c\u0069\u0064\u0020\u0050\u0053\u0020\u0050\u0072\u006f\u0067\u0072\u0061\u006d\u0020\u006e\u006f\u0074\u0020\u0073t\u0061\u0072\u0074\u0069\u006eg\u0020\u0077i\u0074\u0068\u0020\u007b");
};_cfab ,_cdcd :=_bdbe .parseFunction ();if _cdcd !=nil &&_cdcd !=_bd .EOF {return nil ,_cdcd ;};return _cfab ,_cdcd ;};func (_beg *PSOperand )exch (_bbc *PSStack )error {_egd ,_bgd :=_bbc .Pop ();if _bgd !=nil {return _bgd ;};_bbgg ,_bgd :=_bbc .Pop ();
if _bgd !=nil {return _bgd ;};_bgd =_bbc .Push (_egd );if _bgd !=nil {return _bgd ;};_bgd =_bbc .Push (_bbgg );return _bgd ;};func (_dbd *PSOperand )eq (_gdf *PSStack )error {_gag ,_egf :=_gdf .Pop ();if _egf !=nil {return _egf ;};_bffd ,_egf :=_gdf .Pop ();
if _egf !=nil {return _egf ;};_bbd ,_fcc :=_gag .(*PSBoolean );_fgea ,_cfgc :=_bffd .(*PSBoolean );if _fcc ||_cfgc {var _bca error ;if _fcc &&_cfgc {_bca =_gdf .Push (MakeBool (_bbd .Val ==_fgea .Val ));}else {_bca =_gdf .Push (MakeBool (false ));};return _bca ;
};var _cdb float64 ;var _dcd float64 ;if _ceag ,_cfgg :=_gag .(*PSInteger );_cfgg {_cdb =float64 (_ceag .Val );}else if _fada ,_ged :=_gag .(*PSReal );_ged {_cdb =_fada .Val ;}else {return ErrTypeCheck ;};if _eebf ,_ebe :=_bffd .(*PSInteger );_ebe {_dcd =float64 (_eebf .Val );
}else if _bcaf ,_gfb :=_bffd .(*PSReal );_gfb {_dcd =_bcaf .Val ;}else {return ErrTypeCheck ;};if _a .Abs (_dcd -_cdb )< _fd {_egf =_gdf .Push (MakeBool (true ));}else {_egf =_gdf .Push (MakeBool (false ));};return _egf ;};func (_ebf *PSOperand )log (_aafa *PSStack )error {_bag ,_eae :=_aafa .PopNumberAsFloat64 ();
if _eae !=nil {return _eae ;};_egb :=_a .Log10 (_bag );_eae =_aafa .Push (MakeReal (_egb ));return _eae ;};

// MakeInteger returns a new PSInteger object initialized with `val`.
func MakeInteger (val int )*PSInteger {_gegf :=PSInteger {};_gegf .Val =val ;return &_gegf };

// Pop pops an object from the top of the stack.
func (_ffbfa *PSStack )Pop ()(PSObject ,error ){if len (*_ffbfa )< 1{return nil ,ErrStackUnderflow ;};_dabg :=(*_ffbfa )[len (*_ffbfa )-1];*_ffbfa =(*_ffbfa )[0:len (*_ffbfa )-1];return _dabg ,nil ;};

// PSParser is a basic Postscript parser.
type PSParser struct{_efd *_bf .Reader };func (_cda *PSOperand )sin (_adba *PSStack )error {_efgf ,_faa :=_adba .PopNumberAsFloat64 ();if _faa !=nil {return _faa ;};_dgb :=_a .Sin (_efgf *_a .Pi /180.0);_faa =_adba .Push (MakeReal (_dgb ));return _faa ;
};func (_dgg *PSInteger )DebugString ()string {return _f .Sprintf ("\u0069\u006e\u0074\u003a\u0025\u0064",_dgg .Val );};func (_dgda *PSOperand )ln (_agg *PSStack )error {_afe ,_gba :=_agg .PopNumberAsFloat64 ();if _gba !=nil {return _gba ;};_fae :=_a .Log (_afe );
_gba =_agg .Push (MakeReal (_fae ));return _gba ;};

// Exec executes the operand `op` in the state specified by `stack`.
func (_aed *PSOperand )Exec (stack *PSStack )error {_efa :=ErrUnsupportedOperand ;switch *_aed {case "\u0061\u0062\u0073":_efa =_aed .abs (stack );case "\u0061\u0064\u0064":_efa =_aed .add (stack );case "\u0061\u006e\u0064":_efa =_aed .and (stack );case "\u0061\u0074\u0061\u006e":_efa =_aed .atan (stack );
case "\u0062\u0069\u0074\u0073\u0068\u0069\u0066\u0074":_efa =_aed .bitshift (stack );case "\u0063e\u0069\u006c\u0069\u006e\u0067":_efa =_aed .ceiling (stack );case "\u0063\u006f\u0070\u0079":_efa =_aed .copy (stack );case "\u0063\u006f\u0073":_efa =_aed .cos (stack );
case "\u0063\u0076\u0069":_efa =_aed .cvi (stack );case "\u0063\u0076\u0072":_efa =_aed .cvr (stack );case "\u0064\u0069\u0076":_efa =_aed .div (stack );case "\u0064\u0075\u0070":_efa =_aed .dup (stack );case "\u0065\u0071":_efa =_aed .eq (stack );case "\u0065\u0078\u0063\u0068":_efa =_aed .exch (stack );
case "\u0065\u0078\u0070":_efa =_aed .exp (stack );case "\u0066\u006c\u006fo\u0072":_efa =_aed .floor (stack );case "\u0067\u0065":_efa =_aed .ge (stack );case "\u0067\u0074":_efa =_aed .gt (stack );case "\u0069\u0064\u0069\u0076":_efa =_aed .idiv (stack );
case "\u0069\u0066":_efa =_aed .ifCondition (stack );case "\u0069\u0066\u0065\u006c\u0073\u0065":_efa =_aed .ifelse (stack );case "\u0069\u006e\u0064e\u0078":_efa =_aed .index (stack );case "\u006c\u0065":_efa =_aed .le (stack );case "\u006c\u006f\u0067":_efa =_aed .log (stack );
case "\u006c\u006e":_efa =_aed .ln (stack );case "\u006c\u0074":_efa =_aed .lt (stack );case "\u006d\u006f\u0064":_efa =_aed .mod (stack );case "\u006d\u0075\u006c":_efa =_aed .mul (stack );case "\u006e\u0065":_efa =_aed .ne (stack );case "\u006e\u0065\u0067":_efa =_aed .neg (stack );
case "\u006e\u006f\u0074":_efa =_aed .not (stack );case "\u006f\u0072":_efa =_aed .or (stack );case "\u0070\u006f\u0070":_efa =_aed .pop (stack );case "\u0072\u006f\u0075n\u0064":_efa =_aed .round (stack );case "\u0072\u006f\u006c\u006c":_efa =_aed .roll (stack );
case "\u0073\u0069\u006e":_efa =_aed .sin (stack );case "\u0073\u0071\u0072\u0074":_efa =_aed .sqrt (stack );case "\u0073\u0075\u0062":_efa =_aed .sub (stack );case "\u0074\u0072\u0075\u006e\u0063\u0061\u0074\u0065":_efa =_aed .truncate (stack );case "\u0078\u006f\u0072":_efa =_aed .xor (stack );
};return _efa ;};func (_cfc *PSOperand )ifCondition (_adc *PSStack )error {_bee ,_ecd :=_adc .Pop ();if _ecd !=nil {return _ecd ;};_fda ,_ecd :=_adc .Pop ();if _ecd !=nil {return _ecd ;};_ecade ,_afc :=_bee .(*PSProgram );if !_afc {return ErrTypeCheck ;
};_dbda ,_afc :=_fda .(*PSBoolean );if !_afc {return ErrTypeCheck ;};if _dbda .Val {_gcbfb :=_ecade .Exec (_adc );return _gcbfb ;};return nil ;};func (_bbb *PSOperand )ne (_bea *PSStack )error {_afdf :=_bbb .eq (_bea );if _afdf !=nil {return _afdf ;};_afdf =_bbb .not (_bea );
return _afdf ;};func (_edgf *PSOperand )DebugString ()string {return _f .Sprintf ("\u006fp\u003a\u0027\u0025\u0073\u0027",*_edgf );};func (_fed *PSOperand )ge (_ecc *PSStack )error {_caf ,_acc :=_ecc .PopNumberAsFloat64 ();if _acc !=nil {return _acc ;};
_fbe ,_acc :=_ecc .PopNumberAsFloat64 ();if _acc !=nil {return _acc ;};if _a .Abs (_fbe -_caf )< _fd {_cac :=_ecc .Push (MakeBool (true ));return _cac ;}else if _fbe > _caf {_gfe :=_ecc .Push (MakeBool (true ));return _gfe ;}else {_cacf :=_ecc .Push (MakeBool (false ));
return _cacf ;};};func (_agb *PSOperand )and (_fdg *PSStack )error {_ffbf ,_age :=_fdg .Pop ();if _age !=nil {return _age ;};_ce ,_age :=_fdg .Pop ();if _age !=nil {return _age ;};if _cfd ,_adf :=_ffbf .(*PSBoolean );_adf {_aedf ,_cee :=_ce .(*PSBoolean );
if !_cee {return ErrTypeCheck ;};_age =_fdg .Push (MakeBool (_cfd .Val &&_aedf .Val ));return _age ;};if _agba ,_bb :=_ffbf .(*PSInteger );_bb {_fag ,_abe :=_ce .(*PSInteger );if !_abe {return ErrTypeCheck ;};_age =_fdg .Push (MakeInteger (_agba .Val &_fag .Val ));
return _age ;};return ErrTypeCheck ;};func (_bcf *PSParser )parseFunction ()(*PSProgram ,error ){_eafd ,_ :=_bcf ._efd .ReadByte ();if _eafd !='{'{return nil ,_b .New ("\u0069\u006ev\u0061\u006c\u0069d\u0020\u0066\u0075\u006e\u0063\u0074\u0069\u006f\u006e");
};_efgd :=NewPSProgram ();for {_bcf .skipSpaces ();_fdba ,_cff :=_bcf ._efd .Peek (2);if _cff !=nil {if _cff ==_bd .EOF {break ;};return nil ,_cff ;};_gd .Log .Trace ("\u0050e\u0065k\u0020\u0073\u0074\u0072\u0069\u006e\u0067\u003a\u0020\u0025\u0073",string (_fdba ));
if _fdba [0]=='}'{_gd .Log .Trace ("\u0045\u004f\u0046 \u0066\u0075\u006e\u0063\u0074\u0069\u006f\u006e");_bcf ._efd .ReadByte ();break ;}else if _fdba [0]=='{'{_gd .Log .Trace ("\u0046u\u006e\u0063\u0074\u0069\u006f\u006e!");_bcdd ,_ded :=_bcf .parseFunction ();
if _ded !=nil {return nil ,_ded ;};_efgd .Append (_bcdd );}else if _ab .IsDecimalDigit (_fdba [0])||(_fdba [0]=='-'&&_ab .IsDecimalDigit (_fdba [1])){_gd .Log .Trace ("\u002d>\u004e\u0075\u006d\u0062\u0065\u0072!");_cgf ,_ega :=_bcf .parseNumber ();if _ega !=nil {return nil ,_ega ;
};_efgd .Append (_cgf );}else {_gd .Log .Trace ("\u002d>\u004fp\u0065\u0072\u0061\u006e\u0064 \u006f\u0072 \u0062\u006f\u006f\u006c\u003f");_fdba ,_ =_bcf ._efd .Peek (5);_feeg :=string (_fdba );_gd .Log .Trace ("\u0050\u0065\u0065k\u0020\u0073\u0074\u0072\u003a\u0020\u0025\u0073",_feeg );
if (len (_feeg )> 4)&&(_feeg [:5]=="\u0066\u0061\u006cs\u0065"){_afgb ,_bfgd :=_bcf .parseBool ();if _bfgd !=nil {return nil ,_bfgd ;};_efgd .Append (_afgb );}else if (len (_feeg )> 3)&&(_feeg [:4]=="\u0074\u0072\u0075\u0065"){_ecg ,_cdbb :=_bcf .parseBool ();
if _cdbb !=nil {return nil ,_cdbb ;};_efgd .Append (_ecg );}else {_dbgfa ,_gfbd :=_bcf .parseOperand ();if _gfbd !=nil {return nil ,_gfbd ;};_efgd .Append (_dbgfa );};};};return _efgd ,nil ;};func (_gc *PSReal )String ()string {return _f .Sprintf ("\u0025\u002e\u0035\u0066",_gc .Val )};


// String returns a string representation of the stack.
func (_dgbc *PSStack )String ()string {_fbcac :="\u005b\u0020";for _ ,_efb :=range *_dgbc {_fbcac +=_efb .String ();_fbcac +="\u0020";};_fbcac +="\u005d";return _fbcac ;};var ErrStackUnderflow =_b .New ("\u0073t\u0061c\u006b\u0020\u0075\u006e\u0064\u0065\u0072\u0066\u006c\u006f\u0077");
func (_fe *PSProgram )Duplicate ()PSObject {_cae :=&PSProgram {};for _ ,_de :=range *_fe {_cae .Append (_de .Duplicate ());};return _cae ;};func (_abb *PSOperand )sub (_egdf *PSStack )error {_defe ,_cafa :=_egdf .Pop ();if _cafa !=nil {return _cafa ;};
_eeed ,_cafa :=_egdf .Pop ();if _cafa !=nil {return _cafa ;};_dadb ,_gef :=_defe .(*PSReal );_gaga ,_gbgb :=_defe .(*PSInteger );if !_gef &&!_gbgb {return ErrTypeCheck ;};_becc ,_bdgb :=_eeed .(*PSReal );_baa ,_aeg :=_eeed .(*PSInteger );if !_bdgb &&!_aeg {return ErrTypeCheck ;
};if _gbgb &&_aeg {_gbag :=_baa .Val -_gaga .Val ;_bbgf :=_egdf .Push (MakeInteger (_gbag ));return _bbgf ;};var _bfc float64 =0;if _bdgb {_bfc =_becc .Val ;}else {_bfc =float64 (_baa .Val );};if _gef {_bfc -=_dadb .Val ;}else {_bfc -=float64 (_gaga .Val );
};_cafa =_egdf .Push (MakeReal (_bfc ));return _cafa ;};

// PopInteger specificially pops an integer from the top of the stack, returning the value as an int.
func (_bef *PSStack )PopInteger ()(int ,error ){_cef ,_gefec :=_bef .Pop ();if _gefec !=nil {return 0,_gefec ;};if _gab ,_ccfb :=_cef .(*PSInteger );_ccfb {return _gab .Val ,nil ;};return 0,ErrTypeCheck ;};func (_bgee *PSOperand )floor (_fbc *PSStack )error {_aef ,_dda :=_fbc .Pop ();
if _dda !=nil {return _dda ;};if _dfbc ,_abea :=_aef .(*PSReal );_abea {_dda =_fbc .Push (MakeReal (_a .Floor (_dfbc .Val )));}else if _bed ,_adab :=_aef .(*PSInteger );_adab {_dda =_fbc .Push (MakeInteger (_bed .Val ));}else {return ErrTypeCheck ;};return _dda ;
};