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 (_ee "bufio";_e "bytes";_df "errors";_b "fmt";_dc "github.com/unidoc/unipdf/v3/common";_ba "github.com/unidoc/unipdf/v3/core";_c "io";_ca "math";);

// PopInteger specificially pops an integer from the top of the stack, returning the value as an int.
func (_bfdb *PSStack )PopInteger ()(int ,error ){_acb ,_gfea :=_bfdb .Pop ();if _gfea !=nil {return 0,_gfea ;};if _eeg ,_cdcd :=_acb .(*PSInteger );_cdcd {return _eeg .Val ,nil ;};return 0,ErrTypeCheck ;};func (_ge *PSReal )Duplicate ()PSObject {_egc :=PSReal {};_egc .Val =_ge .Val ;return &_egc };

// PSReal represents a real number.
type PSReal struct{Val float64 ;};func (_baeb *PSOperand )xor (_afcb *PSStack )error {_cfgd ,_gbg :=_afcb .Pop ();if _gbg !=nil {return _gbg ;};_fead ,_gbg :=_afcb .Pop ();if _gbg !=nil {return _gbg ;};if _fefg ,_fee :=_cfgd .(*PSBoolean );_fee {_eeb ,_ffed :=_fead .(*PSBoolean );if !_ffed {return ErrTypeCheck ;};_gbg =_afcb .Push (MakeBool (_fefg .Val !=_eeb .Val ));return _gbg ;};if _fce ,_dfgd :=_cfgd .(*PSInteger );_dfgd {_dcdag ,_bbcf :=_fead .(*PSInteger );if !_bbcf {return ErrTypeCheck ;};_gbg =_afcb .Push (MakeInteger (_fce .Val ^_dcdag .Val ));return _gbg ;};return ErrTypeCheck ;};

// PSOperand represents a Postscript operand (text string).
type PSOperand string ;func (_bafg *PSOperand )neg (_bad *PSStack )error {_ffb ,_fbcf :=_bad .Pop ();if _fbcf !=nil {return _fbcf ;};if _bace ,_agaa :=_ffb .(*PSReal );_agaa {_fbcf =_bad .Push (MakeReal (-_bace .Val ));return _fbcf ;}else if _bcad ,_bcee :=_ffb .(*PSInteger );_bcee {_fbcf =_bad .Push (MakeInteger (-_bcad .Val ));return _fbcf ;}else {return ErrTypeCheck ;};};

// NewPSExecutor returns an initialized PSExecutor for an input `program`.
func NewPSExecutor (program *PSProgram )*PSExecutor {_a :=&PSExecutor {};_a .Stack =NewPSStack ();_a ._f =program ;return _a ;};func (_cac *PSInteger )String ()string {return _b .Sprintf ("\u0025\u0064",_cac .Val )};func (_ab *PSOperand )DebugString ()string {return _b .Sprintf ("\u006fp\u003a\u0027\u0025\u0073\u0027",*_ab );};func (_bcgd *PSOperand )idiv (_gda *PSStack )error {_ada ,_affd :=_gda .Pop ();if _affd !=nil {return _affd ;};_ccc ,_affd :=_gda .Pop ();if _affd !=nil {return _affd ;};_febd ,_fdf :=_ada .(*PSInteger );if !_fdf {return ErrTypeCheck ;};if _febd .Val ==0{return ErrUndefinedResult ;};_ccged ,_fdf :=_ccc .(*PSInteger );if !_fdf {return ErrTypeCheck ;};_ceae :=_ccged .Val /_febd .Val ;_affd =_gda .Push (MakeInteger (_ceae ));return _affd ;};func (_gce *PSOperand )String ()string {return _b .Sprintf ("\u0025\u0073",*_gce )};func _ffd (_egeg int )int {if _egeg < 0{return -_egeg ;};return _egeg ;};

// NewPSParser returns a new instance of the PDF Postscript parser from input data.
func NewPSParser (content []byte )*PSParser {_ebdd :=PSParser {};_gfcc :=_e .NewBuffer (content );_ebdd ._aab =_ee .NewReader (_gfcc );return &_ebdd ;};func (_bb *PSBoolean )Duplicate ()PSObject {_dcb :=PSBoolean {};_dcb .Val =_bb .Val ;return &_dcb };var ErrStackUnderflow =_df .New ("\u0073t\u0061c\u006b\u0020\u0075\u006e\u0064\u0065\u0072\u0066\u006c\u006f\u0077");func (_dad *PSOperand )log (_fcba *PSStack )error {_fgff ,_ggd :=_fcba .PopNumberAsFloat64 ();if _ggd !=nil {return _ggd ;};_bcfc :=_ca .Log10 (_fgff );_ggd =_fcba .Push (MakeReal (_bcfc ));return _ggd ;};

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

