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 (_bc "bufio";_ed "bytes";_e "errors";_g "fmt";_dg "github.com/unidoc/unipdf/v3/common";_c "github.com/unidoc/unipdf/v3/core";_d "io";_dd "math";);func (_eaaf *PSOperand )roll (_dddf *PSStack )error {_acbb ,_fbbf :=_dddf .Pop ();if _fbbf !=nil {return _fbbf ;
};_efdd ,_fbbf :=_dddf .Pop ();if _fbbf !=nil {return _fbbf ;};_efa ,_cfcb :=_acbb .(*PSInteger );if !_cfcb {return ErrTypeCheck ;};_cde ,_cfcb :=_efdd .(*PSInteger );if !_cfcb {return ErrTypeCheck ;};if _cde .Val < 0{return ErrRangeCheck ;};if _cde .Val ==0||_cde .Val ==1{return nil ;
};if _cde .Val > len (*_dddf ){return ErrStackUnderflow ;};for _dfg :=0;_dfg < _gdd (_efa .Val );_dfg ++{var _abfa []PSObject ;_abfa =(*_dddf )[len (*_dddf )-(_cde .Val ):len (*_dddf )];if _efa .Val > 0{_bfcc :=_abfa [len (_abfa )-1];_abfa =append ([]PSObject {_bfcc },_abfa [0:len (_abfa )-1]...);
}else {_adag :=_abfa [len (_abfa )-_cde .Val ];_abfa =append (_abfa [1:],_adag );};_dccf :=append ((*_dddf )[0:len (*_dddf )-_cde .Val ],_abfa ...);_dddf =&_dccf ;};return nil ;};

// PSBoolean represents a boolean value.
type PSBoolean struct{Val bool ;};func (_gfc *PSOperand )ge (_eab *PSStack )error {_dda ,_gff :=_eab .PopNumberAsFloat64 ();if _gff !=nil {return _gff ;};_cag ,_gff :=_eab .PopNumberAsFloat64 ();if _gff !=nil {return _gff ;};if _dd .Abs (_cag -_dda )< _edg {_gbdf :=_eab .Push (MakeBool (true ));
return _gbdf ;}else if _cag > _dda {_ffd :=_eab .Push (MakeBool (true ));return _ffd ;}else {_cf :=_eab .Push (MakeBool (false ));return _cf ;};};func (_fd *PSProgram )DebugString ()string {_ad :="\u007b\u0020";for _ ,_ada :=range *_fd {_ad +=_ada .DebugString ();
_ad +="\u0020";};_ad +="\u007d";return _ad ;};func (_ffaa *PSParser )skipSpaces ()(int ,error ){_cgdcf :=0;for {_geg ,_cae :=_ffaa ._ecd .Peek (1);if _cae !=nil {return 0,_cae ;};if _c .IsWhiteSpace (_geg [0]){_ffaa ._ecd .ReadByte ();_cgdcf ++;}else {break ;
};};return _cgdcf ,nil ;};

// Push pushes an object on top of the stack.
func (_aabc *PSStack )Push (obj PSObject )error {if len (*_aabc )> 100{return ErrStackOverflow ;};*_aabc =append (*_aabc ,obj );return nil ;};func (_fbge *PSOperand )truncate (_bfcd *PSStack )error {_aegg ,_dgfc :=_bfcd .Pop ();if _dgfc !=nil {return _dgfc ;
};if _fcde ,_agff :=_aegg .(*PSReal );_agff {_daec :=int (_fcde .Val );_dgfc =_bfcd .Push (MakeReal (float64 (_daec )));}else if _daef ,_edb :=_aegg .(*PSInteger );_edb {_dgfc =_bfcd .Push (MakeInteger (_daef .Val ));}else {return ErrTypeCheck ;};return _dgfc ;
};

// Empty empties the stack.
func (_egcd *PSStack )Empty (){*_egcd =[]PSObject {}};func (_ccd *PSOperand )round (_ebga *PSStack )error {_dae ,_egcc :=_ebga .Pop ();if _egcc !=nil {return _egcc ;};if _eea ,_fag :=_dae .(*PSReal );_fag {_egcc =_ebga .Push (MakeReal (_dd .Floor (_eea .Val +0.5)));
}else if _gggf ,_gbf :=_dae .(*PSInteger );_gbf {_egcc =_ebga .Push (MakeInteger (_gggf .Val ));}else {return ErrTypeCheck ;};return _egcc ;};func (_ege *PSOperand )or (_gcc *PSStack )error {_ddfb ,_addfa :=_gcc .Pop ();if _addfa !=nil {return _addfa ;
};_cbgf ,_addfa :=_gcc .Pop ();if _addfa !=nil {return _addfa ;};if _fgc ,_dccd :=_ddfb .(*PSBoolean );_dccd {_baec ,_cdc :=_cbgf .(*PSBoolean );if !_cdc {return ErrTypeCheck ;};_addfa =_gcc .Push (MakeBool (_fgc .Val ||_baec .Val ));return _addfa ;};if _aag ,_aega :=_ddfb .(*PSInteger );
_aega {_abb ,_bacc :=_cbgf .(*PSInteger );if !_bacc {return ErrTypeCheck ;};_addfa =_gcc .Push (MakeInteger (_aag .Val |_abb .Val ));return _addfa ;};return ErrTypeCheck ;};var ErrTypeCheck =_e .New ("\u0074\u0079p\u0065\u0020\u0063h\u0065\u0063\u006b\u0020\u0065\u0072\u0072\u006f\u0072");


