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 (_e "bufio";_fb "bytes";_g "errors";_ed "fmt";_c "github.com/unidoc/unipdf/v3/common";_ge "github.com/unidoc/unipdf/v3/core";_b "io";_bd "math";);func (_acae *PSOperand )log (_faba *PSStack )error {_dbedd ,_egg :=_faba .PopNumberAsFloat64 ();if _egg !=nil {return _egg ;};_eddc :=_bd .Log10 (_dbedd );_egg =_faba .Push (MakeReal (_eddc ));return _egg ;};func (_ff *PSBoolean )Duplicate ()PSObject {_ee :=PSBoolean {};_ee .Val =_ff .Val ;return &_ee };var ErrTypeCheck =_g .New ("\u0074\u0079p\u0065\u0020\u0063h\u0065\u0063\u006b\u0020\u0065\u0072\u0072\u006f\u0072");func (_cgd *PSOperand )idiv (_abc *PSStack )error {_gbb ,_bgg :=_abc .Pop ();if _bgg !=nil {return _bgg ;};_cfe ,_bgg :=_abc .Pop ();if _bgg !=nil {return _bgg ;};_gdc ,_dcfda :=_gbb .(*PSInteger );if !_dcfda {return ErrTypeCheck ;};if _gdc .Val ==0{return ErrUndefinedResult ;};_acb ,_dcfda :=_cfe .(*PSInteger );if !_dcfda {return ErrTypeCheck ;};_dbeg :=_acb .Val /_gdc .Val ;_bgg =_abc .Push (MakeInteger (_dbeg ));return _bgg ;};func (_bdc *PSInteger )DebugString ()string {return _ed .Sprintf ("\u0069\u006e\u0074\u003a\u0025\u0064",_bdc .Val );};func (_cgb *PSReal )String ()string {return _ed .Sprintf ("\u0025\u002e\u0035\u0066",_cgb .Val )};var ErrUndefinedResult =_g .New ("\u0075\u006e\u0064\u0065fi\u006e\u0065\u0064\u0020\u0072\u0065\u0073\u0075\u006c\u0074\u0020\u0065\u0072\u0072o\u0072");func (_bac *PSOperand )ne (_ffgg *PSStack )error {_ecd :=_bac .eq (_ffgg );if _ecd !=nil {return _ecd ;};_ecd =_bac .not (_ffgg );return _ecd ;};func (_dcf *PSProgram )Duplicate ()PSObject {_ce :=&PSProgram {};for _ ,_ag :=range *_dcf {_ce .Append (_ag .Duplicate ());};return _ce ;};func (_dce *PSOperand )Duplicate ()PSObject {_agg :=*_dce ;return &_agg };