// PopNumberAsFloat64 pops and return the numeric value of the top of the stack as a float64.
// Real or integer only.
func (_aacg *PSStack )PopNumberAsFloat64 ()(float64 ,error ){_acbe ,_dfea :=_aacg .Pop ();if _dfea !=nil {return 0,_dfea ;};if _faa ,_ced :=_acbe .(*PSReal );_ced {return _faa .Val ,nil ;}else if _acde ,_bcbf :=_acbe .(*PSInteger );_bcbf {return float64 (_acde .Val ),nil ;}else {return 0,ErrTypeCheck ;};};func (_bcd *PSBoolean )String ()string {return _b .Sprintf ("\u0025\u0076",_bcd .Val )};func (_cea *PSOperand )floor (_ccge *PSStack )error {_fbb ,_agef :=_ccge .Pop ();if _agef !=nil {return _agef ;};if _cgd ,_gbc :=_fbb .(*PSReal );_gbc {_agef =_ccge .Push (MakeReal (_ca .Floor (_cgd .Val )));}else if _dfg ,_bcc :=_fbb .(*PSInteger );_bcc {_agef =_ccge .Push (MakeInteger (_dfg .Val ));}else {return ErrTypeCheck ;};return _agef ;};func (_bc *PSBoolean )DebugString ()string {return _b .Sprintf ("\u0062o\u006f\u006c\u003a\u0025\u0076",_bc .Val );};

// PSStack defines a stack of PSObjects. PSObjects can be pushed on or pull from the stack.
type PSStack []PSObject ;func (_gbee *PSOperand )sqrt (_dadg *PSStack )error {_becg ,_adfb :=_dadg .PopNumberAsFloat64 ();if _adfb !=nil {return _adfb ;};if _becg < 0{return ErrRangeCheck ;};_acf :=_ca .Sqrt (_becg );_adfb =_dadg .Push (MakeReal (_acf ));return _adfb ;};func (_dba *PSOperand )div (_cdef *PSStack )error {_fa ,_fbea :=_cdef .Pop ();if _fbea !=nil {return _fbea ;};_cbg ,_fbea :=_cdef .Pop ();if _fbea !=nil {return _fbea ;};_dceb ,_dcf :=_fa .(*PSReal );_bagf ,_bcfa :=_fa .(*PSInteger );if !_dcf &&!_bcfa {return ErrTypeCheck ;};if _dcf &&_dceb .Val ==0{return ErrUndefinedResult ;};if _bcfa &&_bagf .Val ==0{return ErrUndefinedResult ;};_ccgg ,_fd :=_cbg .(*PSReal );_aae ,_dbd :=_cbg .(*PSInteger );if !_fd &&!_dbd {return ErrTypeCheck ;};var _bbcd float64 =0;if _fd {_bbcd =_ccgg .Val ;}else {_bbcd =float64 (_aae .Val );};if _dcf {_bbcd /=_dceb .Val ;}else {_bbcd /=float64 (_bagf .Val );};_fbea =_cdef .Push (MakeReal (_bbcd ));return _fbea ;};func (_gef *PSOperand )mul (_adaa *PSStack )error {_dae ,_fgfe :=_adaa .Pop ();if _fgfe !=nil {return _fgfe ;};_edb ,_fgfe :=_adaa .Pop ();if _fgfe !=nil {return _fgfe ;};_agda ,_edbe :=_dae .(*PSReal );_gfde ,_ffef :=_dae .(*PSInteger );if !_edbe &&!_ffef {return ErrTypeCheck ;};_decac ,_dde :=_edb .(*PSReal );_adfd ,_ebf :=_edb .(*PSInteger );if !_dde &&!_ebf {return ErrTypeCheck ;};if _ffef &&_ebf {_ebd :=_gfde .Val *_adfd .Val ;_daa :=_adaa .Push (MakeInteger (_ebd ));return _daa ;};var _adgad float64 =0;if _edbe {_adgad =_agda .Val ;}else {_adgad =float64 (_gfde .Val );};if _dde {_adgad *=_decac .Val ;}else {_adgad *=float64 (_adfd .Val );};_fgfe =_adaa .Push (MakeReal (_adgad ));return _fgfe ;};func (_dge *PSOperand )atan (_abe *PSStack )error {_cfb ,_eed :=_abe .PopNumberAsFloat64 ();if _eed !=nil {return _eed ;};_deg ,_eed :=_abe .PopNumberAsFloat64 ();if _eed !=nil {return _eed ;};if _cfb ==0{var _aga error ;if _deg < 0{_aga =_abe .Push (MakeReal (270));}else {_aga =_abe .Push (MakeReal (90));};return _aga ;};_cga :=_deg /_cfb ;_baa :=_ca .Atan (_cga )*180/_ca .Pi ;_eed =_abe .Push (MakeReal (_baa ));return _eed ;};func (_cfa *PSInteger )Duplicate ()PSObject {_dce :=PSInteger {};_dce .Val =_cfa .Val ;return &_dce };func (_aeff *PSParser )parseOperand ()(*PSOperand ,error ){var _gcge []byte ;for {_bbfd ,_ccac :=_aeff ._aab .Peek (1);if _ccac !=nil {if _ccac ==_c .EOF {break ;};return nil ,_ccac ;};if _ba .IsDelimiter (_bbfd [0]){break ;};if _ba .IsWhiteSpace (_bbfd [0]){break ;};_aebb ,_ :=_aeff ._aab .ReadByte ();_gcge =append (_gcge ,_aebb );};if len (_gcge )==0{return nil ,_df .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 (_gcge )),nil ;};

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