// Exec executes the program, typically leaving output values on the stack.
func (_bca *PSProgram )Exec (stack *PSStack )error {for _ ,_agf :=range *_bca {var _ebaa error ;switch _ab :=_agf .(type ){case *PSInteger :_eg :=_ab ;_ebaa =stack .Push (_eg );case *PSReal :_fcg :=_ab ;_ebaa =stack .Push (_fcg );case *PSBoolean :_ace :=_ab ;
_ebaa =stack .Push (_ace );case *PSProgram :_cb :=_ab ;_ebaa =stack .Push (_cb );case *PSOperand :_fg :=_ab ;_ebaa =_fg .Exec (stack );default:return ErrTypeCheck ;};if _ebaa !=nil {return _ebaa ;};};return nil ;};var ErrStackOverflow =_e .New ("\u0073\u0074\u0061\u0063\u006b\u0020\u006f\u0076\u0065r\u0066\u006c\u006f\u0077");
func (_efe *PSBoolean )DebugString ()string {return _g .Sprintf ("\u0062o\u006f\u006c\u003a\u0025\u0076",_efe .Val );};func (_fc *PSReal )DebugString ()string {return _g .Sprintf ("\u0072e\u0061\u006c\u003a\u0025\u002e\u0035f",_fc .Val );};func (_adg *PSOperand )cos (_aef *PSStack )error {_aa ,_gfa :=_aef .PopNumberAsFloat64 ();
if _gfa !=nil {return _gfa ;};_bdag :=_dd .Cos (_aa *_dd .Pi /180.0);_gfa =_aef .Push (MakeReal (_bdag ));return _gfa ;};func (_eded *PSOperand )atan (_fe *PSStack )error {_ddd ,_gcg :=_fe .PopNumberAsFloat64 ();if _gcg !=nil {return _gcg ;};_cce ,_gcg :=_fe .PopNumberAsFloat64 ();
if _gcg !=nil {return _gcg ;};if _ddd ==0{var _dba error ;if _cce < 0{_dba =_fe .Push (MakeReal (270));}else {_dba =_fe .Push (MakeReal (90));};return _dba ;};_bed :=_cce /_ddd ;_ea :=_dd .Atan (_bed )*180/_dd .Pi ;_gcg =_fe .Push (MakeReal (_ea ));return _gcg ;
};var ErrUndefinedResult =_e .New ("\u0075\u006e\u0064\u0065fi\u006e\u0065\u0064\u0020\u0072\u0065\u0073\u0075\u006c\u0074\u0020\u0065\u0072\u0072o\u0072");func (_fb *PSOperand )add (_cc *PSStack )error {_dcd ,_ee :=_cc .Pop ();if _ee !=nil {return _ee ;
};_cgdf ,_ee :=_cc .Pop ();if _ee !=nil {return _ee ;};_aeb ,_dgf :=_dcd .(*PSReal );_fgg ,_ggaf :=_dcd .(*PSInteger );if !_dgf &&!_ggaf {return ErrTypeCheck ;};_efc ,_aba :=_cgdf .(*PSReal );_adc ,_gca :=_cgdf .(*PSInteger );if !_aba &&!_gca {return ErrTypeCheck ;
};if _ggaf &&_gca {_cd :=_fgg .Val +_adc .Val ;_ff :=_cc .Push (MakeInteger (_cd ));return _ff ;};var _dfb float64 ;if _dgf {_dfb =_aeb .Val ;}else {_dfb =float64 (_fgg .Val );};if _aba {_dfb +=_efc .Val ;}else {_dfb +=float64 (_adc .Val );};_ee =_cc .Push (MakeReal (_dfb ));
return _ee ;};

// MakeInteger returns a new PSInteger object initialized with `val`.
func MakeInteger (val int )*PSInteger {_dagf :=PSInteger {};_dagf .Val =val ;return &_dagf };func (_ce *PSProgram )Duplicate ()PSObject {_bd :=&PSProgram {};for _ ,_afd :=range *_ce {_bd .Append (_afd .Duplicate ());};return _bd ;};func (_dddg *PSOperand )pop (_ddef *PSStack )error {_ ,_baf :=_ddef .Pop ();
if _baf !=nil {return _baf ;};return nil ;};func (_dde *PSProgram )String ()string {_ac :="\u007b\u0020";for _ ,_dc :=range *_dde {_ac +=_dc .String ();_ac +="\u0020";};_ac +="\u007d";return _ac ;};var ErrRangeCheck =_e .New ("\u0072\u0061\u006e\u0067\u0065\u0020\u0063\u0068\u0065\u0063\u006b\u0020e\u0072\u0072\u006f\u0072");
func (_efg *PSOperand )abs (_ggf *PSStack )error {_df ,_gb :=_ggf .Pop ();if _gb !=nil {return _gb ;};if _cgf ,_dge :=_df .(*PSReal );_dge {_cgc :=_cgf .Val ;if _cgc < 0{_gb =_ggf .Push (MakeReal (-_cgc ));}else {_gb =_ggf .Push (MakeReal (_cgc ));};}else if _afec ,_fce :=_df .(*PSInteger );
_fce {_aeda :=_afec .Val ;if _aeda < 0{_gb =_ggf .Push (MakeInteger (-_aeda ));}else {_gb =_ggf .Push (MakeInteger (_aeda ));};}else {return ErrTypeCheck ;};return _gb ;};func (_bac *PSOperand )dup (_acbd *PSStack )error {_gag ,_bgd :=_acbd .Pop ();if _bgd !=nil {return _bgd ;
};_bgd =_acbd .Push (_gag );if _bgd !=nil {return _bgd ;};_bgd =_acbd .Push (_gag .Duplicate ());return _bgd ;};

// Parse parses the postscript and store as a program that can be executed.
func (_bgg *PSParser )Parse ()(*PSProgram ,error ){_bgg .skipSpaces ();_bcg ,_ddac :=_bgg ._ecd .Peek (2);if _ddac !=nil {return nil ,_ddac ;};if _bcg [0]!='{'{return nil ,_e .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");
};_ggc ,_ddac :=_bgg .parseFunction ();if _ddac !=nil &&_ddac !=_d .EOF {return nil ,_ddac ;};return _ggc ,_ddac ;};