// 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 _ ,_bc :=range objects {_ef :=_d .Stack .Push (_bc );if _ef !=nil {return nil ,_ef ;};};_bf :=_d ._cg .Exec (_d .Stack );if _bf !=nil {_c .Log .Debug ("\u0045x\u0065c\u0020\u0066\u0061\u0069\u006c\u0065\u0064\u003a\u0020\u0025\u0076",_bf );return nil ,_bf ;};_db :=[]PSObject (*_d .Stack );_d .Stack .Empty ();return _db ,nil ;};func (_fcf *PSOperand )abs (_eeg *PSStack )error {_eed ,_bce :=_eeg .Pop ();if _bce !=nil {return _bce ;};if _ba ,_deg :=_eed .(*PSReal );_deg {_geb :=_ba .Val ;if _geb < 0{_bce =_eeg .Push (MakeReal (-_geb ));}else {_bce =_eeg .Push (MakeReal (_geb ));};}else if _eb ,_dbe :=_eed .(*PSInteger );_dbe {_ede :=_eb .Val ;if _ede < 0{_bce =_eeg .Push (MakeInteger (-_ede ));}else {_bce =_eeg .Push (MakeInteger (_ede ));};}else {return ErrTypeCheck ;};return _bce ;};func (_deb *PSOperand )bitshift (_ffd *PSStack )error {_cgfc ,_ecf :=_ffd .PopInteger ();if _ecf !=nil {return _ecf ;};_eaf ,_ecf :=_ffd .PopInteger ();if _ecf !=nil {return _ecf ;};var _dcg int ;if _cgfc >=0{_dcg =_eaf <<uint (_cgfc );}else {_dcg =_eaf >>uint (-_cgfc );};_ecf =_ffd .Push (MakeInteger (_dcg ));return _ecf ;};func (_bdcb *PSOperand )exch (_dba *PSStack )error {_gaa ,_cca :=_dba .Pop ();if _cca !=nil {return _cca ;};_ecg ,_cca :=_dba .Pop ();if _cca !=nil {return _cca ;};_cca =_dba .Push (_gaa );if _cca !=nil {return _cca ;};_cca =_dba .Push (_ecg );return _cca ;};func (_fea *PSOperand )lt (_cddg *PSStack )error {_bff ,_dcb :=_cddg .PopNumberAsFloat64 ();if _dcb !=nil {return _dcb ;};_dbedg ,_dcb :=_cddg .PopNumberAsFloat64 ();if _dcb !=nil {return _dcb ;};if _bd .Abs (_dbedg -_bff )< _a {_gbc :=_cddg .Push (MakeBool (false ));return _gbc ;}else if _dbedg < _bff {_gab :=_cddg .Push (MakeBool (true ));return _gab ;}else {_eegd :=_cddg .Push (MakeBool (false ));return _eegd ;};};func (_dcc *PSOperand )exp (_gfg *PSStack )error {_bag ,_eaga :=_gfg .PopNumberAsFloat64 ();if _eaga !=nil {return _eaga ;};_dgc ,_eaga :=_gfg .PopNumberAsFloat64 ();if _eaga !=nil {return _eaga ;};if _bd .Abs (_bag )< 1&&_dgc < 0{return ErrUndefinedResult ;};_age :=_bd .Pow (_dgc ,_bag );_eaga =_gfg .Push (MakeReal (_age ));return _eaga ;};func (_dg *PSOperand )eq (_acf *PSStack )error {_bfe ,_bfee :=_acf .Pop ();if _bfee !=nil {return _bfee ;};_gee ,_bfee :=_acf .Pop ();if _bfee !=nil {return _bfee ;};_bcad ,_dbgg :=_bfe .(*PSBoolean );_cff ,_cceb :=_gee .(*PSBoolean );if _dbgg ||_cceb {var _bfea error ;if _dbgg &&_cceb {_bfea =_acf .Push (MakeBool (_bcad .Val ==_cff .Val ));}else {_bfea =_acf .Push (MakeBool (false ));};return _bfea ;};var _eded float64 ;var _bgb float64 ;if _ebd ,_fae :=_bfe .(*PSInteger );_fae {_eded =float64 (_ebd .Val );}else if _afa ,_ceeg :=_bfe .(*PSReal );_ceeg {_eded =_afa .Val ;}else {return ErrTypeCheck ;};if _gf ,_dfc :=_gee .(*PSInteger );_dfc {_bgb =float64 (_gf .Val );}else if _beb ,_efg :=_gee .(*PSReal );_efg {_bgb =_beb .Val ;}else {return ErrTypeCheck ;};if _bd .Abs (_bgb -_eded )< _a {_bfee =_acf .Push (MakeBool (true ));}else {_bfee =_acf .Push (MakeBool (false ));};return _bfee ;};func (_gce *PSParser )skipSpaces ()(int ,error ){_ggbg :=0;for {_gggg ,_ceg :=_gce ._cdgb .Peek (1);if _ceg !=nil {return 0,_ceg ;};if _ge .IsWhiteSpace (_gggg [0]){_gce ._cdgb .ReadByte ();_ggbg ++;}else {break ;};};return _ggbg ,nil ;};func (_cf *PSInteger )String ()string {return _ed .Sprintf ("\u0025\u0064",_cf .Val )};func (_fded *PSOperand )mod (_cgge *PSStack )error {_dde ,_gcb :=_cgge .Pop ();if _gcb !=nil {return _gcb ;};_cdc ,_gcb :=_cgge .Pop ();if _gcb !=nil {return _gcb ;};_caec ,_bfb :=_dde .(*PSInteger );if !_bfb {return ErrTypeCheck ;};if _caec .Val ==0{return ErrUndefinedResult ;};_ecbe ,_bfb :=_cdc .(*PSInteger );if !_bfb {return ErrTypeCheck ;};_baga :=_ecbe .Val %_caec .Val ;_gcb =_cgge .Push (MakeInteger (_baga ));return _gcb ;};func (_fab *PSOperand )copy (_cceg *PSStack )error {_afg ,_cgg :=_cceg .PopInteger ();if _cgg !=nil {return _cgg ;};if _afg < 0{return ErrRangeCheck ;};if _afg > len (*_cceg ){return ErrRangeCheck ;};*_cceg =append (*

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

// PopInteger specificially pops an integer from the top of the stack, returning the value as an int.
func (_gad *PSStack )PopInteger ()(int ,error ){_bfa ,_fccc :=_gad .Pop ();if _fccc !=nil {return 0,_fccc ;};if _acg ,_fcdc :=_bfa .(*PSInteger );_fcdc {return _acg .Val ,nil ;};return 0,ErrTypeCheck ;};

// Exec executes the program, typically leaving output values on the stack.
func (_ec *PSProgram )Exec (stack *PSStack )error {for _ ,_ea :=range *_ec {var _aad error ;switch _egd :=_ea .(type ){case *PSInteger :_bbf :=_egd ;_aad =stack .Push (_bbf );case *PSReal :_bfc :=_egd ;_aad =stack .Push (_bfc );case *PSBoolean :_eda :=_egd ;_aad =stack .Push (_eda );case *PSProgram :_bfce :=_egd ;_aad =stack .Push (_bfce );case *PSOperand :_fd :=_egd ;_aad =_fd .Exec (stack );default:return ErrTypeCheck ;};if _aad !=nil {return _aad ;};};return nil ;};func (_bae *PSParser )parseFunction ()(*PSProgram ,error ){_aae ,_ :=_bae ._cdgb .ReadByte ();if _aae !='{'{return nil ,_g .New ("\u0069\u006ev\u0061\u006c\u0069d\u0020\u0066\u0075\u006e\u0063\u0074\u0069\u006f\u006e");};_bdeb :=NewPSProgram ();for {_bae .skipSpaces ();_gdgc ,_acd :=_bae ._cdgb .Peek (2);if _acd !=nil {if _acd ==_b .EOF {break ;};return nil ,_acd ;};_c .Log .Trace ("\u0050e\u0065k\u0020\u0073\u0074\u0072\u0069\u006e\u0067\u003a\u0020\u0025\u0073",string (_gdgc ));if _gdgc [0]=='}'{_c .Log .Trace ("\u0045\u004f\u0046 \u0066\u0075\u006e\u0063\u0074\u0069\u006f\u006e");_bae ._cdgb .ReadByte ();break ;}else if _gdgc [0]=='{'{_c .Log .Trace ("\u0046u\u006e\u0063\u0074\u0069\u006f\u006e!");_bgc ,_febd :=_bae .parseFunction ();if _febd !=nil {return nil ,_febd ;};_bdeb .Append (_bgc );}else if _ge .IsDecimalDigit (_gdgc [0])||(_gdgc [0]=='-'&&_ge .IsDecimalDigit (_gdgc [1])){_c .Log .Trace ("\u002d>\u004e\u0075\u006d\u0062\u0065\u0072!");_efa ,_edf :=_bae .parseNumber ();if _edf !=nil {return nil ,_edf ;};_bdeb .Append (_efa );}else {_c .Log .Trace ("\u002d>\u004fp\u0065\u0072\u0061\u006e\u0064 \u006f\u0072 \u0062\u006f\u006f\u006c\u003f");_gdgc ,_ =_bae ._cdgb .Peek (5);_ecdf :=string (_gdgc );_c .Log .Trace ("\u0050\u0065\u0065k\u0020\u0073\u0074\u0072\u003a\u0020\u0025\u0073",_ecdf );if (len (_ecdf )> 4)&&(_ecdf [:5]=="\u0066\u0061\u006cs\u0065"){_aafa ,_dcda :=_bae .parseBool ();if _dcda !=nil {return nil ,_dcda ;};_bdeb .Append (_aafa );}else if (len (_ecdf )> 3)&&(_ecdf [:4]=="\u0074\u0072\u0075\u0065"){_dfcd ,_fceb :=_bae .parseBool ();if _fceb !=nil {return nil ,_fceb ;};_bdeb .Append (_dfcd );}else {_fec ,_fba :=_bae .parseOperand ();if _fba !=nil {return nil ,_fba ;};_bdeb .Append (_fec );};};};return _bdeb ,nil ;};

