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 (_fe "bufio";_d "bytes";_e "errors";_fg "fmt";_b "github.com/unidoc/unipdf/v3/common";_feb "github.com/unidoc/unipdf/v3/core";_ea "io";_eg "math";);func (_ffac *PSOperand )sin (_ddb *PSStack )error {_afgc ,_geea :=_ddb .PopNumberAsFloat64 ();if _geea !=nil {return _geea ;};_eafa :=_eg .Sin (_afgc *_eg .Pi /180.0);_geea =_ddb .Push (MakeReal (_eafa ));return _geea ;};func (_dbe *PSOperand )copy (_cddb *PSStack )error {_deg ,_gab :=_cddb .PopInteger ();if _gab !=nil {return _gab ;};if _deg < 0{return ErrRangeCheck ;};if _deg > len (*_cddb ){return ErrRangeCheck ;};*_cddb =append (*_cddb ,(*_cddb )[len (*_cddb )-_deg :]...);return nil ;};func (_cab *PSOperand )DebugString ()string {return _fg .Sprintf ("\u006fp\u003a\u0027\u0025\u0073\u0027",*_cab );};

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

// MakeBool returns a new PSBoolean object initialized with `val`.
func MakeBool (val bool )*PSBoolean {_ade :=PSBoolean {};_ade .Val =val ;return &_ade };func (_gdg *PSOperand )ifCondition (_caff *PSStack )error {_edc ,_afc :=_caff .Pop ();if _afc !=nil {return _afc ;};_aac ,_afc :=_caff .Pop ();if _afc !=nil {return _afc ;};_gbfd ,_abad :=_edc .(*PSProgram );if !_abad {return ErrTypeCheck ;};_cba ,_abad :=_aac .(*PSBoolean );if !_abad {return ErrTypeCheck ;};if _cba .Val {_eaf :=_gbfd .Exec (_caff );return _eaf ;};return nil ;};

// Exec executes the program, typically leaving output values on the stack.
func (_cdd *PSProgram )Exec (stack *PSStack )error {for _ ,_fdf :=range *_cdd {var _fgd error ;switch _dcg :=_fdf .(type ){case *PSInteger :_cfd :=_dcg ;_fgd =stack .Push (_cfd );case *PSReal :_caa :=_dcg ;_fgd =stack .Push (_caa );case *PSBoolean :_fc :=_dcg ;_fgd =stack .Push (_fc );case *PSProgram :_egf :=_dcg ;_fgd =stack .Push (_egf );case *PSOperand :_geb :=_dcg ;_fgd =_geb .Exec (stack );default:return ErrTypeCheck ;};if _fgd !=nil {return _fgd ;};};return nil ;};func (_ge *PSInteger )Duplicate ()PSObject {_c :=PSInteger {};_c .Val =_ge .Val ;return &_c };func (_decc *PSOperand )sub (_fgdb *PSStack )error {_gce ,_gadb :=_fgdb .Pop ();if _gadb !=nil {return _gadb ;};_ddga ,_gadb :=_fgdb .Pop ();if _gadb !=nil {return _gadb ;};_agg ,_dcec :=_gce .(*PSReal );_badc ,_gefb :=_gce .(*PSInteger );if !_dcec &&!_gefb {return ErrTypeCheck ;};_efd ,_acg :=_ddga .(*PSReal );_aaa ,_fdd :=_ddga .(*PSInteger );if !_acg &&!_fdd {return ErrTypeCheck ;};if _gefb &&_fdd {_gca :=_aaa .Val -_badc .Val ;_ffef :=_fgdb .Push (MakeInteger (_gca ));return _ffef ;};var _bbcfb float64 =0;if _acg {_bbcfb =_efd .Val ;}else {_bbcfb =float64 (_aaa .Val );};if _dcec {_bbcfb -=_agg .Val ;}else {_bbcfb -=float64 (_badc .Val );};_gadb =_fgdb .Push (MakeReal (_bbcfb ));return _gadb ;};var ErrTypeCheck =_e .New ("\u0074\u0079p\u0065\u0020\u0063h\u0065\u0063\u006b\u0020\u0065\u0072\u0072\u006f\u0072");

// MakeOperand returns a new PSOperand object based on string `val`.
func MakeOperand (val string )*PSOperand {_gfeea :=PSOperand (val );return &_gfeea };func (_cbe *PSOperand )gt (_cae *PSStack )error {_ded ,_gec :=_cae .PopNumberAsFloat64 ();if _gec !=nil {return _gec ;};_dbed ,_gec :=_cae .PopNumberAsFloat64 ();if _gec !=nil {return _gec ;};if _eg .Abs (_dbed -_ded )< _a {_eea :=_cae .Push (MakeBool (false ));return _eea ;}else if _dbed > _ded {_fda :=_cae .Push (MakeBool (true ));return _fda ;}else {_egb :=_cae .Push (MakeBool (false ));return _egb ;};};