// PSProgram defines a Postscript program which is a series of PS objects (arguments, commands, programs etc).
type PSProgram []PSObject ;func (_gge *PSOperand )eq (_def *PSStack )error {_gaf ,_ebb :=_def .Pop ();if _ebb !=nil {return _ebb ;};_cgdfd ,_ebb :=_def .Pop ();if _ebb !=nil {return _ebb ;};_cggg ,_dffd :=_gaf .(*PSBoolean );_agfc ,_gdbb :=_cgdfd .(*PSBoolean );
if _dffd ||_gdbb {var _fcc error ;if _dffd &&_gdbb {_fcc =_def .Push (MakeBool (_cggg .Val ==_agfc .Val ));}else {_fcc =_def .Push (MakeBool (false ));};return _fcc ;};var _eff float64 ;var _ffb float64 ;if _acce ,_agfe :=_gaf .(*PSInteger );_agfe {_eff =float64 (_acce .Val );
}else if _cbd ,_aebf :=_gaf .(*PSReal );_aebf {_eff =_cbd .Val ;}else {return ErrTypeCheck ;};if _ggg ,_gef :=_cgdfd .(*PSInteger );_gef {_ffb =float64 (_ggg .Val );}else if _bcc ,_gbge :=_cgdfd .(*PSReal );_gbge {_ffb =_bcc .Val ;}else {return ErrTypeCheck ;
};if _dd .Abs (_ffb -_eff )< _edg {_ebb =_def .Push (MakeBool (true ));}else {_ebb =_def .Push (MakeBool (false ));};return _ebb ;};

// PSOperand represents a Postscript operand (text string).
type PSOperand string ;func (_caa *PSOperand )exp (_cgea *PSStack )error {_bae ,_cdg :=_cgea .PopNumberAsFloat64 ();if _cdg !=nil {return _cdg ;};_cgb ,_cdg :=_cgea .PopNumberAsFloat64 ();if _cdg !=nil {return _cdg ;};if _dd .Abs (_bae )< 1&&_cgb < 0{return ErrUndefinedResult ;
};_dag :=_dd .Pow (_cgb ,_bae );_cdg =_cgea .Push (MakeReal (_dag ));return _cdg ;};func (_abc *PSOperand )bitshift (_ecb *PSStack )error {_bfba ,_gbd :=_ecb .PopInteger ();if _gbd !=nil {return _gbd ;};_ggafg ,_gbd :=_ecb .PopInteger ();if _gbd !=nil {return _gbd ;
};var _bce int ;if _bfba >=0{_bce =_ggafg <<uint (_bfba );}else {_bce =_ggafg >>uint (-_bfba );};_gbd =_ecb .Push (MakeInteger (_bce ));return _gbd ;};func (_dgb *PSOperand )ifCondition (_gagd *PSStack )error {_eeg ,_cac :=_gagd .Pop ();if _cac !=nil {return _cac ;
};_cbc ,_cac :=_gagd .Pop ();if _cac !=nil {return _cac ;};_cgeg ,_bcb :=_eeg .(*PSProgram );if !_bcb {return ErrTypeCheck ;};_dbfd ,_bcb :=_cbc .(*PSBoolean );if !_bcb {return ErrTypeCheck ;};if _dbfd .Val {_bfcg :=_cgeg .Exec (_gagd );return _bfcg ;};
return nil ;};

// PSExecutor has its own execution stack and is used to executre a PS routine (program).
type PSExecutor struct{Stack *PSStack ;_bf *PSProgram ;};var ErrStackUnderflow =_e .New ("\u0073t\u0061c\u006b\u0020\u0075\u006e\u0064\u0065\u0072\u0066\u006c\u006f\u0077");func (_cgd *PSInteger )Duplicate ()PSObject {_bfe :=PSInteger {};_bfe .Val =_cgd .Val ;
return &_bfe };func (_efce *PSOperand )mul (_ceg *PSStack )error {_bfce ,_gcgc :=_ceg .Pop ();if _gcgc !=nil {return _gcgc ;};_bdgd ,_gcgc :=_ceg .Pop ();if _gcgc !=nil {return _gcgc ;};_fgeb ,_eaa :=_bfce .(*PSReal );_gba ,_adae :=_bfce .(*PSInteger );
if !_eaa &&!_adae {return ErrTypeCheck ;};_accf ,_fdc :=_bdgd .(*PSReal );_bbg ,_cgdc :=_bdgd .(*PSInteger );if !_fdc &&!_cgdc {return ErrTypeCheck ;};if _adae &&_cgdc {_ecbb :=_gba .Val *_bbg .Val ;_bbgf :=_ceg .Push (MakeInteger (_ecbb ));return _bbgf ;
};var _cagg float64 ;if _eaa {_cagg =_fgeb .Val ;}else {_cagg =float64 (_gba .Val );};if _fdc {_cagg *=_accf .Val ;}else {_cagg *=float64 (_bbg .Val );};_gcgc =_ceg .Push (MakeReal (_cagg ));return _gcgc ;};var ErrUnsupportedOperand =_e .New ("\u0075\u006e\u0073\u0075pp\u006f\u0072\u0074\u0065\u0064\u0020\u006f\u0070\u0065\u0072\u0061\u006e\u0064");


// 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 _da []float64 ;for _ ,_ge :=range objects {if _ec ,_bb :=_ge .(*PSInteger );_bb {_da =append (_da ,float64 (_ec .Val ));}else if _a ,_cgg :=_ge .(*PSReal );_cgg {_da =append (_da ,_a .Val );
}else {return nil ,ErrTypeCheck ;};};return _da ,nil ;};

