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 (_ef "bufio";_a "bytes";_g "errors";_dg "fmt";_f "github.com/unidoc/unipdf/v3/common";_df "github.com/unidoc/unipdf/v3/core";_e "io";_c "math";);

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

// PSOperand represents a Postscript operand (text string).
type PSOperand string ;func (_af *PSInteger )DebugString ()string {return _dg .Sprintf ("\u0069\u006e\u0074\u003a\u0025\u0064",_af .Val );};

// 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 (_cgfa *PSOperand )xor (_cbdd *PSStack )error {_cdba ,_faba :=_cbdd .Pop ();if _faba !=nil {return _faba ;};_ggb ,_faba :=_cbdd .Pop ();if _faba !=nil {return _faba ;};if _ega ,_gcb :=_cdba .(*PSBoolean );_gcb {_adfc ,_bcdg :=_ggb .(*PSBoolean );if !_bcdg {return ErrTypeCheck ;};_faba =_cbdd .Push (MakeBool (_ega .Val !=_adfc .Val ));return _faba ;};if _ecba ,_cde :=_cdba .(*PSInteger );_cde {_age ,_dcfd :=_ggb .(*PSInteger );if !_dcfd {return ErrTypeCheck ;};_faba =_cbdd .Push (MakeInteger (_ecba .Val ^_age .Val ));return _faba ;};return ErrTypeCheck ;};func (_dgce *PSOperand )roll (_cdbg *PSStack )error {_ada ,_fdbg :=_cdbg .Pop ();if _fdbg !=nil {return _fdbg ;};_bbb ,_fdbg :=_cdbg .Pop ();if _fdbg !=nil {return _fdbg ;};_ebbg ,_cbg :=_ada .(*PSInteger );if !_cbg {return ErrTypeCheck ;};_dfge ,_cbg :=_bbb .(*PSInteger );if !_cbg {return ErrTypeCheck ;};if _dfge .Val < 0{return ErrRangeCheck ;};if _dfge .Val ==0||_dfge .Val ==1{return nil ;};if _dfge .Val > len (*_cdbg ){return ErrStackUnderflow ;};for _dfgb :=0;_dfgb < _ccg (_ebbg .Val );_dfgb ++{var _eefg []PSObject ;_eefg =(*_cdbg )[len (*_cdbg )-(_dfge .Val ):len (*_cdbg )];if _ebbg .Val > 0{_dfbd :=_eefg [len (_eefg )-1];_eefg =append ([]PSObject {_dfbd },_eefg [0:len (_eefg )-1]...);}else {_acb :=_eefg [len (_eefg )-_dfge .Val ];_eefg =append (_eefg [1:],_acb );};_feg :=append ((*_cdbg )[0:len (*_cdbg )-_dfge .Val ],_eefg ...);_cdbg =&_feg ;};return nil ;};

// Push pushes an object on top of the stack.
func (_fac *PSStack )Push (obj PSObject )error {if len (*_fac )> 100{return ErrStackOverflow ;};*_fac =append (*_fac ,obj );return nil ;};func (_afba *PSParser )parseFunction ()(*PSProgram ,error ){_geb ,_ :=_afba ._bcgg .ReadByte ();if _geb !='{'{return nil ,_g .New ("\u0069\u006ev\u0061\u006c\u0069d\u0020\u0066\u0075\u006e\u0063\u0074\u0069\u006f\u006e");};_egc :=NewPSProgram ();for {_afba .skipSpaces ();_ggc ,_edea :=_afba ._bcgg .Peek (2);if _edea !=nil {if _edea ==_e .EOF {break ;};return nil ,_edea ;};_f .Log .Trace ("\u0050e\u0065k\u0020\u0073\u0074\u0072\u0069\u006e\u0067\u003a\u0020\u0025\u0073",string (_ggc ));if _ggc [0]=='}'{_f .Log .Trace ("\u0045\u004f\u0046 \u0066\u0075\u006e\u0063\u0074\u0069\u006f\u006e");_afba ._bcgg .ReadByte ();break ;}else if _ggc [0]=='{'{_f .Log .Trace ("\u0046u\u006e\u0063\u0074\u0069\u006f\u006e!");_deeg ,_eada :=_afba .parseFunction ();if _eada !=nil {return nil ,_eada ;};_egc .Append (_deeg );}else if _df .IsDecimalDigit (_ggc [0])||(_ggc [0]=='-'&&_df .IsDecimalDigit (_ggc [1])){_f .Log .Trace ("\u002d>\u004e\u0075\u006d\u0062\u0065\u0072!");_afbc ,_geec :=_afba .parseNumber ();if _geec !=nil {return nil ,_geec ;};_egc .Append (_afbc );}else {_f .Log .Trace ("\u002d>\u004fp\u0065\u0072\u0061\u006e\u0064 \u006f\u0072 \u0062\u006f\u006f\u006c\u003f");_ggc ,_ =_afba ._bcgg .Peek (5);_cbfd :=string (_ggc );_f .Log .Trace ("\u0050\u0065\u0065k\u0020\u0073\u0074\u0072\u003a\u0020\u0025\u0073",_cbfd );if (len (_cbfd )> 4)&&(_cbfd [:5]=="\u0066\u0061\u006cs\u0065"){_efcb ,_dgcbd :=_afba .parseBool ();if _dgcbd !=nil {return nil ,_dgcbd ;};_egc .Append (_efcb );}else if (len (_cbfd )> 3)&&(_cbfd [:4]=="\u0074\u0072\u0075\u0065"){_adeg ,_dbd :=_afba .parseBool ();if _dbd !=nil {return nil ,_dbd ;};_egc .Append (_adeg );}else {_gaa ,_fccb :=_afba .parseOperand ();if _fccb !=nil {return nil ,_fccb ;};_egc .Append (_gaa );};};};return _egc ,nil ;};func (_eeg *PSOperand )cvi (_dffe *PSStack )error {_ffd ,_dfad :=_dffe .Pop ();if _dfad !=nil {return _dfad ;};if _efd ,_abb :=_ffd .(*PSReal );_abb {_daa :=int (_efd .Val );_dfad =_dffe .Push (MakeInteger (_daa ));}else if _gee ,_gae :=_ffd .(*PSInteger );_gae {_fca :=_gee .Val ;_dfad =_dffe .Push (MakeInteger (_fca ));}else {return ErrTypeCheck ;};return _dfad ;};