// 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 _ff []float64 ;for _ ,_ac :=range objects {if _acc ,_g :=_ac .(*PSInteger );_g {_ff =append (_ff ,float64 (_acc .Val ));}else if _eb ,_af :=_ac .(*PSReal );_af {_ff =append (_ff ,_eb .Val );}else {return nil ,ErrTypeCheck ;};};return _ff ,nil ;};func (_cag *PSOperand )add (_dac *PSStack )error {_bae ,_gcb :=_dac .Pop ();if _gcb !=nil {return _gcb ;};_baf ,_gcb :=_dac .Pop ();if _gcb !=nil {return _gcb ;};_bbd ,_dea :=_bae .(*PSReal );_ffg ,_df :=_bae .(*PSInteger );if !_dea &&!_df {return ErrTypeCheck ;};_dec ,_agf :=_baf .(*PSReal );_bdc ,_gbc :=_baf .(*PSInteger );if !_agf &&!_gbc {return ErrTypeCheck ;};if _df &&_gbc {_ffb :=_ffg .Val +_bdc .Val ;_gee :=_dac .Push (MakeInteger (_ffb ));return _gee ;};var _adg float64 =0;if _dea {_adg =_bbd .Val ;}else {_adg =float64 (_ffg .Val );};if _agf {_adg +=_dec .Val ;}else {_adg +=float64 (_bdc .Val );};_gcb =_dac .Push (MakeReal (_adg ));return _gcb ;};var ErrRangeCheck =_e .New ("\u0072\u0061\u006e\u0067\u0065\u0020\u0063\u0068\u0065\u0063\u006b\u0020e\u0072\u0072\u006f\u0072");func (_cce *PSOperand )lt (_cbfa *PSStack )error {_agcf ,_gag :=_cbfa .PopNumberAsFloat64 ();if _gag !=nil {return _gag ;};_fggb ,_gag :=_cbfa .PopNumberAsFloat64 ();if _gag !=nil {return _gag ;};if _eg .Abs (_fggb -_agcf )< _a {_cgc :=_cbfa .Push (MakeBool (false ));return _cgc ;}else if _fggb < _agcf {_dggb :=_cbfa .Push (MakeBool (true ));return _dggb ;}else {_bbdg :=_cbfa .Push (MakeBool (false ));return _bbdg ;};};func _abbb (_dfaa int )int {if _dfaa < 0{return -_dfaa ;};return _dfaa ;};var ErrUndefinedResult =_e .New ("\u0075\u006e\u0064\u0065fi\u006e\u0065\u0064\u0020\u0072\u0065\u0073\u0075\u006c\u0074\u0020\u0065\u0072\u0072o\u0072");func (_ag *PSProgram )DebugString ()string {_gb :="\u007b\u0020";for _ ,_ffc :=range *_ag {_gb +=_ffc .DebugString ();_gb +="\u0020";};_gb +="\u007d";return _gb ;};func (_agfa *PSOperand )div (_cda *PSStack )error {_dbd ,_dcge :=_cda .Pop ();if _dcge !=nil {return _dcge ;};_cdf ,_dcge :=_cda .Pop ();if _dcge !=nil {return _dcge ;};_bbcf ,_dd :=_dbd .(*PSReal );_acb ,_ada :=_dbd .(*PSInteger );if !_dd &&!_ada {return ErrTypeCheck ;};if _dd &&_bbcf .Val ==0{return ErrUndefinedResult ;};if _ada &&_acb .Val ==0{return ErrUndefinedResult ;};_fcg ,_bafe :=_cdf .(*PSReal );_eeb ,_gd :=_cdf .(*PSInteger );if !_bafe &&!_gd {return ErrTypeCheck ;};var _cca float64 =0;if _bafe {_cca =_fcg .Val ;}else {_cca =float64 (_eeb .Val );};if _dd {_cca /=_bbcf .Val ;}else {_cca /=float64 (_acb .Val );};_dcge =_cda .Push (MakeReal (_cca ));return _dcge ;};func (_ebab *PSOperand )mod (_fbd *PSStack )error {_adbe ,_gdgg :=_fbd .Pop ();if _gdgg !=nil {return _gdgg ;};_edg ,_gdgg :=_fbd .Pop ();if _gdgg !=nil {return _gdgg ;};_gfg ,_bcag :=_adbe .(*PSInteger );if !_bcag {return ErrTypeCheck ;};if _gfg .Val ==0{return ErrUndefinedResult ;};_ecc ,_bcag :=_edg .(*PSInteger );if !_bcag {return ErrTypeCheck ;};_cgdd :=_ecc .Val %_gfg .Val ;_gdgg =_fbd .Push (MakeInteger (_cgdd ));return _gdgg ;};func (_dcc *PSOperand )dup (_bcc *PSStack )error {_fgg ,_eggd :=_bcc .Pop ();if _eggd !=nil {return _eggd ;};_eggd =_bcc .Push (_fgg );if _eggd !=nil {return _eggd ;};_eggd =_bcc .Push (_fgg .Duplicate ());return _eggd ;};func (_ebd *PSOperand )bitshift (_dgb *PSStack )error {_dgf ,_ed :=_dgb .PopInteger ();if _ed !=nil {return _ed ;};_bgec ,_ed :=_dgb .PopInteger ();if _ed !=nil {return _ed ;};var _eca int ;if _dgf >=0{_eca =_bgec <<uint (_dgf );}else {_eca =_bgec >>uint (-_dgf );};_ed =_dgb .Push (MakeInteger (_eca ));return _ed ;};func (_cegf *PSOperand )atan (_dee *PSStack )error {_adb ,_aag :=_dee .PopNumberAsFloat64 ();if _aag !=nil {return _aag ;};_egg ,_aag :=_dee .PopNumberAsFloat64 ();if _aag !=nil {return _aag ;};if _adb ==0{var _bba error ;if _egg < 0{_bba =_dee .Push (MakeReal (270));}else {_bba =_dee .Push (MakeReal (90));};return _bba ;};_cdde :=_egg /_adb ;_dfgf :=_eg .Atan (_cdde )*180/_eg .Pi ;_aag =_dee .Push (MakeReal (_dfgf ));return _aag ;};

