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 (_be "bufio";_d "bytes";_b "errors";_da "fmt";_a "github.com/unidoc/unipdf/v3/common";_ed "github.com/unidoc/unipdf/v3/core";_ea "io";_g "math";);

// NewPSProgram returns an empty, initialized PSProgram.
func NewPSProgram ()*PSProgram {return &PSProgram {}};var ErrRangeCheck =_b .New ("\u0072\u0061\u006e\u0067\u0065\u0020\u0063\u0068\u0065\u0063\u006b\u0020e\u0072\u0072\u006f\u0072");func (_bade *PSOperand )round (_ffga *PSStack )error {_ada ,_gfcc :=_ffga .Pop ();if _gfcc !=nil {return _gfcc ;};if _ebbd ,_bbce :=_ada .(*PSReal );_bbce {_gfcc =_ffga .Push (MakeReal (_g .Floor (_ebbd .Val +0.5)));}else if _ggdd ,_edee :=_ada .(*PSInteger );_edee {_gfcc =_ffga .Push (MakeInteger (_ggdd .Val ));}else {return ErrTypeCheck ;};return _gfcc ;};func (_ffg *PSReal )String ()string {return _da .Sprintf ("\u0025\u002e\u0035\u0066",_ffg .Val )};func _bdg (_fdf int )int {if _fdf < 0{return -_fdf ;};return _fdf ;};func (_egac *PSOperand )sqrt (_fgdg *PSStack )error {_cca ,_fdge :=_fgdg .PopNumberAsFloat64 ();if _fdge !=nil {return _fdge ;};if _cca < 0{return ErrRangeCheck ;};_ddfa :=_g .Sqrt (_cca );_fdge =_fgdg .Push (MakeReal (_ddfa ));return _fdge ;};func (_cgcg *PSOperand )eq (_deb *PSStack )error {_abg ,_ffd :=_deb .Pop ();if _ffd !=nil {return _ffd ;};_cba ,_ffd :=_deb .Pop ();if _ffd !=nil {return _ffd ;};_ecdd ,_fbdf :=_abg .(*PSBoolean );_dgba ,_gfb :=_cba .(*PSBoolean );if _fbdf ||_gfb {var _agc error ;if _fbdf &&_gfb {_agc =_deb .Push (MakeBool (_ecdd .Val ==_dgba .Val ));}else {_agc =_deb .Push (MakeBool (false ));};return _agc ;};var _fdc float64 ;var _cbgb float64 ;if _adb ,_dcf :=_abg .(*PSInteger );_dcf {_fdc =float64 (_adb .Val );}else if _efb ,_gdb :=_abg .(*PSReal );_gdb {_fdc =_efb .Val ;}else {return ErrTypeCheck ;};if _fdb ,_bdef :=_cba .(*PSInteger );_bdef {_cbgb =float64 (_fdb .Val );}else if _febd ,_ede :=_cba .(*PSReal );_ede {_cbgb =_febd .Val ;}else {return ErrTypeCheck ;};if _g .Abs (_cbgb -_fdc )< _c {_ffd =_deb .Push (MakeBool (true ));}else {_ffd =_deb .Push (MakeBool (false ));};return _ffd ;};func (_eae *PSOperand )and (_gbc *PSStack )error {_ebf ,_gcb :=_gbc .Pop ();if _gcb !=nil {return _gcb ;};_dfg ,_gcb :=_gbc .Pop ();if _gcb !=nil {return _gcb ;};if _fda ,_cad :=_ebf .(*PSBoolean );_cad {_bfb ,_gfdg :=_dfg .(*PSBoolean );if !_gfdg {return ErrTypeCheck ;};_gcb =_gbc .Push (MakeBool (_fda .Val &&_bfb .Val ));return _gcb ;};if _abe ,_begc :=_ebf .(*PSInteger );_begc {_dd ,_bga :=_dfg .(*PSInteger );if !_bga {return ErrTypeCheck ;};_gcb =_gbc .Push (MakeInteger (_abe .Val &_dd .Val ));return _gcb ;};return ErrTypeCheck ;};func (_ggf *PSOperand )idiv (_dabg *PSStack )error {_feba ,_gbf :=_dabg .Pop ();if _gbf !=nil {return _gbf ;};_fgae ,_gbf :=_dabg .Pop ();if _gbf !=nil {return _gbf ;};_gbfb ,_eca :=_feba .(*PSInteger );if !_eca {return ErrTypeCheck ;};if _gbfb .Val ==0{return ErrUndefinedResult ;};_dge ,_eca :=_fgae .(*PSInteger );if !_eca {return ErrTypeCheck ;};_cbf :=_dge .Val /_gbfb .Val ;_gbf =_dabg .Push (MakeInteger (_cbf ));return _gbf ;};func (_ceb *PSOperand )div (_cdd *PSStack )error {_eed ,_abec :=_cdd .Pop ();if _abec !=nil {return _abec ;};_ffc ,_abec :=_cdd .Pop ();if _abec !=nil {return _abec ;};_cga ,_fdee :=_eed .(*PSReal );_egb ,_fcee :=_eed .(*PSInteger );if !_fdee &&!_fcee {return ErrTypeCheck ;};if _fdee &&_cga .Val ==0{return ErrUndefinedResult ;};if _fcee &&_egb .Val ==0{return ErrUndefinedResult ;};_efa ,_bcd :=_ffc .(*PSReal );_ebac ,_ded :=_ffc .(*PSInteger );if !_bcd &&!_ded {return ErrTypeCheck ;};var _cfea float64 ;if _bcd {_cfea =_efa .Val ;}else {_cfea =float64 (_ebac .Val );};if _fdee {_cfea /=_cga .Val ;}else {_cfea /=float64 (_egb .Val );};_abec =_cdd .Push (MakeReal (_cfea ));return _abec ;};func (_gfa *PSOperand )le (_cacf *PSStack )error {_fdg ,_dgea :=_cacf .PopNumberAsFloat64 ();if _dgea !=nil {return _dgea ;};_cab ,_dgea :=_cacf .PopNumberAsFloat64 ();if _dgea !=nil {return _dgea ;};if _g .Abs (_cab -_fdg )< _c {_dde :=_cacf .Push (MakeBool (true ));return _dde ;}else if _cab < _fdg {_cbd :=_cacf .Push (MakeBool (true ));return _cbd ;}else {_cgd :=_cacf .Push (MakeBool (false ));return _cgd ;};};

