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 (_gf "bufio";_c "bytes";_d "errors";_ge "fmt";_bf "github.com/unidoc/unipdf/v3/common";_a "github.com/unidoc/unipdf/v3/core";_gb "io";_b "math";);var ErrRangeCheck =_d .New ("\u0072\u0061\u006e\u0067\u0065\u0020\u0063\u0068\u0065\u0063\u006b\u0020e\u0072\u0072\u006f\u0072");

// PSReal represents a real number.
type PSReal struct{Val float64 ;};func (_gece *PSOperand )cvi (_cdb *PSStack )error {_gee ,_cgf :=_cdb .Pop ();if _cgf !=nil {return _cgf ;};if _cff ,_cfd :=_gee .(*PSReal );_cfd {_bcf :=int (_cff .Val );_cgf =_cdb .Push (MakeInteger (_bcf ));}else if _dd ,_ffa :=_gee .(*PSInteger );_ffa {_dcb :=_dd .Val ;_cgf =_cdb .Push (MakeInteger (_dcb ));}else {return ErrTypeCheck ;};return _cgf ;};func (_ccec *PSParser )parseFunction ()(*PSProgram ,error ){_bed ,_ :=_ccec ._faef .ReadByte ();if _bed !='{'{return nil ,_d .New ("\u0069\u006ev\u0061\u006c\u0069d\u0020\u0066\u0075\u006e\u0063\u0074\u0069\u006f\u006e");};_aabb :=NewPSProgram ();for {_ccec .skipSpaces ();_fadc ,_cgac :=_ccec ._faef .Peek (2);if _cgac !=nil {if _cgac ==_gb .EOF {break ;};return nil ,_cgac ;};_bf .Log .Trace ("\u0050e\u0065k\u0020\u0073\u0074\u0072\u0069\u006e\u0067\u003a\u0020\u0025\u0073",string (_fadc ));if _fadc [0]=='}'{_bf .Log .Trace ("\u0045\u004f\u0046 \u0066\u0075\u006e\u0063\u0074\u0069\u006f\u006e");_ccec ._faef .ReadByte ();break ;}else if _fadc [0]=='{'{_bf .Log .Trace ("\u0046u\u006e\u0063\u0074\u0069\u006f\u006e!");_bddc ,_ccg :=_ccec .parseFunction ();if _ccg !=nil {return nil ,_ccg ;};_aabb .Append (_bddc );}else if _a .IsDecimalDigit (_fadc [0])||(_fadc [0]=='-'&&_a .IsDecimalDigit (_fadc [1])){_bf .Log .Trace ("\u002d>\u004e\u0075\u006d\u0062\u0065\u0072!");_baec ,_acc :=_ccec .parseNumber ();if _acc !=nil {return nil ,_acc ;};_aabb .Append (_baec );}else {_bf .Log .Trace ("\u002d>\u004fp\u0065\u0072\u0061\u006e\u0064 \u006f\u0072 \u0062\u006f\u006f\u006c\u003f");_fadc ,_ =_ccec ._faef .Peek (5);_fgab :=string (_fadc );_bf .Log .Trace ("\u0050\u0065\u0065k\u0020\u0073\u0074\u0072\u003a\u0020\u0025\u0073",_fgab );if (len (_fgab )> 4)&&(_fgab [:5]=="\u0066\u0061\u006cs\u0065"){_gbaf ,_cafb :=_ccec .parseBool ();if _cafb !=nil {return nil ,_cafb ;};_aabb .Append (_gbaf );}else if (len (_fgab )> 3)&&(_fgab [:4]=="\u0074\u0072\u0075\u0065"){_gda ,_ccge :=_ccec .parseBool ();if _ccge !=nil {return nil ,_ccge ;};_aabb .Append (_gda );}else {_egb ,_bgde :=_ccec .parseOperand ();if _bgde !=nil {return nil ,_bgde ;};_aabb .Append (_egb );};};};return _aabb ,nil ;};func (_bgcb *PSOperand )copy (_ede *PSStack )error {_aee ,_fed :=_ede .PopInteger ();if _fed !=nil {return _fed ;};if _aee < 0{return ErrRangeCheck ;};if _aee > len (*_ede ){return ErrRangeCheck ;};*_ede =append (*_ede ,(*_ede )[len (*_ede )-_aee :]...);return nil ;};func (_babc *PSOperand )and (_add *PSStack )error {_cfa ,_efg :=_add .Pop ();if _efg !=nil {return _efg ;};_agc ,_efg :=_add .Pop ();if _efg !=nil {return _efg ;};if _gbb ,_afb :=_cfa .(*PSBoolean );_afb {_gd ,_bega :=_agc .(*PSBoolean );if !_bega {return ErrTypeCheck ;};_efg =_add .Push (MakeBool (_gbb .Val &&_gd .Val ));return _efg ;};if _fgf ,_dfg :=_cfa .(*PSInteger );_dfg {_fbd ,_aa :=_agc .(*PSInteger );if !_aa {return ErrTypeCheck ;};_efg =_add .Push (MakeInteger (_fgf .Val &_fbd .Val ));return _efg ;};return ErrTypeCheck ;};func (_eebg *PSOperand )idiv (_bec *PSStack )error {_gbab ,_aca :=_bec .Pop ();if _aca !=nil {return _aca ;};_cdee ,_aca :=_bec .Pop ();if _aca !=nil {return _aca ;};_ebf ,_dgab :=_gbab .(*PSInteger );if !_dgab {return ErrTypeCheck ;};if _ebf .Val ==0{return ErrUndefinedResult ;};_cgad ,_dgab :=_cdee .(*PSInteger );if !_dgab {return ErrTypeCheck ;};_bcad :=_cgad .Val /_ebf .Val ;_aca =_bec .Push (MakeInteger (_bcad ));return _aca ;};

