Como seria o fonte

  Vou responder a esse post com outra pergunta,
  e também a resposta :-)

  - Como os compiladores fazem para transformar expressões
    matemáticas em instruções?

  Resposta: Alguns (se não todos) utilizam um método para
            "empilhar" a expressão por ordem de precedência
            Utilizam vários PUSH´s e POP´s para inserir e remover
            os ítens das expressões na na "Pilha". Mas antes disso,
            ele tem que converter a expressão passada para um formato
            mais "fácil", normalmente chamado de "PostFix".
            O que é o formato "PostFix" ? Um exemplo:

            A expressão (1+(1+4)/2)*(5+2) no formato "PostFix"

            fica assim: 1 1 4 + 2 / + 5 2 + *

            Mas aí, como avaliar a expressão:

            1  1   4    + 2  / +  5  2  + *
     1)     !  !----+---! !  ! !  !  !  ! ! 
            !       !     !  ! !  !  !  ! !
     2)     !       5     2  ! !  !  !  ! !
            !       !     !  ! !  !  !  ! !
            !       !----+---+ !  !  !  ! !
            !            !     !  !  !  ! !
     3)     1           2,5    !  !  !  ! !
            !            !     !  !  !  ! !
            +------------+-----+  !  !  ! !
                         !        !  !  ! !
                        3,5       !  !  ! !
     4)                  !        5  2  ! !  
                         +----+---+--+--+ !
                         !        !     ! !
                         !        +--+--+ +
                         !           !    !
     5)                 3,5          7    !
                         !           !    !
                         +-----------+----+
                                     !
                                    24,5
                                    ==== 
  
     Complicado? Um "pouco" ...

     Para implementar isso, é preciso criar um rotina para 
     converter a expressão para o formato "PostFix", e em
     seguida, executar as operações acima.

     Resumindo, comece da esquerda para a direita, 
     se o ítem é num número, então "empilhe-o".
     Quando encontrar um operador "+, -, *, /", 
     pegue os dois operandos do "topo" da pilha, 
     e execute a operação em questão. Quando checar 
     ao final da expressão, o conteúdo do "Topo" da pilha, 
     será o resultado a expressão.

     Escreví uma função para isso. Ela simula um "Pilha" para
     armazenar os dados que serão inseridos (Push) e 
     retirados (Pop).

// ---------------------------------------------------------
// Função para avaliar expressões matemáticas...
// by e_gama
// Por enquanto, só executa expressões com número inteiros,
// mas o resultado é um ´Real´
// ---------------------------------------------------------

function AvaliaExpressao(Expr: string): Real;
// Uses StrUtils...

var aOperadores   : array[0..99] of Char;
    aOperandos    : array[0..99] of Real;
    OperadorIndex : Integer;
    OperandosIndex: Integer;

    // Pilha de Operadoes
    // Procedure PUSH
    procedure Push(C: Char);
    begin
      Inc(OperadorIndex);
      aOperadores[OperadorIndex] := C;
    end;

    // Procedure POP
    function Pop: Char;
    begin
      Result := aOperadores[OperadorIndex];
      if OperadorIndex > 0 then
         Dec(OperadorIndex);
    end;

    // Pilha de Operandos
    // Procedure PUSH
    procedure PushOperando(V: Real);
    begin
      Inc(OperandosIndex);
      aOperandos[OperandosIndex] := V;
    end;

    // Procedure POP
    function PopOperando: Real;
    begin
      Result := aOperandos[OperandosIndex];
      if OperandosIndex > 0 then
         Dec(OperandosIndex);
    end;

var I, J        : Integer;
    C, X        : Char;
    strExpressao: string;
    AuxExpressao: string;
    Operando    : Real;

begin
  OperadorIndex  := 0;
  aOperadores[0] := ´ ´;
  Push(´(´);

  strExpressao := Expr + ´)´;
  AuxExpressao := ´´;
  X            := 0;
  I            := 0;

  while I < Length(strExpressao) do
    begin
      Inc(I);
      C := strExpressao[I];
      if C in [´0´..´9´] then
         begin
           AuxExpressao := AuxExpressao + C;
           if I < Length(strExpressao) then
              begin
                C := strExpressao[I + 1];
                if not (C in [´0´..´9´]) then
                   AuxExpressao := AuxExpressao + ´ ´;
              end;
         end
      else
         if C = ´(´ then
            Push(C)
         else
            if C = ´)´ then
               begin
                 C := Pop;
                 while (C <> ´ ´) and (C <> ´(´) do
                   begin
                     AuxExpressao := AuxExpressao + C + ´ ´;
                     C := Pop;
                   end;
               end
            else
               begin
                 if C in [´*´, ´/´, ´+´, ´-´] then
                    begin
                      if C in [´*´, ´/´] then
                         begin
                           while not (aOperadores[OperadorIndex] in [´ ´, ´+´, ´-´, ´(´]) do
                             begin
                               AuxExpressao := ´ ´ + AuxExpressao + Pop + ´ ´;
                             end;
                         end
                      else
                         begin
                           while not (aOperadores[OperadorIndex] in [´ ´, ´(´]) do
                             begin
                               AuxExpressao := AuxExpressao + Pop + ´ ´;
                             end;
                         end;
                      Push(C);
                    end;
               end;
      X := strExpressao[I];
    end;

  // Neste ponto, AuxEmpressão está no formato "PostFix"
  // Executa expressão
  OperadorIndex  := 0;
  OperandosIndex := 0;
  I              := 0;

  AuxExpressao := AuxExpressao;
  I := Pos(´ ´, AuxExpressao);
  J := 1;
  while I > 0 do
    begin
      strExpressao := Copy(AuxExpressao, J, I - J);
      C            := strExpressao[1];
      if not (C in [´+´, ´-´, ´*´, ´/´]) then
         begin
           Operando := StrToFloat(strExpressao);
           PushOperando(Operando);
         end
      else
         begin
           Operando := PopOperando;
           case C of
                ´+´: PushOperando(PopOperando + Operando);
                ´-´: PushOperando(PopOperando - Operando);
                ´*´: PushOperando(PopOperando * Operando);
                ´/´: PushOperando(PopOperando / Operando);
           end;
         end;
      J := I + 1;
      I := PosEx(´ ´, AuxExpressao, J);
    end;

  Result := PopOperando;
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
  Label1.Caption := FloatToStr(AvaliaExpressao(Edit1.Text));
end;