\begin{lisp:documentation}{*version*}{PARAMETER}{"1.3  28$-$jun$-$96" }
{\ } % NO DOCUMENTATION FOR *VERSION*
\end{lisp:documentation}

\begin{lisp:documentation}{*print$-$infix$-$copyright*}{PARAMETER}{t }
If non$-$NIL, prints a copyright notice upon loading this file.
\end{lisp:documentation}

\begin{lisp:documentation}{infix$-$copyright}{FUNCTION}{{\sf \&optional} (stream *standard$-$output*) }
Prints an INFIX copyright notice and header upon startup.
\end{lisp:documentation}

\begin{lisp:documentation}{*infix$-$readtable*}{PARAMETER}{(copy$-$readtable nil) }
{\ } % NO DOCUMENTATION FOR *INFIX-READTABLE*
\end{lisp:documentation}

\begin{lisp:documentation}{*normal$-$readtable*}{PARAMETER}{(copy$-$readtable nil) }
{\ } % NO DOCUMENTATION FOR *NORMAL-READTABLE*
\end{lisp:documentation}

\begin{lisp:documentation}{infix$-$error}{MACRO}{format$-$string {\sf \&rest} args }
{\ } % NO DOCUMENTATION FOR INFIX-ERROR
\end{lisp:documentation}

\begin{lisp:documentation}{infix$-$reader}{FUNCTION}{stream subchar arg }
{\ } % NO DOCUMENTATION FOR INFIX-READER
\end{lisp:documentation}

\begin{lisp:documentation}{string$-$$>$prefix}{FUNCTION}{string }
Convert a string to a prefix s$-$expression using the infix reader.
 If the argument is not a string, just return it as is.
\end{lisp:documentation}

\begin{lisp:documentation}{read$-$infix}{FUNCTION}{stream }
{\ } % NO DOCUMENTATION FOR READ-INFIX
\end{lisp:documentation}

\begin{lisp:documentation}{read$-$regular}{FUNCTION}{stream }
{\ } % NO DOCUMENTATION FOR READ-REGULAR
\end{lisp:documentation}

\begin{lisp:documentation}{same$-$operator$-$p}{FUNCTION}{x y }
{\ } % NO DOCUMENTATION FOR SAME-OPERATOR-P
\end{lisp:documentation}

\begin{lisp:documentation}{same$-$token$-$p}{FUNCTION}{x y }
{\ } % NO DOCUMENTATION FOR SAME-TOKEN-P
\end{lisp:documentation}

\begin{lisp:documentation}{*peeked$-$token*}{VARIABLE}{nil }
{\ } % NO DOCUMENTATION FOR *PEEKED-TOKEN*
\end{lisp:documentation}

\begin{lisp:documentation}{read$-$token}{FUNCTION}{stream }
{\ } % NO DOCUMENTATION FOR READ-TOKEN
\end{lisp:documentation}

\begin{lisp:documentation}{peek$-$token}{FUNCTION}{stream }
{\ } % NO DOCUMENTATION FOR PEEK-TOKEN
\end{lisp:documentation}

\begin{lisp:documentation}{fancy$-$number$-$format$-$p}{FUNCTION}{left operator stream }
{\ } % NO DOCUMENTATION FOR FANCY-NUMBER-FORMAT-P
\end{lisp:documentation}

\begin{lisp:documentation}{valid$-$numberp}{FUNCTION}{string }
{\ } % NO DOCUMENTATION FOR VALID-NUMBERP
\end{lisp:documentation}

\begin{lisp:documentation}{gather$-$superiors}{FUNCTION}{previous$-$operator stream }
Gathers an expression whose operators all exceed the precedence of
the operator to the left.
\end{lisp:documentation}

\begin{lisp:documentation}{get$-$first$-$token}{FUNCTION}{stream }
{\ } % NO DOCUMENTATION FOR GET-FIRST-TOKEN
\end{lisp:documentation}

