<aa><bb><cc="2009" /><dd /><ee /><tt>qq</tt></bb>

var
  S: String;
begin
  S:='<aa><bb><cc="2009" /><dd /><ee /><tt>qq</tt></bb>';
  S:=StringReplace(S, '/>', '/><WWW />', [rfIgnoreCase]);
  Memo.Text:=S;
end;

Конечное значение S:
<aa><bb><cc="2009" /><WWW /><dd /><ee /><tt>qq</tt></bb>

var
  S: String;
begin
  S:='<aa><bb><cc="2009" /><dd /><ee /><tt>qq</tt></bb>';
  S:=Replace(S, '/>', '/><WWW />', [rfIgnoreCase]);
  Memo.Text:=S;
end;

Конечное значение S:
<aa><bb><cc="2009" /><WWW /><aa><bb><cc="2009" /><dd /><ee /><tt>qq</tt></bb>

      if not (rfReplaceAll in Flags) then
        Break;
      I := I + RLen;
      LastI := I;
      J := J + RLen;

      I := I + RLen;
      LastI := I;
      J := J + RLen;
      if not (rfReplaceAll in Flags)
        then Break;

...

var
  I, J, LastI: Integer;
  UC, LC: Char;
  Tmp: String;
begin
  if (S = '') or (OldPattern = '') then
  begin
    Result := S;
    Exit;
  end;

  RLen := Length(OldPattern);
  RToLen := Length(NewPattern);
  TextLen := Length(S);
  ResLen := 0;
  ResSize := TextLen;
  SetLength(Result, ResSize);

  if rfIgnoreCase in Flags then
  begin
    Tmp := OldPattern[1];
    UC := AnsiUpperCase(Tmp)[1];
    LC := AnsiLowerCase(Tmp)[1];
    CompareText := @CompareMemNC;
  end
  else
  begin
    UC := OldPattern[1];
    LC := OldPattern[1];
    CompareText := @CompareMemCS;
  end;

  I := 1;
  J := RLen;
  LastI := 1;
  while I <= TextLen do
  begin
    if J > TextLen then
      Break;

    if ((S[I] = LC) or (S[I] = UC)) and
       CompareText(@(PChar(Pointer(S))[I]), @(PChar(Pointer(OldPattern))[1]), RLen - 1) then
    begin
      Add_Org(LastI, I);
      Add_Replace(I);
      if not (rfReplaceAll in Flags) then
        Break;
      I := I + RLen;
      LastI := I;
      J := J + RLen;
    end
    else
    begin
      Inc(I);
      Inc(J);
    end;
  end;
  Add_Org(LastI, TextLen + 1);

  if Length(Result) <> ResLen then
    SetLength(Result, ResLen);
end;

 Александр Алексеев

function Replace(const S, OldPattern, NewPattern: String; Flags: TReplaceFlags): string;
var
  RLen, TextLen, ResLen, ResSize, RToLen: Integer;
  CompareText: function(const S1, S2: PChar; const ALen: Integer): Boolean;

  // Компаратор для сравнения с учётом регистра символов
  function CompareMemCS(const S1, S2: PChar; const ALen: Integer): Boolean;
  begin
    Result := CompareMem(S1, S2, ALen * SizeOf(Char));
  end;

  // Компаратор для сравнения с игнорированием регистра символов
  function CompareMemNC(const S1, S2: PChar; const ALen: Integer): Boolean;
  begin
    Result := (AnsiStrLComp(S1, S2, ALen) = 0);
  end;

  procedure Add_Replace(const Index: Integer);
  begin
    if ResLen + RToLen > ResSize then
    begin
      ResSize := ResSize * 2 + RToLen;
      SetLength(Result, ResSize);
    end;

    MoveChars(NewPattern[1], Result[ResLen + 1], RToLen);

    ResLen := ResLen + RToLen;
  end;

  procedure Add_Org(const LastI, Index: Integer);
  var
    Sz, Dest: Integer;

  begin
    Sz := Index - LastI;
    if Sz <= 0 then
      Exit;

    Dest := ResLen;
    Inc(Dest);
    ResLen := ResLen + Sz;

    if ResLen > ResSize then
    begin
      ResSize := ResSize * 2;
      SetLength(Result, ResSize);
    end;

    MoveChars(S[LastI], Result[Dest], Sz);
  end;

 Александр Алексеев

  procedure DoReplace;
  var
  i: integer;
  FirstU, LastU: Char;
  begin
  WhatB:=AnsiUpperCase(ReplaceBegin);
  WhatE:=AnsiUpperCase(ReplaceEnd);
  FirstU:=WhatB[1];
  LastU:=WhatE[1];

  i:=1;
  Stop:=False;
  while i<=TextLen do
    begin{0}
    IF NOT Stop THEN
    BEGIN{1}
    IF StrBool THEN
      BEGIN{2}
      if UpperConv[Text[i]]=LastU then
        begin{3}
      if SameTextE(i) then
          begin{4}
        End_Replace(i);
        if not All then
        Stop:=True;
          end{4}
        else
      Add_Org(i);
        end{3}
        else
      Add_Org(i);
      END{2}
    ELSE
      BEGIN{5}
      if UpperConv[Text[i]]=FirstU then
        begin{6}
      if SameTextB(i) then
      Begin_Replace(i)
        else
      Add_Org(i);
        end{6}
        else
      Add_Org(i);
      END;{5}
    END{1}
      ELSE Add_Org(i);
    end;{0}

  if StrBool then
    begin{0}
    ResLen:=ResLen+IndexStr;
      if ResLen>ResSize then
        begin{1}
      ResSize:=ResLen*2;
      SetLength(Result, ResSize);
        end;{1}
    for i:=1 to IndexStr do
    result[PosStr+i-1]:=ReadStr[i];
    end;{0}    
  end;
  ////////////////////////////////////////