// 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 _aa []float64 ;for _ ,_g :=range objects {if _fe ,_eb :=_g .(*PSInteger );_eb {_aa =append (_aa ,float64 (_fe .Val ));}else if _cf ,_bg :=_g .(*PSReal );_bg {_aa =append (_aa ,_cf .Val );}else {return nil ,ErrTypeCheck ;};};return _aa ,nil ;};func (_fga *PSOperand )pop (_aecg *PSStack )error {_ ,_gac :=_aecg .Pop ();if _gac !=nil {return _gac ;};return nil ;};func (_edf *PSOperand )index (_edfg *PSStack )error {_aef ,_adb :=_edfg .Pop ();if _adb !=nil {return _adb ;};_bec ,_babg :=_aef .(*PSInteger );if !_babg {return ErrTypeCheck ;};if _bec .Val < 0{return ErrRangeCheck ;};if _bec .Val > len (*_edfg )-1{return ErrStackUnderflow ;};_gffe :=(*_edfg )[len (*_edfg )-1-_bec .Val ];_adb =_edfg .Push (_gffe .Duplicate ());return _adb ;};func (_abd *PSOperand )gt (_bbce *PSStack )error {_ffec ,_cebb :=_bbce .PopNumberAsFloat64 ();if _cebb !=nil {return _cebb ;};_dfe ,_cebb :=_bbce .PopNumberAsFloat64 ();if _cebb !=nil {return _cebb ;};if _ca .Abs (_dfe -_ffec )< _cd {_feg :=_bbce .Push (MakeBool (false ));return _feg ;}else if _dfe > _ffec {_eef :=_bbce .Push (MakeBool (true ));return _eef ;}else {_geac :=_bbce .Push (MakeBool (false ));return _geac ;};};

// String returns a string representation of the stack.
func (_gcc *PSStack )String ()string {_dcbd :="\u005b\u0020";for _ ,_beef :=range *_gcc {_dcbd +=_beef .String ();_dcbd +="\u0020";};_dcbd +="\u005d";return _dcbd ;};func (_cdcc *PSOperand )round (_decf *PSStack )error {_bgb ,_gace :=_decf .Pop ();if _gace !=nil {return _gace ;};if _ggad ,_cad :=_bgb .(*PSReal );_cad {_gace =_decf .Push (MakeReal (_ca .Floor (_ggad .Val +0.5)));}else if _ceff ,_daf :=_bgb .(*PSInteger );_daf {_gace =_decf .Push (MakeInteger (_ceff .Val ));}else {return ErrTypeCheck ;};return _gace ;};

// PSExecutor has its own execution stack and is used to executre a PS routine (program).
type PSExecutor struct{Stack *PSStack ;_f *PSProgram ;};func (_bfg *PSOperand )add (_bbe *PSStack )error {_ceee ,_cfd :=_bbe .Pop ();if _cfd !=nil {return _cfd ;};_baga ,_cfd :=_bbe .Pop ();if _cfd !=nil {return _cfd ;};_fff ,_gcg :=_ceee .(*PSReal );_ebaa ,_fbf :=_ceee .(*PSInteger );if !_gcg &&!_fbf {return ErrTypeCheck ;};_gg ,_cdd :=_baga .(*PSReal );_bga ,_ggf :=_baga .(*PSInteger );if !_cdd &&!_ggf {return ErrTypeCheck ;};if _fbf &&_ggf {_fg :=_ebaa .Val +_bga .Val ;_efd :=_bbe .Push (MakeInteger (_fg ));return _efd ;};var _fbg float64 =0;if _gcg {_fbg =_fff .Val ;}else {_fbg =float64 (_ebaa .Val );};if _cdd {_fbg +=_gg .Val ;}else {_fbg +=float64 (_bga .Val );};_cfd =_bbe .Push (MakeReal (_fbg ));return _cfd ;};var ErrRangeCheck =_df .New ("\u0072\u0061\u006e\u0067\u0065\u0020\u0063\u0068\u0065\u0063\u006b\u0020e\u0072\u0072\u006f\u0072");

// PSObject represents a postscript object.
type PSObject interface{

// Duplicate makes a fresh copy of the PSObject.
Duplicate ()PSObject ;

// DebugString returns a descriptive representation of the PSObject with more information than String()
// for debugging purposes.
DebugString ()string ;

// String returns a string representation of the PSObject.
String ()string ;};func (_dgd *PSOperand )dup (_fgd *PSStack )error {_efdc ,_cce :=_fgd .Pop ();if _cce !=nil {return _cce ;};_cce =_fgd .Push (_efdc );if _cce !=nil {return _cce ;};_cce =_fgd .Push (_efdc .Duplicate ());return _cce ;};var ErrUndefinedResult =_df .New ("\u0075\u006e\u0064\u0065fi\u006e\u0065\u0064\u0020\u0072\u0065\u0073\u0075\u006c\u0074\u0020\u0065\u0072\u0072o\u0072");

