procedure tOptomizer.DoExpression( var CodeTree: pCodeTree);
  begin
    if Assigned( CodeTree) then
      begin
        DoExpression( CodeTree^.Left);
        DoExpression( CodeTree^.Right);
        case CodeTree^.Node.CodeType of
...    

procedure tOptomizer.DoExpression( var CodeTree: pCodeTree);
var
  stack: array of pCodeTree;
  i: integer;
begin
  // Initialize the stack and push the root node onto it
  SetLength(stack, 1);
  stack[0] := CodeTree;

  // Process nodes from the stack until it is empty
  i := 0;
  while i < Length(stack) do
  begin
    // Pop the top node from the stack
    CodeTree := stack[i];
    Inc(i);

    // Push the left and right children of the node onto the stack
    if Assigned(CodeTree^.Left) then
    begin
      SetLength(stack, Length(stack)+1);
      stack[Length(stack)-1] := CodeTree^.Left;
    end;
    if Assigned(CodeTree^.Right) then
    begin
      SetLength(stack, Length(stack)+1);
      stack[Length(stack)-1] := CodeTree^.Right;
    end;

    // Process the node
    case CodeTree^.Node.CodeType of
      ...
    end;
  end;
end;    

procedure tOptomizer.DoExpression(var CodeTree: pCodeTree);
var
  CurrentNode: pCodeTree;
begin
  CurrentNode := CodeTree;
  while Assigned(CurrentNode) do
  begin
    // Process the left subtree of the current node
    if Assigned(CurrentNode^.Left) then
    begin
      DoExpression(CurrentNode^.Left);
    end;

    // Process the right subtree of the current node
    if Assigned(CurrentNode^.Right) then
    begin
      DoExpression(CurrentNode^.Right);
    end;

    // Perform the appropriate operation based on the current node's code type
    case CurrentNode^.Node.CodeType of
    // ...
    end;

    // Move to the next node in the tree
    CurrentNode := CurrentNode^.Next;
  end;
end;    

From a performance standpoint I like to use recursion because the stack (RSP) is usually in the data cache. Since the entry point is the same there is no need to push return addresses on the stack (don't use CALL) and termination can be handled with a sentinel on the stack. (If null is used for the stack sentinel then left/right will need to be handled internally to insure null is not pushed on the stack.)