begin
if (ReplaceBegin='') or (ReplaceEnd='') or (Text='') then
  begin
result:=Text;
exit;
  end;

RLen:=Length(ReplaceBegin);
LLen:=Length(ReplaceEnd);
RToLen:=Length(ReplaceTo);
ResLen:=0;
PosStr:=1;
TextLen:=Length(Text);
ResSize:=TextLen;
SetString(result, nil, ResSize);
StrSize:=ResSize;
SetString(ReadStr, nil, StrSize);
StrBool:=False;

DoReplace;

if Length(result)<>ResLen then
SetLength(result, ResLen);
end;

  procedure End_Replace(var Index: integer);
  var
  i: integer;
  begin
  StrBool:=False;

  if ResLen+RToLen>ResSize then
    begin
  ResSize:=ResSize*2+RToLen;
  SetLength(result, ResSize);
    end;

  for i:=1 to RToLen do
  result[ResLen+i]:=ReplaceTo[i];

  if LLen>StrSize then
    begin
  StrSize:=LLen*2;
  SetLength(ReadStr, StrSize);
    end;

  for i:=1 to LLen do
    begin
  inc(IndexStr);
  ReadStr[IndexStr]:=Text[Index+i-1];
    end;

  if Length(ReadStr)<>IndexStr then
  SetLength(ReadStr, IndexStr);
  //ShowMessage(ReadStr); в переменной ReadStr содержится текст строки, которую мы заменили
  //если этот текст вам нужен - быстрее берите отсюда.

  SetString(ReadStr, nil, ResSize);
  ResLen:=ResLen+RToLen;
  Index:=Index+LLen;
  end;
  ////////////////////////////////////////
  procedure Add_Org(var Index: integer);
  begin
  if StrBool then
    begin{0}
      if IndexStr>StrSize then
        begin{1}
      StrSize:=IndexStr*2;
      SetLength(ReadStr, StrSize);
        end;{1}
      inc(IndexStr);
    ReadStr[IndexStr]:=Text[Index];
    end{0}
  else
    begin{2}
    inc(ResLen);
      if ResLen>ResSize then
        begin{3}
      ResSize:=ResSize*2;
      SetLength(Result, ResSize);
        end;{3}
    result[ResLen]:=Text[Index];
    end;{2}
  inc(Index);
  end;
  ////////////////////////////////////////
  function SameTextB(Ind: integer): boolean;
  var
  i: integer;
  begin
  result:=Ind+RLen-1<=TextLen;

  if result then
  for i:=1 to RLen-1 do
    if UpperConv[Text[Ind+i]]<>WhatB[1+i] then
      begin
    result:=False;
    exit;
      end;
  end;
  ////////////////////////////////////////
  function SameTextE(Ind: integer): boolean;
  var
  i: integer;
  begin
  result:=Ind+LLen-1<=TextLen;

  if result then
  for i:=1 to LLen-1 do
    if UpperConv[Text[Ind+i]]<>WhatE[1+i] then
      begin
    result:=False;
    exit;
      end;
  end;
  ////////////////////////////////////////

var
  UpperConv: array [AnsiChar] of AnsiChar; {глобальная переменная}
  //Единственное, функция не учитывает регистр букв (т.к. в моей задаче это не требуется), но исправить это несложно :)