// Empty empties the stack.
func (_bcde *PSStack )Empty (){*_bcde =[]PSObject {}};func (_ffa *PSOperand )exch (_cff *PSStack )error {_cfea ,_gea :=_cff .Pop ();if _gea !=nil {return _gea ;};_fge ,_gea :=_cff .Pop ();if _gea !=nil {return _gea ;};_gea =_cff .Push (_cfea );if _gea !=nil {return _gea ;};_gea =_cff .Push (_fge );return _gea ;};func (_gdf *PSOperand )cvr (_efc *PSStack )error {_ggc ,_eec :=_efc .Pop ();if _eec !=nil {return _eec ;};if _aec ,_dbb :=_ggc .(*PSReal );_dbb {_eec =_efc .Push (MakeReal (_aec .Val ));}else if _add ,_bee :=_ggc .(*PSInteger );_bee {_eec =_efc .Push (MakeReal (float64 (_add .Val )));}else {return ErrTypeCheck ;};return _eec ;};func (_ffg *PSOperand )exp (_gad *PSStack )error {_gcb ,_dbe :=_gad .PopNumberAsFloat64 ();if _dbe !=nil {return _dbe ;};_bge ,_dbe :=_gad .PopNumberAsFloat64 ();if _dbe !=nil {return _dbe ;};if _ca .Abs (_gcb )< 1&&_bge < 0{return ErrUndefinedResult ;};_ffe :=_ca .Pow (_bge ,_gcb );_dbe =_gad .Push (MakeReal (_ffe ));return _dbe ;};func (_ceb *PSProgram )String ()string {_ac :="\u007b\u0020";for _ ,_ea :=range *_ceb {_ac +=_ea .String ();_ac +="\u0020";};_ac +="\u007d";return _ac ;};func (_bagac *PSOperand )ifCondition (_eda *PSStack )error {_fage ,_baf :=_eda .Pop ();if _baf !=nil {return _baf ;};_dfc ,_baf :=_eda .Pop ();if _baf !=nil {return _baf ;};_beac ,_afd :=_fage .(*PSProgram );if !_afd {return ErrTypeCheck ;};_gbe ,_afd :=_dfc .(*PSBoolean );if !_afd {return ErrTypeCheck ;};if _gbe .Val {_gaa :=_beac .Exec (_eda );return _gaa ;};return nil ;};func (_bdb *PSOperand )cos (_da *PSStack )error {_cc ,_baab :=_da .PopNumberAsFloat64 ();if _baab !=nil {return _baab ;};_aaa :=_ca .Cos (_cc *_ca .Pi /180.0);_baab =_da .Push (MakeReal (_aaa ));return _baab ;};

// PSProgram defines a Postscript program which is a series of PS objects (arguments, commands, programs etc).
type PSProgram []PSObject ;func (_bab *PSOperand )abs (_bbc *PSStack )error {_fbe ,_bcdb :=_bbc .Pop ();if _bcdb !=nil {return _bcdb ;};if _dca ,_ef :=_fbe .(*PSReal );_ef {_bbd :=_dca .Val ;if _bbd < 0{_bcdb =_bbc .Push (MakeReal (-_bbd ));}else {_bcdb =_bbc .Push (MakeReal (_bbd ));};}else if _age ,_cfg :=_fbe .(*PSInteger );_cfg {_bcf :=_age .Val ;if _bcf < 0{_bcdb =_bbc .Push (MakeInteger (-_bcf ));}else {_bcdb =_bbc .Push (MakeInteger (_bcf ));};}else {return ErrTypeCheck ;};return _bcdb ;};

// Exec executes the program, typically leaving output values on the stack.
func (_dcd *PSProgram )Exec (stack *PSStack )error {for _ ,_dee :=range *_dcd {var _cbc error ;switch _cg :=_dee .(type ){case *PSInteger :_ed :=_cg ;_cbc =stack .Push (_ed );case *PSReal :_fea :=_cg ;_cbc =stack .Push (_fea );case *PSBoolean :_ag :=_cg ;_cbc =stack .Push (_ag );case *PSProgram :_ff :=_cg ;_cbc =stack .Push (_ff );case *PSOperand :_fb :=_cg ;_cbc =_fb .Exec (stack );default:return ErrTypeCheck ;};if _cbc !=nil {return _cbc ;};};return nil ;};

// NewPSProgram returns an empty, initialized PSProgram.
func NewPSProgram ()*PSProgram {return &PSProgram {}};func (_gacd *PSOperand )sub (_edd *PSStack )error {_fegf ,_bfa :=_edd .Pop ();if _bfa !=nil {return _bfa ;};_fef ,_bfa :=_edd .Pop ();if _bfa !=nil {return _bfa ;};_eaf ,_eag :=_fegf .(*PSReal );_bgcg ,_cfc :=_fegf .(*PSInteger );if !_eag &&!_cfc {return ErrTypeCheck ;};_dcda ,_bdg :=_fef .(*PSReal );_fcd ,_afc :=_fef .(*PSInteger );if !_bdg &&!_afc {return ErrTypeCheck ;};if _cfc &&_afc {_caf :=_fcd .Val -_bgcg .Val ;_bcea :=_edd .Push (MakeInteger (_caf ));return _bcea ;};var _gebe float64 =0;if _bdg {_gebe =_dcda .Val ;}else {_gebe =float64 (_fcd .Val );};if _eag {_gebe -=_eaf .Val ;}else {_gebe -=float64 (_bgcg .Val );};_bfa =_edd .Push (MakeReal (_gebe ));return _bfa ;};