// NewPSProgram returns an empty, initialized PSProgram.
func NewPSProgram ()*PSProgram {return &PSProgram {}};func (_aab *PSOperand )cvi (_cdf *PSStack )error {_bbb ,_efgg :=_cdf .Pop ();if _efgg !=nil {return _efgg ;};if _fba ,_fcdd :=_bbb .(*PSReal );_fcdd {_bdg :=int (_fba .Val );_efgg =_cdf .Push (MakeInteger (_bdg ));
}else if _eef ,_fad :=_bbb .(*PSInteger );_fad {_aff :=_eef .Val ;_efgg =_cdf .Push (MakeInteger (_aff ));}else {return ErrTypeCheck ;};return _efgg ;};func (_ggb *PSParser )parseNumber ()(PSObject ,error ){_abfb ,_eabf :=_c .ParseNumber (_ggb ._ecd );
if _eabf !=nil {return nil ,_eabf ;};switch _decg :=_abfb .(type ){case *_c .PdfObjectFloat :return MakeReal (float64 (*_decg )),nil ;case *_c .PdfObjectInteger :return MakeInteger (int (*_decg )),nil ;};return nil ,_g .Errorf ("\u0075n\u0068\u0061\u006e\u0064\u006c\u0065\u0064\u0020\u006e\u0075\u006db\u0065\u0072\u0020\u0074\u0079\u0070\u0065\u0020\u0025\u0054",_abfb );
};func (_dad *PSOperand )sub (_fee *PSStack )error {_daeg ,_baff :=_fee .Pop ();if _baff !=nil {return _baff ;};_adad ,_baff :=_fee .Pop ();if _baff !=nil {return _baff ;};_bef ,_aedb :=_daeg .(*PSReal );_fecf ,_gagdf :=_daeg .(*PSInteger );if !_aedb &&!_gagdf {return ErrTypeCheck ;
};_eabe ,_dafa :=_adad .(*PSReal );_ecga ,_fef :=_adad .(*PSInteger );if !_dafa &&!_fef {return ErrTypeCheck ;};if _gagdf &&_fef {_eege :=_ecga .Val -_fecf .Val ;_gfdb :=_fee .Push (MakeInteger (_eege ));return _gfdb ;};var _aee float64 =0;if _dafa {_aee =_eabe .Val ;
}else {_aee =float64 (_ecga .Val );};if _aedb {_aee -=_bef .Val ;}else {_aee -=float64 (_fecf .Val );};_baff =_fee .Push (MakeReal (_aee ));return _baff ;};func (_fdbd *PSOperand )index (_deb *PSStack )error {_fde ,_gfd :=_deb .Pop ();if _gfd !=nil {return _gfd ;
};_daf ,_egb :=_fde .(*PSInteger );if !_egb {return ErrTypeCheck ;};if _daf .Val < 0{return ErrRangeCheck ;};if _daf .Val > len (*_deb )-1{return ErrStackUnderflow ;};_gbe :=(*_deb )[len (*_deb )-1-_daf .Val ];_gfd =_deb .Push (_gbe .Duplicate ());return _gfd ;
};func (_adgd *PSOperand )exch (_ccc *PSStack )error {_ggd ,_dfe :=_ccc .Pop ();if _dfe !=nil {return _dfe ;};_abe ,_dfe :=_ccc .Pop ();if _dfe !=nil {return _dfe ;};_dfe =_ccc .Push (_ggd );if _dfe !=nil {return _dfe ;};_dfe =_ccc .Push (_abe );return _dfe ;
};func (_eac *PSOperand )lt (_cba *PSStack )error {_gcfe ,_gefg :=_cba .PopNumberAsFloat64 ();if _gefg !=nil {return _gefg ;};_cbgc ,_gefg :=_cba .PopNumberAsFloat64 ();if _gefg !=nil {return _gefg ;};if _dd .Abs (_cbgc -_gcfe )< _edg {_dfdb :=_cba .Push (MakeBool (false ));
return _dfdb ;}else if _cbgc < _gcfe {_gaff :=_cba .Push (MakeBool (true ));return _gaff ;}else {_gfff :=_cba .Push (MakeBool (false ));return _gfff ;};};func (_cdfg *PSParser )parseBool ()(*PSBoolean ,error ){_ccg ,_bcbe :=_cdfg ._ecd .Peek (4);if _bcbe !=nil {return MakeBool (false ),_bcbe ;
};if (len (_ccg )>=4)&&(string (_ccg [:4])=="\u0074\u0072\u0075\u0065"){_cdfg ._ecd .Discard (4);return MakeBool (true ),nil ;};_ccg ,_bcbe =_cdfg ._ecd .Peek (5);if _bcbe !=nil {return MakeBool (false ),_bcbe ;};if (len (_ccg )>=5)&&(string (_ccg [:5])=="\u0066\u0061\u006cs\u0065"){_cdfg ._ecd .Discard (5);
return MakeBool (false ),nil ;};return MakeBool (false ),_e .New ("\u0075n\u0065\u0078\u0070\u0065c\u0074\u0065\u0064\u0020\u0062o\u006fl\u0065a\u006e\u0020\u0073\u0074\u0072\u0069\u006eg");};func (_ebbc *PSOperand )neg (_fcdde *PSStack )error {_aedg ,_gdge :=_fcdde .Pop ();
if _gdge !=nil {return _gdge ;};if _edde ,_bbfa :=_aedg .(*PSReal );_bbfa {_gdge =_fcdde .Push (MakeReal (-_edde .Val ));return _gdge ;}else if _ecg ,_bdgdc :=_aedg .(*PSInteger );_bdgdc {_gdge =_fcdde .Push (MakeInteger (-_ecg .Val ));return _gdge ;}else {return ErrTypeCheck ;
};};func (_gfe *PSOperand )ln (_ddda *PSStack )error {_dfed ,_gecf :=_ddda .PopNumberAsFloat64 ();if _gecf !=nil {return _gecf ;};_gaee :=_dd .Log (_dfed );_gecf =_ddda .Push (MakeReal (_gaee ));return _gecf ;};func (_gfac *PSOperand )ifelse (_dec *PSStack )error {_edc ,_gggd :=_dec .Pop ();
if _gggd !=nil {return _gggd ;};_aad ,_gggd :=_dec .Pop ();if _gggd !=nil {return _gggd ;};_addf ,_gggd :=_dec .Pop ();if _gggd !=nil {return _gggd ;};_bcd ,_bfa :=_edc .(*PSProgram );if !_bfa {return ErrTypeCheck ;};_ffbg ,_bfa :=_aad .(*PSProgram );if !_bfa {return ErrTypeCheck ;
};_cbb ,_bfa :=_addf .(*PSBoolean );if !_bfa {return ErrTypeCheck ;};if _cbb .Val {_bedc :=_ffbg .Exec (_dec );return _bedc ;};_gggd =_bcd .Exec (_dec );return _gggd ;};func (_age *PSOperand )idiv (_fbag *PSStack )error {_bagf ,_dfdd :=_fbag .Pop ();if _dfdd !=nil {return _dfdd ;
};_adgb ,_dfdd :=_fbag .Pop ();if _dfdd !=nil {return _dfdd ;};_edga ,_eeb :=_bagf .(*PSInteger );if !_eeb {return ErrTypeCheck ;};if _edga .Val ==0{return ErrUndefinedResult ;};_bfc ,_eeb :=_adgb .(*PSInteger );if !_eeb {return ErrTypeCheck ;};_gcf :=_bfc .Val /_edga .Val ;
_dfdd =_fbag .Push (MakeInteger (_gcf ));return _dfdd ;};func (_fcf *PSOperand )gt (_feg *PSStack )error {_bdace ,_fed :=_feg .PopNumberAsFloat64 ();if _fed !=nil {return _fed ;};_dfd ,_fed :=_feg .PopNumberAsFloat64 ();if _fed !=nil {return _fed ;};if _dd .Abs (_dfd -_bdace )< _edg {_edd :=_feg .Push (MakeBool (false ));
return _edd ;}else if _dfd > _bdace {_baea :=_feg .Push (MakeBool (true ));return _baea ;}else {_cgae :=_feg .Push (MakeBool (false ));return _cgae ;};};