// PopNumberAsFloat64 pops and return the numeric value of the top of the stack as a float64.
// Real or integer only.
func (_ccea *PSStack )PopNumberAsFloat64 ()(float64 ,error ){_ebc ,_gfa :=_ccea .Pop ();if _gfa !=nil {return 0,_gfa ;};if _bgfd ,_ffgd :=_ebc .(*PSReal );_ffgd {return _bgfd .Val ,nil ;}else if _gagc ,_ggd :=_ebc .(*PSInteger );_ggd {return float64 (_gagc .Val ),nil ;}else {return 0,ErrTypeCheck ;};};func (_ebb *PSOperand )sqrt (_gbag *PSStack )error {_fcfe ,_dcaa :=_gbag .PopNumberAsFloat64 ();if _dcaa !=nil {return _dcaa ;};if _fcfe < 0{return ErrRangeCheck ;};_gad :=_eg .Sqrt (_fcfe );_dcaa =_gbag .Push (MakeReal (_gad ));return _dcaa ;};func (_dce *PSOperand )cvr (_gbf *PSStack )error {_bbc ,_ega :=_gbf .Pop ();if _ega !=nil {return _ega ;};if _baa ,_ebf :=_bbc .(*PSReal );_ebf {_ega =_gbf .Push (MakeReal (_baa .Val ));}else if _bdad ,_dead :=_bbc .(*PSInteger );_dead {_ega =_gbf .Push (MakeReal (float64 (_bdad .Val )));}else {return ErrTypeCheck ;};return _ega ;};

// PSInteger represents an integer.
type PSInteger struct{Val int ;};func (_bf *PSProgram )String ()string {_ca :="\u007b\u0020";for _ ,_afg :=range *_bf {_ca +=_afg .String ();_ca +="\u0020";};_ca +="\u007d";return _ca ;};func (_gae *PSOperand )ln (_edce *PSStack )error {_gdb ,_gacg :=_edce .PopNumberAsFloat64 ();if _gacg !=nil {return _gacg ;};_cabc :=_eg .Log (_gdb );_gacg =_edce .Push (MakeReal (_cabc ));return _gacg ;};

// Append appends an object to the PSProgram.
func (_aa *PSProgram )Append (obj PSObject ){*_aa =append (*_aa ,obj )};func (_bbg *PSOperand )ne (_cfaa *PSStack )error {_bbgd :=_bbg .eq (_cfaa );if _bbgd !=nil {return _bbgd ;};_bbgd =_bbg .not (_cfaa );return _bbgd ;};func (_ga *PSProgram )Duplicate ()PSObject {_db :=&PSProgram {};for _ ,_caf :=range *_ga {_db .Append (_caf .Duplicate ());};return _db ;};

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