// MakeInteger returns a new PSInteger object initialized with `val`.
func MakeInteger (val int )*PSInteger {_ccaa :=PSInteger {};_ccaa .Val =val ;return &_ccaa };func (_ffa *PSOperand )copy (_abd *PSStack )error {_gdc ,_ffg :=_abd .PopInteger ();if _ffg !=nil {return _ffg ;};if _gdc < 0{return ErrRangeCheck ;};if _gdc > len (*_abd ){return ErrRangeCheck ;};*_abd =append (*_abd ,(*_abd )[len (*_abd )-_gdc :]...);return nil ;};var ErrUnsupportedOperand =_g .New ("\u0075\u006e\u0073\u0075pp\u006f\u0072\u0074\u0065\u0064\u0020\u006f\u0070\u0065\u0072\u0061\u006e\u0064");

// PopInteger specificially pops an integer from the top of the stack, returning the value as an int.
func (_bccd *PSStack )PopInteger ()(int ,error ){_bbf ,_aeda :=_bccd .Pop ();if _aeda !=nil {return 0,_aeda ;};if _cbc ,_bfe :=_bbf .(*PSInteger );_bfe {return _cbc .Val ,nil ;};return 0,ErrTypeCheck ;};func (_cag *PSOperand )log (_ddcg *PSStack )error {_dcccg ,_dgf :=_ddcg .PopNumberAsFloat64 ();if _dgf !=nil {return _dgf ;};_eba :=_c .Log10 (_dcccg );_dgf =_ddcg .Push (MakeReal (_eba ));return _dgf ;};

// NewPSStack returns an initialized PSStack.
func NewPSStack ()*PSStack {return &PSStack {}};func (_eed *PSOperand )ifCondition (_gcegg *PSStack )error {_beg ,_gda :=_gcegg .Pop ();if _gda !=nil {return _gda ;};_eggg ,_gda :=_gcegg .Pop ();if _gda !=nil {return _gda ;};_aeg ,_cab :=_beg .(*PSProgram );if !_cab {return ErrTypeCheck ;};_abbb ,_cab :=_eggg .(*PSBoolean );if !_cab {return ErrTypeCheck ;};if _abbb .Val {_ddce :=_aeg .Exec (_gcegg );return _ddce ;};return nil ;};func (_dcb *PSOperand )and (_dbf *PSStack )error {_bdg ,_agc :=_dbf .Pop ();if _agc !=nil {return _agc ;};_eab ,_agc :=_dbf .Pop ();if _agc !=nil {return _agc ;};if _ff ,_bbe :=_bdg .(*PSBoolean );_bbe {_fde ,_fc :=_eab .(*PSBoolean );if !_fc {return ErrTypeCheck ;};_agc =_dbf .Push (MakeBool (_ff .Val &&_fde .Val ));return _agc ;};if _gfee ,_fbgc :=_bdg .(*PSInteger );_fbgc {_dag ,_bgb :=_eab .(*PSInteger );if !_bgb {return ErrTypeCheck ;};_agc =_dbf .Push (MakeInteger (_gfee .Val &_dag .Val ));return _agc ;};return ErrTypeCheck ;};func (_geg *PSOperand )exch (_egf *PSStack )error {_bde ,_fdea :=_egf .Pop ();if _fdea !=nil {return _fdea ;};_bdb ,_fdea :=_egf .Pop ();if _fdea !=nil {return _fdea ;};_fdea =_egf .Push (_bde );if _fdea !=nil {return _fdea ;};_fdea =_egf .Push (_bdb );return _fdea ;};

