Node:String Operations, Next:Accessing Command Line Arguments, Previous:File Routines, Up:Library Routines

#### String Operations

In the following description, `s1` and `s2` may be arbitrary string expressions, `s` is a variable of string type.

`WriteStr (s, write-parameter-list)`
`ReadStr (s1, read-parameter-list)`
  Write to a string and read from a string. The parameter lists are identical to `Write`/`Read` from `Text` files. The semantics is closely modeled after file I/O.
`Index (s1, s2)`
  If `s2` is empty, return 1 else if `s1` is empty return 0 else returns the position of `s2` in `s1` (an integer).
`Length (s1)`
  Return the length of `s1` (an integer from `0 .. s1.Capacity`).
`Trim (s1)`
  Returns a new string with spaces stripped of the end of `s`.
`SubStr (s1, i)`
`SubStr (s1, i, j)`
  Return a new substring of `s1` that contains `j` characters starting from `i`. If `j` is missing, return all the characters starting from `i`.
`EQ (s1, s2)`
`NE (s1, s2)`
`LT (s1, s2)`
`LE (s1, s2)`
`GT (s1, s2)`
`GE (s1, s2)`
  Lexicographic comparisons of `s1` and `s2`. Returns a boolean result. Strings are not padded with spaces.
`s1 = s2`
`s1 <> s2`
`s1 < s2`
`s1 <= s2`
`s1 > s2`
`s1 >= s2`
  Lexicographic comparisons of `s1` and `s2`. Returns a boolean result. The shorter string is blank padded to length of the longer one, but only in `--extended-pascal` mode.

GPC supports string catenation with the `+` operator or the `Concat` function. All string-types are compatible, so you may catenate any chars, fixed length strings and variable length strings.

    program ConcatDemo (Input, Output);

    var
      Ch  : Char;
      Str : String (100);
      Str2: String (50);
      FStr: packed array [1 .. 20] of Char;

    begin
       Ch := '$';
       FStr := 'demo';  { padded with blanks }
       Write ('Give me some chars to play with: ');
       ReadLn (Str);
       Str := '^' + 'prefix:' + Str + ':suffix:' + FStr + Ch;
       WriteLn (Concat ('Le', 'ng', 'th'), ' = ', Length (Str));
       WriteLn (Str)
    end.

Note: The length of strings in GPC is limited only by the range of `Integer` (at least 32 bits, i.e., 2 GB), or the available memory, whichever is smaller. :-)

When trying to write programs portable to other EP compilers, it is however safe to assume a limit of about 32 KB. At least Prospero's Extended Pascal compiler limits strings to 32760 bytes. DEC Pascal limits strings to 65535 bytes.