// MakeInteger returns a new PSInteger object initialized with `val`.
func MakeInteger (val int )*PSInteger {_egc :=PSInteger {};_egc .Val =val ;return &_egc };func (_dbedb *PSParser )parseNumber ()(PSObject ,error ){_dec ,_ddd :=_ge .ParseNumber (_dbedb ._cdgb );if _ddd !=nil {return nil ,_ddd ;};switch _ggcf :=_dec .(type ){case *_ge .PdfObjectFloat :return MakeReal (float64 (*_ggcf )),nil ;case *_ge .PdfObjectInteger :return MakeInteger (int (*_ggcf )),nil ;};return nil ,_ed .Errorf ("\u0075n\u0068\u0061\u006e\u0064\u006c\u0065\u0064\u0020\u006e\u0075\u006db\u0065\u0072\u0020\u0074\u0079\u0070\u0065\u0020\u0025\u0054",_dec );};func (_cgc *PSInteger )Duplicate ()PSObject {_aaf :=PSInteger {};_aaf .Val =_cgc .Val ;return &_aaf };func (_geba *PSOperand )gt (_ab *PSStack )error {_eacf ,_aed :=_ab .PopNumberAsFloat64 ();if _aed !=nil {return _aed ;};_bcbe ,_aed :=_ab .PopNumberAsFloat64 ();if _aed !=nil {return _aed ;};if _bd .Abs (_bcbe -_eacf )< _a {_fcec :=_ab .Push (MakeBool (false ));return _fcec ;}else if _bcbe > _eacf {_aadce :=_ab .Push (MakeBool (true ));return _aadce ;}else {_bbd :=_ab .Push (MakeBool (false ));return _bbd ;};};func (_edb *PSOperand )cvr (_bcda *PSStack )error {_cb ,_agc :=_bcda .Pop ();if _agc !=nil {return _agc ;};if _cggg ,_gc :=_cb .(*PSReal );_gc {_agc =_bcda .Push (MakeReal (_cggg .Val ));}else if _ggf ,_fcb :=_cb .(*PSInteger );_fcb {_agc =_bcda .Push (MakeReal (float64 (_ggf .Val )));}else {return ErrTypeCheck ;};return _agc ;};func (_ca *PSReal )Duplicate ()PSObject {_eg :=PSReal {};_eg .Val =_ca .Val ;return &_eg };

// 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 _cd []float64 ;for _ ,_gea :=range objects {if _gd ,_fe :=_gea .(*PSInteger );_fe {_cd =append (_cd ,float64 (_gd .Val ));}else if _fc ,_aa :=_gea .(*PSReal );_aa {_cd =append (_cd ,_fc .Val );}else {return nil ,ErrTypeCheck ;};};return _cd ,nil ;};

// Empty empties the stack.
func (_bgfg *PSStack )Empty (){*_bgfg =[]PSObject {}};