// 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 (_ad *PSOperand )String ()string {return _fg .Sprintf ("\u0025\u0073",*_ad )};func (_gc *PSOperand )Duplicate ()PSObject {_fde :=*_gc ;return &_fde };func (_bbde *PSOperand )ceiling (_bda *PSStack )error {_decb ,_ace :=_bda .Pop ();if _ace !=nil {return _ace ;};if _efc ,_gef :=_decb .(*PSReal );_gef {_ace =_bda .Push (MakeReal (_eg .Ceil (_efc .Val )));}else if _deb ,_edb :=_decb .(*PSInteger );_edb {_ace =_bda .Push (MakeInteger (_deb .Val ));}else {_ace =ErrTypeCheck ;};return _ace ;};func (_bgge *PSParser )parseFunction ()(*PSProgram ,error ){_fge ,_ :=_bgge ._gde .ReadByte ();if _fge !='{'{return nil ,_e .New ("\u0069\u006ev\u0061\u006c\u0069d\u0020\u0066\u0075\u006e\u0063\u0074\u0069\u006f\u006e");};_gccd :=NewPSProgram ();for {_bgge .skipSpaces ();_fbdf ,_dbc :=_bgge ._gde .Peek (2);if _dbc !=nil {if _dbc ==_ea .EOF {break ;};return nil ,_dbc ;};_b .Log .Trace ("\u0050e\u0065k\u0020\u0073\u0074\u0072\u0069\u006e\u0067\u003a\u0020\u0025\u0073",string (_fbdf ));if _fbdf [0]=='}'{_b .Log .Trace ("\u0045\u004f\u0046 \u0066\u0075\u006e\u0063\u0074\u0069\u006f\u006e");_bgge ._gde .ReadByte ();break ;}else if _fbdf [0]=='{'{_b .Log .Trace ("\u0046u\u006e\u0063\u0074\u0069\u006f\u006e!");_fce ,_faa :=_bgge .parseFunction ();if _faa !=nil {return nil ,_faa ;};_gccd .Append (_fce );}else if _feb .IsDecimalDigit (_fbdf [0])||(_fbdf [0]=='-'&&_feb .IsDecimalDigit (_fbdf [1])){_b .Log .Trace ("\u002d>\u004e\u0075\u006d\u0062\u0065\u0072!");_bbgg ,_gcaa :=_bgge .parseNumber ();if _gcaa !=nil {return nil ,_gcaa ;};_gccd .Append (_bbgg );}else {_b .Log .Trace ("\u002d>\u004fp\u0065\u0072\u0061\u006e\u0064 \u006f\u0072 \u0062\u006f\u006f\u006c\u003f");_fbdf ,_ =_bgge ._gde .Peek (5);_fafb :=string (_fbdf );_b .Log .Trace ("\u0050\u0065\u0065k\u0020\u0073\u0074\u0072\u003a\u0020\u0025\u0073",_fafb );if (len (_fafb )> 4)&&(_fafb [:5]=="\u0066\u0061\u006cs\u0065"){_fbgc ,_abce :=_bgge .parseBool ();if _abce !=nil {return nil ,_abce ;};_gccd .Append (_fbgc );}else if (len (_fafb )> 3)&&(_fafb [:4]=="\u0074\u0072\u0075\u0065"){_afbf ,_baad :=_bgge .parseBool ();if _baad !=nil {return nil ,_baad ;};_gccd .Append (_afbf );}else {_aadb ,_cedb :=_bgge .parseOperand ();if _cedb !=nil {return nil ,_cedb ;};_gccd .Append (_aadb );};};};return _gccd ,nil ;};func (_dbdc *PSOperand )floor (_abc *PSStack )error {_cfa ,_gdd :=_abc .Pop ();if _gdd !=nil {return _gdd ;};if _cfe ,_cdbc :=_cfa .(*PSReal );_cdbc {_gdd =_abc .Push (MakeReal (_eg .Floor (_cfe .Val )));}else if _cac ,_ede :=_cfa .(*PSInteger );_ede {_gdd =_abc .Push (MakeInteger (_cac .Val ));}else {return ErrTypeCheck ;};return _gdd ;};const _a =0.000001;func (_gf *PSBoolean )String ()string {return _fg .Sprintf ("\u0025\u0076",_gf .Val )};func (_dbb *PSOperand )cvi (_dba *PSStack )error {_gabc ,_fgc :=_dba .Pop ();if _fgc !=nil {return _fgc ;};if _gebg ,_bef :=_gabc .(*PSReal );_bef {_afgb :=int (_gebg .Val );_fgc =_dba .Push (MakeInteger (_afgb ));}else if _cdbb ,_efa :=_gabc .(*PSInteger );_efa {_decd :=_cdbb .Val ;_fgc =_dba .Push (MakeInteger (_decd ));}else {return ErrTypeCheck ;};return _fgc ;};func (_gaa *PSOperand )roll (_gggf *PSStack )error {_caae ,_edcc :=_gggf .Pop ();if _edcc !=nil {return _edcc ;};_bcd ,_edcc :=_gggf .Pop ();if _edcc !=nil {return _edcc ;};_abae ,_ggae :=_caae .(*PSInteger );if !_ggae {return ErrTypeCheck ;};_bgag ,_ggae :=_bcd .(*PSInteger );if !_ggae {return ErrTypeCheck ;};if _bgag .Val < 0{return ErrRangeCheck ;};if _bgag .Val ==0||_bgag .Val ==1{return nil ;};if _bgag .Val > len (*_gggf ){return ErrStackUnderflow ;};for _fdb :=0;_fdb < _abbb (_abae .Val );_fdb ++{var _ggf []PSObject ;_ggf =(*_gggf )[len (*_gggf )-(_bgag .Val ):len (*_gggf )];if _abae .Val > 0{_ecee :=_ggf [len (_ggf )-1];_ggf =append ([]PSObject {_ecee },_ggf [0:len (_ggf )-1]...);}else {_cceb :=_ggf [len (_ggf )-_bgag .Val ];_ggf =append (_ggf [1:],_cceb );};_bgg :=append ((*_gggf )[0:len (*_gggf )-_bgag .Val ],_ggf ...);_gggf =&_bgg ;};return nil ;};