// DebugString returns a descriptive string representation of the stack - intended for debugging.
func (_dffda *PSStack )DebugString ()string {_efcg :="\u005b\u0020";for _ ,_fegd :=range *_dffda {_efcg +=_fegd .DebugString ();_efcg +="\u0020";};_efcg +="\u005d";return _efcg ;};

// NewPSStack returns an initialized PSStack.
func NewPSStack ()*PSStack {return &PSStack {}};

// PSReal represents a real number.
type PSReal struct{Val float64 ;};func (_dcc *PSOperand )not (_daag *PSStack )error {_cfc ,_eaad :=_daag .Pop ();if _eaad !=nil {return _eaad ;};if _bcec ,_egc :=_cfc .(*PSBoolean );_egc {_eaad =_daag .Push (MakeBool (!_bcec .Val ));return _eaad ;}else if _bgc ,_bbff :=_cfc .(*PSInteger );
_bbff {_eaad =_daag .Push (MakeInteger (^_bgc .Val ));return _eaad ;}else {return ErrTypeCheck ;};};

// NewPSParser returns a new instance of the PDF Postscript parser from input data.
func NewPSParser (content []byte )*PSParser {_fbad :=PSParser {};_faf :=_ed .NewBuffer (content );_fbad ._ecd =_bc .NewReader (_faf );return &_fbad ;};func (_bdac *PSOperand )div (_bfbg *PSStack )error {_acg ,_gec :=_bfbg .Pop ();if _gec !=nil {return _gec ;
};_dea ,_gec :=_bfbg .Pop ();if _gec !=nil {return _gec ;};_cdd ,_fbb :=_acg .(*PSReal );_ffee ,_dff :=_acg .(*PSInteger );if !_fbb &&!_dff {return ErrTypeCheck ;};if _fbb &&_cdd .Val ==0{return ErrUndefinedResult ;};if _dff &&_ffee .Val ==0{return ErrUndefinedResult ;
};_fea ,_aae :=_dea .(*PSReal );_aedf ,_fcec :=_dea .(*PSInteger );if !_aae &&!_fcec {return ErrTypeCheck ;};var _dbb float64 ;if _aae {_dbb =_fea .Val ;}else {_dbb =float64 (_aedf .Val );};if _fbb {_dbb /=_cdd .Val ;}else {_dbb /=float64 (_ffee .Val );
};_gec =_bfbg .Push (MakeReal (_dbb ));return _gec ;};func (_af *PSBoolean )Duplicate ()PSObject {_aga :=PSBoolean {};_aga .Val =_af .Val ;return &_aga };func (_edab *PSOperand )floor (_fdd *PSStack )error {_abf ,_gcd :=_fdd .Pop ();if _gcd !=nil {return _gcd ;
};if _gae ,_fec :=_abf .(*PSReal );_fec {_gcd =_fdd .Push (MakeReal (_dd .Floor (_gae .Val )));}else if _bdb ,_fbg :=_abf .(*PSInteger );_fbg {_gcd =_fdd .Push (MakeInteger (_bdb .Val ));}else {return ErrTypeCheck ;};return _gcd ;};func (_ddb *PSOperand )String ()string {return string (*_ddb )};