// PSExecutor has its own execution stack and is used to executre a PS routine (program).
type PSExecutor struct{Stack *PSStack ;_cg *PSProgram ;};func (_efd *PSOperand )roll (_cag *PSStack )error {_ffgb ,_bfd :=_cag .Pop ();if _bfd !=nil {return _bfd ;};_ffbb ,_bfd :=_cag .Pop ();if _bfd !=nil {return _bfd ;};_ceb ,_ddbg :=_ffgb .(*PSInteger );if !_ddbg {return ErrTypeCheck ;};_dbag ,_ddbg :=_ffbb .(*PSInteger );if !_ddbg {return ErrTypeCheck ;};if _dbag .Val < 0{return ErrRangeCheck ;};if _dbag .Val ==0||_dbag .Val ==1{return nil ;};if _dbag .Val > len (*_cag ){return ErrStackUnderflow ;};for _adg :=0;_adg < _fgf (_ceb .Val );_adg ++{var _fbff []PSObject ;_fbff =(*_cag )[len (*_cag )-(_dbag .Val ):len (*_cag )];if _ceb .Val > 0{_ddg :=_fbff [len (_fbff )-1];_fbff =append ([]PSObject {_ddg },_fbff [0:len (_fbff )-1]...);}else {_eccf :=_fbff [len (_fbff )-_dbag .Val ];_fbff =append (_fbff [1:],_eccf );};_fdf :=append ((*_cag )[0:len (*_cag )-_dbag .Val ],_fbff ...);_cag =&_fdf ;};return nil ;};func (_aggg *PSOperand )index (_gba *PSStack )error {_bbb ,_bebe :=_gba .Pop ();if _bebe !=nil {return _bebe ;};_fcde ,_aee :=_bbb .(*PSInteger );if !_aee {return ErrTypeCheck ;};if _fcde .Val < 0{return ErrRangeCheck ;};if _fcde .Val > len (*_gba )-1{return ErrStackUnderflow ;};_degf :=(*_gba )[len (*_gba )-1-_fcde .Val ];_bebe =_gba .Push (_degf .Duplicate ());return _bebe ;};func (_eac *PSOperand )atan (_afeg *PSStack )error {_gdg ,_aadc :=_afeg .PopNumberAsFloat64 ();if _aadc !=nil {return _aadc ;};_gge ,_aadc :=_afeg .PopNumberAsFloat64 ();if _aadc !=nil {return _aadc ;};if _gdg ==0{var _geag error ;if _gge < 0{_geag =_afeg .Push (MakeReal (270));}else {_geag =_afeg .Push (MakeReal (90));};return _geag ;};_fa :=_gge /_gdg ;_ceef :=_bd .Atan (_fa )*180/_bd .Pi ;_aadc =_afeg .Push (MakeReal (_ceef ));return _aadc ;};const _a =0.000001;func (_ecdd *PSOperand )not (_gae *PSStack )error {_edc ,_gcd :=_gae .Pop ();if _gcd !=nil {return _gcd ;};if _edce ,_beg :=_edc .(*PSBoolean );_beg {_gcd =_gae .Push (MakeBool (!_edce .Val ));return _gcd ;}else if _gcg ,_bcab :=_edc .(*PSInteger );_bcab {_gcd =_gae .Push (MakeInteger (^_gcg .Val ));return _gcd ;}else {return ErrTypeCheck ;};};func (_aca *PSOperand )ifCondition (_adac *PSStack )error {_geaf ,_cbe :=_adac .Pop ();if _cbe !=nil {return _cbe ;};_bad ,_cbe :=_adac .Pop ();if _cbe !=nil {return _cbe ;};_fde ,_ggfa :=_geaf .(*PSProgram );if !_ggfa {return ErrTypeCheck ;};_cfa ,_ggfa :=_bad .(*PSBoolean );if !_ggfa {return ErrTypeCheck ;};if _cfa .Val {_aab :=_fde .Exec (_adac );return _aab ;};return nil ;};func (_dcfd *PSOperand )and (_cga *PSStack )error {_cgf ,_dcfe :=_cga .Pop ();if _dcfe !=nil {return _dcfe ;};_cce ,_dcfe :=_cga .Pop ();if _dcfe !=nil {return _dcfe ;};if _ecc ,_dbf :=_cgf .(*PSBoolean );_dbf {_gdfb ,_fbf :=_cce .(*PSBoolean );if !_fbf {return ErrTypeCheck ;};_dcfe =_cga .Push (MakeBool (_ecc .Val &&_gdfb .Val ));return _dcfe ;};if _cae ,_afe :=_cgf .(*PSInteger );_afe {_eeee ,_aec :=_cce .(*PSInteger );if !_aec {return ErrTypeCheck ;};_dcfe =_cga .Push (MakeInteger (_cae .Val &_eeee .Val ));return _dcfe ;};return ErrTypeCheck ;};

// PSReal represents a real number.
type PSReal struct{Val float64 ;};func (_bfbb *PSOperand )sin (_bcdd *PSStack )error {_cab ,_aaaf :=_bcdd .PopNumberAsFloat64 ();if _aaaf !=nil {return _aaaf ;};_cadd :=_bd .Sin (_cab *_bd .Pi /180.0);_aaaf =_bcdd .Push (MakeReal (_cadd ));return _aaaf ;};func (_ggbf *PSOperand )truncate (_efb *PSStack )error {_fdcd ,_afcc :=_efb .Pop ();if _afcc !=nil {return _afcc ;};if _eaac ,_gac :=_fdcd .(*PSReal );_gac {_fag :=int (_eaac .Val );_afcc =_efb .Push (MakeReal (float64 (_fag )));}else if _aff ,_efff :=_fdcd .(*PSInteger );_efff {_afcc =_efb .Push (MakeInteger (_aff .Val ));}else {return ErrTypeCheck ;};return _afcc ;};var ErrStackOverflow =_g .New ("\u0073\u0074\u0061\u0063\u006b\u0020\u006f\u0076\u0065r\u0066\u006c\u006f\u0077");