\begin{lisp:documentation}{apply$-$token$-$prefix$-$operator}{FUNCTION}{token stream }
{\ } % NO DOCUMENTATION FOR APPLY-TOKEN-PREFIX-OPERATOR
\end{lisp:documentation}

\begin{lisp:documentation}{get$-$next$-$token}{FUNCTION}{stream left }
{\ } % NO DOCUMENTATION FOR GET-NEXT-TOKEN
\end{lisp:documentation}

\begin{lisp:documentation}{apply$-$token$-$infix$-$operator}{FUNCTION}{token left stream }
{\ } % NO DOCUMENTATION FOR APPLY-TOKEN-INFIX-OPERATOR
\end{lisp:documentation}

\begin{lisp:documentation}{infix$-$read$-$delimited$-$list}{FUNCTION}{end$-$token delimiter$-$token stream }
{\ } % NO DOCUMENTATION FOR INFIX-READ-DELIMITED-LIST
\end{lisp:documentation}

\begin{lisp:documentation}{*operator$-$ordering*}{PARAMETER}{'(([ ( !) (\symbol{94}) (~) (* / \%) (+ $-$) ($<$$<$ $>$$>$) ($<$ == $>$ $<$= != $>$=) (\&) (\symbol{94}\symbol{94}) (|) (not) (and) (or) (= := += $-$= *= /=) (,) (if) (then else) (] )) (\%infix$-$end$-$token\%)) }
Ordered list of operators of equal precedence.
\end{lisp:documentation}

\begin{lisp:documentation}{operator$-$lessp}{FUNCTION}{op1 op2 }
{\ } % NO DOCUMENTATION FOR OPERATOR-LESSP
\end{lisp:documentation}

\begin{lisp:documentation}{*right$-$associative$-$operators*}{PARAMETER}{'(\symbol{94} =) }
{\ } % NO DOCUMENTATION FOR *RIGHT-ASSOCIATIVE-OPERATORS*
\end{lisp:documentation}

\begin{lisp:documentation}{operator$-$right$-$associative$-$p}{FUNCTION}{operator }
{\ } % NO DOCUMENTATION FOR OPERATOR-RIGHT-ASSOCIATIVE-P
\end{lisp:documentation}

\begin{lisp:documentation}{*token$-$operators*}{VARIABLE}{nil }
{\ } % NO DOCUMENTATION FOR *TOKEN-OPERATORS*
\end{lisp:documentation}

\begin{lisp:documentation}{*token$-$prefix$-$operator$-$table*}{VARIABLE}{(make$-$hash$-$table) }
{\ } % NO DOCUMENTATION FOR *TOKEN-PREFIX-OPERATOR-TABLE*
\end{lisp:documentation}

\begin{lisp:documentation}{*token$-$infix$-$operator$-$table*}{VARIABLE}{(make$-$hash$-$table) }
{\ } % NO DOCUMENTATION FOR *TOKEN-INFIX-OPERATOR-TABLE*
\end{lisp:documentation}

\begin{lisp:documentation}{token$-$operator$-$p}{FUNCTION}{token }
{\ } % NO DOCUMENTATION FOR TOKEN-OPERATOR-P
\end{lisp:documentation}

\begin{lisp:documentation}{get$-$token$-$prefix$-$operator}{FUNCTION}{token }
{\ } % NO DOCUMENTATION FOR GET-TOKEN-PREFIX-OPERATOR
\end{lisp:documentation}

\begin{lisp:documentation}{get$-$token$-$infix$-$operator}{FUNCTION}{token }
{\ } % NO DOCUMENTATION FOR GET-TOKEN-INFIX-OPERATOR
\end{lisp:documentation}

\begin{lisp:documentation}{define$-$token$-$operator}{MACRO}{operator$-$name {\sf \&key} (prefix nil prefix$-$p) (infix nil infix$-$p) }
{\ } % NO DOCUMENTATION FOR DEFINE-TOKEN-OPERATOR
\end{lisp:documentation}

\begin{lisp:documentation}{define$-$character$-$tokenization}{MACRO}{char function }
{\ } % NO DOCUMENTATION FOR DEFINE-CHARACTER-TOKENIZATION
\end{lisp:documentation}

\begin{lisp:documentation}{post$-$process$-$expression}{FUNCTION}{expression }
{\ } % NO DOCUMENTATION FOR POST-PROCESS-EXPRESSION
\end{lisp:documentation}

\begin{lisp:documentation}{*test$-$cases*}{PARAMETER}{'((1 * +2 (* 1 2)) (1 * $-$2 (* 1 ($-$ 2))) (1 * /2 (* 1 (/ 2))) (/2 (/ 2)) (not true (not true)) (foo$\backslash$$-$bar foo$-$bar) (a + b$-$c (+ a b ($-$ c))) (a + b$\backslash$$-$c (+ a b$-$c)) (f$\backslash$oo foo) (!foo$-$bar * 2 (* foo$-$bar 2))
 (!(foo bar baz) (foo bar baz)) (!foo$-$bar  foo$-$bar) (!foo$-$bar foo$-$bar) (a+$-$b (+ a ($-$ b))) (a+b (+ a b)) (a+b*c (+ a (* b c))) (a+b+c (+ a b c)) (a+b$-$c (+ a b ($-$ c))) (a+b$-$c+d (+ a b ($-$ c) d))
 (a+b$-$c$-$d (+ a b ($-$ c) ($-$ d))) (a$-$b ($-$ a b)) (a*b (* a b)) (a*b*c (* a b c)) (a*b+c (+ (* a b) c)) (a/b (/ a b)) (a\symbol{94}b (expt a b)) (foo/$-$bar (/ foo ($-$ bar))) (1+2*3\symbol{94}4 (+ 1 (* 2 (expt 3 4))))
 (1+2*3\symbol{94}4+5 (+ 1 (* 2 (expt 3 4)) 5)) (2*3\symbol{94}4+1 (+ (* 2 (expt 3 4)) 1)) (2+3\symbol{94}4*5 (+ 2 (* (expt 3 4) 5))) (2\symbol{94}3\symbol{94}4 (expt 2 (expt 3 4))) (x\symbol{94}2 + y\symbol{94}2 (+ (expt x 2) (expt y 2))) ((1+2)/3 (/ (+ 1 2) 3)) ((a=b) (setq a b))
 ((a=b,b=c) (progn (setq a b) (setq b c))) (1*(2+3) (* 1 (+ 2 3))) (1+2/3 (+ 1 (/ 2 3))) (a,b (progn a b)) (a,b,c (progn a b c)) (foo(a,b,(c,d)) (foo a b (progn c d))) (foo(a,b,c) (foo a b c))
 ((a+b,c) (progn (+ a b) c)) (1 1) ($-$1 ($-$ 1)) (+1 1) (1. 1) (1.1 1.1) (1e3 1000.0) (1e$-$3 0.001) (1f$-$3 0.001) (1e$-$3e ($-$ 1e 3e)) (!1e$-$3  0.001) (a and b and c (and a b c)) (a and b or c (or (and a b) c))
 (a and b (and a b)) (a or b and c (or a (and b c))) (a or b (or a b)) (a$<$b and b$<$c (and ($<$ a b) ($<$ b c))) (if (if a then b else c) then e (when (if a b c) e)) (if 1 then 2 else 3+4 (if 1 2 (+ 3 4)))
 ((if 1 then 2 else 3)+4 (+ (if 1 2 3) 4)) (if a $<$ b then b else a (if ($<$ a b) b a)) (if a and b then c and d else e and f (if (and a b) (and c d) (and e f)))
 (if a or b then c or d else e or f (if (or a b) (or c d) (or e f))) (if a then (if b then c else d) else e (if a (if b c d) e)) (if a then (if b then c) else d (if a (when b c) d))
 (if a then b else c (if a b c)) (if a then b (when a b)) (if a then if b then c else d else e (if a (if b c d) e)) (if a then if b then c else d (when a (if b c d)))
 (if if a then b else c then e (when (if a b c) e)) (if not a and not b then c (when (and (not a) (not b)) c)) (if not a then not b else not c and d (if (not a) (not b) (and (not c) d)))
 (not a and not b (and (not a) (not b))) (not a or not b (or (not a) (not b))) (not a$<$b and not b$<$c (and (not ($<$ a b)) (not ($<$ b c)))) (not a$<$b (not ($<$ a b))) (a[i,k]*b[j,k] (* (aref a i k) (aref b j k)))
 (foo(bar)=foo[bar,baz] (setf (foo bar) (aref foo bar baz))) (foo(bar,baz) (foo bar baz)) (foo[bar,baz] (aref foo bar baz)) (foo[bar,baz]=barf (setf (aref foo bar baz) barf))
 (max = if a $<$ b then b else a (setq max (if ($<$ a b) b a))) (a $<$ b $<$ c ($<$ a b c)) (a $<$ b $<$= c (and ($<$ a b) ($<$= b c))) (a $<$= b $<$= c ($<$= a b c)) (a $<$= b $<$= c ($<$= a b c)) (a!=b and b$<$c (and (not (= a b)) ($<$ b c)))
 (a!=b (not (= a b))) (a$<$b ($<$ a b)) (a==b (= a b)) (a*b(c)+d (+ (* a (b c)) d)) (a+b(c)*d (+ a (* (b c) d))) (a+b(c)+d (+ a (b c) d)) (d+a*b(c) (+ d (* a (b c)))) (+a+b (+ a b)) ($-$a+b (+ ($-$ a) b))
 ($-$a$-$b (+ ($-$ a) ($-$ b))) ($-$a$-$b$-$c (+ ($-$ a) ($-$ b) ($-$ c))) (a*b/c (/ (* a b) c)) (a+b$-$c (+ a b ($-$ c))) (a$-$b$-$c ($-$ a b c)) (a/b*c (* (/ a b) c)) (a/b/c (/ a b c)) (/a/b (/ (* a b))) (a\symbol{94}b\symbol{94}c (expt a (expt b c)))
 (a(d)\symbol{94}b\symbol{94}c (expt (a d) (expt b c))) (a$<$b+c$<$d ($<$ a (+ b c) d)) (1*~2+3 (+ (* 1 (lognot 2)) 3)) (1+~2*3 (+ 1 (* (lognot 2) 3))) (1+~2+3 (+ 1 (lognot 2) 3)) (f(a)*=g(b) (setf (f a) (* (f a) (g b))))
 (f(a)+=g(b) (incf (f a) (g b))) (f(a)$-$=g(b) (decf (f a) (g b))) (f(a)/=g(b) (setf (f a) (/ (f a) (g b)))) (a\&b (logand a b)) (a\symbol{94}\symbol{94}b (logxor a b)) (a|b (logior a b)) (a$<$$<$b (ash a b)) (a$>$$>$b (ash a ($-$ b)))
 (~a (lognot a)) (a\&\&b (and a b)) (a||b (or a b)) (a\%b (mod a b))
 (x\symbol{94}2   ; the x coordinate
        + y\symbol{94}2 ; the y coordinate error)
 (x\symbol{94}2   ; the x coordinate
        + y\symbol{94}2 ; the y coordinate
         (+ (expt x 2) (expt y 2)))
 (foo(bar,baz error) (foo(bar,baz)) (foo bar baz)) (foo[bar,baz]] error) ([foo,bar] error) (and a error) ($<$ a error) (=bar error) (*bar error) (a not b error) (a if b then c error) ( error) ()a error) (]a error)) }
{\ } % NO DOCUMENTATION FOR *TEST-CASES*
\end{lisp:documentation}

\begin{lisp:documentation}{test$-$infix}{FUNCTION}{{\sf \&optional} (tests *test$-$cases*) }
{\ } % NO DOCUMENTATION FOR TEST-INFIX
\end{lisp:documentation}

\begin{lisp:documentation}{test$-$infix$-$case}{FUNCTION}{string result }
{\ } % NO DOCUMENTATION FOR TEST-INFIX-CASE
\end{lisp:documentation}