// PopInteger specificially pops an integer from the top of the stack, returning the value as an int.
func (_afc *PSStack )PopInteger ()(int ,error ){_faa ,_acgg :=_afc .Pop ();if _acgg !=nil {return 0,_acgg ;};if _abcb ,_eggf :=_faa .(*PSInteger );_eggf {return _abcb .Val ,nil ;};return 0,ErrTypeCheck ;};func (_ffa *PSParser )parseFunction ()(*PSProgram ,error ){_bgge ,_ :=_ffa ._ecd .ReadByte ();
if _bgge !='{'{return nil ,_e .New ("\u0069\u006ev\u0061\u006c\u0069d\u0020\u0066\u0075\u006e\u0063\u0074\u0069\u006f\u006e");};_fdeg :=NewPSProgram ();for {_ffa .skipSpaces ();_ffa .skipComments ();_gcdc ,_bgdd :=_ffa ._ecd .Peek (2);if _bgdd !=nil {if _bgdd ==_d .EOF {break ;
};return nil ,_bgdd ;};_dg .Log .Trace ("\u0050e\u0065k\u0020\u0073\u0074\u0072\u0069\u006e\u0067\u003a\u0020\u0025\u0073",string (_gcdc ));if _gcdc [0]=='}'{_dg .Log .Trace ("\u0045\u004f\u0046 \u0066\u0075\u006e\u0063\u0074\u0069\u006f\u006e");_ffa ._ecd .ReadByte ();
break ;}else if _gcdc [0]=='{'{_dg .Log .Trace ("\u0046u\u006e\u0063\u0074\u0069\u006f\u006e!");_dbd ,_afa :=_ffa .parseFunction ();if _afa !=nil {return nil ,_afa ;};_fdeg .Append (_dbd );}else if _c .IsDecimalDigit (_gcdc [0])||(_gcdc [0]=='-'&&_c .IsDecimalDigit (_gcdc [1])){_dg .Log .Trace ("\u002d>\u004e\u0075\u006d\u0062\u0065\u0072!");
_bacf ,_bdaf :=_ffa .parseNumber ();if _bdaf !=nil {return nil ,_bdaf ;};_fdeg .Append (_bacf );}else {_dg .Log .Trace ("\u002d>\u004fp\u0065\u0072\u0061\u006e\u0064 \u006f\u0072 \u0062\u006f\u006f\u006c\u003f");_gcdc ,_ =_ffa ._ecd .Peek (5);_ddffe :=string (_gcdc );
_dg .Log .Trace ("\u0050\u0065\u0065k\u0020\u0073\u0074\u0072\u003a\u0020\u0025\u0073",_ddffe );if (len (_ddffe )> 4)&&(_ddffe [:5]=="\u0066\u0061\u006cs\u0065"){_bfbf ,_bcf :=_ffa .parseBool ();if _bcf !=nil {return nil ,_bcf ;};_fdeg .Append (_bfbf );
}else if (len (_ddffe )> 3)&&(_ddffe [:4]=="\u0074\u0072\u0075\u0065"){_bfceb ,_bcfe :=_ffa .parseBool ();if _bcfe !=nil {return nil ,_bcfe ;};_fdeg .Append (_bfceb );}else {_dgc ,_eabc :=_ffa .parseOperand ();if _eabc !=nil {return nil ,_eabc ;};_fdeg .Append (_dgc );
};};};return _fdeg ,nil ;};const _edg =0.000001;func (_abg *PSOperand )xor (_gbdg *PSStack )error {_gfab ,_cfg :=_gbdg .Pop ();if _cfg !=nil {return _cfg ;};_fgcg ,_cfg :=_gbdg .Pop ();if _cfg !=nil {return _cfg ;};if _afdf ,_fedg :=_gfab .(*PSBoolean );
_fedg {_ffeg ,_fbgb :=_fgcg .(*PSBoolean );if !_fbgb {return ErrTypeCheck ;};_cfg =_gbdg .Push (MakeBool (_afdf .Val !=_ffeg .Val ));return _cfg ;};if _bgcd ,_bfd :=_gfab .(*PSInteger );_bfd {_ccb ,_bbc :=_fgcg .(*PSInteger );if !_bbc {return ErrTypeCheck ;
};_cfg =_gbdg .Push (MakeInteger (_bgcd .Val ^_ccb .Val ));return _cfg ;};return ErrTypeCheck ;};

// NewPSExecutor returns an initialized PSExecutor for an input `program`.
func NewPSExecutor (program *PSProgram )*PSExecutor {_cg :=&PSExecutor {};_cg .Stack =NewPSStack ();_cg ._bf =program ;return _cg ;};func (_egba *PSOperand )sin (_aabb *PSStack )error {_cddd ,_gda :=_aabb .PopNumberAsFloat64 ();if _gda !=nil {return _gda ;
};_bgff :=_dd .Sin (_cddd *_dd .Pi /180.0);_gda =_aabb .Push (MakeReal (_bgff ));return _gda ;};func (_efdc *PSOperand )log (_aabd *PSStack )error {_efga ,_dged :=_aabd .PopNumberAsFloat64 ();if _dged !=nil {return _dged ;};_dgg :=_dd .Log10 (_efga );_dged =_aabd .Push (MakeReal (_dgg ));
return _dged ;};

// PopNumberAsFloat64 pops and return the numeric value of the top of the stack as a float64.
// Real or integer only.
func (_gcde *PSStack )PopNumberAsFloat64 ()(float64 ,error ){_bdga ,_bdafg :=_gcde .Pop ();if _bdafg !=nil {return 0,_bdafg ;};if _gfg ,_aabbg :=_bdga .(*PSReal );_aabbg {return _gfg .Val ,nil ;}else if _eega ,_cdddf :=_bdga .(*PSInteger );_cdddf {return float64 (_eega .Val ),nil ;
}else {return 0,ErrTypeCheck ;};};

// PSStack defines a stack of PSObjects. PSObjects can be pushed on or pull from the stack.
type PSStack []PSObject ;

// PSParser is a basic Postscript parser.
type PSParser struct{_ecd *_bc .Reader };func (_aed *PSBoolean )String ()string {return _g .Sprintf ("\u0025\u0076",_aed .Val )};func (_bfb *PSReal )String ()string {return _g .Sprintf ("\u0025\u002e\u0035\u0066",_bfb .Val )};func (_gc *PSOperand )Duplicate ()PSObject {_bag :=*_gc ;
return &_bag };