// DebugString returns a descriptive string representation of the stack - intended for debugging.
func (_ggbe *PSStack )DebugString ()string {_dffa :="\u005b\u0020";for _ ,_cbe :=range *_ggbe {_dffa +=_cbe .DebugString ();_dffa +="\u0020";};_dffa +="\u005d";return _dffa ;};func (_bb *PSReal )DebugString ()string {return _da .Sprintf ("\u0072e\u0061\u006c\u003a\u0025\u002e\u0035f",_bb .Val );};func (_bad *PSOperand )ln (_ggc *PSStack )error {_gdcg ,_cgde :=_ggc .PopNumberAsFloat64 ();if _cgde !=nil {return _cgde ;};_fbf :=_g .Log (_gdcg );_cgde =_ggc .Push (MakeReal (_fbf ));return _cgde ;};func (_efeb *PSOperand )sin (_faf *PSStack )error {_bdd ,_eadg :=_faf .PopNumberAsFloat64 ();if _eadg !=nil {return _eadg ;};_cfd :=_g .Sin (_bdd *_g .Pi /180.0);_eadg =_faf .Push (MakeReal (_cfd ));return _eadg ;};func (_gbce *PSParser )parseNumber ()(PSObject ,error ){_afgdc ,_agff :=_ed .ParseNumber (_gbce ._fdcc );if _agff !=nil {return nil ,_agff ;};switch _agcg :=_afgdc .(type ){case *_ed .PdfObjectFloat :return MakeReal (float64 (*_agcg )),nil ;case *_ed .PdfObjectInteger :return MakeInteger (int (*_agcg )),nil ;};return nil ,_da .Errorf ("\u0075n\u0068\u0061\u006e\u0064\u006c\u0065\u0064\u0020\u006e\u0075\u006db\u0065\u0072\u0020\u0074\u0079\u0070\u0065\u0020\u0025\u0054",_afgdc );};func (_afc *PSOperand )copy (_cag *PSStack )error {_eac ,_aeec :=_cag .PopInteger ();if _aeec !=nil {return _aeec ;};if _eac < 0{return ErrRangeCheck ;};if _eac > len (*_cag ){return ErrRangeCheck ;};*_cag =append (*_cag ,(*_cag )[len (*_cag )-_eac :]...);return nil ;};func (_gf *PSBoolean )DebugString ()string {return _da .Sprintf ("\u0062o\u006f\u006c\u003a\u0025\u0076",_gf .Val );};var ErrStackUnderflow =_b .New ("\u0073t\u0061c\u006b\u0020\u0075\u006e\u0064\u0065\u0072\u0066\u006c\u006f\u0077");func (_ce *PSProgram )Duplicate ()PSObject {_dc :=&PSProgram {};for _ ,_aff :=range *_ce {_dc .Append (_aff .Duplicate ());};return _dc ;};func (_dfb *PSOperand )exch (_gae *PSStack )error {_dba ,_cebc :=_gae .Pop ();if _cebc !=nil {return _cebc ;};_gcbb ,_cebc :=_gae .Pop ();if _cebc !=nil {return _cebc ;};_cebc =_gae .Push (_dba );if _cebc !=nil {return _cebc ;};_cebc =_gae .Push (_gcbb );return _cebc ;};