// MakeOperand returns a new PSOperand object based on string `val`.
func MakeOperand (val string )*PSOperand {_addf :=PSOperand (val );return &_addf };func (_cfbb *PSOperand )mod (_dfag *PSStack )error {_cfdg ,_cca :=_dfag .Pop ();if _cca !=nil {return _cca ;};_ece ,_cca :=_dfag .Pop ();if _cca !=nil {return _cca ;};_dcga ,_gab :=_cfdg .(*PSInteger );if !_gab {return ErrTypeCheck ;};if _dcga .Val ==0{return ErrUndefinedResult ;};_fdg ,_gab :=_ece .(*PSInteger );if !_gab {return ErrTypeCheck ;};_aed :=_fdg .Val %_dcga .Val ;_cca =_dfag .Push (MakeInteger (_aed ));return _cca ;};func (_eee *PSOperand )truncate (_cfca *PSStack )error {_dbee ,_gddf :=_cfca .Pop ();if _gddf !=nil {return _gddf ;};if _bage ,_fed :=_dbee .(*PSReal );_fed {_aeee :=int (_bage .Val );_gddf =_cfca .Push (MakeReal (float64 (_aeee )));}else if _ged ,_bfda :=_dbee .(*PSInteger );_bfda {_gddf =_cfca .Push (MakeInteger (_ged .Val ));}else {return ErrTypeCheck ;};return _gddf ;};

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

// PSInteger represents an integer.
type PSInteger struct{Val int ;};func (_gdd *PSOperand )bitshift (_bde *PSStack )error {_ffc ,_cfed :=_bde .PopInteger ();if _cfed !=nil {return _cfed ;};_dec ,_cfed :=_bde .PopInteger ();if _cfed !=nil {return _cfed ;};var _edc int ;if _ffc >=0{_edc =_dec <<uint (_ffc );}else {_edc =_dec >>uint (-_ffc );};_cfed =_bde .Push (MakeInteger (_edc ));return _cfed ;};

// Push pushes an object on top of the stack.
func (_afdf *PSStack )Push (obj PSObject )error {if len (*_afdf )> 100{return ErrStackOverflow ;};*_afdf =append (*_afdf ,obj );return nil ;};func (_dbc *PSOperand )ge (_agc *PSStack )error {_dd ,_fac :=_agc .PopNumberAsFloat64 ();if _fac !=nil {return _fac ;};_bed ,_fac :=_agc .PopNumberAsFloat64 ();if _fac !=nil {return _fac ;};if _ca .Abs (_bed -_dd )< _cd {_aac :=_agc .Push (MakeBool (true ));return _aac ;}else if _bed > _dd {_cdg :=_agc .Push (MakeBool (true ));return _cdg ;}else {_gff :=_agc .Push (MakeBool (false ));return _gff ;};};var ErrStackOverflow =_df .New ("\u0073\u0074\u0061\u0063\u006b\u0020\u006f\u0076\u0065r\u0066\u006c\u006f\u0077");func (_de *PSReal )String ()string {return _b .Sprintf ("\u0025\u002e\u0035\u0066",_de .Val )};var ErrUnsupportedOperand =_df .New ("\u0075\u006e\u0073\u0075pp\u006f\u0072\u0074\u0065\u0064\u0020\u006f\u0070\u0065\u0072\u0061\u006e\u0064");func (_edce *PSOperand )not (_dcac *PSStack )error {_cab ,_cgaa :=_dcac .Pop ();if _cgaa !=nil {return _cgaa ;};if _gge ,_ffefg :=_cab .(*PSBoolean );_ffefg {_cgaa =_dcac .Push (MakeBool (!_gge .Val ));return _cgaa ;}else if _gddb ,_ddc :=_cab .(*PSInteger );_ddc {_cgaa =_dcac .Push (MakeInteger (^_gddb .Val ));return _cgaa ;}else {return ErrTypeCheck ;};};