// Pop pops an object from the top of the stack.
func (_bdde *PSStack )Pop ()(PSObject ,error ){if len (*_bdde )< 1{return nil ,ErrStackUnderflow ;};_bcfcf :=(*_bdde )[len (*_bdde )-1];*_bdde =(*_bdde )[0:len (*_bdde )-1];return _bcfcf ,nil ;};func (_cb *PSOperand )abs (_fbb *PSStack )error {_cba ,_cde :=_fbb .Pop ();if _cde !=nil {return _cde ;};if _ffg ,_dab :=_cba .(*PSReal );_dab {_ccd :=_ffg .Val ;if _ccd < 0{_cde =_fbb .Push (MakeReal (-_ccd ));}else {_cde =_fbb .Push (MakeReal (_ccd ));};}else if _cbg ,_fcd :=_cba .(*PSInteger );_fcd {_gc :=_cbg .Val ;if _gc < 0{_cde =_fbb .Push (MakeInteger (-_gc ));}else {_cde =_fbb .Push (MakeInteger (_gc ));};}else {return ErrTypeCheck ;};return _cde ;};func (_fbg *PSOperand )le (_edeb *PSStack )error {_eeed ,_bac :=_edeb .PopNumberAsFloat64 ();if _bac !=nil {return _bac ;};_gcg ,_bac :=_edeb .PopNumberAsFloat64 ();if _bac !=nil {return _bac ;};if _b .Abs (_gcg -_eeed )< _bfg {_ggg :=_edeb .Push (MakeBool (true ));return _ggg ;}else if _gcg < _eeed {_ffaa :=_edeb .Push (MakeBool (true ));return _ffaa ;}else {_eef :=_edeb .Push (MakeBool (false ));return _eef ;};};

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

// Exec executes the program, typically leaving output values on the stack.
func (_gg *PSProgram )Exec (stack *PSStack )error {for _ ,_cgg :=range *_gg {var _ce error ;switch _cee :=_cgg .(type ){case *PSInteger :_fga :=_cee ;_ce =stack .Push (_fga );case *PSReal :_de :=_cee ;_ce =stack .Push (_de );case *PSBoolean :_ef :=_cee ;_ce =stack .Push (_ef );case *PSProgram :_dgg :=_cee ;_ce =stack .Push (_dgg );case *PSOperand :_beg :=_cee ;_ce =_beg .Exec (stack );default:return ErrTypeCheck ;};if _ce !=nil {return _ce ;};};return nil ;};var ErrTypeCheck =_d .New ("\u0074\u0079p\u0065\u0020\u0063h\u0065\u0063\u006b\u0020\u0065\u0072\u0072\u006f\u0072");

// 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 ;};func (_fae *PSOperand )xor (_afc *PSStack )error {_edb ,_fgfc :=_afc .Pop ();if _fgfc !=nil {return _fgfc ;};_dbd ,_fgfc :=_afc .Pop ();if _fgfc !=nil {return _fgfc ;};if _gccg ,_eff :=_edb .(*PSBoolean );_eff {_aeb ,_bgcgc :=_dbd .(*PSBoolean );if !_bgcgc {return ErrTypeCheck ;};_fgfc =_afc .Push (MakeBool (_gccg .Val !=_aeb .Val ));return _fgfc ;};if _bdeg ,_fcce :=_edb .(*PSInteger );_fcce {_ceb ,_ecbg :=_dbd .(*PSInteger );if !_ecbg {return ErrTypeCheck ;};_fgfc =_afc .Push (MakeInteger (_bdeg .Val ^_ceb .Val ));return _fgfc ;};return ErrTypeCheck ;};func (_efc *PSOperand )add (_cbe *PSStack )error {_ad ,_dfe :=_cbe .Pop ();if _dfe !=nil {return _dfe ;};_cdd ,_dfe :=_cbe .Pop ();if _dfe !=nil {return _dfe ;};_ec ,_aba :=_ad .(*PSReal );_dad ,_ffd :=_ad .(*PSInteger );if !_aba &&!_ffd {return ErrTypeCheck ;};_fgb ,_afg :=_cdd .(*PSReal );_bca ,_fdg :=_cdd .(*PSInteger );if !_afg &&!_fdg {return ErrTypeCheck ;};if _ffd &&_fdg {_bgcd :=_dad .Val +_bca .Val ;_cef :=_cbe .Push (MakeInteger (_bgcd ));return _cef ;};var _fcc float64 ;if _aba {_fcc =_ec .Val ;}else {_fcc =float64 (_dad .Val );};if _afg {_fcc +=_fgb .Val ;}else {_fcc +=float64 (_bca .Val );};_dfe =_cbe .Push (MakeReal (_fcc ));return _dfe ;};

// Push pushes an object on top of the stack.
func (_dacc *PSStack )Push (obj PSObject )error {if len (*_dacc )> 100{return ErrStackOverflow ;};*_dacc =append (*_dacc ,obj );return nil ;};func (_eda *PSOperand )mod (_bba *PSStack )error {_adcf ,_fdcb :=_bba .Pop ();if _fdcb !=nil {return _fdcb ;};_dccc ,_fdcb :=_bba .Pop ();if _fdcb !=nil {return _fdcb ;};_ccaaa ,_fgag :=_adcf .(*PSInteger );if !_fgag {return ErrTypeCheck ;};if _ccaaa .Val ==0{return ErrUndefinedResult ;};_gdf ,_fgag :=_dccc .(*PSInteger );if !_fgag {return ErrTypeCheck ;};_bge :=_gdf .Val %_ccaaa .Val ;_fdcb =_bba .Push (MakeInteger (_bge ));return _fdcb ;};func (_gcd *PSOperand )ne (_cgab *PSStack )error {_abdf :=_gcd .eq (_cgab );if _abdf !=nil {return _abdf ;};_abdf =_gcd .not (_cgab );return _abdf ;};