// Parse parses the postscript and store as a program that can be executed.
func (_ace *PSParser )Parse ()(*PSProgram ,error ){_ace .skipSpaces ();_accf ,_ggg :=_ace ._bcgg .Peek (2);if _ggg !=nil {return nil ,_ggg ;};if _accf [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");};_fgf ,_ggg :=_ace .parseFunction ();if _ggg !=nil &&_ggg !=_e .EOF {return nil ,_ggg ;};return _fgf ,_ggg ;};var ErrUndefinedResult =_g .New ("\u0075\u006e\u0064\u0065fi\u006e\u0065\u0064\u0020\u0072\u0065\u0073\u0075\u006c\u0074\u0020\u0065\u0072\u0072o\u0072");func (_dd *PSReal )String ()string {return _dg .Sprintf ("\u0025\u002e\u0035\u0066",_dd .Val )};var ErrStackUnderflow =_g .New ("\u0073t\u0061c\u006b\u0020\u0075\u006e\u0064\u0065\u0072\u0066\u006c\u006f\u0077");

// DebugString returns a descriptive string representation of the stack - intended for debugging.
func (_bcdb *PSStack )DebugString ()string {_cfeg :="\u005b\u0020";for _ ,_bab :=range *_bcdb {_cfeg +=_bab .DebugString ();_cfeg +="\u0020";};_cfeg +="\u005d";return _cfeg ;};func (_aa *PSProgram )DebugString ()string {_fae :="\u007b\u0020";for _ ,_cc :=range *_aa {_fae +=_cc .DebugString ();_fae +="\u0020";};_fae +="\u007d";return _fae ;};func _ccg (_bdf int )int {if _bdf < 0{return -_bdf ;};return _bdf ;};func (_adc *PSOperand )idiv (_bfgb *PSStack )error {_bfff ,_cedd :=_bfgb .Pop ();if _cedd !=nil {return _cedd ;};_eef ,_cedd :=_bfgb .Pop ();if _cedd !=nil {return _cedd ;};_bfb ,_fdf :=_bfff .(*PSInteger );if !_fdf {return ErrTypeCheck ;};if _bfb .Val ==0{return ErrUndefinedResult ;};_dae ,_fdf :=_eef .(*PSInteger );if !_fdf {return ErrTypeCheck ;};_cfd :=_dae .Val /_bfb .Val ;_cedd =_bfgb .Push (MakeInteger (_cfd ));return _cedd ;};func (_bfcb *PSOperand )mul (_fcdab *PSStack )error {_fdde ,_fdda :=_fcdab .Pop ();if _fdda !=nil {return _fdda ;};_adff ,_fdda :=_fcdab .Pop ();if _fdda !=nil {return _fdda ;};_cega ,_aec :=_fdde .(*PSReal );_ebg ,_adcg :=_fdde .(*PSInteger );if !_aec &&!_adcg {return ErrTypeCheck ;};_dbeb ,_cfbg :=_adff .(*PSReal );_fdfa ,_bada :=_adff .(*PSInteger );if !_cfbg &&!_bada {return ErrTypeCheck ;};if _adcg &&_bada {_gdb :=_ebg .Val *_fdfa .Val ;_faeb :=_fcdab .Push (MakeInteger (_gdb ));return _faeb ;};var _dfb float64 =0;if _aec {_dfb =_cega .Val ;}else {_dfb =float64 (_ebg .Val );};if _cfbg {_dfb *=_dbeb .Val ;}else {_dfb *=float64 (_fdfa .Val );};_fdda =_fcdab .Push (MakeReal (_dfb ));return _fdda ;};func (_cba *PSOperand )sub (_faa *PSStack )error {_cbd ,_cbgd :=_faa .Pop ();if _cbgd !=nil {return _cbgd ;};_bagf ,_cbgd :=_faa .Pop ();if _cbgd !=nil {return _cbgd ;};_cgb ,_edbf :=_cbd .(*PSReal );_gcda ,_eedbd :=_cbd .(*PSInteger );if !_edbf &&!_eedbd {return ErrTypeCheck ;};_cfcc ,_gcg :=_bagf .(*PSReal );_aae ,_bbad :=_bagf .(*PSInteger );if !_gcg &&!_bbad {return ErrTypeCheck ;};if _eedbd &&_bbad {_ecga :=_aae .Val -_gcda .Val ;_geae :=_faa .Push (MakeInteger (_ecga ));return _geae ;};var _cegc float64 =0;if _gcg {_cegc =_cfcc .Val ;}else {_cegc =float64 (_aae .Val );};if _edbf {_cegc -=_cgb .Val ;}else {_cegc -=float64 (_gcda .Val );};_cbgd =_faa .Push (MakeReal (_cegc ));return _cbgd ;};func (_fd *PSInteger )String ()string {return _dg .Sprintf ("\u0025\u0064",_fd .Val )};

// Pop pops an object from the top of the stack.
func (_aged *PSStack )Pop ()(PSObject ,error ){if len (*_aged )< 1{return nil ,ErrStackUnderflow ;};_gfd :=(*_aged )[len (*_aged )-1];*_aged =(*_aged )[0:len (*_aged )-1];return _gfd ,nil ;};func (_bdafe *PSOperand )eq (_fab *PSStack )error {_bac ,_eae :=_fab .Pop ();if _eae !=nil {return _eae ;};_gaf ,_eae :=_fab .Pop ();if _eae !=nil {return _eae ;};_bcc ,_dba :=_bac .(*PSBoolean );_gdd ,_gca :=_gaf .(*PSBoolean );if _dba ||_gca {var _fee error ;if _dba &&_gca {_fee =_fab .Push (MakeBool (_bcc .Val ==_gdd .Val ));}else {_fee =_fab .Push (MakeBool (false ));};return _fee ;};var _efa float64 ;var _bfc float64 ;if _feb ,_ed :=_bac .(*PSInteger );_ed {_efa =float64 (_feb .Val );}else if _cefc ,_gbe :=_bac .(*PSReal );_gbe {_efa =_cefc .Val ;}else {return ErrTypeCheck ;};if _dada ,_ebe :=_gaf .(*PSInteger );_ebe {_bfc =float64 (_dada .Val );}else if _ebf ,_afce :=_gaf .(*PSReal );_afce {_bfc =_ebf .Val ;}else {return ErrTypeCheck ;};if _c .Abs (_bfc -_efa )< _b {_eae =_fab .Push (MakeBool (true ));}else {_eae =_fab .Push (MakeBool (false ));};return _eae ;};

// PopNumberAsFloat64 pops and return the numeric value of the top of the stack as a float64.
// Real or integer only.
func (_ebba *PSStack )PopNumberAsFloat64 ()(float64 ,error ){_dcec ,_edg :=_ebba .Pop ();if _edg !=nil {return 0,_edg ;};if _gga ,_fdc :=_dcec .(*PSReal );_fdc {return _gga .Val ,nil ;}else if _fcdf ,_dcea :=_dcec .(*PSInteger );_dcea {return float64 (_fcdf .Val ),nil ;}else {return 0,ErrTypeCheck ;};};

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

// PSReal represents a real number.
type PSReal struct{Val float64 ;};var ErrTypeCheck =_g .New ("\u0074\u0079p\u0065\u0020\u0063h\u0065\u0063\u006b\u0020\u0065\u0072\u0072\u006f\u0072");func (_dega *PSParser )skipSpaces ()(int ,error ){_badb :=0;for {_ddad ,_cbgdc :=_dega ._bcgg .Peek (1);if _cbgdc !=nil {return 0,_cbgdc ;};if _df .IsWhiteSpace (_ddad [0]){_dega ._bcgg .ReadByte ();_badb ++;}else {break ;};};return _badb ,nil ;};

// MakeBool returns a new PSBoolean object initialized with `val`.
func MakeBool (val bool )*PSBoolean {_cfde :=PSBoolean {};_cfde .Val =val ;return &_cfde };func (_gd *PSOperand )DebugString ()string {return _dg .Sprintf ("\u006fp\u003a\u0027\u0025\u0073\u0027",*_gd );};func (_bdec *PSOperand )or (_bacf *PSStack )error {_dac ,_dbgb :=_bacf .Pop ();if _dbgb !=nil {return _dbgb ;};_eedb ,_dbgb :=_bacf .Pop ();if _dbgb !=nil {return _dbgb ;};if _ccd ,_eccea :=_dac .(*PSBoolean );_eccea {_fed ,_adcc :=_eedb .(*PSBoolean );if !_adcc {return ErrTypeCheck ;};_dbgb =_bacf .Push (MakeBool (_ccd .Val ||_fed .Val ));return _dbgb ;};if _gaff ,_bebc :=_dac .(*PSInteger );_bebc {_cfcf ,_bgfb :=_eedb .(*PSInteger );if !_bgfb {return ErrTypeCheck ;};_dbgb =_bacf .Push (MakeInteger (_gaff .Val |_cfcf .Val ));return _dbgb ;};return ErrTypeCheck ;};func (_bba *PSOperand )ne (_ede *PSStack )error {_adbg :=_bba .eq (_ede );if _adbg !=nil {return _adbg ;};_adbg =_bba .not (_ede );return _adbg ;};func (_ced *PSOperand )cvr (_cfaf *PSStack )error {_afb ,_aff :=_cfaf .Pop ();if _aff !=nil {return _aff ;};if _gag ,_dea :=_afb .(*PSReal );_dea {_aff =_cfaf .Push (MakeReal (_gag .Val ));}else if _bc ,_bfad :=_afb .(*PSInteger );_bfad {_aff =_cfaf .Push (MakeReal (float64 (_bc .Val )));}else {return ErrTypeCheck ;};return _aff ;};

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

// 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 _gb []float64 ;for _ ,_gf :=range objects {if _fa ,_fb :=_gf .(*PSInteger );_fb {_gb =append (_gb ,float64 (_fa .Val ));}else if _ag ,_cf :=_gf .(*PSReal );_cf {_gb =append (_gb ,_ag .Val );}else {return nil ,ErrTypeCheck ;};};return _gb ,nil ;};

// PSExecutor has its own execution stack and is used to executre a PS routine (program).
type PSExecutor struct{Stack *PSStack ;_bf *PSProgram ;};func (_abbg *PSOperand )ge (_dfae *PSStack )error {_dce ,_ddc :=_dfae .PopNumberAsFloat64 ();if _ddc !=nil {return _ddc ;};_fcc ,_ddc :=_dfae .PopNumberAsFloat64 ();if _ddc !=nil {return _ddc ;};if _c .Abs (_fcc -_dce )< _b {_abf :=_dfae .Push (MakeBool (true ));return _abf ;}else if _fcc > _dce {_fgg :=_dfae .Push (MakeBool (true ));return _fgg ;}else {_dedd :=_dfae .Push (MakeBool (false ));return _dedd ;};};func (_efe *PSBoolean )DebugString ()string {return _dg .Sprintf ("\u0062o\u006f\u006c\u003a\u0025\u0076",_efe .Val );};

// MakeReal returns a new PSReal object initialized with `val`.
func MakeReal (val float64 )*PSReal {_add :=PSReal {};_add .Val =val ;return &_add };

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

// Execute executes the program for an input parameters `objects` and returns a slice of output objects.
func (_de *PSExecutor )Execute (objects []PSObject )([]PSObject ,error ){for _ ,_bd :=range objects {_cd :=_de .Stack .Push (_bd );if _cd !=nil {return nil ,_cd ;};};_cfe :=_de ._bf .Exec (_de .Stack );if _cfe !=nil {_f .Log .Debug ("\u0045x\u0065c\u0020\u0066\u0061\u0069\u006c\u0065\u0064\u003a\u0020\u0025\u0076",_cfe );return nil ,_cfe ;};_dfa :=[]PSObject (*_de .Stack );_de .Stack .Empty ();return _dfa ,nil ;};func (_cg *PSOperand )exp (_gddf *PSStack )error {_ca ,_gagb :=_gddf .PopNumberAsFloat64 ();if _gagb !=nil {return _gagb ;};_egg ,_gagb :=_gddf .PopNumberAsFloat64 ();if _gagb !=nil {return _gagb ;};if _c .Abs (_ca )< 1&&_egg < 0{return ErrUndefinedResult ;};_ac :=_c .Pow (_egg ,_ca );_gagb =_gddf .Push (MakeReal (_ac ));return _gagb ;};func (_adb *PSOperand )ln (_eccf *PSStack )error {_fdd ,_fbe :=_eccf .PopNumberAsFloat64 ();if _fbe !=nil {return _fbe ;};_ffe :=_c .Log (_fdd );_fbe =_eccf .Push (MakeReal (_ffe ));return _fbe ;};func (_cfa *PSOperand )abs (_ecc *PSStack )error {_ecce ,_aac :=_ecc .Pop ();if _aac !=nil {return _aac ;};if _aba ,_abe :=_ecce .(*PSReal );_abe {_ad :=_aba .Val ;if _ad < 0{_aac =_ecc .Push (MakeReal (-_ad ));}else {_aac =_ecc .Push (MakeReal (_ad ));};}else if _bb ,_gcd :=_ecce .(*PSInteger );_gcd {_eff :=_bb .Val ;if _eff < 0{_aac =_ecc .Push (MakeInteger (-_eff ));}else {_aac =_ecc .Push (MakeInteger (_eff ));};}else {return ErrTypeCheck ;};return _aac ;};func (_ab *PSProgram )Duplicate ()PSObject {_fg :=&PSProgram {};for _ ,_ba :=range *_ab {_fg .Append (_ba .Duplicate ());};return _fg ;};func (_dc *PSProgram )String ()string {_efc :="\u007b\u0020";for _ ,_bfa :=range *_dc {_efc +=_bfa .String ();_efc +="\u0020";};_efc +="\u007d";return _efc ;};

// PSStack defines a stack of PSObjects. PSObjects can be pushed on or pull from the stack.
type PSStack []PSObject ;var ErrStackOverflow =_g .New ("\u0073\u0074\u0061\u0063\u006b\u0020\u006f\u0076\u0065r\u0066\u006c\u006f\u0077");var ErrRangeCheck =_g .New ("\u0072\u0061\u006e\u0067\u0065\u0020\u0063\u0068\u0065\u0063\u006b\u0020e\u0072\u0072\u006f\u0072");func (_dbc *PSOperand )le (_bgf *PSStack )error {_dbe ,_agb :=_bgf .PopNumberAsFloat64 ();if _agb !=nil {return _agb ;};_ebc ,_agb :=_bgf .PopNumberAsFloat64 ();if _agb !=nil {return _agb ;};if _c .Abs (_ebc -_dbe )< _b {_fcda :=_bgf .Push (MakeBool (true ));return _fcda ;}else if _ebc < _dbe {_ecg :=_bgf .Push (MakeBool (true ));return _ecg ;}else {_bea :=_bgf .Push (MakeBool (false ));return _bea ;};};

// String returns a string representation of the stack.
func (_fce *PSStack )String ()string {_adg :="\u005b\u0020";for _ ,_aada :=range *_fce {_adg +=_aada .String ();_adg +="\u0020";};_adg +="\u005d";return _adg ;};func (_ga *PSOperand )String ()string {return _dg .Sprintf ("\u0025\u0073",*_ga )};func (_ffdd *PSOperand )gt (_cdg *PSStack )error {_ddca ,_cdc :=_cdg .PopNumberAsFloat64 ();if _cdc !=nil {return _cdc ;};_gega ,_cdc :=_cdg .PopNumberAsFloat64 ();if _cdc !=nil {return _cdc ;};if _c .Abs (_gega -_ddca )< _b {_gddb :=_cdg .Push (MakeBool (false ));return _gddb ;}else if _gega > _ddca {_fcga :=_cdg .Push (MakeBool (true ));return _fcga ;}else {_cb :=_cdg .Push (MakeBool (false ));return _cb ;};};

// PSProgram defines a Postscript program which is a series of PS objects (arguments, commands, programs etc).
type PSProgram []PSObject ;func (_bgbc *PSOperand )ifelse (_gdda *PSStack )error {_dead ,_bee :=_gdda .Pop ();if _bee !=nil {return _bee ;};_eca ,_bee :=_gdda .Pop ();if _bee !=nil {return _bee ;};_cec ,_bee :=_gdda .Pop ();if _bee !=nil {return _bee ;};_bdc ,_cefa :=_dead .(*PSProgram );if !_cefa {return ErrTypeCheck ;};_bfbc ,_cefa :=_eca .(*PSProgram );if !_cefa {return ErrTypeCheck ;};_eegc ,_cefa :=_cec .(*PSBoolean );if !_cefa {return ErrTypeCheck ;};if _eegc .Val {_fdec :=_bfbc .Exec (_gdda );return _fdec ;};_bee =_bdc .Exec (_gdda );return _bee ;};func (_ece *PSOperand )lt (_cbf *PSStack )error {_eaa ,_beee :=_cbf .PopNumberAsFloat64 ();if _beee !=nil {return _beee ;};_ffab ,_beee :=_cbf .PopNumberAsFloat64 ();if _beee !=nil {return _beee ;};if _c .Abs (_ffab -_eaa )< _b {_cfc :=_cbf .Push (MakeBool (false ));return _cfc ;}else if _ffab < _eaa {_bgbe :=_cbf .Push (MakeBool (true ));return _bgbe ;}else {_dgcb :=_cbf .Push (MakeBool (false ));return _dgcb ;};};func (_aab *PSOperand )mod (_ead *PSStack )error {_afa ,_gdg :=_ead .Pop ();if _gdg !=nil {return _gdg ;};_bdcf ,_gdg :=_ead .Pop ();if _gdg !=nil {return _gdg ;};_aegb ,_deec :=_afa .(*PSInteger );if !_deec {return ErrTypeCheck ;};if _aegb .Val ==0{return ErrUndefinedResult ;};_aedc ,_deec :=_bdcf .(*PSInteger );if !_deec {return ErrTypeCheck ;};_dbgg :=_aedc .Val %_aegb .Val ;_gdg =_ead .Push (MakeInteger (_dbgg ));return _gdg ;};func (_bda *PSOperand )ceiling (_fga *PSStack )error {_gbc ,_adf :=_fga .Pop ();if _adf !=nil {return _adf ;};if _ee ,_dga :=_gbc .(*PSReal );_dga {_adf =_fga .Push (MakeReal (_c .Ceil (_ee .Val )));}else if _dad ,_bdaf :=_gbc .(*PSInteger );_bdaf {_adf =_fga .Push (MakeInteger (_dad .Val ));}else {_adf =ErrTypeCheck ;};return _adf ;};func (_ec *PSBoolean )String ()string {return _dg .Sprintf ("\u0025\u0076",_ec .Val )};

// Exec executes the operand `op` in the state specified by `stack`.
func (_ded *PSOperand )Exec (stack *PSStack )error {_gea :=ErrUnsupportedOperand ;switch *_ded {case "\u0061\u0062\u0073":_gea =_ded .abs (stack );case "\u0061\u0064\u0064":_gea =_ded .add (stack );case "\u0061\u006e\u0064":_gea =_ded .and (stack );case "\u0061\u0074\u0061\u006e":_gea =_ded .atan (stack );case "\u0062\u0069\u0074\u0073\u0068\u0069\u0066\u0074":_gea =_ded .bitshift (stack );case "\u0063e\u0069\u006c\u0069\u006e\u0067":_gea =_ded .ceiling (stack );case "\u0063\u006f\u0070\u0079":_gea =_ded .copy (stack );case "\u0063\u006f\u0073":_gea =_ded .cos (stack );case "\u0063\u0076\u0069":_gea =_ded .cvi (stack );case "\u0063\u0076\u0072":_gea =_ded .cvr (stack );case "\u0064\u0069\u0076":_gea =_ded .div (stack );case "\u0064\u0075\u0070":_gea =_ded .dup (stack );case "\u0065\u0071":_gea =_ded .eq (stack );case "\u0065\u0078\u0063\u0068":_gea =_ded .exch (stack );case "\u0065\u0078\u0070":_gea =_ded .exp (stack );case "\u0066\u006c\u006fo\u0072":_gea =_ded .floor (stack );case "\u0067\u0065":_gea =_ded .ge (stack );case "\u0067\u0074":_gea =_ded .gt (stack );case "\u0069\u0064\u0069\u0076":_gea =_ded .idiv (stack );case "\u0069\u0066":_gea =_ded .ifCondition (stack );case "\u0069\u0066\u0065\u006c\u0073\u0065":_gea =_ded .ifelse (stack );case "\u0069\u006e\u0064e\u0078":_gea =_ded .index (stack );case "\u006c\u0065":_gea =_ded .le (stack );case "\u006c\u006f\u0067":_gea =_ded .log (stack );case "\u006c\u006e":_gea =_ded .ln (stack );case "\u006c\u0074":_gea =_ded .lt (stack );case "\u006d\u006f\u0064":_gea =_ded .mod (stack );case "\u006d\u0075\u006c":_gea =_ded .mul (stack );case "\u006e\u0065":_gea =_ded .ne (stack );case "\u006e\u0065\u0067":_gea =_ded .neg (stack );case "\u006e\u006f\u0074":_gea =_ded .not (stack );case "\u006f\u0072":_gea =_ded .or (stack );case "\u0070\u006f\u0070":_gea =_ded .pop (stack );case "\u0072\u006f\u0075n\u0064":_gea =_ded .round (stack );case "\u0072\u006f\u006c\u006c":_gea =_ded .roll (stack );case "\u0073\u0069\u006e":_gea =_ded .sin (stack );case "\u0073\u0071\u0072\u0074":_gea =_ded .sqrt (stack );case "\u0073\u0075\u0062":_gea =_ded .sub (stack );case "\u0074\u0072\u0075\u006e\u0063\u0061\u0074\u0065":_gea =_ded .truncate (stack );case "\u0078\u006f\u0072":_gea =_ded .xor (stack );};return _gea ;};func (_afc *PSReal )DebugString ()string {return _dg .Sprintf ("\u0072e\u0061\u006c\u003a\u0025\u002e\u0035f",_afc .Val );};func (_eag *PSOperand )sin (_cegd *PSStack )error {_ade ,_gfa :=_cegd .PopNumberAsFloat64 ();if _gfa !=nil {return _gfa ;};_bcd :=_c .Sin (_ade *_c .Pi /180.0);_gfa =_cegd .Push (MakeReal (_bcd ));return _gfa ;};

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

// NewPSParser returns a new instance of the PDF Postscript parser from input data.
func NewPSParser (content []byte )*PSParser {_fedc :=PSParser {};_dbb :=_a .NewBuffer (content );_fedc ._bcgg =_ef .NewReader (_dbb );return &_fedc ;};func (_afcee *PSOperand )sqrt (_eeb *PSStack )error {_egd ,_bga :=_eeb .PopNumberAsFloat64 ();if _bga !=nil {return _bga ;};if _egd < 0{return ErrRangeCheck ;};_bgg :=_c .Sqrt (_egd );_bga =_eeb .Push (MakeReal (_bgg ));return _bga ;};

// Exec executes the program, typically leaving output values on the stack.
func (_fe *PSProgram )Exec (stack *PSStack )error {for _ ,_aad :=range *_fe {var _fbg error ;switch _dee :=_aad .(type ){case *PSInteger :_dbg :=_dee ;_fbg =stack .Push (_dbg );case *PSReal :_ceg :=_dee ;_fbg =stack .Push (_ceg );case *PSBoolean :_bff :=_dee ;_fbg =stack .Push (_bff );case *PSProgram :_ddb :=_dee ;_fbg =stack .Push (_ddb );case *PSOperand :_efgf :=_dee ;_fbg =_efgf .Exec (stack );default:return ErrTypeCheck ;};if _fbg !=nil {return _fbg ;};};return nil ;};func (_bg *PSReal )Duplicate ()PSObject {_dgc :=PSReal {};_dgc .Val =_bg .Val ;return &_dgc };func (_gbf *PSOperand )not (_gcf *PSStack )error {_acc ,_dgba :=_gcf .Pop ();if _dgba !=nil {return _dgba ;};if _dbac ,_afag :=_acc .(*PSBoolean );_afag {_dgba =_gcf .Push (MakeBool (!_dbac .Val ));return _dgba ;}else if _cefg ,_cfcb :=_acc .(*PSInteger );_cfcb {_dgba =_gcf .Push (MakeInteger (^_cefg .Val ));return _dgba ;}else {return ErrTypeCheck ;};};func (_eb *PSOperand )div (_bed *PSStack )error {_fba ,_fdg :=_bed .Pop ();if _fdg !=nil {return _fdg ;};_cea ,_fdg :=_bed .Pop ();if _fdg !=nil {return _fdg ;};_dgag ,_cca :=_fba .(*PSReal );_affe ,_efb :=_fba .(*PSInteger );if !_cca &&!_efb {return ErrTypeCheck ;};if _cca &&_dgag .Val ==0{return ErrUndefinedResult ;};if _efb &&_affe .Val ==0{return ErrUndefinedResult ;};_eccd ,_gfeg :=_cea .(*PSReal );_gfg ,_gbg :=_cea .(*PSInteger );if !_gfeg &&!_gbg {return ErrTypeCheck ;};var _bag float64 =0;if _gfeg {_bag =_eccd .Val ;}else {_bag =float64 (_gfg .Val );};if _cca {_bag /=_dgag .Val ;}else {_bag /=float64 (_affe .Val );};_fdg =_bed .Push (MakeReal (_bag ));return _fdg ;};

// PSInteger represents an integer.
type PSInteger struct{Val int ;};func (_dfadg *PSOperand )dup (_fcg *PSStack )error {_ddd ,_ggd :=_fcg .Pop ();if _ggd !=nil {return _ggd ;};_ggd =_fcg .Push (_ddd );if _ggd !=nil {return _ggd ;};_ggd =_fcg .Push (_ddd .Duplicate ());return _ggd ;};

// PSBoolean represents a boolean value.
type PSBoolean struct{Val bool ;};func (_dca *PSOperand )atan (_be *PSStack )error {_bad ,_cdf :=_be .PopNumberAsFloat64 ();if _cdf !=nil {return _cdf ;};_gce ,_cdf :=_be .PopNumberAsFloat64 ();if _cdf !=nil {return _cdf ;};if _bad ==0{var _cef error ;if _gce < 0{_cef =_be .Push (MakeReal (270));}else {_cef =_be .Push (MakeReal (90));};return _cef ;};_afd :=_gce /_bad ;_ggf :=_c .Atan (_afd )*180/_c .Pi ;_cdf =_be .Push (MakeReal (_ggf ));return _cdf ;};const _b =0.000001;func (_db *PSInteger )Duplicate ()PSObject {_ea :=PSInteger {};_ea .Val =_db .Val ;return &_ea };func (_fbgf *PSOperand )cos (_ccc *PSStack )error {_aadf ,_eacd :=_ccc .PopNumberAsFloat64 ();if _eacd !=nil {return _eacd ;};_agd :=_c .Cos (_aadf *_c .Pi /180.0);_eacd =_ccc .Push (MakeReal (_agd ));return _eacd ;};func (_agcg *PSOperand )index (_fec *PSStack )error {_gab ,_fcd :=_fec .Pop ();if _fcd !=nil {return _fcd ;};_bbd ,_ecf :=_gab .(*PSInteger );if !_ecf {return ErrTypeCheck ;};if _bbd .Val < 0{return ErrRangeCheck ;};if _bbd .Val > len (*_fec )-1{return ErrStackUnderflow ;};_fcf :=(*_fec )[len (*_fec )-1-_bbd .Val ];_fcd =_fec .Push (_fcf .Duplicate ());return _fcd ;};

// PSParser is a basic Postscript parser.
type PSParser struct{_bcgg *_ef .Reader };func (_edc *PSOperand )floor (_fabb *PSStack )error {_bcg ,_cge :=_fabb .Pop ();if _cge !=nil {return _cge ;};if _edb ,_fafb :=_bcg .(*PSReal );_fafb {_cge =_fabb .Push (MakeReal (_c .Floor (_edb .Val )));}else if _cfbc ,_bffb :=_bcg .(*PSInteger );_bffb {_cge =_fabb .Push (MakeInteger (_cfbc .Val ));}else {return ErrTypeCheck ;};return _cge ;};func (_eg *PSOperand )Duplicate ()PSObject {_cdb :=*_eg ;return &_cdb };func (_abbd *PSParser )parseOperand ()(*PSOperand ,error ){var _abeb []byte ;for {_gcfa ,_dfff :=_abbd ._bcgg .Peek (1);if _dfff !=nil {if _dfff ==_e .EOF {break ;};return nil ,_dfff ;};if _df .IsDelimiter (_gcfa [0]){break ;};if _df .IsWhiteSpace (_gcfa [0]){break ;};_bdd ,_ :=_abbd ._bcgg .ReadByte ();_abeb =append (_abeb ,_bdd );};if len (_abeb )==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 (_abeb )),nil ;};func (_bfg *PSOperand )add (_da *PSStack )error {_fbd ,_dgb :=_da .Pop ();if _dgb !=nil {return _dgb ;};_efcf ,_dgb :=_da .Pop ();if _dgb !=nil {return _dgb ;};_dcc ,_dccc :=_fbd .(*PSReal );_eac ,_aed :=_fbd .(*PSInteger );if !_dccc &&!_aed {return ErrTypeCheck ;};_eacg ,_gfc :=_efcf .(*PSReal );_efcfb ,_fad :=_efcf .(*PSInteger );if !_gfc &&!_fad {return ErrTypeCheck ;};if _aed &&_fad {_cfb :=_eac .Val +_efcfb .Val ;_dfg :=_da .Push (MakeInteger (_cfb ));return _dfg ;};var _deg float64 =0;if _dccc {_deg =_dcc .Val ;}else {_deg =float64 (_eac .Val );};if _gfc {_deg +=_eacg .Val ;}else {_deg +=float64 (_efcfb .Val );};_dgb =_da .Push (MakeReal (_deg ));return _dgb ;};func (_dgfe *PSParser )parseNumber ()(PSObject ,error ){_gbee ,_cae :=_df .ParseNumber (_dgfe ._bcgg );if _cae !=nil {return nil ,_cae ;};switch _aacb :=_gbee .(type ){case *_df .PdfObjectFloat :return MakeReal (float64 (*_aacb )),nil ;case *_df .PdfObjectInteger :return MakeInteger (int (*_aacb )),nil ;};return nil ,_dg .Errorf ("\u0075n\u0068\u0061\u006e\u0064\u006c\u0065\u0064\u0020\u006e\u0075\u006db\u0065\u0072\u0020\u0074\u0079\u0070\u0065\u0020\u0025\u0054",_gbee );};func (_cgf *PSOperand )round (_efae *PSStack )error {_ccb ,_cfaa :=_efae .Pop ();if _cfaa !=nil {return _cfaa ;};if _cedf ,_fdb :=_ccb .(*PSReal );_fdb {_cfaa =_efae .Push (MakeReal (_c .Floor (_cedf .Val +0.5)));}else if _cbe ,_cfag :=_ccb .(*PSInteger );_cfag {_cfaa =_efae .Push (MakeInteger (_cbe .Val ));}else {return ErrTypeCheck ;};return _cfaa ;};func (_dda *PSOperand )truncate (_dcac *PSStack )error {_ceae ,_ecfe :=_dcac .Pop ();if _ecfe !=nil {return _ecfe ;};if _bfd ,_dbgf :=_ceae .(*PSReal );_dbgf {_aeb :=int (_bfd .Val );_ecfe =_dcac .Push (MakeReal (float64 (_aeb )));}else if _fea ,_dace :=_ceae .(*PSInteger );_dace {_ecfe =_dcac .Push (MakeInteger (_fea .Val ));}else {return ErrTypeCheck ;};return _ecfe ;};func (_dagb *PSParser )parseBool ()(*PSBoolean ,error ){_cbb ,_eded :=_dagb ._bcgg .Peek (4);if _eded !=nil {return MakeBool (false ),_eded ;};if (len (_cbb )>=4)&&(string (_cbb [:4])=="\u0074\u0072\u0075\u0065"){_dagb ._bcgg .Discard (4);return MakeBool (true ),nil ;};_cbb ,_eded =_dagb ._bcgg .Peek (5);if _eded !=nil {return MakeBool (false ),_eded ;};if (len (_cbb )>=5)&&(string (_cbb [:5])=="\u0066\u0061\u006cs\u0065"){_dagb ._bcgg .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");};func (_dcf *PSOperand )neg (_cee *PSStack )error {_aca ,_efde :=_cee .Pop ();if _efde !=nil {return _efde ;};if _dgbb ,_ebab :=_aca .(*PSReal );_ebab {_efde =_cee .Push (MakeReal (-_dgbb .Val ));return _efde ;}else if _fcb ,_beb :=_aca .(*PSInteger );_beb {_efde =_cee .Push (MakeInteger (-_fcb .Val ));return _efde ;}else {return ErrTypeCheck ;};};func (_afg *PSOperand )bitshift (_ecb *PSStack )error {_aee ,_fbga :=_ecb .PopInteger ();if _fbga !=nil {return _fbga ;};_gceg ,_fbga :=_ecb .PopInteger ();if _fbga !=nil {return _fbga ;};var _dff int ;if _aee >=0{_dff =_gceg <<uint (_aee );}else {_dff =_gceg >>uint (-_aee );};_fbga =_ecb .Push (MakeInteger (_dff ));return _fbga ;};func (_gc *PSBoolean )Duplicate ()PSObject {_efg :=PSBoolean {};_efg .Val =_gc .Val ;return &_efg };func (_deeb *PSOperand )pop (_dde *PSStack )error {_ ,_afga :=_dde .Pop ();if _afga !=nil {return _afga ;};return nil ;};