Нужно перевести код с Delphi на C++ Builder

unit frmPostfix;
 
interface
 
uses
  Windows, SysUtils, Classes, Controls, Forms, Contnrs, StdCtrls, Math;
 
type
  POperation = ^TOperation;
  TOperation = packed record
    Name: string;
    OpCount: Byte;
    Priority: Byte;
  end;
  PSymbol = ^TSymbol;
  TSymbol = packed record
    Kind: (tkNumber, tkOperation, tkOpenedBracket, tkClosedBracket);
    case Byte of
      0: (Number: Double);
      1: (Operation: DWORD);
  end;
  TExpression = array of TSymbol;
  TPostfixFrm = class(TForm)
    ExpEdt: TEdit;
    ParsedEdt: TEdit;
    ParseBtn: TButton;
    ResultEdt: TEdit;
    EvalBtn: TButton;
    procedure ParseBtnClick(Sender: TObject);
    procedure EvalBtnClick(Sender: TObject);
  private
    { Private declarations }
    ConvExp: TExpression;
    { *** }
    function OpIndexToPtr(const OpIndex: DWORD): POperation;
    function ExprToStr(const Expr: TExpression): string;
    { *** }
    function ParseExpression(Expression: string;
      var ParsedExp: TExpression): Boolean;
    function ConvertExpression(const ParsedExp: TExpression;
      var ConvertedExp: TExpression): Boolean;
    function EvaluateExpression(const ConvertedExp: TExpression;
      var aResult: Double): Boolean;
  public
    { Public declarations }
  end;
 
const
  OPERATION_COUNT = 15;
  Operations: array [0..OPERATION_COUNT-1] of TOperation =
  {  Name: <имя_операции>; OpCount: <колво_операндов>; Priority: <приоритет>;
           (нулевой приоритет использовать НИЗЗЗЗЯЯЯ!!!!) }
    ((Name:'+';      OpCount:2; Priority:1),
     (Name:'-';      OpCount:2; Priority:1),
     (Name:'*';      OpCount:2; Priority:2),
     (Name:'/';      OpCount:2; Priority:2),
     (Name:'^';      OpCount:2; Priority:4),
     (Name:'sin';    OpCount:1; Priority:255),
     (Name:'cos';    OpCount:1; Priority:255),
     (Name:'arcsin'; OpCount:1; Priority:255),
     (Name:'arccos'; OpCount:1; Priority:255),
     (Name:'ln';     OpCount:1; Priority:255),
     (Name:'exp';    OpCount:1; Priority:255),
     (Name:'round';  OpCount:1; Priority:255),
     (Name:'trunc';  OpCount:1; Priority:255),
     (Name:'tan';    OpCount:1; Priority:255),
     (Name:'cotan';  OpCount:1; Priority:255));
 
var
  PostfixFrm: TPostfixFrm;
 
implementation
 
{$R *.dfm}
 
{ TPostfixFrm }
 
function TPostfixFrm.OpIndexToPtr(const OpIndex: DWORD): POperation;
begin
  Result := @Operations[OpIndex];
end;
 
function TPostfixFrm.ExprToStr(const Expr: TExpression): string;
var
  i: Integer;
begin
  Result := '';
  for i := 0 to High(Expr) do
    case Expr[i].Kind of
      tkNumber: Result := Result + FloatToStr(Expr[i].Number) + ' ';
      tkOperation: Result := Result + OpIndexToPtr(Expr[i].Operation).Name + ' ';
      tkOpenedBracket: Result := Result + '( ';
      tkClosedBracket: Result := Result + ') ';
    end;
end;
 