// String returns a string representation of the stack.
func (_fgg *PSStack )String ()string {_dde :="\u005b\u0020";for _ ,_afbd :=range *_fgg {_dde +=_afbd .String ();_dde +="\u0020";};_dde +="\u005d";return _dde ;};func (_af *PSOperand )Duplicate ()PSObject {_fc :=*_af ;return &_fc };

// PSOperand represents a Postscript operand (text string).
type PSOperand string ;func (_fac *PSBoolean )DebugString ()string {return _ge .Sprintf ("\u0062o\u006f\u006c\u003a\u0025\u0076",_fac .Val );};

// MakeInteger returns a new PSInteger object initialized with `val`.
func MakeInteger (val int )*PSInteger {_dbba :=PSInteger {};_dbba .Val =val ;return &_dbba };var ErrStackOverflow =_d .New ("\u0073\u0074\u0061\u0063\u006b\u0020\u006f\u0076\u0065r\u0066\u006c\u006f\u0077");func (_dcd *PSOperand )bitshift (_ggf *PSStack )error {_ee ,_abc :=_ggf .PopInteger ();if _abc !=nil {return _abc ;};_ecb ,_abc :=_ggf .PopInteger ();if _abc !=nil {return _abc ;};var _cad int ;if _ee >=0{_cad =_ecb <<uint (_ee );}else {_cad =_ecb >>uint (-_ee );};_abc =_ggf .Push (MakeInteger (_cad ));return _abc ;};func (_aad *PSOperand )cos (_ged *PSStack )error {_eca ,_fbc :=_ged .PopNumberAsFloat64 ();if _fbc !=nil {return _fbc ;};_ac :=_b .Cos (_eca *_b .Pi /180.0);_fbc =_ged .Push (MakeReal (_ac ));return _fbc ;};func (_dc *PSReal )String ()string {return _ge .Sprintf ("\u0025\u002e\u0035\u0066",_dc .Val )};func (_abag *PSOperand )exch (_dgaa *PSStack )error {_dff ,_cfb :=_dgaa .Pop ();if _cfb !=nil {return _cfb ;};_cbfb ,_cfb :=_dgaa .Pop ();if _cfb !=nil {return _cfb ;};_cfb =_dgaa .Push (_dff );if _cfb !=nil {return _cfb ;};_cfb =_dgaa .Push (_cbfb );return _cfb ;};func _gbbg (_ebbb int )int {if _ebbb < 0{return -_ebbb ;};return _ebbb ;};

// NewPSStack returns an initialized PSStack.
func NewPSStack ()*PSStack {return &PSStack {}};var ErrStackUnderflow =_d .New ("\u0073t\u0061c\u006b\u0020\u0075\u006e\u0064\u0065\u0072\u0066\u006c\u006f\u0077");func (_agag *PSOperand )div (_dcc *PSStack )error {_abcc ,_gfb :=_dcc .Pop ();if _gfb !=nil {return _gfb ;};_cfg ,_gfb :=_dcc .Pop ();if _gfb !=nil {return _gfb ;};_cggc ,_bee :=_abcc .(*PSReal );_bfb ,_fefb :=_abcc .(*PSInteger );if !_bee &&!_fefb {return ErrTypeCheck ;};if _bee &&_cggc .Val ==0{return ErrUndefinedResult ;};if _fefb &&_bfb .Val ==0{return ErrUndefinedResult ;};_fgc ,_fefbd :=_cfg .(*PSReal );_gfd ,_cbab :=_cfg .(*PSInteger );if !_fefbd &&!_cbab {return ErrTypeCheck ;};var _bad float64 ;if _fefbd {_bad =_fgc .Val ;}else {_bad =float64 (_gfd .Val );};if _bee {_bad /=_cggc .Val ;}else {_bad /=float64 (_bfb .Val );};_gfb =_dcc .Push (MakeReal (_bad ));return _gfb ;};func (_bda *PSOperand )cvr (_aadc *PSStack )error {_ffga ,_dbb :=_aadc .Pop ();if _dbb !=nil {return _dbb ;};if _efcc ,_ea :=_ffga .(*PSReal );_ea {_dbb =_aadc .Push (MakeReal (_efcc .Val ));}else if _fff ,_fedc :=_ffga .(*PSInteger );_fedc {_dbb =_aadc .Push (MakeReal (float64 (_fff .Val )));}else {return ErrTypeCheck ;};return _dbb ;};

// Append appends an object to the PSProgram.
func (_feg *PSProgram )Append (obj PSObject ){*_feg =append (*_feg ,obj )};

// PSProgram defines a Postscript program which is a series of PS objects (arguments, commands, programs etc).
type PSProgram []PSObject ;func (_bcfc *PSOperand )neg (_fdce *PSStack )error {_ddb ,_fgae :=_fdce .Pop ();if _fgae !=nil {return _fgae ;};if _dfb ,_cfae :=_ddb .(*PSReal );_cfae {_fgae =_fdce .Push (MakeReal (-_dfb .Val ));return _fgae ;}else if _fgcc ,_baa :=_ddb .(*PSInteger );_baa {_fgae =_fdce .Push (MakeInteger (-_fgcc .Val ));return _fgae ;}else {return ErrTypeCheck ;};};func (_dg *PSInteger )String ()string {return _ge .Sprintf ("\u0025\u0064",_dg .Val )};