// Append appends an object to the PSProgram.
func (_gedb *PSProgram )Append (obj PSObject ){*_gedb =append (*_gedb ,obj )};func (_ga *PSOperand )add (_fbd *PSStack )error {_be ,_fbga :=_fbd .Pop ();if _fbga !=nil {return _fbga ;};_feb ,_fbga :=_fbd .Pop ();if _fbga !=nil {return _fbga ;};_bdg ,_gg :=_be .(*PSReal );_feg ,_eaa :=_be .(*PSInteger );if !_gg &&!_eaa {return ErrTypeCheck ;};_dbg ,_cee :=_feb .(*PSReal );_cc ,_fg :=_feb .(*PSInteger );if !_cee &&!_fg {return ErrTypeCheck ;};if _eaa &&_fg {_bca :=_feg .Val +_cc .Val ;_ebe :=_fbd .Push (MakeInteger (_bca ));return _ebe ;};var _eee float64 ;if _gg {_eee =_bdg .Val ;}else {_eee =float64 (_feg .Val );};if _cee {_eee +=_dbg .Val ;}else {_eee +=float64 (_cc .Val );};_fbga =_fbd .Push (MakeReal (_eee ));return _fbga ;};

// Pop pops an object from the top of the stack.
func (_bfdf *PSStack )Pop ()(PSObject ,error ){if len (*_bfdf )< 1{return nil ,ErrStackUnderflow ;};_eae :=(*_bfdf )[len (*_bfdf )-1];*_bfdf =(*_bfdf )[0:len (*_bfdf )-1];return _eae ,nil ;};func (_bg *PSBoolean )String ()string {return _ed .Sprintf ("\u0025\u0076",_bg .Val )};func (_ad *PSOperand )String ()string {return string (*_ad )};

// PSOperand represents a Postscript operand (text string).
type PSOperand string ;

// PSParser is a basic Postscript parser.
type PSParser struct{_cdgb *_e .Reader };func (_eff *PSOperand )le (_aaad *PSStack )error {_effa ,_agce :=_aaad .PopNumberAsFloat64 ();if _agce !=nil {return _agce ;};_ggc ,_agce :=_aaad .PopNumberAsFloat64 ();if _agce !=nil {return _agce ;};if _bd .Abs (_ggc -_effa )< _a {_ead :=_aaad .Push (MakeBool (true ));return _ead ;}else if _ggc < _effa {_gfab :=_aaad .Push (MakeBool (true ));return _gfab ;}else {_geg :=_aaad .Push (MakeBool (false ));return _geg ;};};func (_eea *PSOperand )sub (_bee *PSStack )error {_dccf ,_ceca :=_bee .Pop ();if _ceca !=nil {return _ceca ;};_dege ,_ceca :=_bee .Pop ();if _ceca !=nil {return _ceca ;};_egb ,_bfbd :=_dccf .(*PSReal );_bebf ,_aea :=_dccf .(*PSInteger );if !_bfbd &&!_aea {return ErrTypeCheck ;};_bcec ,_ebba :=_dege .(*PSReal );_fge ,_cfg :=_dege .(*PSInteger );if !_ebba &&!_cfg {return ErrTypeCheck ;};if _aea &&_cfg {_afd :=_fge .Val -_bebf .Val ;_bda :=_bee .Push (MakeInteger (_afd ));return _bda ;};var _cde float64 =0;if _ebba {_cde =_bcec .Val ;}else {_cde =float64 (_fge .Val );};if _bfbd {_cde -=_egb .Val ;}else {_cde -=float64 (_bebf .Val );};_ceca =_bee .Push (MakeReal (_cde ));return _ceca ;};func _fgf (_egba int )int {if _egba < 0{return -_egba ;};return _egba ;};func (_aabd *PSOperand )mul (_def *PSStack )error {_ded ,_bdef :=_def .Pop ();if _bdef !=nil {return _bdef ;};_bgbg ,_bdef :=_def .Pop ();if _bdef !=nil {return _bdef ;};_aag ,_ggg :=_ded .(*PSReal );_afc ,_da :=_ded .(*PSInteger );if !_ggg &&!_da {return ErrTypeCheck ;};_gafg ,_ccegb :=_bgbg .(*PSReal );_geac ,_bba :=_bgbg .(*PSInteger );if !_ccegb &&!_bba {return ErrTypeCheck ;};if _da &&_bba {_dgg :=_afc .Val *_geac .Val ;_dgcc :=_def .Push (MakeInteger (_dgg ));return _dgcc ;};var _eca float64 ;if _ggg {_eca =_aag .Val ;}else {_eca =float64 (_afc .Val );};if _ccegb {_eca *=_gafg .Val ;}else {_eca *=float64 (_geac .Val );};_bdef =_def .Push (MakeReal (_eca ));return _bdef ;};

// MakeReal returns a new PSReal object initialized with `val`.
func MakeReal (val float64 )*PSReal {_acbe :=PSReal {};_acbe .Val =val ;return &_acbe };func (_bdcc *PSOperand )ceiling (_bab *PSStack )error {_bdgb ,_cfc :=_bab .Pop ();if _cfc !=nil {return _cfc ;};if _faf ,_fcd :=_bdgb .(*PSReal );_fcd {_cfc =_bab .Push (MakeReal (_bd .Ceil (_faf .Val )));}else if _ggb ,_gb :=_bdgb .(*PSInteger );_gb {_cfc =_bab .Push (MakeInteger (_ggb .Val ));}else {_cfc =ErrTypeCheck ;};return _cfc ;};func (_fcc *PSOperand )or (_bdce *PSStack )error {_bcg ,_bgge :=_bdce .Pop ();if _bgge !=nil {return _bgge ;};_gabd ,_bgge :=_bdce .Pop ();if _bgge !=nil {return _bgge ;};if _ggff ,_adc :=_bcg .(*PSBoolean );_adc {_fbde ,_fdc :=_gabd .(*PSBoolean );if !_fdc {return ErrTypeCheck ;};_bgge =_bdce .Push (MakeBool (_ggff .Val ||_fbde .Val ));return _bgge ;};if _fcg ,_cgaf :=_bcg .(*PSInteger );_cgaf {_fcecb ,_cfcd :=_gabd .(*PSInteger );if !_cfcd {return ErrTypeCheck ;};_bgge =_bdce .Push (MakeInteger (_fcg .Val |_fcecb .Val ));return _bgge ;};return ErrTypeCheck ;};func (_aada *PSParser )parseOperand ()(*PSOperand ,error ){var _eba []byte ;for {_ggbd ,_gace :=_aada ._cdgb .Peek (1);if _gace !=nil {if _gace ==_b .EOF {break ;};return nil ,_gace ;};if _ge .IsDelimiter (_ggbd [0]){break ;};if _ge .IsWhiteSpace (_ggbd [0]){break ;};_gefc ,_ :=_aada ._cdgb .ReadByte ();_eba =append (_eba ,_gefc );};if len (_eba )==0{return nil ,_g .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 (_eba )),nil ;};var ErrRangeCheck =_g .New ("\u0072\u0061\u006e\u0067\u0065\u0020\u0063\u0068\u0065\u0063\u006b\u0020e\u0072\u0072\u006f\u0072");