// PSBoolean represents a boolean value.
type PSBoolean struct{Val bool ;};func (_fcdf *PSParser )skipSpaces ()(int ,error ){_edff :=0;for {_gbd ,_acd :=_fcdf ._aab .Peek (1);if _acd !=nil {return 0,_acd ;};if _ba .IsWhiteSpace (_gbd [0]){_fcdf ._aab .ReadByte ();_edff ++;}else {break ;};};return _edff ,nil ;};func (_feb *PSProgram )Duplicate ()PSObject {_gcf :=&PSProgram {};for _ ,_bdf :=range *_feb {_gcf .Append (_bdf .Duplicate ());};return _gcf ;};func (_ddf *PSOperand )ln (_fgb *PSStack )error {_edgd ,_ffee :=_fgb .PopNumberAsFloat64 ();if _ffee !=nil {return _ffee ;};_fab :=_ca .Log (_edgd );_ffee =_fgb .Push (MakeReal (_fab ));return _ffee ;};func (_bgdg *PSOperand )roll (_ggce *PSStack )error {_cec ,_dfeb :=_ggce .Pop ();if _dfeb !=nil {return _dfeb ;};_gfeg ,_dfeb :=_ggce .Pop ();if _dfeb !=nil {return _dfeb ;};_adgb ,_bdbc :=_cec .(*PSInteger );if !_bdbc {return ErrTypeCheck ;};_ecd ,_bdbc :=_gfeg .(*PSInteger );if !_bdbc {return ErrTypeCheck ;};if _ecd .Val < 0{return ErrRangeCheck ;};if _ecd .Val ==0||_ecd .Val ==1{return nil ;};if _ecd .Val > len (*_ggce ){return ErrStackUnderflow ;};for _bacdg :=0;_bacdg < _ffd (_adgb .Val );_bacdg ++{var _edbg []PSObject ;_edbg =(*_ggce )[len (*_ggce )-(_ecd .Val ):len (*_ggce )];if _adgb .Val > 0{_ega :=_edbg [len (_edbg )-1];_edbg =append ([]PSObject {_ega },_edbg [0:len (_edbg )-1]...);}else {_ccb :=_edbg [len (_edbg )-_ecd .Val ];_edbg =append (_edbg [1:],_ccb );};_aefd :=append ((*_ggce )[0:len (*_ggce )-_ecd .Val ],_edbg ...);_ggce =&_aefd ;};return nil ;};func (_dcg *PSProgram )DebugString ()string {_cee :="\u007b\u0020";for _ ,_dfa :=range *_dcg {_cee +=_dfa .DebugString ();_cee +="\u0020";};_cee +="\u007d";return _cee ;};func (_bcb *PSOperand )lt (_ec *PSStack )error {_cgdc ,_bgc :=_ec .PopNumberAsFloat64 ();if _bgc !=nil {return _bgc ;};_bfb ,_bgc :=_ec .PopNumberAsFloat64 ();if _bgc !=nil {return _bgc ;};if _ca .Abs (_bfb -_cgdc )< _cd {_fad :=_ec .Push (MakeBool (false ));return _fad ;}else if _bfb < _cgdc {_gga :=_ec .Push (MakeBool (true ));return _gga ;}else {_adag :=_ec .Push (MakeBool (false ));return _adag ;};};func (_ce *PSInteger )DebugString ()string {return _b .Sprintf ("\u0069\u006e\u0074\u003a\u0025\u0064",_ce .Val );};func (_fggb *PSOperand )ifelse (_dege *PSStack )error {_bgda ,_eecc :=_dege .Pop ();if _eecc !=nil {return _eecc ;};_fcb ,_eecc :=_dege .Pop ();if _eecc !=nil {return _eecc ;};_acg ,_eecc :=_dege .Pop ();if _eecc !=nil {return _eecc ;};_adf ,_cge :=_bgda .(*PSProgram );if !_cge {return ErrTypeCheck ;};_dcef ,_cge :=_fcb .(*PSProgram );if !_cge {return ErrTypeCheck ;};_aaad ,_cge :=_acg .(*PSBoolean );if !_cge {return ErrTypeCheck ;};if _aaad .Val {_dbg :=_dcef .Exec (_dege );return _dbg ;};_eecc =_adf .Exec (_dege );return _eecc ;};

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

// MakeBool returns a new PSBoolean object initialized with `val`.
func MakeBool (val bool )*PSBoolean {_fcf :=PSBoolean {};_fcf .Val =val ;return &_fcf };func (_cgb *PSOperand )le (_gdg *PSStack )error {_cgae ,_cef :=_gdg .PopNumberAsFloat64 ();if _cef !=nil {return _cef ;};_deca ,_cef :=_gdg .PopNumberAsFloat64 ();if _cef !=nil {return _cef ;};if _ca .Abs (_deca -_cgae )< _cd {_agee :=_gdg .Push (MakeBool (true ));return _agee ;}else if _deca < _cgae {_cbd :=_gdg .Push (MakeBool (true ));return _cbd ;}else {_cbb :=_gdg .Push (MakeBool (false ));return _cbb ;};};func (_gcgg *PSParser )parseFunction ()(*PSProgram ,error ){_ffab ,_ :=_gcgg ._aab .ReadByte ();if _ffab !='{'{return nil ,_df .New ("\u0069\u006ev\u0061\u006c\u0069d\u0020\u0066\u0075\u006e\u0063\u0074\u0069\u006f\u006e");};_afg :=NewPSProgram ();for {_gcgg .skipSpaces ();_badb ,_bbb :=_gcgg ._aab .Peek (2);if _bbb !=nil {if _bbb ==_c .EOF {break ;};return nil ,_bbb ;};_dc .Log .Trace ("\u0050e\u0065k\u0020\u0073\u0074\u0072\u0069\u006e\u0067\u003a\u0020\u0025\u0073",string (_badb ));if _badb [0]=='}'{_dc .Log .Trace ("\u0045\u004f\u0046 \u0066\u0075\u006e\u0063\u0074\u0069\u006f\u006e");_gcgg ._aab .ReadByte ();break ;}else if _badb [0]=='{'{_dc .Log .Trace ("\u0046u\u006e\u0063\u0074\u0069\u006f\u006e!");_acc ,_afgg :=_gcgg .parseFunction ();if _afgg !=nil {return nil ,_afgg ;};_afg .Append (_acc );}else if _ba .IsDecimalDigit (_badb [0])||(_badb [0]=='-'&&_ba .IsDecimalDigit (_badb [1])){_dc .Log .Trace ("\u002d>\u004e\u0075\u006d\u0062\u0065\u0072!");_ggca ,_fba :=_gcgg .parseNumber ();if _fba !=nil {return nil ,_fba ;};_afg .Append (_ggca );}else {_dc .Log .Trace ("\u002d>\u004fp\u0065\u0072\u0061\u006e\u0064 \u006f\u0072 \u0062\u006f\u006f\u006c\u003f");_badb ,_ =_gcgg ._aab .Peek (5);_fdc :=string (_badb );_dc .Log .Trace ("\u0050\u0065\u0065k\u0020\u0073\u0074\u0072\u003a\u0020\u0025\u0073",_fdc );if (len (_fdc )> 4)&&(_fdc [:5]=="\u0066\u0061\u006cs\u0065"){_bafd ,_caec :=_gcgg .parseBool ();if _caec !=nil {return nil ,_caec ;};_afg .Append (_bafd );}else if (len (_fdc )> 3)&&(_fdc [:4]=="\u0074\u0072\u0075\u0065"){_bff ,_fbga :=_gcgg .parseBool ();if _fbga !=nil {return nil ,_fbga ;};_afg .Append (_bff );}else {_becc ,_gbfb :=_gcgg .parseOperand ();if _gbfb !=nil {return nil ,_gbfb ;};_afg .Append (_becc );};};};return _afg ,nil ;};func (_ddg *PSParser )parseBool ()(*PSBoolean ,error ){_agb ,_ffff :=_ddg ._aab .Peek (4);if _ffff !=nil {return MakeBool (false ),_ffff ;};if (len (_agb )>=4)&&(string (_agb [:4])=="\u0074\u0072\u0075\u0065"){_ddg ._aab .Discard (4);return MakeBool (true ),nil ;};_agb ,_ffff =_ddg ._aab .Peek (5);if _ffff !=nil {return MakeBool (false ),_ffff ;};if (len (_agb )>=5)&&(string (_agb [:5])=="\u0066\u0061\u006cs\u0065"){_ddg ._aab .Discard (5);return MakeBool (false ),nil ;};return MakeBool (false ),_df .New ("\u0075n\u0065\u0078\u0070\u0065c\u0074\u0065\u0064\u0020\u0062o\u006fl\u0065a\u006e\u0020\u0073\u0074\u0072\u0069\u006eg");};func (_bdd *PSOperand )copy (_adg *PSStack )error {_feab ,_bce :=_adg .PopInteger ();if _bce !=nil {return _bce ;};if _feab < 0{return ErrRangeCheck ;};if _feab > len (*_adg ){return ErrRangeCheck ;};*_adg =append (*_adg ,(*_adg )[len (*_adg )-_feab :]...);return nil ;};