// Append appends an object to the PSProgram.
func (_gaa *PSProgram )Append (obj PSObject ){*_gaa =append (*_gaa ,obj )};func (_cg *PSOperand )add (_eba *PSStack )error {_fe ,_gc :=_eba .Pop ();if _gc !=nil {return _gc ;};_ab ,_gc :=_eba .Pop ();if _gc !=nil {return _gc ;};_aa ,_ca :=_fe .(*PSReal );_eccb ,_ega :=_fe .(*PSInteger );if !_ca &&!_ega {return ErrTypeCheck ;};_aeb ,_cac :=_ab .(*PSReal );_aaf ,_aab :=_ab .(*PSInteger );if !_cac &&!_aab {return ErrTypeCheck ;};if _ega &&_aab {_bc :=_eccb .Val +_aaf .Val ;_afb :=_eba .Push (MakeInteger (_bc ));return _afb ;};var _bf float64 ;if _ca {_bf =_aa .Val ;}else {_bf =float64 (_eccb .Val );};if _cac {_bf +=_aeb .Val ;}else {_bf +=float64 (_aaf .Val );};_gc =_eba .Push (MakeReal (_bf ));return _gc ;};func (_cbab *PSOperand )index (_ecaa *PSStack )error {_dad ,_adf :=_ecaa .Pop ();if _adf !=nil {return _adf ;};_dag ,_fbgf :=_dad .(*PSInteger );if !_fbgf {return ErrTypeCheck ;};if _dag .Val < 0{return ErrRangeCheck ;};if _dag .Val > len (*_ecaa )-1{return ErrStackUnderflow ;};_aca :=(*_ecaa )[len (*_ecaa )-1-_dag .Val ];_adf =_ecaa .Push (_aca .Duplicate ());return _adf ;};

// Exec executes the program, typically leaving output values on the stack.
func (_cfa *PSProgram )Exec (stack *PSStack )error {for _ ,_edb :=range *_cfa {var _ac error ;switch _dgd :=_edb .(type ){case *PSInteger :_egc :=_dgd ;_ac =stack .Push (_egc );case *PSReal :_bg :=_dgd ;_ac =stack .Push (_bg );case *PSBoolean :_fde :=_dgd ;_ac =stack .Push (_fde );case *PSProgram :_dab :=_dgd ;_ac =stack .Push (_dab );case *PSOperand :_bbc :=_dgd ;_ac =_bbc .Exec (stack );default:return ErrTypeCheck ;};if _ac !=nil {return _ac ;};};return nil ;};func (_cd *PSBoolean )Duplicate ()PSObject {_ge :=PSBoolean {};_ge .Val =_cd .Val ;return &_ge };func (_bgc *PSOperand )mod (_cfee *PSStack )error {_bff ,_abd :=_cfee .Pop ();if _abd !=nil {return _abd ;};_fba ,_abd :=_cfee .Pop ();if _abd !=nil {return _abd ;};_eace ,_bdb :=_bff .(*PSInteger );if !_bdb {return ErrTypeCheck ;};if _eace .Val ==0{return ErrUndefinedResult ;};_bbe ,_bdb :=_fba .(*PSInteger );if !_bdb {return ErrTypeCheck ;};_gbb :=_bbe .Val %_eace .Val ;_abd =_cfee .Push (MakeInteger (_gbb ));return _abd ;};

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

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

// PSParser is a basic Postscript parser.
type PSParser struct{_fdcc *_be .Reader };func (_ggfd *PSOperand )roll (_ceca *PSStack )error {_cadg ,_bfaf :=_ceca .Pop ();if _bfaf !=nil {return _bfaf ;};_gfbe ,_bfaf :=_ceca .Pop ();if _bfaf !=nil {return _bfaf ;};_bed ,_ccff :=_cadg .(*PSInteger );if !_ccff {return ErrTypeCheck ;};_dbe ,_ccff :=_gfbe .(*PSInteger );if !_ccff {return ErrTypeCheck ;};if _dbe .Val < 0{return ErrRangeCheck ;};if _dbe .Val ==0||_dbe .Val ==1{return nil ;};if _dbe .Val > len (*_ceca ){return ErrStackUnderflow ;};for _fagb :=0;_fagb < _bdg (_bed .Val );_fagb ++{var _cdff []PSObject ;_cdff =(*_ceca )[len (*_ceca )-(_dbe .Val ):len (*_ceca )];if _bed .Val > 0{_dce :=_cdff [len (_cdff )-1];_cdff =append ([]PSObject {_dce },_cdff [0:len (_cdff )-1]...);}else {_cefb :=_cdff [len (_cdff )-_dbe .Val ];_cdff =append (_cdff [1:],_cefb );};_bec :=append ((*_ceca )[0:len (*_ceca )-_dbe .Val ],_cdff ...);_ceca =&_bec ;};return nil ;};

// PopNumberAsFloat64 pops and return the numeric value of the top of the stack as a float64.
// Real or integer only.
func (_ffbb *PSStack )PopNumberAsFloat64 ()(float64 ,error ){_cdbg ,_aafc :=_ffbb .Pop ();if _aafc !=nil {return 0,_aafc ;};if _eefe ,_fgg :=_cdbg .(*PSReal );_fgg {return _eefe .Val ,nil ;}else if _fbff ,_add :=_cdbg .(*PSInteger );_add {return float64 (_fbff .Val ),nil ;}else {return 0,ErrTypeCheck ;};};func (_dg *PSProgram )String ()string {_eg :="\u007b\u0020";for _ ,_ffb :=range *_dg {_eg +=_ffb .String ();_eg +="\u0020";};_eg +="\u007d";return _eg ;};