// NewPSExecutor returns an initialized PSExecutor for an input `program`.
func NewPSExecutor (program *PSProgram )*PSExecutor {_ged :=&PSExecutor {};_ged .Stack =NewPSStack ();_ged ._cg =program ;return _ged ;};func (_bbga *PSOperand )xor (_fff *PSStack )error {_dac ,_gddc :=_fff .Pop ();if _gddc !=nil {return _gddc ;};_ecdgg ,_gddc :=_fff .Pop ();if _gddc !=nil {return _gddc ;};if _ecbf ,_dfg :=_dac .(*PSBoolean );_dfg {_dbc ,_gfc :=_ecdgg .(*PSBoolean );if !_gfc {return ErrTypeCheck ;};_gddc =_fff .Push (MakeBool (_ecbf .Val !=_dbc .Val ));return _gddc ;};if _dge ,_cdg :=_dac .(*PSInteger );_cdg {_bcabf ,_gdce :=_ecdgg .(*PSInteger );if !_gdce {return ErrTypeCheck ;};_gddc =_fff .Push (MakeInteger (_dge .Val ^_bcabf .Val ));return _gddc ;};return ErrTypeCheck ;};func (_geeg *PSOperand )pop (_agb *PSStack )error {_ ,_ecdg :=_agb .Pop ();if _ecdg !=nil {return _ecdg ;};return nil ;};

// NewPSParser returns a new instance of the PDF Postscript parser from input data.
func NewPSParser (content []byte )*PSParser {_cdee :=PSParser {};_ebga :=_fb .NewBuffer (content );_cdee ._cdgb =_e .NewReader (_ebga );return &_cdee ;};func (_ggcb *PSOperand )round (_aga *PSStack )error {_eagf ,_cafg :=_aga .Pop ();if _cafg !=nil {return _cafg ;};if _geff ,_gda :=_eagf .(*PSReal );_gda {_cafg =_aga .Push (MakeReal (_bd .Floor (_geff .Val +0.5)));}else if _feae ,_baa :=_eagf .(*PSInteger );_baa {_cafg =_aga .Push (MakeInteger (_feae .Val ));}else {return ErrTypeCheck ;};return _cafg ;};

// NewPSStack returns an initialized PSStack.
func NewPSStack ()*PSStack {return &PSStack {}};func (_bcd *PSOperand )DebugString ()string {return _ed .Sprintf ("\u006fp\u003a\u0027\u0025\u0073\u0027",*_bcd );};func (_ebg *PSOperand )cos (_ceee *PSStack )error {_dfe ,_ecb :=_ceee .PopNumberAsFloat64 ();if _ecb !=nil {return _ecb ;};_fac :=_bd .Cos (_dfe *_bd .Pi /180.0);_ecb =_ceee .Push (MakeReal (_fac ));return _ecb ;};func (_ace *PSOperand )dup (_fcba *PSStack )error {_afga ,_gcc :=_fcba .Pop ();if _gcc !=nil {return _gcc ;};_gcc =_fcba .Push (_afga );if _gcc !=nil {return _gcc ;};_gcc =_fcba .Push (_afga .Duplicate ());return _gcc ;};

// MakeOperand returns a new PSOperand object based on string `val`.
func MakeOperand (val string )*PSOperand {_cfd :=PSOperand (val );return &_cfd };

// PSBoolean represents a boolean value.
type PSBoolean struct{Val bool ;};func (_gacc *PSParser )parseBool ()(*PSBoolean ,error ){_aeg ,_eadb :=_gacc ._cdgb .Peek (4);if _eadb !=nil {return MakeBool (false ),_eadb ;};if (len (_aeg )>=4)&&(string (_aeg [:4])=="\u0074\u0072\u0075\u0065"){_gacc ._cdgb .Discard (4);return MakeBool (true ),nil ;};_aeg ,_eadb =_gacc ._cdgb .Peek (5);if _eadb !=nil {return MakeBool (false ),_eadb ;};if (len (_aeg )>=5)&&(string (_aeg [:5])=="\u0066\u0061\u006cs\u0065"){_gacc ._cdgb .Discard (5);return MakeBool (false ),nil ;};return MakeBool (false ),_g .New ("\u0075n\u0065\u0078\u0070\u0065c\u0074\u0065\u0064\u0020\u0062o\u006fl\u0065a\u006e\u0020\u0073\u0074\u0072\u0069\u006eg");};

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