// 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 _f []float64 ;for _ ,_db :=range objects {if _bc ,_fa :=_db .(*PSInteger );_fa {_f =append (_f ,float64 (_bc .Val ));}else if _cc ,_ba :=_db .(*PSReal );_ba {_f =append (_f ,_cc .Val );}else {return nil ,ErrTypeCheck ;};};return _f ,nil ;};func (_aafd *PSOperand )sub (_dccd *PSStack )error {_adcc ,_afdc :=_dccd .Pop ();if _afdc !=nil {return _afdc ;};_feda ,_afdc :=_dccd .Pop ();if _afdc !=nil {return _afdc ;};_ecbc ,_ebd :=_adcc .(*PSReal );_acg ,_eabf :=_adcc .(*PSInteger );if !_ebd &&!_eabf {return ErrTypeCheck ;};_dae ,_dcfb :=_feda .(*PSReal );_afbe ,_cege :=_feda .(*PSInteger );if !_dcfb &&!_cege {return ErrTypeCheck ;};if _eabf &&_cege {_fdge :=_afbe .Val -_acg .Val ;_fagf :=_dccd .Push (MakeInteger (_fdge ));return _fagf ;};var _badd float64 =0;if _dcfb {_badd =_dae .Val ;}else {_badd =float64 (_afbe .Val );};if _ebd {_badd -=_ecbc .Val ;}else {_badd -=float64 (_acg .Val );};_afdc =_dccd .Push (MakeReal (_badd ));return _afdc ;};func (_ada *PSOperand )lt (_aae *PSStack )error {_dfgb ,_ffb :=_aae .PopNumberAsFloat64 ();if _ffb !=nil {return _ffb ;};_bde ,_ffb :=_aae .PopNumberAsFloat64 ();if _ffb !=nil {return _ffb ;};if _b .Abs (_bde -_dfgb )< _bfg {_afbg :=_aae .Push (MakeBool (false ));return _afbg ;}else if _bde < _dfgb {_dbef :=_aae .Push (MakeBool (true ));return _dbef ;}else {_cbabd :=_aae .Push (MakeBool (false ));return _cbabd ;};};func (_agf *PSOperand )roll (_eag *PSStack )error {_bea ,_efgg :=_eag .Pop ();if _efgg !=nil {return _efgg ;};_bgce ,_efgg :=_eag .Pop ();if _efgg !=nil {return _efgg ;};_bbdd ,_faa :=_bea .(*PSInteger );if !_faa {return ErrTypeCheck ;};_gab ,_faa :=_bgce .(*PSInteger );if !_faa {return ErrTypeCheck ;};if _gab .Val < 0{return ErrRangeCheck ;};if _gab .Val ==0||_gab .Val ==1{return nil ;};if _gab .Val > len (*_eag ){return ErrStackUnderflow ;};for _adec :=0;_adec < _gbbg (_bbdd .Val );_adec ++{var _bacd []PSObject ;_bacd =(*_eag )[len (*_eag )-(_gab .Val ):len (*_eag )];if _bbdd .Val > 0{_ffda :=_bacd [len (_bacd )-1];_bacd =append ([]PSObject {_ffda },_bacd [0:len (_bacd )-1]...);}else {_abe :=_bacd [len (_bacd )-_gab .Val ];_bacd =append (_bacd [1:],_abe );};_fedg :=append ((*_eag )[0:len (*_eag )-_gab .Val ],_bacd ...);_eag =&_fedg ;};return nil ;};func (_eggf *PSOperand )not (_fdfd *PSStack )error {_gcc ,_fedf :=_fdfd .Pop ();if _fedf !=nil {return _fedf ;};if _gcfc ,_cdc :=_gcc .(*PSBoolean );_cdc {_fedf =_fdfd .Push (MakeBool (!_gcfc .Val ));return _fedf ;}else if _cbgd ,_gedf :=_gcc .(*PSInteger );_gedf {_fedf =_fdfd .Push (MakeInteger (^_cbgd .Val ));return _fedf ;}else {return ErrTypeCheck ;};};