function TPostfixFrm.ParseExpression(Expression: string;
  var ParsedExp: TExpression): Boolean;
 
  function FindOp(const sym: string): Integer;
  var
    i: Integer;
  begin
    Result := -1;
    for i := 0 to OPERATION_COUNT-1 do
      if sym = Operations[i].Name then
      begin
        Result := i;
        Exit;
      end;
  end;
 
  function AddSymbol(const sym: string): Boolean;
  var
    f: Extended;
    IsNumber: Boolean;
    op: Integer;
  begin
    Result := True; if (sym = '') or (sym[1] = #0) then Exit;
    SetLength(ParsedExp,Length(ParsedExp)+1);
    if sym = '(' then
    begin
      ParsedExp[High(ParsedExp)].Kind := tkOpenedBracket;
      Exit;
    end;
    if sym = ')' then
    begin
      ParsedExp[High(ParsedExp)].Kind := tkClosedBracket;
      Exit;
    end;
    IsNumber := TextToFloat(PChar(sym),f,fvExtended);
    if IsNumber then
    begin
      ParsedExp[High(ParsedExp)].Kind := tkNumber;
      ParsedExp[High(ParsedExp)].Number := f;
    end else
    begin
      ParsedExp[High(ParsedExp)].Kind := tkOperation;
      op := FindOp(sym);
      if op = -1 then
      begin
        Result := False;
        Exit;
      end;
      ParsedExp[High(ParsedExp)].Operation := op;
    end;
  end;
 
const
  Separators = ['+','-','/','*','(',')','^'];
var
  i: Integer;
  s: string;
begin
  Result := False; Finalize(ParsedExp);
  i := 0;
  while i <> Length(Expression) do
    if Expression[i] = ' ' then Delete(Expression,i,1) else Inc(i);
  Expression := '('+Expression+')';
  i := Pos('(-',Expression);
  while i > 0 do
  begin
    Insert('0',Expression,i+1);
    i := Pos('(-',Expression);
  end;
  for i := 1 to Length(Expression) do
    if Expression[i] in Separators then
    begin
      if not AddSymbol(s) then Exit;
      if not AddSymbol(Expression[i]) then Exit;
      s := '';
    end else
      s := s + Expression[i];
  Result := True;
end;
 
function TPostfixFrm.ConvertExpression(const ParsedExp: TExpression;
  var ConvertedExp: TExpression): Boolean;
 
  procedure CopySymbol(const sym: PSymbol);
  begin
    SetLength(ConvertedExp,Length(ConvertedExp)+1);
    ConvertedExp[High(ConvertedExp)] := sym^;
  end;
 
var
  i: Integer;
  psym: PSymbol;
  OldPrior: Byte;
  Stack: TStack;
begin
  Finalize(ConvExp); Result := True; i := -1;
  Stack := TStack.Create;
  try
    while i < High(ParsedExp) do
    begin
      Inc(i); OldPrior := 0;
      if (Stack.Count > 0) and (PSymbol(Stack.Peek).Kind = tkOperation) then
        OldPrior := OpIndexToPtr(PSymbol(Stack.Peek).Operation).Priority;
      case ParsedExp[i].Kind of
        tkNumber: CopySymbol(@ParsedExp[i]);
        tkOperation:
          if (OldPrior >= OpIndexToPtr(ParsedExp[i].Operation).Priority) then
          begin
            CopySymbol(Stack.Pop);
            Dec(i);
          end else Stack.Push(@ParsedExp[i]);
        tkOpenedBracket: Stack.Push(@ParsedExp[i]);
        tkClosedBracket:
          begin
            if Stack.Count = 0 then
            begin
              Result := False;
              Break;
            end;
            psym := Stack.Pop;
            if psym.Kind <> tkOpenedBracket then
            begin
              CopySymbol(psym);
              Dec(i);
            end else
              if (Stack.Count > 0) and (PSymbol(Stack.Peek).Kind = tkOperation) and
                 (OpIndexToPtr(PSymbol(Stack.Peek).Operation).Priority = 255) then
                   CopySymbol(Stack.Pop);
          end;
      end;
    end;
    while Stack.Count > 0 do CopySymbol(Stack.Pop);
  finally
    Stack.Free;
  end;
end;
 
function TPostfixFrm.EvaluateExpression(const ConvertedExp: TExpression;
  var aResult: Double): Boolean;
 
  function ExecOp(OpIndex: Byte; Operands: array of Double): Double;
  begin
    case OpIndex of
      0: Result := Operands[1] + Operands[0];      { сумма }
      1: Result := Operands[1] - Operands[0];      { разность }
      2: Result := Operands[1] * Operands[0];      { произведение }
      3: Result := Operands[1] / Operands[0];      { деление }
      4: Result := Power(Operands[1],Operands[0]); { степень }
      5: Result := sin(Operands[0]);
      6: Result := cos(Operands[0]);
      7: Result := arcsin(Operands[0]);
      8: Result := arccos(Operands[0]);
      9: Result := ln(Operands[0]);
      10: Result := exp(Operands[0]);
      11: Result := round(Operands[0]);
      12: Result := trunc(Operands[0]);
      13: Result := tan(Operands[0]);
      14: Result := cotan(Operands[0]);
      else Result := 0;
    end;
  end;
 
var
  i,j: Integer;
  Stack: TStack;
  TmpNums: array of PSymbol;
  Ops: array of Double;
begin
  Result := True; Stack := TStack.Create;
  try
    for i := 0 to High(ConvertedExp) do
    begin
      if ConvertedExp[i].Kind = tkNumber then Stack.Push(@ConvertedExp[i]) else
      begin
        if (ConvertedExp[i].Kind in [tkOpenedBracket,tkClosedBracket]) or
          (Stack.Count < OpIndexToPtr(ConvertedExp[i].Operation).OpCount) then
        begin
          Result := False;
          Break;
        end;
        SetLength(Ops,OpIndexToPtr(ConvertedExp[i].Operation).OpCount);
        for j := 0 to High(Ops) do
          Ops[j] := PSymbol(Stack.Pop).Number;
        SetLength(TmpNums,Length(TmpNums)+1);
        TmpNums[High(TmpNums)] := New(PSymbol);
        TmpNums[High(TmpNums)].Kind := tkNumber;
        TmpNums[High(TmpNums)].Number :=
          ExecOp(ConvertedExp[i].Operation,Ops);
        Stack.Push(TmpNums[High(TmpNums)]);
      end;
    end;
    if (Stack.Count = 1) and Result then
      aResult := PSymbol(Stack.Pop).Number else Result := False;
  finally
    Stack.Free;
  end;
  for i := 0 to High(TmpNums) do Dispose(TmpNums[i]);
end;
 
procedure TPostfixFrm.ParseBtnClick(Sender: TObject);
var
  ParsedExpression: TExpression;
begin
  ResultEdt.Text := ''; ParsedEdt.Text := ''; EvalBtn.Enabled := False;
  if (ParseExpression(ExpEdt.Text,ParsedExpression) and
    ConvertExpression(ParsedExpression,ConvExp)) then
  begin
    ParsedEdt.Text := ExprToStr(ConvExp);
    EvalBtn.Enabled := True;
  end else
    MessageBox(Handle,'Ошибка преобразования выражения!',nil,MB_ICONERROR);
end;
 
procedure TPostfixFrm.EvalBtnClick(Sender: TObject);
var
  rslt: Double;
begin
  if EvaluateExpression(ConvExp,rslt) then
    ResultEdt.Text := FloatToStr(rslt)
  else
    MessageBox(Handle,'Ошибка вычисления выражения!',nil,MB_ICONERROR);
end;
 
end.