// MakeOperand returns a new PSOperand object based on string `val`.
func MakeOperand (val string )*PSOperand {_deba :=PSOperand (val );return &_deba };func (_dcb *PSOperand )cvi (_bdc *PSStack )error {_bbf ,_bdcg :=_bdc .Pop ();if _bdcg !=nil {return _bdcg ;};if _ad ,_aba :=_bbf .(*PSReal );_aba {_ebb :=int (_ad .Val );_bdcg =_bdc .Push (MakeInteger (_ebb ));}else if _caf ,_bde :=_bbf .(*PSInteger );_bde {_aafb :=_caf .Val ;_bdcg =_bdc .Push (MakeInteger (_aafb ));}else {return ErrTypeCheck ;};return _bdcg ;};

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

// PSExecutor has its own execution stack and is used to executre a PS routine (program).
type PSExecutor struct{Stack *PSStack ;_f *PSProgram ;};func (_ddeb *PSOperand )not (_efab *PSStack )error {_ffdc ,_afba :=_efab .Pop ();if _afba !=nil {return _afba ;};if _fffb ,_agg :=_ffdc .(*PSBoolean );_agg {_afba =_efab .Push (MakeBool (!_fffb .Val ));return _afba ;}else if _baa ,_bcc :=_ffdc .(*PSInteger );_bcc {_afba =_efab .Push (MakeInteger (^_baa .Val ));return _afba ;}else {return ErrTypeCheck ;};};func (_cf *PSProgram )DebugString ()string {_edf :="\u007b\u0020";for _ ,_fceg :=range *_cf {_edf +=_fceg .DebugString ();_edf +="\u0020";};_edf +="\u007d";return _edf ;};