// Exec executes the operand `op` in the state specified by `stack`.
func (_bab *PSOperand )Exec (stack *PSStack )error {_babg :=ErrUnsupportedOperand ;switch *_bab {case "\u0061\u0062\u0073":_babg =_bab .abs (stack );case "\u0061\u0064\u0064":_babg =_bab .add (stack );case "\u0061\u006e\u0064":_babg =_bab .and (stack );case "\u0061\u0074\u0061\u006e":_babg =_bab .atan (stack );case "\u0062\u0069\u0074\u0073\u0068\u0069\u0066\u0074":_babg =_bab .bitshift (stack );case "\u0063e\u0069\u006c\u0069\u006e\u0067":_babg =_bab .ceiling (stack );case "\u0063\u006f\u0070\u0079":_babg =_bab .copy (stack );case "\u0063\u006f\u0073":_babg =_bab .cos (stack );case "\u0063\u0076\u0069":_babg =_bab .cvi (stack );case "\u0063\u0076\u0072":_babg =_bab .cvr (stack );case "\u0064\u0069\u0076":_babg =_bab .div (stack );case "\u0064\u0075\u0070":_babg =_bab .dup (stack );case "\u0065\u0071":_babg =_bab .eq (stack );case "\u0065\u0078\u0063\u0068":_babg =_bab .exch (stack );case "\u0065\u0078\u0070":_babg =_bab .exp (stack );case "\u0066\u006c\u006fo\u0072":_babg =_bab .floor (stack );case "\u0067\u0065":_babg =_bab .ge (stack );case "\u0067\u0074":_babg =_bab .gt (stack );case "\u0069\u0064\u0069\u0076":_babg =_bab .idiv (stack );case "\u0069\u0066":_babg =_bab .ifCondition (stack );case "\u0069\u0066\u0065\u006c\u0073\u0065":_babg =_bab .ifelse (stack );case "\u0069\u006e\u0064e\u0078":_babg =_bab .index (stack );case "\u006c\u0065":_babg =_bab .le (stack );case "\u006c\u006f\u0067":_babg =_bab .log (stack );case "\u006c\u006e":_babg =_bab .ln (stack );case "\u006c\u0074":_babg =_bab .lt (stack );case "\u006d\u006f\u0064":_babg =_bab .mod (stack );case "\u006d\u0075\u006c":_babg =_bab .mul (stack );case "\u006e\u0065":_babg =_bab .ne (stack );case "\u006e\u0065\u0067":_babg =_bab .neg (stack );case "\u006e\u006f\u0074":_babg =_bab .not (stack );case "\u006f\u0072":_babg =_bab .or (stack );case "\u0070\u006f\u0070":_babg =_bab .pop (stack );case "\u0072\u006f\u0075n\u0064":_babg =_bab .round (stack );case "\u0072\u006f\u006c\u006c":_babg =_bab .roll (stack );case "\u0073\u0069\u006e":_babg =_bab .sin (stack );case "\u0073\u0071\u0072\u0074":_babg =_bab .sqrt (stack );case "\u0073\u0075\u0062":_babg =_bab .sub (stack );case "\u0074\u0072\u0075\u006e\u0063\u0061\u0074\u0065":_babg =_bab .truncate (stack );case "\u0078\u006f\u0072":_babg =_bab .xor (stack );};return _babg ;};

// PSBoolean represents a boolean value.
type PSBoolean struct{Val bool ;};func (_fb *PSProgram )DebugString ()string {_cgb :="\u007b\u0020";for _ ,_e :=range *_fb {_cgb +=_e .DebugString ();_cgb +="\u0020";};_cgb +="\u007d";return _cgb ;};func (_aga *PSOperand )String ()string {return string (*_aga )};func (_fea *PSOperand )or (_gbc *PSStack )error {_aaf ,_bag :=_gbc .Pop ();if _bag !=nil {return _bag ;};_cag ,_bag :=_gbc .Pop ();if _bag !=nil {return _bag ;};if _fagd ,_bgdf :=_aaf .(*PSBoolean );_bgdf {_afgc ,_gge :=_cag .(*PSBoolean );if !_gge {return ErrTypeCheck ;};_bag =_gbc .Push (MakeBool (_fagd .Val ||_afgc .Val ));return _bag ;};if _cdg ,_ceg :=_aaf .(*PSInteger );_ceg {_ddd ,_bbea :=_cag .(*PSInteger );if !_bbea {return ErrTypeCheck ;};_bag =_gbc .Push (MakeInteger (_cdg .Val |_ddd .Val ));return _bag ;};return ErrTypeCheck ;};

// Empty empties the stack.
func (_dfca *PSStack )Empty (){*_dfca =[]PSObject {}};func (_ccae *PSOperand )exp (_bade *PSStack )error {_bdf ,_bbda :=_bade .PopNumberAsFloat64 ();if _bbda !=nil {return _bbda ;};_cga ,_bbda :=_bade .PopNumberAsFloat64 ();if _bbda !=nil {return _bbda ;};if _b .Abs (_bdf )< 1&&_cga < 0{return ErrUndefinedResult ;};_fegc :=_b .Pow (_cga ,_bdf );_bbda =_bade .Push (MakeReal (_fegc ));return _bbda ;};const _bfg =0.000001;func (_bbf *PSOperand )ge (_agagg *PSStack )error {_fdc ,_aeef :=_agagg .PopNumberAsFloat64 ();if _aeef !=nil {return _aeef ;};_dfc ,_aeef :=_agagg .PopNumberAsFloat64 ();if _aeef !=nil {return _aeef ;};if _b .Abs (_dfc -_fdc )< _bfg {_aag :=_agagg .Push (MakeBool (true ));return _aag ;}else if _dfc > _fdc {_dcde :=_agagg .Push (MakeBool (true ));return _dcde ;}else {_ecd :=_agagg .Push (MakeBool (false ));return _ecd ;};};func (_cd *PSInteger )DebugString ()string {return _ge .Sprintf ("\u0069\u006e\u0074\u003a\u0025\u0064",_cd .Val );};func (_degf *PSOperand )ln (_eec *PSStack )error {_daf ,_afd :=_eec .PopNumberAsFloat64 ();if _afd !=nil {return _afd ;};_fefab :=_b .Log (_daf );_afd =_eec .Push (MakeReal (_fefab ));return _afd ;};func (_gfdg *PSOperand )truncate (_ffcc *PSStack )error {_aab ,_ebb :=_ffcc .Pop ();if _ebb !=nil {return _ebb ;};if _dcdeg ,_eae :=_aab .(*PSReal );_eae {_bbb :=int (_dcdeg .Val );_ebb =_ffcc .Push (MakeReal (float64 (_bbb )));}else if _bgcf ,_edf :=_aab .(*PSInteger );_edf {_ebb =_ffcc .Push (MakeInteger (_bgcf .Val ));}else {return ErrTypeCheck ;};return _ebb ;};func (_dba *PSBoolean )String ()string {return _ge .Sprintf ("\u0025\u0076",_dba .Val )};