// DebugString returns a descriptive string representation of the stack - intended for debugging.
func (_eeba *PSStack )DebugString ()string {_cbbb :="\u005b\u0020";for _ ,_cgec :=range *_eeba {_cbbb +=_cgec .DebugString ();_cbbb +="\u0020";};_cbbb +="\u005d";return _cbbb ;};func (_dab *PSOperand )or (_dfb *PSStack )error {_gdge ,_gaf :=_dfb .Pop ();if _gaf !=nil {return _gaf ;};_dgg ,_gaf :=_dfb .Pop ();if _gaf !=nil {return _gaf ;};if _gbf ,_ceeea :=_gdge .(*PSBoolean );_ceeea {_gafb ,_bdfg :=_dgg .(*PSBoolean );if !_bdfg {return ErrTypeCheck ;};_gaf =_dfb .Push (MakeBool (_gbf .Val ||_gafb .Val ));return _gaf ;};if _bfc ,_fbef :=_gdge .(*PSInteger );_fbef {_ddcc ,_bbf :=_dgg .(*PSInteger );if !_bbf {return ErrTypeCheck ;};_gaf =_dfb .Push (MakeInteger (_bfc .Val |_ddcc .Val ));return _gaf ;};return ErrTypeCheck ;};func (_cdb *PSOperand )Duplicate ()PSObject {_cae :=*_cdb ;return &_cae };func (_dggf *PSOperand )sin (_efg *PSStack )error {_aee ,_edcd :=_efg .PopNumberAsFloat64 ();if _edcd !=nil {return _edcd ;};_daed :=_ca .Sin (_aee *_ca .Pi /180.0);_edcd =_efg .Push (MakeReal (_daed ));return _edcd ;};

// Pop pops an object from the top of the stack.
func (_deb *PSStack )Pop ()(PSObject ,error ){if len (*_deb )< 1{return nil ,ErrStackUnderflow ;};_dgdf :=(*_deb )[len (*_deb )-1];*_deb =(*_deb )[0:len (*_deb )-1];return _dgdf ,nil ;};func (_gca *PSOperand )ceiling (_fffb *PSStack )error {_abc ,_cgc :=_fffb .Pop ();if _cgc !=nil {return _cgc ;};if _gcee ,_gb :=_abc .(*PSReal );_gb {_cgc =_fffb .Push (MakeReal (_ca .Ceil (_gcee .Val )));}else if _cgad ,_bfd :=_abc .(*PSInteger );_bfd {_cgc =_fffb .Push (MakeInteger (_cgad .Val ));}else {_cgc =ErrTypeCheck ;};return _cgc ;};func (_ead *PSOperand )and (_bcg *PSStack )error {_gf ,_cde :=_bcg .Pop ();if _cde !=nil {return _cde ;};_ad ,_cde :=_bcg .Pop ();if _cde !=nil {return _cde ;};if _bca ,_fgf :=_gf .(*PSBoolean );_fgf {_ebb ,_dg :=_ad .(*PSBoolean );if !_dg {return ErrTypeCheck ;};_cde =_bcg .Push (MakeBool (_bca .Val &&_ebb .Val ));return _cde ;};if _gd ,_cdc :=_gf .(*PSInteger );_cdc {_gfe ,_ga :=_ad .(*PSInteger );if !_ga {return ErrTypeCheck ;};_cde =_bcg .Push (MakeInteger (_gd .Val &_gfe .Val ));return _cde ;};return ErrTypeCheck ;};func (_bgf *PSReal )DebugString ()string {return _b .Sprintf ("\u0072e\u0061\u006c\u003a\u0025\u002e\u0035f",_bgf .Val );};func (_cgdb *PSOperand )ne (_bbcc *PSStack )error {_bae :=_cgdb .eq (_bbcc );if _bae !=nil {return _bae ;};_bae =_cgdb .not (_bbcc );return _bae ;};const _cd =0.000001;var ErrTypeCheck =_df .New ("\u0074\u0079p\u0065\u0020\u0063h\u0065\u0063\u006b\u0020\u0065\u0072\u0072\u006f\u0072");

