function ReplaceAll(
  const Subject: String;               // the source string
  const OldPatterns: array of String;  // the substrings to locate and replace
  const NewPatterns: array of String;  // the replacement substrings
  IgnoreCase: Boolean                  // is search case insensitive?
): String;                             // returns the string, whose substrings are changed

function ReplaceAll(const Subject: String;
  const OldPatterns, NewPatterns: array of String;
  IgnoreCase: Boolean): String;
var
  ReplaceFlags: TReplaceFlags;
  NewPattern: String;
  I: Integer;
begin
  ReplaceFlags := [rfReplaceAll];
  if IgnoreCase then
    Include(ReplaceFlags, rfIgnoreCase);
  Result := Subject;
  for I := Low(OldPatterns) to High(OldPatterns) do
  begin
    if I <= High(NewPatterns) then
      NewPattern := NewPatterns[I] 
    else
      NewPattern := '';
    Result := StringReplace(Result, OldPatterns[I], NewPattern, ReplaceFlags);
  end;
end;

function ReplaceAll(const Subject: String;
  const OldPatterns, NewPatterns: array of String;
  IgnoreCase: Boolean): String;
var
  Buffer: String;       // the result buffer
  BufferPos: Integer;   // the number of characters in the buffer
 
  // appends characters to the result buffer
  procedure Append(P: PChar; Count: Integer);
  var
    NewBufferPos: Integer;  // tne number of characters in the buffer, after append
  begin
    // calculate the number of characters in the buffer after append
    NewBufferPos := BufferPos + Count;
    // if there is not enough space in the buffer, expand it
    if NewBufferPos > Length(Buffer) then
      SetLength(Buffer, NewBufferPos + 512);
    // copy character(s) to the buffer
    if Count = 1 then
      Buffer[NewBufferPos] := P^
    else
      Move(P^, Buffer[BufferPos + 1], Count * SizeOf(Char));
    // update buffer position
    BufferPos := NewBufferPos;
  end;
 
  {$IFDEF UNICODE}
  // workaround: to have pointer to the Unicode version of StrLComp function
  function StrLComp(const S1, S2: PChar; MaxLen: Integer): Integer;
  begin
    Result := SysUtils.StrLComp(S1, S2, MaxLen);
  end;
 
  // workaround: to have pointer to the Unicode version of StrLIComp function
  function StrLIComp(const S1, S2: PChar; MaxLen: Integer): Integer;
  begin
    Result := SysUtils.StrLIComp(S1, S2, MaxLen);
  end;
  {$ENDIF}
 
var
  Compare: function(const S1, S2: PChar; MaxLen: Integer): Integer;
  Len: Integer;    // length of the current substring to locate
  I: Integer;      // index of the current substring to locate
  S: PChar;        // pointer to the current search location
  E: PChar;        // pointer to the last search location
  P: PChar;        // pointer to the beginning of unchanged characters
begin
  // which compare function should be used? 
  // keep pointer to the appropriate function
  if IgnoreCase then
    @Compare := @StrLIComp   // case insensitive
  else
    @Compare := @StrLComp;   // case sensitive
  // pre-allocate the result buffer
  SetString(Buffer, nil, Length(Subject));
  // no characters in the buffer yet
  BufferPos := 0;
  // suppose the string is not going to be altered
  P := PChar(Subject);
  // find out end of the string as the last search position
  E := PChar(Subject) + Length(Subject);
  // start the search from the beginning of the string
  S := PChar(Subject);
  // while end of string is not reached
  while S < E do
  begin
    // iterate through each substring
    for I := Low(OldPatterns) to High(OldPatterns) do
    begin
      // keep length of the current substring
      Len := Length(OldPatterns[I]);
      // if substring is located at this position
      if (S + Len <= E) and (Compare(S, PChar(OldPatterns[I]), Len) = 0) then
      begin
        // any unchanged characters left behind?
        // append them to the buffer
        if P <> S then
          Append(P, S - P);
        // is there substitute for the substring?
        // append it to the buffer
        if (I <= High(NewPatterns)) and (Length(NewPatterns[I]) <> 0) then
          Append(PChar(NewPatterns[I]), Length(NewPatterns[I]));
        // skip the found substring
        Inc(S, Len);
        // suppose the string is not going to be altered any more
        P := S;
        // go one character back, because we advance one character later
        Dec(S);
        // we are done at this position, no need to search for the other substrings
        Break;
      end;
    end;
    // advance to the next search position
    Inc(S);
  end;
  // any unchanged characters left behind?
  // append them to the buffer
  if P <> S then
    Append(P, S - P);
  // adjust length of the result buffer
  SetLength(Buffer, BufferPos);
  Result := Buffer;
end;