// NewPSProgram returns an empty, initialized PSProgram.
func NewPSProgram ()*PSProgram {return &PSProgram {}};

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

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

// Push pushes an object on top of the stack.
func (_gcda *PSStack )Push (obj PSObject )error {if len (*_gcda )> 100{return ErrStackOverflow ;};*_gcda =append (*_gcda ,obj );return nil ;};func (_de *PSReal )DebugString ()string {return _ed .Sprintf ("\u0072e\u0061\u006c\u003a\u0025\u002e\u0035f",_de .Val );};func (_ecgc *PSOperand )sqrt (_dbbc *PSStack )error {_cba ,_bfeeb :=_dbbc .PopNumberAsFloat64 ();if _bfeeb !=nil {return _bfeeb ;};if _cba < 0{return ErrRangeCheck ;};_cfab :=_bd .Sqrt (_cba );_bfeeb =_dbbc .Push (MakeReal (_cfab ));return _bfeeb ;};func (_afbe *PSOperand )div (_gef *PSStack )error {_fce ,_cccd :=_gef .Pop ();if _cccd !=nil {return _cccd ;};_dd ,_cccd :=_gef .Pop ();if _cccd !=nil {return _cccd ;};_cda ,_cecf :=_fce .(*PSReal );_bcb ,_bbfa :=_fce .(*PSInteger );if !_cecf &&!_bbfa {return ErrTypeCheck ;};if _cecf &&_cda .Val ==0{return ErrUndefinedResult ;};if _bbfa &&_bcb .Val ==0{return ErrUndefinedResult ;};_ada ,_fgd :=_dd .(*PSReal );_afgc ,_dbed :=_dd .(*PSInteger );if !_fgd &&!_dbed {return ErrTypeCheck ;};var _dbb float64 ;if _fgd {_dbb =_ada .Val ;}else {_dbb =float64 (_afgc .Val );};if _cecf {_dbb /=_cda .Val ;}else {_dbb /=float64 (_bcb .Val );};_cccd =_gef .Push (MakeReal (_dbb ));return _cccd ;};func (_aecc *PSOperand )ln (_eec *PSStack )error {_edbb ,_ddb :=_eec .PopNumberAsFloat64 ();if _ddb !=nil {return _ddb ;};_ffb :=_bd .Log (_edbb );_ddb =_eec .Push (MakeReal (_ffb ));return _ddb ;};

// PSInteger represents an integer.
type PSInteger struct{Val int ;};func (_ac *PSOperand )cvi (_fdd *PSStack )error {_cad ,_eag :=_fdd .Pop ();if _eag !=nil {return _eag ;};if _cggd ,_cea :=_cad .(*PSReal );_cea {_ccc :=int (_cggd .Val );_eag =_fdd .Push (MakeInteger (_ccc ));}else if _fgb ,_ggba :=_cad .(*PSInteger );_ggba {_afb :=_fgb .Val ;_eag =_fdd .Push (MakeInteger (_afb ));}else {return ErrTypeCheck ;};return _eag ;};var ErrUnsupportedOperand =_g .New ("\u0075\u006e\u0073\u0075pp\u006f\u0072\u0074\u0065\u0064\u0020\u006f\u0070\u0065\u0072\u0061\u006e\u0064");

// PopNumberAsFloat64 pops and return the numeric value of the top of the stack as a float64.
// Real or integer only.
func (_eada *PSStack )PopNumberAsFloat64 ()(float64 ,error ){_bge ,_eegg :=_eada .Pop ();if _eegg !=nil {return 0,_eegg ;};if _ecdgc ,_ggef :=_bge .(*PSReal );_ggef {return _ecdgc .Val ,nil ;}else if _gbae ,_bcgg :=_bge .(*PSInteger );_bcgg {return float64 (_gbae .Val ),nil ;}else {return 0,ErrTypeCheck ;};};

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

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

