NextToken := [tkNumber,
                                          tkLBracket];
                       end;
                  ')': begin
                            if not (tkRBracket in
                                   NextToken) then
                               begin
                                    Result := I;
                                    InList.Clear;
                                    Break;
                               end;
                            Dec(iBracket);
                            Token.Token := tkRBracket;
                            InList.Add(NewToken(@Token));
                            NextToken := [tkAdd,
                                          tkSub,
                                          tkMul,
                                          tkDiv,
                                          tkRBracket];
                       end;
                  ' ': ;
                  else begin
                            Result := I;
                            InList.Clear;
                            Break;
                       end;
                end;
                Inc(I);
           end;
     if iBracket > 0 then
        begin
             Result := iLen;
             InList.Clear;
        end;
end;

function InsideToSuffix(InList: TList): String;
var
   I: Integer;
   Stack: TStack;
   Token: PToken;
   sTemp, sSymbol: String;
begin
     sTemp := '';
     Stack := TStack.Create;
     For I := 0 to InList.Count - 1 do
         begin
              Token := PToken(InList.Items[I]);
              Case Token^.Token of
                tkNumber: sTemp := sTemp +
                                   FloatToStr(Token.DValue) +
                                   ' ';
                tkAdd: if not IsEmpty(Stack) then
                          if Peek(Stack) = '(' then
                             Push(Stack, '+')
                             else
                             begin
                                  sSymbol := Pop(Stack);
                                  sTemp := sTemp +
                                           sSymbol +
                                           ' ';
                                  Push(Stack, '+');
                             end
                          else
                          Push(Stack, '+');
                tkSub: if not IsEmpty(Stack) then
                          if Peek(Stack) = '(' then
                             Push(Stack, '-')
                             else
                             begin
                                  sSymbol := Pop(Stack);
                                  sTemp := sTemp +
                                           sSymbol +
                                           ' ';
                                  Push(Stack, '-');
                             end
                          else
                          Push(Stack, '-');
                tkMul: if not IsEmpty(Stack) then
                          begin
                               sSymbol := Peek(Stack);
                               if sSymbol = '(' then
                                  Push(Stack, '*')
                                  else
                                  if CompareSymbol('*',
                                                   sSymbol) then
                                     Push(Stack, '*')
                                     else
                                     begin
                                          sSymbol := Pop(Stack);
                                          sTemp := sTemp +
                                                   sSymbol +
                                                  ' ';
                                          Push(Stack, '*');
                                     end;
                          end
                          else
                          Push(Stack, '*');
                tkDiv: if not IsEmpty(Stack) then
                          begin
                               sSymbol := Peek(Stack);
                               if sSymbol = '(' then
                                  Push(Stack, '/')
                                  else
                                  if CompareSymbol('/',
                                                   sSymbol) then
                                     Push(Stack, '/')
                                     else
                                     begin
                                          sSymbol := Pop(Stack);
                                          sTemp := sTemp +
                                                   sSymbol +
                                                  ' ';
                                          Push(Stack, '/');
                                     end;
                          end
                          else
                          Push(Stack, '/');
                tkLBracket: Push(Stack, '(');
                tkRBracket: While Stack.Count > 0 do
                                  begin
                                       sSymbol := Pop(Stack);
                                       if sSymbol = '(' then Break;
                                       sTemp := sTemp +
                                                sSymbol +
                                                ' ';
                                  end;
              end;
         end;
     For I := 1 to Stack.Count do
         begin
              sSymbol := Pop(Stack);
              sTemp := sTemp +
                       sSymbol +
                       ' ';
         end;
     Stack.Free;
     Result := Trim(sTemp);
end;

function Evaluate(SuExpr: String): Double;
var
   sTemp: String;
   Stack: TStack;
   I, iLen: Integer;
   dTempA, dTempB, dResult: Double;
begin
     I := 1;
     iLen := Length(SuExpr);
     Stack := TStack.Create;
     While I <= iLen do
           begin
                Case SuExpr[I] of
                  '0'..'9': begin
                                 sTemp := '';
                                 While I <= iLen do
                                       begin
                                            if SuExpr[I] in
                                               ['0'..'9', '.'] then
                                               sTemp := sTemp +
                                                        SuExpr[I]
                                               else
                                               begin
                                                    Dec(I);
                                                    Break;
                                               end;
                                            Inc(I);
                                       end;
                                 Push(Stack, sTemp);
                            end;
                  '+': begin
                            dTempA := StrToFloat(Pop(Stack));
                            dTempB := StrToFloat(Pop(Stack));
                            dResult := dTempB + dTempA;
                            Push(Stack,
                                 FloatToStr(dResult));
                       end;
                  '-': begin
                            dTempA := StrToFloat(Pop(Stack));
                            dTempB := StrToFloat(Pop(Stack));
                            dResult := dTempB - dTempA;
                            Push(Stack,
                                 FloatToStr(dResult));
                       end;
                  '*': begin
                            dTempA := StrToFloat(Pop(Stack));
                            dTempB := StrToFloat(Pop(Stack));
                            dResult := dTempB * dTempA;
                            Push(Stack,
                                 FloatToStr(dResult));
                       end;
                  '/': begin
                            dTempA := StrToFloat(Pop(Stack));
                            dTempB := StrToFloat(Pop(Stack));
                            dResult := dTempB / dTempA;
                            Push(Stack,
                                 FloatToStr(dResult));
                       end;
                end;
                Inc(I);
           end;
     Result := StrToFloat(Pop(Stack));
end;

end.