// MakeBool returns a new PSBoolean object initialized with `val`.
func MakeBool (val bool )*PSBoolean {_fdf :=PSBoolean {};_fdf .Val =val ;return &_fdf };

// MakeReal returns a new PSReal object initialized with `val`.
func MakeReal (val float64 )*PSReal {_cgab :=PSReal {};_cgab .Val =val ;return &_cgab };func (_cfd *PSOperand )mod (_dcb *PSStack )error {_fgeg ,_fcb :=_dcb .Pop ();if _fcb !=nil {return _fcb ;};_daae ,_fcb :=_dcb .Pop ();if _fcb !=nil {return _fcb ;};
_baa ,_ffdg :=_fgeg .(*PSInteger );if !_ffdg {return ErrTypeCheck ;};if _baa .Val ==0{return ErrUndefinedResult ;};_fdda ,_ffdg :=_daae .(*PSInteger );if !_ffdg {return ErrTypeCheck ;};_cdff :=_fdda .Val %_baa .Val ;_fcb =_dcb .Push (MakeInteger (_cdff ));
return _fcb ;};func (_bg *PSInteger )DebugString ()string {return _g .Sprintf ("\u0069\u006e\u0074\u003a\u0025\u0064",_bg .Val );};func (_ebae *PSOperand )le (_beb *PSStack )error {_agfa ,_ecf :=_beb .PopNumberAsFloat64 ();if _ecf !=nil {return _ecf ;};
_bcdg ,_ecf :=_beb .PopNumberAsFloat64 ();if _ecf !=nil {return _ecf ;};if _dd .Abs (_bcdg -_agfa )< _edg {_fge :=_beb .Push (MakeBool (true ));return _fge ;}else if _bcdg < _agfa {_efd :=_beb .Push (MakeBool (true ));return _efd ;}else {_gdg :=_beb .Push (MakeBool (false ));
return _gdg ;};};

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

// Execute executes the program for an input parameters `objects` and returns a slice of output objects.
func (_gg *PSExecutor )Execute (objects []PSObject )([]PSObject ,error ){for _ ,_ae :=range objects {_ef :=_gg .Stack .Push (_ae );if _ef !=nil {return nil ,_ef ;};};_dac :=_gg ._bf .Exec (_gg .Stack );if _dac !=nil {_dg .Log .Debug ("\u0045x\u0065c\u0020\u0066\u0061\u0069\u006c\u0065\u0064\u003a\u0020\u0025\u0076",_dac );
return nil ,_dac ;};_gga :=[]PSObject (*_gg .Stack );_gg .Stack .Empty ();return _gga ,nil ;};func (_ede *PSReal )Duplicate ()PSObject {_ba :=PSReal {};_ba .Val =_ede .Val ;return &_ba };func (_cga *PSOperand )ceiling (_ffe *PSStack )error {_fa ,_dbf :=_ffe .Pop ();
if _dbf !=nil {return _dbf ;};if _cge ,_gf :=_fa .(*PSReal );_gf {_dbf =_ffe .Push (MakeReal (_dd .Ceil (_cge .Val )));}else if _add ,_agb :=_fa .(*PSInteger );_agb {_dbf =_ffe .Push (MakeInteger (_add .Val ));}else {_dbf =ErrTypeCheck ;};return _dbf ;
};func (_ca *PSOperand )copy (_fdb *PSStack )error {_gdb ,_dbe :=_fdb .PopInteger ();if _dbe !=nil {return _dbe ;};if _gdb < 0{return ErrRangeCheck ;};if _gdb > len (*_fdb ){return ErrRangeCheck ;};*_fdb =append (*_fdb ,(*_fdb )[len (*_fdb )-_gdb :]...);
return nil ;};func (_ddf *PSOperand )cvr (_gdf *PSStack )error {_bcac ,_fceb :=_gdf .Pop ();if _fceb !=nil {return _fceb ;};if _acb ,_bbf :=_bcac .(*PSReal );_bbf {_fceb =_gdf .Push (MakeReal (_acb .Val ));}else if _gbg ,_edec :=_bcac .(*PSInteger );_edec {_fceb =_gdf .Push (MakeReal (float64 (_gbg .Val )));
}else {return ErrTypeCheck ;};return _fceb ;};

// Append appends an object to the PSProgram.
func (_db *PSProgram )Append (obj PSObject ){*_db =append (*_db ,obj )};func _gdd (_bdf int )int {if _bdf < 0{return -_bdf ;};return _bdf ;};

// MakeOperand returns a new PSOperand object based on string `val`.
func MakeOperand (val string )*PSOperand {_eag :=PSOperand (val );return &_eag };func (_de *PSOperand )and (_eda *PSStack )error {_aeg ,_gcb :=_eda .Pop ();if _gcb !=nil {return _gcb ;};_bda ,_gcb :=_eda .Pop ();if _gcb !=nil {return _gcb ;};if _cbg ,_bcaa :=_aeg .(*PSBoolean );
_bcaa {_be ,_gd :=_bda .(*PSBoolean );if !_gd {return ErrTypeCheck ;};_gcb =_eda .Push (MakeBool (_cbg .Val &&_be .Val ));return _gcb ;};if _ga ,_aegf :=_aeg .(*PSInteger );_aegf {_adb ,_egd :=_bda .(*PSInteger );if !_egd {return ErrTypeCheck ;};_gcb =_eda .Push (MakeInteger (_ga .Val &_adb .Val ));
return _gcb ;};return ErrTypeCheck ;};func (_cad *PSOperand )sqrt (_cdeb *PSStack )error {_ece ,_bdab :=_cdeb .PopNumberAsFloat64 ();if _bdab !=nil {return _bdab ;};if _ece < 0{return ErrRangeCheck ;};_cbf :=_dd .Sqrt (_ece );_bdab =_cdeb .Push (MakeReal (_cbf ));
return _bdab ;};func (_dcg *PSOperand )ne (_ddff *PSStack )error {_gab :=_dcg .eq (_ddff );if _gab !=nil {return _gab ;};_gab =_dcg .not (_ddff );return _gab ;};func (_fcd *PSOperand )DebugString ()string {return _g .Sprintf ("\u006fp\u003a\u0027\u0025\u0073\u0027",*_fcd );
};func (_ag *PSInteger )String ()string {return _g .Sprintf ("\u0025\u0064",_ag .Val )};