// DebugString returns a descriptive string representation of the stack - intended for debugging.
func (_fdbd *PSStack )DebugString ()string {_dceca :="\u005b\u0020";for _ ,_bfcf :=range *_fdbd {_dceca +=_bfcf .DebugString ();_dceca +="\u0020";};_dceca +="\u005d";return _dceca ;};func (_gg *PSInteger )DebugString ()string {return _fg .Sprintf ("\u0069\u006e\u0074\u003a\u0025\u0064",_gg .Val );};func (_dc *PSInteger )String ()string {return _fg .Sprintf ("\u0025\u0064",_dc .Val )};func (_affd *PSOperand )mul (_bdgc *PSStack )error {_egd ,_ege :=_bdgc .Pop ();if _ege !=nil {return _ege ;};_ggg ,_ege :=_bdgc .Pop ();if _ege !=nil {return _ege ;};_afa ,_ffdf :=_egd .(*PSReal );_gbfb ,_abac :=_egd .(*PSInteger );if !_ffdf &&!_abac {return ErrTypeCheck ;};_baee ,_acfc :=_ggg .(*PSReal );_bad ,_fbg :=_ggg .(*PSInteger );if !_acfc &&!_fbg {return ErrTypeCheck ;};if _abac &&_fbg {_befc :=_gbfb .Val *_bad .Val ;_ffa :=_bdgc .Push (MakeInteger (_befc ));return _ffa ;};var _fef float64 =0;if _ffdf {_fef =_afa .Val ;}else {_fef =float64 (_gbfb .Val );};if _acfc {_fef *=_baee .Val ;}else {_fef *=float64 (_bad .Val );};_ege =_bdgc .Push (MakeReal (_fef ));return _ege ;};

// PSBoolean represents a boolean value.
type PSBoolean struct{Val bool ;};func (_bgf *PSOperand )abs (_gfd *PSStack )error {_gcc ,_bd :=_gfd .Pop ();if _bd !=nil {return _bd ;};if _ffe ,_ebe :=_gcc .(*PSReal );_ebe {_aca :=_ffe .Val ;if _aca < 0{_bd =_gfd .Push (MakeReal (-_aca ));}else {_bd =_gfd .Push (MakeReal (_aca ));};}else if _ece ,_fga :=_gcc .(*PSInteger );_fga {_gfe :=_ece .Val ;if _gfe < 0{_bd =_gfd .Push (MakeInteger (-_gfe ));}else {_bd =_gfd .Push (MakeInteger (_gfe ));};}else {return ErrTypeCheck ;};return _bd ;};func (_cga *PSOperand )exp (_aga *PSStack )error {_ced ,_bga :=_aga .PopNumberAsFloat64 ();if _bga !=nil {return _bga ;};_bcbf ,_bga :=_aga .PopNumberAsFloat64 ();if _bga !=nil {return _bga ;};if _eg .Abs (_ced )< 1&&_bcbf < 0{return ErrUndefinedResult ;};_dgg :=_eg .Pow (_bcbf ,_ced );_bga =_aga .Push (MakeReal (_dgg ));return _bga ;};func (_bb *PSReal )DebugString ()string {return _fg .Sprintf ("\u0072e\u0061\u006c\u003a\u0025\u002e\u0035f",_bb .Val );};func (_eggb *PSParser )parseNumber ()(PSObject ,error ){_eaga ,_adffa :=_feb .ParseNumber (_eggb ._gde );if _adffa !=nil {return nil ,_adffa ;};switch _gage :=_eaga .(type ){case *_feb .PdfObjectFloat :return MakeReal (float64 (*_gage )),nil ;case *_feb .PdfObjectInteger :return MakeInteger (int (*_gage )),nil ;};return nil ,_fg .Errorf ("\u0075n\u0068\u0061\u006e\u0064\u006c\u0065\u0064\u0020\u006e\u0075\u006db\u0065\u0072\u0020\u0074\u0079\u0070\u0065\u0020\u0025\u0054",_eaga );};var ErrUnsupportedOperand =_e .New ("\u0075\u006e\u0073\u0075pp\u006f\u0072\u0074\u0065\u0064\u0020\u006f\u0070\u0065\u0072\u0061\u006e\u0064");func (_abcf *PSParser )parseOperand ()(*PSOperand ,error ){var _dfe []byte ;for {_fbcb ,_abb :=_abcf ._gde .Peek (1);if _abb !=nil {if _abb ==_ea .EOF {break ;};return nil ,_abb ;};if _feb .IsDelimiter (_fbcb [0]){break ;};if _feb .IsWhiteSpace (_fbcb [0]){break ;};_bdd ,_ :=_abcf ._gde .ReadByte ();_dfe =append (_dfe ,_bdd );};if len (_dfe )==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 (_dfe )),nil ;};func (_gfde *PSOperand )log (_fgcc *PSStack )error {_cadb ,_ddg :=_fgcc .PopNumberAsFloat64 ();if _ddg !=nil {return _ddg ;};_bbe :=_eg .Log10 (_cadb );_ddg =_fgcc .Push (MakeReal (_bbe ));return _ddg ;};