procedure Init_CaseConv; {вызывается при инициализации модуля}
var
i: integer;
s: string;
begin
SetLength(s, 256);

for i:=0 to 255 do
s[i+1]:=Chr(i);

s:=SysUtils.AnsiUpperCase(s);
for i:=0 to 255 do
UpperConv[Chr(i)]:=s[i+1];
end;

function ReplaceEx(const Text, ReplaceBegin, ReplaceEnd, ReplaceTo: string; All: boolean=True): string;
var
RLen, LLen, TextLen, ResLen, ResSize, StrSize, RToLen, PosStr, IndexStr: integer;
ReadStr, WhatB, WhatE: string;
StrBool, Stop: boolean;
  ////////////////////////////////////////
  procedure Begin_Replace(var Index: integer);
  var
  i: integer;
  begin
  StrBool:=True;
  PosStr:=ResLen+1;
  IndexStr:=0;

  if RLen>StrSize then
    begin
  StrSize:=RLen*2;
  SetLength(ReadStr, StrSize);
    end;

  for i:=1 to RLen do
    begin
  inc(IndexStr);
  ReadStr[IndexStr]:=Text[Index+i-1];
    end;

  Index:=Index+RLen;
  end;
  ////////////////////////////////////////

var
  UpperConv: array [AnsiChar] of AnsiChar;
  LowerConv: array [AnsiChar] of AnsiChar;

procedure Init_CaseConv; { вызывается при инициализации модуля }
var
  i: Integer;
  s: string;
begin
  SetLength(s, 256);
  for i := 0 to 255 do
    s[i+1] := Chr(i);

  s := SysUtils.AnsiUpperCase(s);
  for i := 0 to 255 do
    UpperConv[Chr(i)] := s[i+1];

  s := SysUtils.AnsiLowerCase(s);
  for i := 0 to 255 do
    LowerConv[Chr(i)] := s[i+1];
end;

function Replace(const Text, What, ReplaceTo: string;
  CaseSensitive: Boolean): string;
var
  RLen, TextLen, ResLen, ResSize, RToLen: Integer;
  WhatU: string;

  function SameText_Case(Ind: Integer): Boolean;
  var
    i: Integer;
  begin
    Result := Ind-1+RLen <= TextLen;

    if Result then
      for i := 1 to RLen-1 do
        if Text[Ind+i] <> What[1+i] then
        begin
          Result := False;
          Exit;
        end;
  end;

  function SameText_NoCase(Ind: Integer): Boolean;
  var
    i: Integer;
    CurU: Char;
  begin
    Result := Ind-1+RLen <= TextLen;

    if Result then
      for i := 1 to RLen-1 do
        if UpperConv[Text[Ind+i]] <> WhatU[1+i] then
        begin
          Result := False;
          Exit;
        end;
  end;

  procedure Add_Replace(var Index: Integer);
  var
    i: Integer;
  begin
    if ResLen+RToLen > ResSize then
    begin
      ResSize := ResSize*2+RToLen;
      SetLength(Result, ResSize);
    end;

    for i := 1 to RToLen do
      Result[ResLen+i] := ReplaceTo[i];

    ResLen := ResLen+RToLen;
    Index := Index+RLen;
  end;

  procedure Add_Org(var Index: Integer);
  begin
    Inc(ResLen);

    if ResLen > ResSize then
    begin
      ResSize := ResSize*2;
      SetLength(Result, ResSize);
    end;

    Result[ResLen] := Text[Index];
    Index := Index+1;
  end;

  procedure DoCase;
  var
    i: Integer;
    First: Char;
  begin
    First := What[1];

    i := 1;
    while i <= TextLen do
    begin
      if (Text[i] = First) and SameText_Case(i) then
        Add_Replace(i)
      else
        Add_Org(i);
    end;
  end;

  procedure DoNoCase;
  var
    i: Integer;
    FirstU: Char;
  begin
    WhatU := AnsiUpperCase(What);
    FirstU := WhatU[1];

    i := 1;
    while i <= TextLen do
    begin
      if (UpperConv[Text[i]] = FirstU) and SameText_NoCase(i) then
        Add_Replace(i)
      else
        Add_Org(i);
    end;
  end;

begin
  if (What = '') or (Text = '') then
  begin
    Result := Text;
    Exit;
  end;

  RLen := Length(What);
  RToLen := Length(ReplaceTo);
  TextLen := Length(Text);
  ResLen := 0;
  ResSize := TextLen;
  SetString(Result, nil, ResSize);

  if CaseSensitive then
    DoCase
  else
    DoNoCase;

  if Length(Result) <> ResLen then
    SetLength(Result, ResLen);
end;