// Exec executes the operand `op` in the state specified by `stack`.
func (_ebg *PSOperand )Exec (stack *PSStack )error {_afe :=ErrUnsupportedOperand ;switch *_ebg {case "\u0061\u0062\u0073":_afe =_ebg .abs (stack );case "\u0061\u0064\u0064":_afe =_ebg .add (stack );case "\u0061\u006e\u0064":_afe =_ebg .and (stack );case "\u0061\u0074\u0061\u006e":_afe =_ebg .atan (stack );
case "\u0062\u0069\u0074\u0073\u0068\u0069\u0066\u0074":_afe =_ebg .bitshift (stack );case "\u0063e\u0069\u006c\u0069\u006e\u0067":_afe =_ebg .ceiling (stack );case "\u0063\u006f\u0070\u0079":_afe =_ebg .copy (stack );case "\u0063\u006f\u0073":_afe =_ebg .cos (stack );
case "\u0063\u0076\u0069":_afe =_ebg .cvi (stack );case "\u0063\u0076\u0072":_afe =_ebg .cvr (stack );case "\u0064\u0069\u0076":_afe =_ebg .div (stack );case "\u0064\u0075\u0070":_afe =_ebg .dup (stack );case "\u0065\u0071":_afe =_ebg .eq (stack );case "\u0065\u0078\u0063\u0068":_afe =_ebg .exch (stack );
case "\u0065\u0078\u0070":_afe =_ebg .exp (stack );case "\u0066\u006c\u006fo\u0072":_afe =_ebg .floor (stack );case "\u0067\u0065":_afe =_ebg .ge (stack );case "\u0067\u0074":_afe =_ebg .gt (stack );case "\u0069\u0064\u0069\u0076":_afe =_ebg .idiv (stack );
case "\u0069\u0066":_afe =_ebg .ifCondition (stack );case "\u0069\u0066\u0065\u006c\u0073\u0065":_afe =_ebg .ifelse (stack );case "\u0069\u006e\u0064e\u0078":_afe =_ebg .index (stack );case "\u006c\u0065":_afe =_ebg .le (stack );case "\u006c\u006f\u0067":_afe =_ebg .log (stack );
case "\u006c\u006e":_afe =_ebg .ln (stack );case "\u006c\u0074":_afe =_ebg .lt (stack );case "\u006d\u006f\u0064":_afe =_ebg .mod (stack );case "\u006d\u0075\u006c":_afe =_ebg .mul (stack );case "\u006e\u0065":_afe =_ebg .ne (stack );case "\u006e\u0065\u0067":_afe =_ebg .neg (stack );
case "\u006e\u006f\u0074":_afe =_ebg .not (stack );case "\u006f\u0072":_afe =_ebg .or (stack );case "\u0070\u006f\u0070":_afe =_ebg .pop (stack );case "\u0072\u006f\u0075n\u0064":_afe =_ebg .round (stack );case "\u0072\u006f\u006c\u006c":_afe =_ebg .roll (stack );
case "\u0073\u0069\u006e":_afe =_ebg .sin (stack );case "\u0073\u0071\u0072\u0074":_afe =_ebg .sqrt (stack );case "\u0073\u0075\u0062":_afe =_ebg .sub (stack );case "\u0074\u0072\u0075\u006e\u0063\u0061\u0074\u0065":_afe =_ebg .truncate (stack );case "\u0078\u006f\u0072":_afe =_ebg .xor (stack );
};return _afe ;};func (_bdbe *PSParser )skipComments ()error {if _ ,_fbc :=_bdbe .skipSpaces ();_fbc !=nil {return _fbc ;};_fcdf :=true ;for {_acgb ,_fgd :=_bdbe ._ecd .Peek (1);if _fgd !=nil {_dg .Log .Debug ("\u0045\u0072\u0072\u006f\u0072\u0020\u0025\u0073",_fgd .Error ());
return _fgd ;};if _fcdf &&_acgb [0]!='%'{return nil ;};_fcdf =false ;if (_acgb [0]!='\r')&&(_acgb [0]!='\n'){_bdbe ._ecd .ReadByte ();}else {break ;};};return _bdbe .skipComments ();};func (_gccc *PSParser )parseOperand ()(*PSOperand ,error ){var _cbcf []byte ;
for {_bcbb ,_bgdde :=_gccc ._ecd .Peek (1);if _bgdde !=nil {if _bgdde ==_d .EOF {break ;};return nil ,_bgdde ;};if _c .IsDelimiter (_bcbb [0]){break ;};if _c .IsWhiteSpace (_bcbb [0]){break ;};_gfef ,_ :=_gccc ._ecd .ReadByte ();_cbcf =append (_cbcf ,_gfef );
};if len (_cbcf )==0{return nil ,_e .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 (_cbcf )),nil ;};

// 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 ;};

// PSInteger represents an integer.
type PSInteger struct{Val int ;};

// String returns a string representation of the stack.
func (_eabd *PSStack )String ()string {_dbfde :="\u005b\u0020";for _ ,_dfdf :=range *_eabd {_dbfde +=_dfdf .String ();_dbfde +="\u0020";};_dbfde +="\u005d";return _dbfde ;};