// Parse parses the postscript and store as a program that can be executed.
func (_dfce *PSParser )Parse ()(*PSProgram ,error ){_dfce .skipSpaces ();_cdb ,_fbge :=_dfce ._fdcc .Peek (2);if _fbge !=nil {return nil ,_fbge ;};if _cdb [0]!='{'{return nil ,_b .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");};_gef ,_fbge :=_dfce .parseFunction ();if _fbge !=nil &&_fbge !=_ea .EOF {return nil ,_fbge ;};return _gef ,_fbge ;};func (_faba *PSParser )skipSpaces ()(int ,error ){_ccad :=0;for {_egag ,_afab :=_faba ._fdcc .Peek (1);if _afab !=nil {return 0,_afab ;};if _ed .IsWhiteSpace (_egag [0]){_faba ._fdcc .ReadByte ();_ccad ++;}else {break ;};};return _ccad ,nil ;};func (_dabgb *PSOperand )ifelse (_dcbf *PSStack )error {_gbd ,_cece :=_dcbf .Pop ();if _cece !=nil {return _cece ;};_aac ,_cece :=_dcbf .Pop ();if _cece !=nil {return _cece ;};_aaa ,_cece :=_dcbf .Pop ();if _cece !=nil {return _cece ;};_cfb ,_gfc :=_gbd .(*PSProgram );if !_gfc {return ErrTypeCheck ;};_bac ,_gfc :=_aac .(*PSProgram );if !_gfc {return ErrTypeCheck ;};_bfd ,_gfc :=_aaa .(*PSBoolean );if !_gfc {return ErrTypeCheck ;};if _bfd .Val {_efce :=_bac .Exec (_dcbf );return _efce ;};_cece =_cfb .Exec (_dcbf );return _cece ;};func (_aeg *PSOperand )cos (_gfg *PSStack )error {_dga ,_bfc :=_gfg .PopNumberAsFloat64 ();if _bfc !=nil {return _bfc ;};_de :=_g .Cos (_dga *_g .Pi /180.0);_bfc =_gfg .Push (MakeReal (_de ));return _bfc ;};func (_cafg *PSOperand )sub (_geag *PSStack )error {_ccfe ,_gce :=_geag .Pop ();if _gce !=nil {return _gce ;};_cefd ,_gce :=_geag .Pop ();if _gce !=nil {return _gce ;};_eef ,_cae :=_ccfe .(*PSReal );_abea ,_dbef :=_ccfe .(*PSInteger );if !_cae &&!_dbef {return ErrTypeCheck ;};_abdg ,_deed :=_cefd .(*PSReal );_abcd ,_ggb :=_cefd .(*PSInteger );if !_deed &&!_ggb {return ErrTypeCheck ;};if _dbef &&_ggb {_fae :=_abcd .Val -_abea .Val ;_gag :=_geag .Push (MakeInteger (_fae ));return _gag ;};var _gfgc float64 =0;if _deed {_gfgc =_abdg .Val ;}else {_gfgc =float64 (_abcd .Val );};if _cae {_gfgc -=_eef .Val ;}else {_gfgc -=float64 (_abea .Val );};_gce =_geag .Push (MakeReal (_gfgc ));return _gce ;};func (_db *PSOperand )ceiling (_gea *PSStack )error {_gadd ,_gdf :=_gea .Pop ();if _gdf !=nil {return _gdf ;};if _fcd ,_bcg :=_gadd .(*PSReal );_bcg {_gdf =_gea .Push (MakeReal (_g .Ceil (_fcd .Val )));}else if _afg ,_ba :=_gadd .(*PSInteger );_ba {_gdf =_gea .Push (MakeInteger (_afg .Val ));}else {_gdf =ErrTypeCheck ;};return _gdf ;};func (_gdbg *PSOperand )pop (_acaa *PSStack )error {_ ,_baf :=_acaa .Pop ();if _baf !=nil {return _baf ;};return nil ;};

// 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 _eab []float64 ;for _ ,_cc :=range objects {if _ead ,_dff :=_cc .(*PSInteger );_dff {_eab =append (_eab ,float64 (_ead .Val ));}else if _fc ,_gb :=_cc .(*PSReal );_gb {_eab =append (_eab ,_fc .Val );}else {return nil ,ErrTypeCheck ;};};return _eab ,nil ;};

// PSStack defines a stack of PSObjects. PSObjects can be pushed on or pull from the stack.
type PSStack []PSObject ;func (_fgb *PSOperand )abs (_cb *PSStack )error {_gfd ,_egg :=_cb .Pop ();if _egg !=nil {return _egg ;};if _aee ,_fbg :=_gfd .(*PSReal );_fbg {_ecc :=_aee .Val ;if _ecc < 0{_egg =_cb .Push (MakeReal (-_ecc ));}else {_egg =_cb .Push (MakeReal (_ecc ));};}else if _eccd ,_fbe :=_gfd .(*PSInteger );_fbe {_eb :=_eccd .Val ;if _eb < 0{_egg =_cb .Push (MakeInteger (-_eb ));}else {_egg =_cb .Push (MakeInteger (_eb ));};}else {return ErrTypeCheck ;};return _egg ;};func (_bbb *PSParser )parseOperand ()(*PSOperand ,error ){var _bffbf []byte ;for {_fafb ,_fddec :=_bbb ._fdcc .Peek (1);if _fddec !=nil {if _fddec ==_ea .EOF {break ;};return nil ,_fddec ;};if _ed .IsDelimiter (_fafb [0]){break ;};if _ed .IsWhiteSpace (_fafb [0]){break ;};_fecf ,_ :=_bbb ._fdcc .ReadByte ();_bffbf =append (_bffbf ,_fecf );};if len (_bffbf )==0{return nil ,_b .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 (_bffbf )),nil ;};func (_dgb *PSOperand )DebugString ()string {return _da .Sprintf ("\u006fp\u003a\u0027\u0025\u0073\u0027",*_dgb );};var ErrTypeCheck =_b .New ("\u0074\u0079p\u0065\u0020\u0063h\u0065\u0063\u006b\u0020\u0065\u0072\u0072\u006f\u0072");

// PopInteger specificially pops an integer from the top of the stack, returning the value as an int.
func (_fcde *PSStack )PopInteger ()(int ,error ){_afd ,_cfeb :=_fcde .Pop ();if _cfeb !=nil {return 0,_cfeb ;};if _ecb ,_ffgf :=_afd .(*PSInteger );_ffgf {return _ecb .Val ,nil ;};return 0,ErrTypeCheck ;};

// Pop pops an object from the top of the stack.
func (_ggce *PSStack )Pop ()(PSObject ,error ){if len (*_ggce )< 1{return nil ,ErrStackUnderflow ;};_dadb :=(*_ggce )[len (*_ggce )-1];*_ggce =(*_ggce )[0:len (*_ggce )-1];return _dadb ,nil ;};func (_ffba *PSParser )parseBool ()(*PSBoolean ,error ){_gaag ,_adag :=_ffba ._fdcc .Peek (4);if _adag !=nil {return MakeBool (false ),_adag ;};if (len (_gaag )>=4)&&(string (_gaag [:4])=="\u0074\u0072\u0075\u0065"){_ffba ._fdcc .Discard (4);return MakeBool (true ),nil ;};_gaag ,_adag =_ffba ._fdcc .Peek (5);if _adag !=nil {return MakeBool (false ),_adag ;};if (len (_gaag )>=5)&&(string (_gaag [:5])=="\u0066\u0061\u006cs\u0065"){_ffba ._fdcc .Discard (5);return MakeBool (false ),nil ;};return MakeBool (false ),_b .New ("\u0075n\u0065\u0078\u0070\u0065c\u0074\u0065\u0064\u0020\u0062o\u006fl\u0065a\u006e\u0020\u0073\u0074\u0072\u0069\u006eg");};func (_dcg *PSOperand )floor (_ddf *PSStack )error {_bfa ,_aegg :=_ddf .Pop ();if _aegg !=nil {return _aegg ;};if _aafg ,_eaed :=_bfa .(*PSReal );_eaed {_aegg =_ddf .Push (MakeReal (_g .Floor (_aafg .Val )));}else if _efe ,_gbe :=_bfa .(*PSInteger );_gbe {_aegg =_ddf .Push (MakeInteger (_efe .Val ));}else {return ErrTypeCheck ;};return _aegg ;};func (_fced *PSOperand )String ()string {return string (*_fced )};func (_dbc *PSParser )parseFunction ()(*PSProgram ,error ){_bacb ,_ :=_dbc ._fdcc .ReadByte ();if _bacb !='{'{return nil ,_b .New ("\u0069\u006ev\u0061\u006c\u0069d\u0020\u0066\u0075\u006e\u0063\u0074\u0069\u006f\u006e");};_cee :=NewPSProgram ();for {_dbc .skipSpaces ();_gefe ,_eecb :=_dbc ._fdcc .Peek (2);if _eecb !=nil {if _eecb ==_ea .EOF {break ;};return nil ,_eecb ;};_a .Log .Trace ("\u0050e\u0065k\u0020\u0073\u0074\u0072\u0069\u006e\u0067\u003a\u0020\u0025\u0073",string (_gefe ));if _gefe [0]=='}'{_a .Log .Trace ("\u0045\u004f\u0046 \u0066\u0075\u006e\u0063\u0074\u0069\u006f\u006e");_dbc ._fdcc .ReadByte ();break ;}else if _gefe [0]=='{'{_a .Log .Trace ("\u0046u\u006e\u0063\u0074\u0069\u006f\u006e!");_dgf ,_fcega :=_dbc .parseFunction ();if _fcega !=nil {return nil ,_fcega ;};_cee .Append (_dgf );}else if _ed .IsDecimalDigit (_gefe [0])||(_gefe [0]=='-'&&_ed .IsDecimalDigit (_gefe [1])){_a .Log .Trace ("\u002d>\u004e\u0075\u006d\u0062\u0065\u0072!");_affg ,_afgd :=_dbc .parseNumber ();if _afgd !=nil {return nil ,_afgd ;};_cee .Append (_affg );}else {_a .Log .Trace ("\u002d>\u004fp\u0065\u0072\u0061\u006e\u0064 \u006f\u0072 \u0062\u006f\u006f\u006c\u003f");_gefe ,_ =_dbc ._fdcc .Peek (5);_fceb :=string (_gefe );_a .Log .Trace ("\u0050\u0065\u0065k\u0020\u0073\u0074\u0072\u003a\u0020\u0025\u0073",_fceb );if (len (_fceb )> 4)&&(_fceb [:5]=="\u0066\u0061\u006cs\u0065"){_bdee ,_gcd :=_dbc .parseBool ();if _gcd !=nil {return nil ,_gcd ;};_cee .Append (_bdee );}else if (len (_fceb )> 3)&&(_fceb [:4]=="\u0074\u0072\u0075\u0065"){_egd ,_eddgg :=_dbc .parseBool ();if _eddgg !=nil {return nil ,_eddgg ;};_cee .Append (_egd );}else {_aggb ,_bdbg :=_dbc .parseOperand ();if _bdbg !=nil {return nil ,_bdbg ;};_cee .Append (_aggb );};};};return _cee ,nil ;};func (_ggad *PSOperand )xor (_agf *PSStack )error {_bffb ,_eedd :=_agf .Pop ();if _eedd !=nil {return _eedd ;};_aceb ,_eedd :=_agf .Pop ();if _eedd !=nil {return _eedd ;};if _cfbf ,_cadc :=_bffb .(*PSBoolean );_cadc {_gfba ,_eec :=_aceb .(*PSBoolean );if !_eec {return ErrTypeCheck ;};_eedd =_agf .Push (MakeBool (_cfbf .Val !=_gfba .Val ));return _eedd ;};if _dgc ,_ggbg :=_bffb .(*PSInteger );_ggbg {_efef ,_geb :=_aceb .(*PSInteger );if !_geb {return ErrTypeCheck ;};_eedd =_agf .Push (MakeInteger (_dgc .Val ^_efef .Val ));return _eedd ;};return ErrTypeCheck ;};const _c =0.000001;

// MakeInteger returns a new PSInteger object initialized with `val`.
func MakeInteger (val int )*PSInteger {_eaba :=PSInteger {};_eaba .Val =val ;return &_eaba };func (_eddgb *PSOperand )or (_aegb *PSStack )error {_gab ,_ddc :=_aegb .Pop ();if _ddc !=nil {return _ddc ;};_daa ,_ddc :=_aegb .Pop ();if _ddc !=nil {return _ddc ;};if _bagb ,_egcb :=_gab .(*PSBoolean );_egcb {_fgde ,_bdea :=_daa .(*PSBoolean );if !_bdea {return ErrTypeCheck ;};_ddc =_aegb .Push (MakeBool (_bagb .Val ||_fgde .Val ));return _ddc ;};if _ggab ,_gadf :=_gab .(*PSInteger );_gadf {_ggde ,_eabf :=_daa .(*PSInteger );if !_eabf {return ErrTypeCheck ;};_ddc =_aegb .Push (MakeInteger (_ggab .Val |_ggde .Val ));return _ddc ;};return ErrTypeCheck ;};func (_dfga *PSOperand )exp (_beb *PSStack )error {_eeb ,_ace :=_beb .PopNumberAsFloat64 ();if _ace !=nil {return _ace ;};_cbaf ,_ace :=_beb .PopNumberAsFloat64 ();if _ace !=nil {return _ace ;};if _g .Abs (_eeb )< 1&&_cbaf < 0{return ErrUndefinedResult ;};_fdde :=_g .Pow (_cbaf ,_eeb );_ace =_beb .Push (MakeReal (_fdde ));return _ace ;};func (_ebfe *PSOperand )truncate (_eabc *PSStack )error {_bgae ,_abcb :=_eabc .Pop ();if _abcb !=nil {return _abcb ;};if _ddg ,_ged :=_bgae .(*PSReal );_ged {_dfc :=int (_ddg .Val );_abcb =_eabc .Push (MakeReal (float64 (_dfc )));}else if _ggfb ,_edff :=_bgae .(*PSInteger );_edff {_abcb =_eabc .Push (MakeInteger (_ggfb .Val ));}else {return ErrTypeCheck ;};return _abcb ;};func (_edd *PSInteger )Duplicate ()PSObject {_fa :=PSInteger {};_fa .Val =_edd .Val ;return &_fa };func (_gbdg *PSOperand )mul (_cdg *PSStack )error {_dcfa ,_gac :=_cdg .Pop ();if _gac !=nil {return _gac ;};_eagb ,_gac :=_cdg .Pop ();if _gac !=nil {return _gac ;};_gbge ,_fgag :=_dcfa .(*PSReal );_fab ,_bge :=_dcfa .(*PSInteger );if !_fgag &&!_bge {return ErrTypeCheck ;};_age ,_cdf :=_eagb .(*PSReal );_fee ,_gdg :=_eagb .(*PSInteger );if !_cdf &&!_gdg {return ErrTypeCheck ;};if _bge &&_gdg {_bcb :=_fab .Val *_fee .Val ;_fcf :=_cdg .Push (MakeInteger (_bcb ));return _fcf ;};var _cfbg float64 ;if _fgag {_cfbg =_gbge .Val ;}else {_cfbg =float64 (_fab .Val );};if _cdf {_cfbg *=_age .Val ;}else {_cfbg *=float64 (_fee .Val );};_gac =_cdg .Push (MakeReal (_cfbg ));return _gac ;};

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

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

// MakeBool returns a new PSBoolean object initialized with `val`.
func MakeBool (val bool )*PSBoolean {_feef :=PSBoolean {};_feef .Val =val ;return &_feef };func (_fg *PSReal )Duplicate ()PSObject {_beg :=PSReal {};_beg .Val =_fg .Val ;return &_beg };var ErrStackOverflow =_b .New ("\u0073\u0074\u0061\u0063\u006b\u0020\u006f\u0076\u0065r\u0066\u006c\u006f\u0077");func (_dae *PSOperand )bitshift (_abf *PSStack )error {_ee ,_ecd :=_abf .PopInteger ();if _ecd !=nil {return _ecd ;};_fac ,_ecd :=_abf .PopInteger ();if _ecd !=nil {return _ecd ;};var _ebc int ;if _ee >=0{_ebc =_fac <<uint (_ee );}else {_ebc =_fac >>uint (-_ee );};_ecd =_abf .Push (MakeInteger (_ebc ));return _ecd ;};func (_bd *PSOperand )Duplicate ()PSObject {_edbf :=*_bd ;return &_edbf };

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

// Push pushes an object on top of the stack.
func (_gage *PSStack )Push (obj PSObject )error {if len (*_gage )> 100{return ErrStackOverflow ;};*_gage =append (*_gage ,obj );return nil ;};func (_fgbf *PSOperand )neg (_dcgf *PSStack )error {_fdgb ,_cef :=_dcgf .Pop ();if _cef !=nil {return _cef ;};if _gfe ,_fcfa :=_fdgb .(*PSReal );_fcfa {_cef =_dcgf .Push (MakeReal (-_gfe .Val ));return _cef ;}else if _fcdg ,_abc :=_fdgb .(*PSInteger );_abc {_cef =_dcgf .Push (MakeInteger (-_fcdg .Val ));return _cef ;}else {return ErrTypeCheck ;};};

// PSBoolean represents a boolean value.
type PSBoolean struct{Val bool ;};func (_gbef *PSOperand )log (_fedf *PSStack )error {_dgbd ,_eag :=_fedf .PopNumberAsFloat64 ();if _eag !=nil {return _eag ;};_gcg :=_g .Log10 (_dgbd );_eag =_fedf .Push (MakeReal (_gcg ));return _eag ;};func (_gg *PSInteger )DebugString ()string {return _da .Sprintf ("\u0069\u006e\u0074\u003a\u0025\u0064",_gg .Val );};func (_bfac *PSOperand )ifCondition (_gga *PSStack )error {_gca ,_ggd :=_gga .Pop ();if _ggd !=nil {return _ggd ;};_cbgbg ,_ggd :=_gga .Pop ();if _ggd !=nil {return _ggd ;};_dee ,_gaae :=_gca .(*PSProgram );if !_gaae {return ErrTypeCheck ;};_dcc ,_gaae :=_cbgbg .(*PSBoolean );if !_gaae {return ErrTypeCheck ;};if _dcc .Val {_bag :=_dee .Exec (_gga );return _bag ;};return nil ;};func (_fed *PSOperand )cvr (_eee *PSStack )error {_gdfe ,_cbg :=_eee .Pop ();if _cbg !=nil {return _cbg ;};if _afa ,_bda :=_gdfe .(*PSReal );_bda {_cbg =_eee .Push (MakeReal (_afa .Val ));}else if _dac ,_feb :=_gdfe .(*PSInteger );_feb {_cbg =_eee .Push (MakeReal (float64 (_dac .Val )));}else {return ErrTypeCheck ;};return _cbg ;};func (_fbd *PSOperand )dup (_fdd *PSStack )error {_gbg ,_cgc :=_fdd .Pop ();if _cgc !=nil {return _cgc ;};_cgc =_fdd .Push (_gbg );if _cgc !=nil {return _cgc ;};_cgc =_fdd .Push (_gbg .Duplicate ());return _cgc ;};func (_fdaa *PSOperand )gt (_fga *PSStack )error {_aag ,_beaa :=_fga .PopNumberAsFloat64 ();if _beaa !=nil {return _beaa ;};_eddg ,_beaa :=_fga .PopNumberAsFloat64 ();if _beaa !=nil {return _beaa ;};if _g .Abs (_eddg -_aag )< _c {_gdc :=_fga .Push (MakeBool (false ));return _gdc ;}else if _eddg > _aag {_fff :=_fga .Push (MakeBool (true ));return _fff ;}else {_ffa :=_fga .Push (MakeBool (false ));return _ffa ;};};

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

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

// PSProgram defines a Postscript program which is a series of PS objects (arguments, commands, programs etc).
type PSProgram []PSObject ;func (_gaf *PSOperand )atan (_cde *PSStack )error {_bgf ,_gad :=_cde .PopNumberAsFloat64 ();if _gad !=nil {return _gad ;};_cfe ,_gad :=_cde .PopNumberAsFloat64 ();if _gad !=nil {return _gad ;};if _bgf ==0{var _cdeg error ;if _cfe < 0{_cdeg =_cde .Push (MakeReal (270));}else {_cdeg =_cde .Push (MakeReal (90));};return _cdeg ;};_ebfd :=_cfe /_bgf ;_ef :=_g .Atan (_ebfd )*180/_g .Pi ;_gad =_cde .Push (MakeReal (_ef ));return _gad ;};func (_cdc *PSOperand )lt (_deec *PSStack )error {_edg ,_bada :=_deec .PopNumberAsFloat64 ();if _bada !=nil {return _bada ;};_gge ,_bada :=_deec .PopNumberAsFloat64 ();if _bada !=nil {return _bada ;};if _g .Abs (_gge -_edg )< _c {_dfd :=_deec .Push (MakeBool (false ));return _dfd ;}else if _gge < _edg {_geae :=_deec .Push (MakeBool (true ));return _geae ;}else {_fbb :=_deec .Push (MakeBool (false ));return _fbb ;};};var ErrUnsupportedOperand =_b .New ("\u0075\u006e\u0073\u0075pp\u006f\u0072\u0074\u0065\u0064\u0020\u006f\u0070\u0065\u0072\u0061\u006e\u0064");func (_bca *PSOperand )ne (_bgg *PSStack )error {_ccf :=_bca .eq (_bgg );if _ccf !=nil {return _ccf ;};_ccf =_bca .not (_bgg );return _ccf ;};

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

// PSOperand represents a Postscript operand (text string).
type PSOperand string ;var ErrUndefinedResult =_b .New ("\u0075\u006e\u0064\u0065fi\u006e\u0065\u0064\u0020\u0072\u0065\u0073\u0075\u006c\u0074\u0020\u0065\u0072\u0072o\u0072");func (_cbc *PSOperand )ge (_efc *PSStack )error {_fdcg ,_bea :=_efc .PopNumberAsFloat64 ();if _bea !=nil {return _bea ;};_cec ,_bea :=_efc .PopNumberAsFloat64 ();if _bea !=nil {return _bea ;};if _g .Abs (_cec -_fdcg )< _c {_bef :=_efc .Push (MakeBool (true ));return _bef ;}else if _cec > _fdcg {_fec :=_efc .Push (MakeBool (true ));return _fec ;}else {_fgd :=_efc .Push (MakeBool (false ));return _fgd ;};};

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

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