// NewPSParser returns a new instance of the PDF Postscript parser from input data.
func NewPSParser (content []byte )*PSParser {_eac :=PSParser {};_dcce :=_c .NewBuffer (content );_eac ._faef =_gf .NewReader (_dcce );return &_eac ;};

// PopInteger specificially pops an integer from the top of the stack, returning the value as an int.
func (_ccbb *PSStack )PopInteger ()(int ,error ){_adaa ,_bga :=_ccbb .Pop ();if _bga !=nil {return 0,_bga ;};if _ddg ,_bff :=_adaa .(*PSInteger );_bff {return _ddg .Val ,nil ;};return 0,ErrTypeCheck ;};func (_badg *PSOperand )log (_eab *PSStack )error {_ffce ,_egc :=_eab .PopNumberAsFloat64 ();if _egc !=nil {return _egc ;};_cbfa :=_b .Log10 (_ffce );_egc =_eab .Push (MakeReal (_cbfa ));return _egc ;};

// PSExecutor has its own execution stack and is used to executre a PS routine (program).
type PSExecutor struct{Stack *PSStack ;_ca *PSProgram ;};func (_dbga *PSParser )parseBool ()(*PSBoolean ,error ){_effe ,_dbfd :=_dbga ._faef .Peek (4);if _dbfd !=nil {return MakeBool (false ),_dbfd ;};if (len (_effe )>=4)&&(string (_effe [:4])=="\u0074\u0072\u0075\u0065"){_dbga ._faef .Discard (4);return MakeBool (true ),nil ;};_effe ,_dbfd =_dbga ._faef .Peek (5);if _dbfd !=nil {return MakeBool (false ),_dbfd ;};if (len (_effe )>=5)&&(string (_effe [:5])=="\u0066\u0061\u006cs\u0065"){_dbga ._faef .Discard (5);return MakeBool (false ),nil ;};return MakeBool (false ),_d .New ("\u0075n\u0065\u0078\u0070\u0065c\u0074\u0065\u0064\u0020\u0062o\u006fl\u0065a\u006e\u0020\u0073\u0074\u0072\u0069\u006eg");};

// NewPSProgram returns an empty, initialized PSProgram.
func NewPSProgram ()*PSProgram {return &PSProgram {}};func (_fg *PSProgram )Duplicate ()PSObject {_ae :=&PSProgram {};for _ ,_abd :=range *_fg {_ae .Append (_abd .Duplicate ());};return _ae ;};func (_feb *PSOperand )mul (_afa *PSStack )error {_dcf ,_ceee :=_afa .Pop ();if _ceee !=nil {return _ceee ;};_eed ,_ceee :=_afa .Pop ();if _ceee !=nil {return _ceee ;};_acac ,_dgc :=_dcf .(*PSReal );_ccb ,_dee :=_dcf .(*PSInteger );if !_dgc &&!_dee {return ErrTypeCheck ;};_bgeg ,_gff :=_eed .(*PSReal );_ecfg ,_bce :=_eed .(*PSInteger );if !_gff &&!_bce {return ErrTypeCheck ;};if _dee &&_bce {_aea :=_ccb .Val *_ecfg .Val ;_gaee :=_afa .Push (MakeInteger (_aea ));return _gaee ;};var _gdd float64 ;if _dgc {_gdd =_acac .Val ;}else {_gdd =float64 (_ccb .Val );};if _gff {_gdd *=_bgeg .Val ;}else {_gdd *=float64 (_ecfg .Val );};_ceee =_afa .Push (MakeReal (_gdd ));return _ceee ;};func (_fedcg *PSParser )parseOperand ()(*PSOperand ,error ){var _gdc []byte ;for {_begg ,_gcda :=_fedcg ._faef .Peek (1);if _gcda !=nil {if _gcda ==_gb .EOF {break ;};return nil ,_gcda ;};if _a .IsDelimiter (_begg [0]){break ;};if _a .IsWhiteSpace (_begg [0]){break ;};_gcef ,_ :=_fedcg ._faef .ReadByte ();_gdc =append (_gdc ,_gcef );};if len (_gdc )==0{return nil ,_d .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 (_gdc )),nil ;};func (_fccc *PSOperand )atan (_dfgg *PSStack )error {_fcf ,_ed :=_dfgg .PopNumberAsFloat64 ();if _ed !=nil {return _ed ;};_bbe ,_ed :=_dfgg .PopNumberAsFloat64 ();if _ed !=nil {return _ed ;};if _fcf ==0{var _gae error ;if _bbe < 0{_gae =_dfgg .Push (MakeReal (270));}else {_gae =_dfgg .Push (MakeReal (90));};return _gae ;};_gca :=_bbe /_fcf ;_bgf :=_b .Atan (_gca )*180/_b .Pi ;_ed =_dfgg .Push (MakeReal (_bgf ));return _ed ;};func (_afbeb *PSParser )skipSpaces ()(int ,error ){_bbac :=0;for {_cda ,_dacf :=_afbeb ._faef .Peek (1);if _dacf !=nil {return 0,_dacf ;};if _a .IsWhiteSpace (_cda [0]){_afbeb ._faef .ReadByte ();_bbac ++;}else {break ;};};return _bbac ,nil ;};

