Added function calls (must be defined in the /func dictionary),
prefix/postfix ops. And reprise the snazzy argument helper,
give it a name that reminds you to `end` later, and Presto!

And Comments!

531(1)04:35 AM:ps 0> cat infix4.ps
%!
%infix4.ps
% Implementation of the Shunting-Yard Algorithm
% for (infix) algebraic formula evaluation in PS
%Caveats:
% Since it uses the PS `token` operator to scan
% the string, all elements must be separated by spaces
% except (balanced parens) which are "self-delimiting".
% This is why we cannot use '<' or '>' because
% `token` considers them to be balanced delimiters
% enclosing a hex-string. So we use 'lt' and 'gt' and
% just map them to the same names.
% In particular , commas must be "fully-articulated":
% (atan(a , - b)) eval     % ie.: a b neg atan

%a helper procedure
/factorial { 1 exch cvi abs -1 1 {mul} for } def

%the basis of the operator tables
%this array is sliced into 3 dictionaries
%relating the key to its various properties
[ %   oper  prec  left
[ /,  {/prev null def} 12 true ]
[ /fac {factorial}
             11   false  ]
[ /plus {}   10   true   ]
[ /neg {neg} 10   true   ]

[ /&   {and} 9     true   ]
[ /and {and} 9     true   ]
[ /|   {or}  8     true   ]
[ /or  {or}  8     true   ]
[ /^   {xor} 7     true   ]
[ /xor {xor} 7     true   ]

[ /eq {eq}  6     true   ]
[ /ne {ne}  6     true   ]
[ /gt {gt}  5     true   ]
[ /ge {ge}  5     true   ]
[ /lt {lt}  5     true   ]
[ /le {le}  5     true   ]

[ /** {exp} 4     false  ]
[ /*  {mul} 3     true   ]
%the single slash / is a sigil in PS
% which resolves to the empty name
[ /   {div} 3     true   ]
[ /+  {add} 2     true   ]
[ /-  {sub} 2     true   ]

]
dup /oper exch dup length dict begin {
    dup 0 get exch 1 get def

%prefix operators + (do nothing) and - (negate)
/preop 2 dict begin
    /+ /plus def
    /- /neg def
currentdict end def

%postfix operator ! (factorial)
/postop 1 dict begin
    /! /fac def
currentdict end def

%recognized function names
/func 10 dict begin
    /sin {sin} def
    /cos {cos} def
    /exp {exp} def
    /abs {abs} def
    /ceil {ceiling} def
    /floor {floor} def
    /round {round} def
    /trunc {truncate} def
    /sqrt {sqrt} def
    /ln {ln} def
    /log {log} def
    /atan {atan} def
currentdict end def

%opstack utilities
% push and pop to/from the operator stack array
% NB not well encapsulated. should provide 'isempty' or 'count'
/oppush {
    /opptr opptr 1 add def
    opptr opstack length eq { /stackoverflow signalerror } if
    opstack opptr 3 2 roll put

    %prev is oper or null: prefix
    /prev load null eq {
        unop
    }{

        oper /prev load known {
            unop
        }{ %prev is operand: postfix or binary
            dup postop exch known { %postfix
                    %load the postfix op from postop
                postop exch get cvx
                binop %"fall thru"
            }{ %binary
                binop
            } ifelse
        } ifelse

    } ifelse

%Some simplistic testing
/testeval {
    /a 2 def (a = )print a =
    /b 3 def (b = )print b =
    [
    (a + b)
    (a * b)
    (a + b * b)
    (a * b + b)
    (a + b / a * b)
    (b * b * b / a * b * a)
    ((b * b * b) / (a * b * a))
    (1 + 2 + 3 + 4)
    (1 * 2 * 3 * 4)
    (3 + 4 * 2 / ( 1 - 5 ) ** 2 ** 3)
    (b eq b)
    (a le b)
    (a gt b)
    ((a lt b) or (5 ne 5))
    (+ 5)
    (- 12 * b / a)
    (2 !)
    (3 !)
    (4 !)
    (5 !)
    (6 !)
    (3 ! !)
    (sin (30))
    (sin(b)** 2 + cos(b)** 2)
    (exp(10 , 5))
    (atan(b , - a))
    ] { dup print(=)= eval = } forall

%argument assignment shortcut
/$begin { dup length dict begin { exch def } forall } def

%simple example
/dist { {/y/x}$begin (sqrt(x ** 2 + y ** 2)) eval end } def