String manipulation and parsing is often a place where we wish that we had
more functions and methods to do our work for us.  There are many existing
methods that cover our work-a-day needs, but every now and then we need
something more.

In Paradox for Windows, there is an immensely useful function called
BreakApart().  It can do so many things that I have written one (or two)
for Delphi.

Here is how it works:
You pass the base string that you want to parse and the string that you
want to use for the BreakApart().  The function then separates the string
into several pieces and fills a TStringList with their values.

Example:

Base String:  "Here we go."
Break String: " "

Resulting array:
TStringList[0]: "Here"

TStringList[1]: "we"
TStringList[2]: "go."

Note that the break string, in this case spaces, is not to be seen
anywhere in the output.

Now that we know what is done, lets take a look at how to do it.

First, lets look at the string version.

function sBreakApart(BaseString, BreakString: string; StringList: TStringList): TStringList;
var
  EndOfCurrentString: byte;
  TempStr: string;
begin
  repeat
    EndOfCurrentString := Pos(BreakString, BaseString);
    if EndOfCurrentString = 0 then
      StringList.add(BaseString)
    else
      StringList.add(Copy(BaseString, 1, EndOfCurrentString - 1));
    BaseString := Copy(BaseString, EndOfCurrentString + length(BreakString), length(BaseString) - EndOfCurrentString);

  until EndOfCurrentString = 0;
  result := StringList;
end;

This is a fairly straight forward version (as compared with the PChar
version).  We look for the break string.  If we don’t find it at all,
then we just assign it to the TStringList and go on our merry way.
(Note:  The TStringList must be created outside the function or there
will be problems when the variable goes out of scope.)  If we do find it,
then we want to extract that portion of the string and assign it to the
next available position in the TStringList.  Note that the string is
updated each step of the way.  This is done just because it simplifies
the code.  There are several possible ways of doing this.  I just picked
one.

Let me answer some questions that I hear you asking.

1.  Why didn’t I make this a procedure?  It is true that the TStringList
would reflect all changes without a value returned, but I left it as a
function because it allows for use in another function that uses the
TStringList.  I use the function in this way later in the article.

E.g.  Listbox1.items.assign(sBreakApart(...));

2.  It doesn’t interfere with calling it as if it was a procedure.
(I.e. You don’t need to catch the result if you don’t want to code it that
way.)

Now that we have seen that it does something, how about if we have it do
something useful.

Here is a search and replace that uses the string version of the
BreakApart() function.

function ReplaceStr(BaseString, ReplaceThis, WithThis: string): string;
var
  t: TStringList;

  i: integer;
begin
  t := TStringList.create;
  sBreakApart(BaseString, ReplaceThis, t);
  if t.count > 1 then
  begin
    result := '';
    for i := 0 to t.count - 2 do
      result := result + t[i] + WithThis;
    result := result + t[i + 1];
  end
  else result := BaseString;
  t.free;
end;

This example requires a form with a pushbutton and 3 edit boxes.
You can call this function like this:

edit1.text := ReplaceStr(edit1.text, edit2.text, edit3.text);

It replaces all occurrences of edit2.text in edit1.text with edit3.text.

I told you that this was simple and useful!

Now lets take a look at the PChar version.  Since we have an idea of how
this works now, I’ll show the code first.

function pBreakApart(BaseString, BreakString: PChar; StringList: TStringList): TStringList;
var
  BreakStringLength: word;
  pEndOfCurrentString, pEndOfBaseString: PChar;
{Automatically gets memory allocated for it.}
  temp: array[0..255] of char;
begin
{Initialize the pointers.}
  BreakStringLength := StrLen(BreakString);
  pEndOfBaseString := BaseString;
  inc(pEndOfBaseString, StrLen(BaseString));
  repeat
    pEndOfCurrentString := StrPos(BaseString, BreakString);
    StringList.add(StrPas(StrLCopy(temp, BaseString, pEndOfCurrentString - BaseString)));

    inc(BaseString, pEndOfCurrentString - BaseString + BreakStringLength);
  until BaseString >= pEndOfBaseString - BreakStringLength;
  result := StringList;
end;

This takes a different approach to solving the same problem.  Since this
is done with a PChar that can be of greatly varying size, it was best to
do it with pointers and pointer arithmetic.  Since we are not changing the
value passed in (which would be bad as it is passed by reference and that
would change the values in their original memory locations) we need a way
to keep track of just where we are in the current part of the process.

A word about pointer arithmetic...  The Inc() and Dec() functions have an
undocumented feature that allows for pointer arithmetic.  The relevant
feature is that the function "knows" the size of the object pointed to
and increments the pointer the correct number of bytes.

Here is an example that uses the PChar version:

procedure TForm1.Button1Click(Sender: TObject);
var
  f: file;
  pStr: PChar;
  LengthOfFile: integer;
  t: TStringList;
begin
  {Get the information.}
  AssignFile(f, 'c:\autoexec.bat');
  {Because this is not a text file type, the record size is 1 (char)}
  Reset(f, 1);
  LengthOfFile := FileSize(f) + 1; {Add one for the null terminator.}
  pStr := AllocMem(LengthOfFile); {Zeros the memory also.}
  BlockRead(f, pStr^, LengthOfFile - 1);
  CloseFile(f);
  t := TStringList.create;
  listBox1.items.assign(pBreakApart(pStr, #13#10, t));
  t.free;
  FreeMem(pStr, LengthOfFile);
end;

This example requires a form that has a listbox and a pushbutton. It reads
the autoexec.bat file into memory in a single gulp using Blockread().
There is just enough memory allocated to get the job done.  This is done
by using the file’s size as the basis.  The PChar version is called and
assigned directly, and the file is "broken apart" by carriage return/line
feed.  (Note:  I know that a LoadFromFile() will do this also, but this is
an exercise in memory juggling.)  Then memory clean up is performed.
The contents of the autoexec.bat file are then displayed in the listbox
line by line.

The uses for this are many and varied.  If you used this on a filename with
the full path and did a BreakApart() on "\", you would have element 0 of
the list as the drive, and the last element would be the file name.  You
could break that apart on the ".", and get the separated file name and
extension.

I did not include error checking here.  A string can only hold 255
characters.  It is possible that your users might try to put more than
that in there.  If you want to do the error checking for them, then I
wish you well.  I thought that it would be beyond the scope of this short
article and left it to the reader.