// Parse parses the postscript and store as a program that can be executed.
func (_bbdf *PSParser )Parse ()(*PSProgram ,error ){_bbdf .skipSpaces ();_dgff ,_dag :=_bbdf ._gde .Peek (2);if _dag !=nil {return nil ,_dag ;};if _dgff [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");};_abg ,_dag :=_bbdf .parseFunction ();if _dag !=nil &&_dag !=_ea .EOF {return nil ,_dag ;};return _abg ,_dag ;};func (_bea *PSOperand )ifelse (_aff *PSStack )error {_dbee ,_dbda :=_aff .Pop ();if _dbda !=nil {return _dbda ;};_gbg ,_dbda :=_aff .Pop ();if _dbda !=nil {return _dbda ;};_eba ,_dbda :=_aff .Pop ();if _dbda !=nil {return _dbda ;};_cea ,_gga :=_dbee .(*PSProgram );if !_gga {return ErrTypeCheck ;};_adf ,_gga :=_gbg .(*PSProgram );if !_gga {return ErrTypeCheck ;};_def ,_gga :=_eba .(*PSBoolean );if !_gga {return ErrTypeCheck ;};if _def .Val {_bebd :=_adf .Exec (_aff );return _bebd ;};_dbda =_cea .Exec (_aff );return _dbda ;};

// MakeInteger returns a new PSInteger object initialized with `val`.
func MakeInteger (val int )*PSInteger {_aef :=PSInteger {};_aef .Val =val ;return &_aef };func (_ffd *PSBoolean )DebugString ()string {return _fg .Sprintf ("\u0062o\u006f\u006c\u003a\u0025\u0076",_ffd .Val );};func (_cbee *PSOperand )not (_bab *PSStack )error {_eccg ,_cgdg :=_bab .Pop ();if _cgdg !=nil {return _cgdg ;};if _aegg ,_cdbbg :=_eccg .(*PSBoolean );_cdbbg {_cgdg =_bab .Push (MakeBool (!_aegg .Val ));return _cgdg ;}else if _affe ,_bagf :=_eccg .(*PSInteger );_bagf {_cgdg =_bab .Push (MakeInteger (^_affe .Val ));return _cgdg ;}else {return ErrTypeCheck ;};};func (_edec *PSOperand )ge (_bage *PSStack )error {_bfe ,_bdg :=_bage .PopNumberAsFloat64 ();if _bdg !=nil {return _bdg ;};_adc ,_bdg :=_bage .PopNumberAsFloat64 ();if _bdg !=nil {return _bdg ;};if _eg .Abs (_adc -_bfe )< _a {_fad :=_bage .Push (MakeBool (true ));return _fad ;}else if _adc > _bfe {_fff :=_bage .Push (MakeBool (true ));return _fff ;}else {_cef :=_bage .Push (MakeBool (false ));return _cef ;};};func (_ee *PSReal )Duplicate ()PSObject {_aba :=PSReal {};_aba .Val =_ee .Val ;return &_aba };var ErrStackOverflow =_e .New ("\u0073\u0074\u0061\u0063\u006b\u0020\u006f\u0076\u0065r\u0066\u006c\u006f\u0077");

// NewPSExecutor returns an initialized PSExecutor for an input `program`.
func NewPSExecutor (program *PSProgram )*PSExecutor {_de :=&PSExecutor {};_de .Stack =NewPSStack ();_de ._fb =program ;return _de ;};

// PSReal represents a real number.
type PSReal struct{Val float64 ;};

// NewPSProgram returns an empty, initialized PSProgram.
func NewPSProgram ()*PSProgram {return &PSProgram {}};func (_cd *PSReal )String ()string {return _fg .Sprintf ("\u0025\u002e\u0035\u0066",_cd .Val )};

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

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

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

// PSParser is a basic Postscript parser.
type PSParser struct{_gde *_fe .Reader };func (_adff *PSOperand )or (_dcgb *PSStack )error {_befe ,_adac :=_dcgb .Pop ();if _adac !=nil {return _adac ;};_dca ,_adac :=_dcgb .Pop ();if _adac !=nil {return _adac ;};if _dgd ,_bgc :=_befe .(*PSBoolean );_bgc {_fbe ,_fcfb :=_dca .(*PSBoolean );if !_fcfb {return ErrTypeCheck ;};_adac =_dcgb .Push (MakeBool (_dgd .Val ||_fbe .Val ));return _adac ;};if _bgcg ,_faf :=_befe .(*PSInteger );_faf {_fbc ,_fdec :=_dca .(*PSInteger );if !_fdec {return ErrTypeCheck ;};_adac =_dcgb .Push (MakeInteger (_bgcg .Val |_fbc .Val ));return _adac ;};return ErrTypeCheck ;};func (_afe *PSParser )parseBool ()(*PSBoolean ,error ){_dcfb ,_fgef :=_afe ._gde .Peek (4);if _fgef !=nil {return MakeBool (false ),_fgef ;};if (len (_dcfb )>=4)&&(string (_dcfb [:4])=="\u0074\u0072\u0075\u0065"){_afe ._gde .Discard (4);return MakeBool (true ),nil ;};_dcfb ,_fgef =_afe ._gde .Peek (5);if _fgef !=nil {return MakeBool (false ),_fgef ;};if (len (_dcfb )>=5)&&(string (_dcfb [:5])=="\u0066\u0061\u006cs\u0065"){_afe ._gde .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 (_fcc *PSOperand )le (_ecf *PSStack )error {_eebg ,_cedc :=_ecf .PopNumberAsFloat64 ();if _cedc !=nil {return _cedc ;};_dcce ,_cedc :=_ecf .PopNumberAsFloat64 ();if _cedc !=nil {return _cedc ;};if _eg .Abs (_dcce -_eebg )< _a {_bgd :=_ecf .Push (MakeBool (true ));return _bgd ;}else if _dcce < _eebg {_bfbf :=_ecf .Push (MakeBool (true ));return _bfbf ;}else {_bfc :=_ecf .Push (MakeBool (false ));return _bfc ;};};func (_be *PSOperand )cos (_abe *PSStack )error {_beb ,_gfb :=_abe .PopNumberAsFloat64 ();if _gfb !=nil {return _gfb ;};_bgee :=_eg .Cos (_beb *_eg .Pi /180.0);_gfb =_abe .Push (MakeReal (_bgee ));return _gfb ;};

// PopInteger specificially pops an integer from the top of the stack, returning the value as an int.
func (_ddbg *PSStack )PopInteger ()(int ,error ){_ebbe ,_aed :=_ddbg .Pop ();if _aed !=nil {return 0,_aed ;};if _abd ,_fee :=_ebbe .(*PSInteger );_fee {return _abd .Val ,nil ;};return 0,ErrTypeCheck ;};

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

// PSProgram defines a Postscript program which is a series of PS objects (arguments, commands, programs etc).
type PSProgram []PSObject ;func (_faga *PSOperand )round (_cddd *PSStack )error {_bfd ,_dfa :=_cddd .Pop ();if _dfa !=nil {return _dfa ;};if _gba ,_gbe :=_bfd .(*PSReal );_gbe {_dfa =_cddd .Push (MakeReal (_eg .Floor (_gba .Val +0.5)));}else if _eage ,_caef :=_bfd .(*PSInteger );_caef {_dfa =_cddd .Push (MakeInteger (_eage .Val ));}else {return ErrTypeCheck ;};return _dfa ;};func (_ce *PSOperand )and (_fec *PSStack )error {_fa ,_aaf :=_fec .Pop ();if _aaf !=nil {return _aaf ;};_bc ,_aaf :=_fec .Pop ();if _aaf !=nil {return _aaf ;};if _dg ,_bde :=_fa .(*PSBoolean );_bde {_bca ,_eeg :=_bc .(*PSBoolean );if !_eeg {return ErrTypeCheck ;};_aaf =_fec .Push (MakeBool (_dg .Val &&_bca .Val ));return _aaf ;};if _efb ,_ceg :=_fa .(*PSInteger );_ceg {_dfg ,_cdb :=_bc .(*PSInteger );if !_cdb {return ErrTypeCheck ;};_aaf =_fec .Push (MakeInteger (_efb .Val &_dfg .Val ));return _aaf ;};return ErrTypeCheck ;};func (_da *PSBoolean )Duplicate ()PSObject {_ef :=PSBoolean {};_ef .Val =_da .Val ;return &_ef };

// Pop pops an object from the top of the stack.
func (_cbeg *PSStack )Pop ()(PSObject ,error ){if len (*_cbeg )< 1{return nil ,ErrStackUnderflow ;};_egec :=(*_cbeg )[len (*_cbeg )-1];*_cbeg =(*_cbeg )[0:len (*_cbeg )-1];return _egec ,nil ;};func (_eed *PSOperand )xor (_bee *PSStack )error {_ddc ,_debg :=_bee .Pop ();if _debg !=nil {return _debg ;};_ecg ,_debg :=_bee .Pop ();if _debg !=nil {return _debg ;};if _bdb ,_aec :=_ddc .(*PSBoolean );_aec {_dedd ,_aeec :=_ecg .(*PSBoolean );if !_aeec {return ErrTypeCheck ;};_debg =_bee .Push (MakeBool (_bdb .Val !=_dedd .Val ));return _debg ;};if _fffb ,_dga :=_ddc .(*PSInteger );_dga {_gabd ,_abada :=_ecg .(*PSInteger );if !_abada {return ErrTypeCheck ;};_debg =_bee .Push (MakeInteger (_fffb .Val ^_gabd .Val ));return _debg ;};return ErrTypeCheck ;};var ErrStackUnderflow =_e .New ("\u0073t\u0061c\u006b\u0020\u0075\u006e\u0064\u0065\u0072\u0066\u006c\u006f\u0077");func (_ccf *PSParser )skipSpaces ()(int ,error ){_bfde :=0;for {_gcf ,_acda :=_ccf ._gde .Peek (1);if _acda !=nil {return 0,_acda ;};if _feb .IsWhiteSpace (_gcf [0]){_ccf ._gde .ReadByte ();_bfde ++;}else {break ;};};return _bfde ,nil ;};func (_gge *PSOperand )truncate (_afce *PSStack )error {_cgf ,_ecb :=_afce .Pop ();if _ecb !=nil {return _ecb ;};if _acdb ,_gcbc :=_cgf .(*PSReal );_gcbc {_cde :=int (_acdb .Val );_ecb =_afce .Push (MakeReal (float64 (_cde )));}else if _gfcd ,_fbec :=_cgf .(*PSInteger );_fbec {_ecb =_afce .Push (MakeInteger (_gfcd .Val ));}else {return ErrTypeCheck ;};return _ecb ;};func (_edba *PSOperand )index (_eeab *PSStack )error {_fcf ,_cad :=_eeab .Pop ();if _cad !=nil {return _cad ;};_bcae ,_fagd :=_fcf .(*PSInteger );if !_fagd {return ErrTypeCheck ;};if _bcae .Val < 0{return ErrRangeCheck ;};if _bcae .Val > len (*_eeab )-1{return ErrStackUnderflow ;};_adfe :=(*_eeab )[len (*_eeab )-1-_bcae .Val ];_cad =_eeab .Push (_adfe .Duplicate ());return _cad ;};

// NewPSParser returns a new instance of the PDF Postscript parser from input data.
func NewPSParser (content []byte )*PSParser {_bdab :=PSParser {};_bagd :=_d .NewBuffer (content );_bdab ._gde =_fe .NewReader (_bagd );return &_bdab ;};

// MakeReal returns a new PSReal object initialized with `val`.
func MakeReal (val float64 )*PSReal {_dbdb :=PSReal {};_dbdb .Val =val ;return &_dbdb };func (_egc *PSOperand )idiv (_egfe *PSStack )error {_dae ,_acd :=_egfe .Pop ();if _acd !=nil {return _acd ;};_ggb ,_acd :=_egfe .Pop ();if _acd !=nil {return _acd ;};_bce ,_gebb :=_dae .(*PSInteger );if !_gebb {return ErrTypeCheck ;};if _bce .Val ==0{return ErrUndefinedResult ;};_dfc ,_gebb :=_ggb .(*PSInteger );if !_gebb {return ErrTypeCheck ;};_fea :=_dfc .Val /_bce .Val ;_acd =_egfe .Push (MakeInteger (_fea ));return _acd ;};func (_geffc *PSOperand )pop (_baeb *PSStack )error {_ ,_gdc :=_baeb .Pop ();if _gdc !=nil {return _gdc ;};return nil ;};

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

// Empty empties the stack.
func (_dcff *PSStack )Empty (){*_dcff =[]PSObject {}};func (_aee *PSOperand )neg (_ccgb *PSStack )error {_gdf ,_acde :=_ccgb .Pop ();if _acde !=nil {return _acde ;};if _agd ,_dbbd :=_gdf .(*PSReal );_dbbd {_acde =_ccgb .Push (MakeReal (-_agd .Val ));return _acde ;}else if _eaa ,_bfa :=_gdf .(*PSInteger );_bfa {_acde =_ccgb .Push (MakeInteger (-_eaa .Val ));return _acde ;}else {return ErrTypeCheck ;};};func (_cdfa *PSOperand )exch (_fag *PSStack )error {_aeg ,_acf :=_fag .Pop ();if _acf !=nil {return _acf ;};_beff ,_acf :=_fag .Pop ();if _acf !=nil {return _acf ;};_acf =_fag .Push (_aeg );if _acf !=nil {return _acf ;};_acf =_fag .Push (_beff );return _acf ;};

// NewPSStack returns an initialized PSStack.
func NewPSStack ()*PSStack {return &PSStack {}};func (_bag *PSOperand )eq (_ccg *PSStack )error {_cgd ,_geff :=_ccg .Pop ();if _geff !=nil {return _geff ;};_bcb ,_geff :=_ccg .Pop ();if _geff !=nil {return _geff ;};_cb ,_ccag :=_cgd .(*PSBoolean );_gfc ,_gac :=_bcb .(*PSBoolean );if _ccag ||_gac {var _afgd error ;if _ccag &&_gac {_afgd =_ccg .Push (MakeBool (_cb .Val ==_gfc .Val ));}else {_afgd =_ccg .Push (MakeBool (false ));};return _afgd ;};var _edbg float64 ;var _gebe float64 ;if _cbf ,_ggc :=_cgd .(*PSInteger );_ggc {_edbg =float64 (_cbf .Val );}else if _ae ,_agc :=_cgd .(*PSReal );_agc {_edbg =_ae .Val ;}else {return ErrTypeCheck ;};if _dfd ,_acbc :=_bcb .(*PSInteger );_acbc {_gebe =float64 (_dfd .Val );}else if _gff ,_bfb :=_bcb .(*PSReal );_bfb {_gebe =_gff .Val ;}else {return ErrTypeCheck ;};if _eg .Abs (_gebe -_edbg )< _a {_geff =_ccg .Push (MakeBool (true ));}else {_geff =_ccg .Push (MakeBool (false ));};return _geff ;};