``````{
THAI TRAN

{
I've netmailed you the full-featured version (800 lines!) that will do
Functions, exponentiation, factorials, and has all the bells and whistles,
but I thought you might want to take a look at a simple version so you can
understand the algorithm.

This one only works With +, -, *, /, (, and ).  I wrote it quickly, so it
makes extensive use of global Variables and has no error checking; Use at

Algorithm to convert infix to postfix (RPN) notation
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Parse through the entire expression getting each token (number, arithmetic
operator, left or right parenthesis).  For each token, if it is:
1. an operand (number)        Send it to the RPN calculator
2. a left parenthesis         Push it onto the operator stack
3. a right parenthesis        Pop operators off stack and send to RPN
calculator Until the a left parenthesis is
on top of the stack.  Pop it also, but don't
send it to the calculator.
4. an operator                While the stack is not empty, pop operators
off the stack and send them to the RPN
calculator Until you reach one With a higher
precedence than the current operator (Note:
a left parenthesis has the least precendence).
Then push the current operator onto the stack.

This will convert (4+5)*6/(2-3) to 4 5 + 6 * 2 3 - /

Algorithm For RPN calculator
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Note:  this Uses a different stack from the one described above.

In RPN, if an operand (a number) is entered, it is just pushed onto the
stack.  For binary arithmetic operators (+, -, *, /, and ^), the top two
operands are popped off the stack, operated on, and the result pushed back
onto the stack.  if everything has gone correctly, at the end, the answer
should be at the top of the stack.

Released to Public Domain by Thai Tran (if that matters).
}

{\$X+}
Program Expression_Evaluator;

Const
RPNMax = 10;              { I think you only need 4, but just to be safe }
OpMax  = 25;

Type
String15 = String;

Var
Expression : String;
RPNStack   : Array[1..RPNMax] of Real;        { Stack For RPN calculator }
RPNTop     : Integer;
OpStack    : Array[1..OpMax] of Char;    { Operator stack For conversion }
OpTop      : Integer;

Procedure RPNPush(Num : Real); { Add an operand to the top of the RPN stack }
begin
if RPNTop < RPNMax then
begin
Inc(RPNTop);
RPNStack[RPNTop] := Num;
end
else  { Put some error handler here }
end;

Function RPNPop : Real;       { Get the operand at the top of the RPN stack }
begin
if RPNTop > 0 then
begin
RPNPop := RPNStack[RPNTop];
Dec(RPNTop);
end
else  { Put some error handler here }
end;

Procedure RPNCalc(Token : String15);                       { RPN Calculator }
Var
Temp  : Real;
Error : Integer;
begin
Write(Token, ' ');                { This just outputs the RPN expression }

if (Length(Token) = 1) and (Token in ['+', '-', '*', '/']) then
Case Token of                                   { Handle operators }
'+' : RPNPush(RPNPop + RPNPop);
'-' : RPNPush(-(RPNPop - RPNPop));
'*' : RPNPush(RPNPop * RPNPop);
'/' :
begin
Temp := RPNPop;
if Temp <> 0 then
RPNPush(RPNPop/Temp)
else  { Handle divide by 0 error }
end;
end
else
begin                   { Convert String to number and add to stack }
Val(Token, Temp, Error);
if Error = 0 then
RPNPush(Temp)
else  { Handle error }
end;
end;

Procedure OpPush(Operator : Char);  { Add an operator onto top of the stack }
begin
if OpTop < OpMax then
begin
Inc(OpTop);
OpStack[OpTop] := Operator;
end
else  { Put some error handler here }
end;

Function OpPop : Char;               { Get operator at the top of the stack }
begin
if OpTop > 0 then
begin
OpPop := OpStack[OpTop];
Dec(OpTop);
end
else  { Put some error handler here }
end;

Function Priority(Operator : Char) : Integer; { Return priority of operator }
begin
Case Operator OF
'('      : Priority := 0;
'+', '-' : Priority := 1;
'*', '/' : Priority := 2;
else  { More error handling }
end;
end;

Procedure Evaluate(Expr : String);                                  { Guess }
Var
I     : Integer;
Token : String15;
begin
OpTop  := 0;                                              { Reset stacks }
RPNTop := 0;
Token  := '';

For I := 1 to Length(Expr) DO
if Expr[I] in ['0'..'9'] then
begin       { Build multi-digit numbers }
Token := Token + Expr[I];
if I = Length(Expr) then          { Send last one to calculator }
RPNCalc(Token);
end
else
if Expr[I] in ['+', '-', '*', '/', '(', ')'] then
begin
if Token <> '' then
begin        { Send last built number to calc. }
RPNCalc(Token);
Token := '';
end;

Case Expr[I] OF
'(' : OpPush('(');
')' :
begin
While OpStack[OpTop] <> '(' DO
RPNCalc(OpPop);
OpPop;                          { Pop off and ignore the '(' }
end;

'+', '-', '*', '/' :
begin
While (OpTop > 0) AND
(Priority(Expr[I]) <= Priority(OpStack[OpTop])) DO
RPNCalc(OpPop);
OpPush(Expr[I]);
end;
end; { Case }
end
else;
{ Handle bad input error }

While OpTop > 0 do                     { Pop off the remaining operators }
RPNCalc(OpPop);
end;

begin
Write('Enter expression: ');