// Parse parses the postscript and store as a program that can be executed.
func (_ccea *PSParser )Parse ()(*PSProgram ,error ){_ccea .skipSpaces ();_dgeb ,_ecgd :=_ccea ._cdgb .Peek (2);if _ecgd !=nil {return nil ,_ecgd ;};if _dgeb [0]!='{'{return nil ,_g .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");};_cagf ,_ecgd :=_ccea .parseFunction ();if _ecgd !=nil &&_ecgd !=_b .EOF {return nil ,_ecgd ;};return _cagf ,_ecgd ;};func (_df *PSBoolean )DebugString ()string {return _ed .Sprintf ("\u0062o\u006f\u006c\u003a\u0025\u0076",_df .Val );};func (_gdf *PSProgram )String ()string {_bbg :="\u007b\u0020";for _ ,_bgf :=range *_gdf {_bbg +=_bgf .String ();_bbg +="\u0020";};_bbg +="\u007d";return _bbg ;};func (_bcba *PSOperand )floor (_aaa *PSStack )error {_gfa ,_bed :=_aaa .Pop ();if _bed !=nil {return _bed ;};if _fef ,_gfd :=_gfa .(*PSReal );_gfd {_bed =_aaa .Push (MakeReal (_bd .Floor (_fef .Val )));}else if _cgab ,_gaf :=_gfa .(*PSInteger );_gaf {_bed =_aaa .Push (MakeInteger (_cgab .Val ));}else {return ErrTypeCheck ;};return _bed ;};var ErrStackUnderflow =_g .New ("\u0073t\u0061c\u006b\u0020\u0075\u006e\u0064\u0065\u0072\u0066\u006c\u006f\u0077");func (_fdg *PSOperand )ge (_cdd *PSStack )error {_cbc ,_ffdg :=_cdd .PopNumberAsFloat64 ();if _ffdg !=nil {return _ffdg ;};_bbfe ,_ffdg :=_cdd .PopNumberAsFloat64 ();if _ffdg !=nil {return _ffdg ;};if _bd .Abs (_bbfe -_cbc )< _a {_bga :=_cdd .Push (MakeBool (true ));return _bga ;}else if _bbfe > _cbc {_ece :=_cdd .Push (MakeBool (true ));return _ece ;}else {_ebb :=_cdd .Push (MakeBool (false ));return _ebb ;};};func (_af *PSProgram )DebugString ()string {_gdd :="\u007b\u0020";for _ ,_dc :=range *_af {_gdd +=_dc .DebugString ();_gdd +="\u0020";};_gdd +="\u007d";return _gdd ;};

// Exec executes the operand `op` in the state specified by `stack`.
func (_ffg *PSOperand )Exec (stack *PSStack )error {_bde :=ErrUnsupportedOperand ;switch *_ffg {case "\u0061\u0062\u0073":_bde =_ffg .abs (stack );case "\u0061\u0064\u0064":_bde =_ffg .add (stack );case "\u0061\u006e\u0064":_bde =_ffg .and (stack );case "\u0061\u0074\u0061\u006e":_bde =_ffg .atan (stack );case "\u0062\u0069\u0074\u0073\u0068\u0069\u0066\u0074":_bde =_ffg .bitshift (stack );case "\u0063e\u0069\u006c\u0069\u006e\u0067":_bde =_ffg .ceiling (stack );case "\u0063\u006f\u0070\u0079":_bde =_ffg .copy (stack );case "\u0063\u006f\u0073":_bde =_ffg .cos (stack );case "\u0063\u0076\u0069":_bde =_ffg .cvi (stack );case "\u0063\u0076\u0072":_bde =_ffg .cvr (stack );case "\u0064\u0069\u0076":_bde =_ffg .div (stack );case "\u0064\u0075\u0070":_bde =_ffg .dup (stack );case "\u0065\u0071":_bde =_ffg .eq (stack );case "\u0065\u0078\u0063\u0068":_bde =_ffg .exch (stack );case "\u0065\u0078\u0070":_bde =_ffg .exp (stack );case "\u0066\u006c\u006fo\u0072":_bde =_ffg .floor (stack );case "\u0067\u0065":_bde =_ffg .ge (stack );case "\u0067\u0074":_bde =_ffg .gt (stack );case "\u0069\u0064\u0069\u0076":_bde =_ffg .idiv (stack );case "\u0069\u0066":_bde =_ffg .ifCondition (stack );case "\u0069\u0066\u0065\u006c\u0073\u0065":_bde =_ffg .ifelse (stack );case "\u0069\u006e\u0064e\u0078":_bde =_ffg .index (stack );case "\u006c\u0065":_bde =_ffg .le (stack );case "\u006c\u006f\u0067":_bde =_ffg .log (stack );case "\u006c\u006e":_bde =_ffg .ln (stack );case "\u006c\u0074":_bde =_ffg .lt (stack );case "\u006d\u006f\u0064":_bde =_ffg .mod (stack );case "\u006d\u0075\u006c":_bde =_ffg .mul (stack );case "\u006e\u0065":_bde =_ffg .ne (stack );case "\u006e\u0065\u0067":_bde =_ffg .neg (stack );case "\u006e\u006f\u0074":_bde =_ffg .not (stack );case "\u006f\u0072":_bde =_ffg .or (stack );case "\u0070\u006f\u0070":_bde =_ffg .pop (stack );case "\u0072\u006f\u0075n\u0064":_bde =_ffg .round (stack );case "\u0072\u006f\u006c\u006c":_bde =_ffg .roll (stack );case "\u0073\u0069\u006e":_bde =_ffg .sin (stack );case "\u0073\u0071\u0072\u0074":_bde =_ffg .sqrt (stack );case "\u0073\u0075\u0062":_bde =_ffg .sub (stack );case "\u0074\u0072\u0075\u006e\u0063\u0061\u0074\u0065":_bde =_ffg .truncate (stack );case "\u0078\u006f\u0072":_bde =_ffg .xor (stack );};return _bde ;};func (_ffa *PSOperand )ifelse (_aaff *PSStack )error {_eacg ,_ddc :=_aaff .Pop ();if _ddc !=nil {return _ddc ;};_dbeda ,_ddc :=_aaff .Pop ();if _ddc !=nil {return _ddc ;};_fbfe ,_ddc :=_aaff .Pop ();if _ddc !=nil {return _ddc ;};_dcce ,_ffe :=_eacg .(*PSProgram );if !_ffe {return ErrTypeCheck ;};_baf ,_ffe :=_dbeda .(*PSProgram );if !_ffe {return ErrTypeCheck ;};_afgaf ,_ffe :=_fbfe .(*PSBoolean );if !_ffe {return ErrTypeCheck ;};if _afgaf .Val {_dcgd :=_baf .Exec (_aaff );return _dcgd ;};_ddc =_dcce .Exec (_aaff );return _ddc ;};func (_ddce *PSOperand )neg (_dcd *PSStack )error {_bffa ,_face :=_dcd .Pop ();if _face !=nil {return _face ;};if _geef ,_caf :=_bffa .(*PSReal );_caf {_face =_dcd .Push (MakeReal (-_geef .Val ));return _face ;}else if _ddef ,_gdde :=_bffa .(*PSInteger );_gdde {_face =_dcd .Push (MakeInteger (-_ddef .Val ));return _face ;}else {return ErrTypeCheck ;};};