// Execute executes the program for an input parameters `objects` and returns a slice of output objects.
func (_bf *PSExecutor )Execute (objects []PSObject )([]PSObject ,error ){for _ ,_eg :=range objects {_gc :=_bf .Stack .Push (_eg );if _gc !=nil {return nil ,_gc ;};};_db :=_bf ._f .Exec (_bf .Stack );if _db !=nil {_dc .Log .Debug ("\u0045x\u0065c\u0020\u0066\u0061\u0069\u006c\u0065\u0064\u003a\u0020\u0025\u0076",_db );return nil ,_db ;};_cfe :=[]PSObject (*_bf .Stack );_bf .Stack .Empty ();return _cfe ,nil ;};func (_ccd *PSParser )parseNumber ()(PSObject ,error ){_decc ,_cgbg :=_ba .ParseNumber (_ccd ._aab );if _cgbg !=nil {return nil ,_cgbg ;};switch _bdc :=_decc .(type ){case *_ba .PdfObjectFloat :return MakeReal (float64 (*_bdc )),nil ;case *_ba .PdfObjectInteger :return MakeInteger (int (*_bdc )),nil ;};return nil ,_b .Errorf ("\u0075n\u0068\u0061\u006e\u0064\u006c\u0065\u0064\u0020\u006e\u0075\u006db\u0065\u0072\u0020\u0074\u0079\u0070\u0065\u0020\u0025\u0054",_decc );};

// Parse parses the postscript and store as a program that can be executed.
func (_bfbg *PSParser )Parse ()(*PSProgram ,error ){_bfbg .skipSpaces ();_gdc ,_bfgd :=_bfbg ._aab .Peek (2);if _bfgd !=nil {return nil ,_bfgd ;};if _gdc [0]!='{'{return nil ,_df .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");};_ffca ,_bfgd :=_bfbg .parseFunction ();if _bfgd !=nil &&_bfgd !=_c .EOF {return nil ,_bfgd ;};return _ffca ,_bfgd ;};

// MakeInteger returns a new PSInteger object initialized with `val`.
func MakeInteger (val int )*PSInteger {_ebdb :=PSInteger {};_ebdb .Val =val ;return &_ebdb };func (_egb *PSOperand )eq (_ege *PSStack )error {_edg ,_adga :=_ege .Pop ();if _adga !=nil {return _adga ;};_gfd ,_adga :=_ege .Pop ();if _adga !=nil {return _adga ;};_gfb ,_gfc :=_edg .(*PSBoolean );_efe ,_dgb :=_gfd .(*PSBoolean );if _gfc ||_dgb {var _geb error ;if _gfc &&_dgb {_geb =_ege .Push (MakeBool (_gfb .Val ==_efe .Val ));}else {_geb =_ege .Push (MakeBool (false ));};return _geb ;};var _fag float64 ;var _agd float64 ;if _bacd ,_fbd :=_edg .(*PSInteger );_fbd {_fag =float64 (_bacd .Val );}else if _ccef ,_cagg :=_edg .(*PSReal );_cagg {_fag =_ccef .Val ;}else {return ErrTypeCheck ;};if _fc ,_abcd :=_gfd .(*PSInteger );_abcd {_agd =float64 (_fc .Val );}else if _bea ,_eadc :=_gfd .(*PSReal );_eadc {_agd =_bea .Val ;}else {return ErrTypeCheck ;};if _ca .Abs (_agd -_fag )< _cd {_adga =_ege .Push (MakeBool (true ));}else {_adga =_ege .Push (MakeBool (false ));};return _adga ;};func (_bac *PSOperand )cvi (_ccg *PSStack )error {_fbc ,_cgf :=_ccg .Pop ();if _cgf !=nil {return _cgf ;};if _cdce ,_fgg :=_fbc .(*PSReal );_fgg {_cdf :=int (_cdce .Val );_cgf =_ccg .Push (MakeInteger (_cdf ));}else if _ae ,_aff :=_fbc .(*PSInteger );_aff {_ace :=_ae .Val ;_cgf =_ccg .Push (MakeInteger (_ace ));}else {return ErrTypeCheck ;};return _cgf ;};

// PSParser is a basic Postscript parser.
type PSParser struct{_aab *_ee .Reader };