// PSParser is a basic Postscript parser.
type PSParser struct{_faef *_gf .Reader };func (_dbg *PSReal )DebugString ()string {return _ge .Sprintf ("\u0072e\u0061\u006c\u003a\u0025\u002e\u0035f",_dbg .Val );};func (_cbgf *PSOperand )floor (_fdf *PSStack )error {_dcg ,_cbgb :=_fdf .Pop ();if _cbgb !=nil {return _cbgb ;};if _eb ,_bcae :=_dcg .(*PSReal );_bcae {_cbgb =_fdf .Push (MakeReal (_b .Floor (_eb .Val )));}else if _gaf ,_dgd :=_dcg .(*PSInteger );_dgd {_cbgb =_fdf .Push (MakeInteger (_gaf .Val ));}else {return ErrTypeCheck ;};return _cbgb ;};func (_cf *PSProgram )String ()string {_fd :="\u007b\u0020";for _ ,_ffc :=range *_cf {_fd +=_ffc .String ();_fd +="\u0020";};_fd +="\u007d";return _fd ;};func (_dbe *PSReal )Duplicate ()PSObject {_ag :=PSReal {};_ag .Val =_dbe .Val ;return &_ag };

// Parse parses the postscript and store as a program that can be executed.
func (_ecaa *PSParser )Parse ()(*PSProgram ,error ){_ecaa .skipSpaces ();_faae ,_adg :=_ecaa ._faef .Peek (2);if _adg !=nil {return nil ,_adg ;};if _faae [0]!='{'{return nil ,_d .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");};_bdfa ,_adg :=_ecaa .parseFunction ();if _adg !=nil &&_adg !=_gb .EOF {return nil ,_adg ;};return _bdfa ,_adg ;};func (_dbf *PSOperand )sqrt (_abed *PSStack )error {_egd ,_edg :=_abed .PopNumberAsFloat64 ();if _edg !=nil {return _edg ;};if _egd < 0{return ErrRangeCheck ;};_eecg :=_b .Sqrt (_egd );_edg =_abed .Push (MakeReal (_eecg ));return _edg ;};

// NewPSExecutor returns an initialized PSExecutor for an input `program`.
func NewPSExecutor (program *PSProgram )*PSExecutor {_bg :=&PSExecutor {};_bg .Stack =NewPSStack ();_bg ._ca =program ;return _bg ;};func (_dca *PSOperand )ifelse (_ade *PSStack )error {_fgbbd ,_dec :=_ade .Pop ();if _dec !=nil {return _dec ;};_dbec ,_dec :=_ade .Pop ();if _dec !=nil {return _dec ;};_gac ,_dec :=_ade .Pop ();if _dec !=nil {return _dec ;};_ccaa ,_cea :=_fgbbd .(*PSProgram );if !_cea {return ErrTypeCheck ;};_bfc ,_cea :=_dbec .(*PSProgram );if !_cea {return ErrTypeCheck ;};_bgcg ,_cea :=_gac .(*PSBoolean );if !_cea {return ErrTypeCheck ;};if _bgcg .Val {_gbfb :=_bfc .Exec (_ade );return _gbfb ;};_dec =_ccaa .Exec (_ade );return _dec ;};var ErrUnsupportedOperand =_d .New ("\u0075\u006e\u0073\u0075pp\u006f\u0072\u0074\u0065\u0064\u0020\u006f\u0070\u0065\u0072\u0061\u006e\u0064");func (_bcb *PSParser )parseNumber ()(PSObject ,error ){_egbf ,_cgfc :=_a .ParseNumber (_bcb ._faef );if _cgfc !=nil {return nil ,_cgfc ;};switch _gaaa :=_egbf .(type ){case *_a .PdfObjectFloat :return MakeReal (float64 (*_gaaa )),nil ;case *_a .PdfObjectInteger :return MakeInteger (int (*_gaaa )),nil ;};return nil ,_ge .Errorf ("\u0075n\u0068\u0061\u006e\u0064\u006c\u0065\u0064\u0020\u006e\u0075\u006db\u0065\u0072\u0020\u0074\u0079\u0070\u0065\u0020\u0025\u0054",_egbf );};func (_bgd *PSBoolean )Duplicate ()PSObject {_cg :=PSBoolean {};_cg .Val =_bgd .Val ;return &_cg };func (_cgbg *PSOperand )index (_agca *PSStack )error {_ccc ,_bdfd :=_agca .Pop ();if _bdfd !=nil {return _bdfd ;};_gfa ,_gcf :=_ccc .(*PSInteger );if !_gcf {return ErrTypeCheck ;};if _gfa .Val < 0{return ErrRangeCheck ;};if _gfa .Val > len (*_agca )-1{return ErrStackUnderflow ;};_cfec :=(*_agca )[len (*_agca )-1-_gfa .Val ];_bdfd =_agca .Push (_cfec .Duplicate ());return _bdfd ;};

// MakeReal returns a new PSReal object initialized with `val`.
func MakeReal (val float64 )*PSReal {_edee :=PSReal {};_edee .Val =val ;return &_edee };var ErrUndefinedResult =_d .New ("\u0075\u006e\u0064\u0065fi\u006e\u0065\u0064\u0020\u0072\u0065\u0073\u0075\u006c\u0074\u0020\u0065\u0072\u0072o\u0072");func (_abf *PSOperand )ifCondition (_fec *PSStack )error {_cdbb ,_cace :=_fec .Pop ();if _cace !=nil {return _cace ;};_cbgfa ,_cace :=_fec .Pop ();if _cace !=nil {return _cace ;};_fag ,_ecf :=_cdbb .(*PSProgram );if !_ecf {return ErrTypeCheck ;};_cacd ,_ecf :=_cbgfa .(*PSBoolean );if !_ecf {return ErrTypeCheck ;};if _cacd .Val {_ecba :=_fag .Exec (_fec );return _ecba ;};return nil ;};func (_fef *PSOperand )DebugString ()string {return _ge .Sprintf ("\u006fp\u003a\u0027\u0025\u0073\u0027",*_fef );};func (_abee *PSOperand )sin (_geg *PSStack )error {_ebc ,_ccdd :=_geg .PopNumberAsFloat64 ();if _ccdd !=nil {return _ccdd ;};_bae :=_b .Sin (_ebc *_b .Pi /180.0);_ccdd =_geg .Push (MakeReal (_bae ));return _ccdd ;};

// PSStack defines a stack of PSObjects. PSObjects can be pushed on or pull from the stack.
type PSStack []PSObject ;func (_gfc *PSOperand )eq (_cac *PSStack )error {_fdb ,_ega :=_cac .Pop ();if _ega !=nil {return _ega ;};_agg ,_ega :=_cac .Pop ();if _ega !=nil {return _ega ;};_bbd ,_fad :=_fdb .(*PSBoolean );_gga ,_cgga :=_agg .(*PSBoolean );if _fad ||_cgga {var _bfe error ;if _fad &&_cgga {_bfe =_cac .Push (MakeBool (_bbd .Val ==_gga .Val ));}else {_bfe =_cac .Push (MakeBool (false ));};return _bfe ;};var _deg float64 ;var _cca float64 ;if _gcb ,_cddd :=_fdb .(*PSInteger );_cddd {_deg =float64 (_gcb .Val );}else if _dga ,_gaa :=_fdb .(*PSReal );_gaa {_deg =_dga .Val ;}else {return ErrTypeCheck ;};if _bcaa ,_eee :=_agg .(*PSInteger );_eee {_cca =float64 (_bcaa .Val );}else if _fba ,_cbf :=_agg .(*PSReal );_cbf {_cca =_fba .Val ;}else {return ErrTypeCheck ;};if _b .Abs (_cca -_deg )< _bfg {_ega =_cac .Push (MakeBool (true ));}else {_ega =_cac .Push (MakeBool (false ));};return _ega ;};func (_ceea *PSOperand )round (_bfec *PSStack )error {_ffdd ,_dggd :=_bfec .Pop ();if _dggd !=nil {return _dggd ;};if _gdfg ,_aaga :=_ffdd .(*PSReal );_aaga {_dggd =_bfec .Push (MakeReal (_b .Floor (_gdfg .Val +0.5)));}else if _afgcc ,_def :=_ffdd .(*PSInteger );_def {_dggd =_bfec .Push (MakeInteger (_afgcc .Val ));}else {return ErrTypeCheck ;};return _dggd ;};

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

// PopNumberAsFloat64 pops and return the numeric value of the top of the stack as a float64.
// Real or integer only.
func (_eeg *PSStack )PopNumberAsFloat64 ()(float64 ,error ){_fcfc ,_egcf :=_eeg .Pop ();if _egcf !=nil {return 0,_egcf ;};if _eeaa ,_bgec :=_fcfc .(*PSReal );_bgec {return _eeaa .Val ,nil ;}else if _gfca ,_aec :=_fcfc .(*PSInteger );_aec {return float64 (_gfca .Val ),nil ;}else {return 0,ErrTypeCheck ;};};

// MakeBool returns a new PSBoolean object initialized with `val`.
func MakeBool (val bool )*PSBoolean {_adgf :=PSBoolean {};_adgf .Val =val ;return &_adgf };func (_gedg *PSOperand )gt (_age *PSStack )error {_dgad ,_gce :=_age .PopNumberAsFloat64 ();if _gce !=nil {return _gce ;};_eeb ,_gce :=_age .PopNumberAsFloat64 ();if _gce !=nil {return _gce ;};if _b .Abs (_eeb -_dgad )< _bfg {_acb :=_age .Push (MakeBool (false ));return _acb ;}else if _eeb > _dgad {_cddb :=_age .Push (MakeBool (true ));return _cddb ;}else {_cfe :=_age .Push (MakeBool (false ));return _cfe ;};};

// MakeOperand returns a new PSOperand object based on string `val`.
func MakeOperand (val string )*PSOperand {_eecd :=PSOperand (val );return &_eecd };func (_eea *PSOperand )dup (_fefa *PSStack )error {_egg ,_bdd :=_fefa .Pop ();if _bdd !=nil {return _bdd ;};_bdd =_fefa .Push (_egg );if _bdd !=nil {return _bdd ;};_bdd =_fefa .Push (_egg .Duplicate ());return _bdd ;};func (_ab *PSInteger )Duplicate ()PSObject {_fee :=PSInteger {};_fee .Val =_ab .Val ;return &_fee };func (_eg *PSOperand )ceiling (_fab *PSStack )error {_adc ,_gba :=_fab .Pop ();if _gba !=nil {return _gba ;};if _gec ,_dac :=_adc .(*PSReal );_dac {_gba =_fab .Push (MakeReal (_b .Ceil (_gec .Val )));}else if _cce ,_fgbb :=_adc .(*PSInteger );_fgbb {_gba =_fab .Push (MakeInteger (_cce .Val ));}else {_gba =ErrTypeCheck ;};return _gba ;};func (_adee *PSOperand )pop (_cccf *PSStack )error {_ ,_dcfg :=_cccf .Pop ();if _dcfg !=nil {return _dcfg ;};return nil ;};

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