Strings in Turbo Pascal

Follow these fast links:

Concat Function
Copy Function
Delete Procedure
Insert Procedure
Length Function
Pos Function
Str Procedure
Upcase Function
Val Procedure
Miscellaneous Notes

String Basics in Turbo Pascal

In Turbo Pascal, a string is stored as a char array. The zero^th location in the array contains a binary value equal to the usable length of the string, i.e., no characters past the subscript equal to this value are treated as being part of the string.

Strings may be declared in two ways:

longest_str : string;
mystr : string[n]; where n is the maximum number of characters which may be stored in the string

The first method results in a default maximum length of 255, the largest unsigned binary number which can be stored in a byte. This is also the absolute maximum length for a string in Turbo Pascal. This method of string storage has ramifications for how text must be handled.

The following declares a string called mystr. Pascal provides an array consisting of sixteen consecutive bytes of memory. The subscripts used for the array start with zero (0).

mystr : string[15];

The following is a representation of what would be in RAM, if the string 'Hello, world!' were stored in this variable.

Characters: CR  H  e  l  l  o  ,     w  o  r  l  d  ! ?? ??
Hex values: 0D 48 65 6C 6C 6F 2C 20 77 6F 71 6C 64 21 ?? ??
Subscripts:  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15

The zero^th location contains the current length of the string. As it happens, this value corresponds to the Carriage Return code of the ASCII character set. The last two locations are here filled with the dummy placeholder ??. Anything could be there, but the values are irrelevant because Pascal uses only the 13 characters as specified by the zero^th location.

Concat Function

Syntax: NewString := Concat(str1, str2, ...)
where NewString, str1, str2, etc. are string identifiers

Concat is used to concatenate all of its parameters into a single string which is then returned. This is equivalent to pasting one string onto the end of another.

There are two common uses for Concat.

Concatenating a common-separated list of strings together into a new variable

FirstName : string;
MiddleName : string;
LastName : string;
FullName : string;

FirstName := 'John';
MiddleName := 'A.';
LastName := 'Macdonald';
FullName := Concat( FirstName, ' ', MiddleName, ' ', LastName);

which results in FullName containing John A. Macdonald

Concatenating (appending) a string onto the end of another
```
Str1 : string;
Str2 : string;

Str1 := 'hot';
Str2 := 'dog';
Str1 := Concat(Str1, Str2)
```
which results in Str1 containing hotdog

Copy Function

Syntax: substr := Copy(mystr, n1, n2)
    where substr and mystr are string identifiers;
        n1 is the starting location for copying; and
        n2 is how many characters are to be copied

Copy is used to copy a portion (or all) of a string into another string variable. Given the following declarations, several things are possible.

S : string[25];
D : string[25];

Putting text into a string (which is equivalent to S := 'This is String 1.'):
```
S := Copy('This is String 1.', 1, 17)
```
Copying a whole string from S to D (which is equivalent to D := S):
```
D := Copy(S, 1, Length(S)) 
```
Copying an internal part (is) of string S to D:
```
D := Copy(S, 6, 2)
```
Copying the tail end (ring 1.) of string S to D (which is equivalent to D := (S, 11, 7):
```
D := Copy(S, Pos('ring', S), Length(S) - Pos('ring', S) + 1) 
```

Delete Procedure

Syntax: Delete(mystr, nStart, nHowmany)
where mystr is a string identifier; and
nStart and nHowmany are integers

Delete eliminates nHowmany characters from mystr starting with the nStart^th character.

After the following code fragment is executed, mystr will be 'cool'.

mystr := 'school';
Delete(mystr, 3, 1);
Delete(mystr, 1, 1)

Insert Procedure

Syntax: Insert(newstr, mystr, nLocation)
    where newstr is a string identifier or constant;
    mystr is a string identifier; and
    nLocation is an integer

Insert puts newstr into mystr starting at nLocation.

After the following code fragment is executed, mystr will be 'Macdonald'.

mystr := 'McDonald';
Delete(mystr, 2, 2);
Insert('acd', mystr, 2)

Length Function

Syntax: len = Length(mystr)
where len is an integer and
mystr is the identifier of a string variable

Length returns the length of a string by checking the zero^th location in the array. The following code will result in len having the value 13.

len : integer;
mystr : string[15];

mystr := 'Hello, world!';
len := Length(mystr);

Pos Function

Syntax: Location := Pos(substr, mystr)
where substr is the substring being looked for and
mystr is the string being searched

Pos returns as an integer the location (subscript) of where substr was found to start in mystr.

Substr : string;
MyStr : string;
Location : integer;

SubStr := 'don';
MyStr := 'Macdonald';
Location := Pos(SubStr, MyStr)

As a result of the above code, Location will hold the value 4.

Str Procedure

Syntax: Str(number, mystr)
where number is a numeric data type and
mystr is a string identifier

Str is used to convert an integer, real, etc. into a string. This procedure permits the programmer to then use the Length function to find out how much space (i.e., characters) would be required to print the item. In this way, you could determine the longest item in a column so you could line all of them up neatly in the column. Given the following declarations and assignments, several things are possible.

num_int : integer;
num_real : real;
mystr : string;

num_int := 345;
num_real := 34.567;

The following code would result in mystr containing '345'.
```
Str(num_int, mystr)
```
The following code would result in mystr containing ' 345', with two leading spaces.
```
Str(num_int:5, mystr)
```
The following code would result in mystr containing '34.57'.
```
Str(num_real:1:2, mystr)
```
The following code would result in mystr containing ' 34.6', with three leading spaces.
```
Str(num_real:7:1, mystr)
```

Upcase Function

Syntax: NewChar := Upcase(OldChar)
where NewChar and OldChar are of type char

Upcase takes the char OldChar and returns the uppercase version of it. Consequently, if the character stored in OldChar is not a lowercase alphabetic, no change occurs and the original character is returned.

This function is very useful when handling user input. Checking of alphabetic input need only be a comparison with an uppercase letter, e.g.,

YesNo : char;

write('Do you wish to continue? (Y/N) ');
readln(YesNo);
if Upcase(YesNo) = 'N' then halt

Individual characters in a string can also be changed using this function, e.g., After the following code fragment is executed, mystr will be 'McDonald'.

mystr := 'Mcdonald';
mystr[3] := Upcase(mystr[3])

Val Procedure

Syntax: Val(mystr, number, errorflag)
    where mystr is a string identifier;
    number is a numeric data type; and
    errorflag is an integer

Val attempts to convert the string mystr into its numeric representation of the same type as that of number. If the attempt fails because an character illegal for the given data type is found, its position in the string is placed in errorflag. A value of 0 indicates that the conversion was successful. This procedure is extremely useful in checking user input so as to avoid run-time errors when the user mistypes. Examine the following examples and the bulletproofing code in Getting Good Data with the repeat-until Loop II.

num_int : integer;
num_real : real;
mystr : string;
errorflag : integer;

If mystr contains the text '34.5', the following line of code will be successful and errorflag will have a value of 0.
```
Val(mystr, num_real, errorflag)
```
If mystr contains the text '2w3', the following line of code will be unsuccessful and errorflag will have a value of 2.
```
Val(mystr, num_int, errorflag)
```

Miscellaneous Notes

Single characters can be replaced in a string. Given the following declarations and assignments, several things are possible.

mystr : string;
ch : char;
D : string[25];

mystr := 'cot;
ch := 'u';
D := 'pat';

Replacing a single character using a char variable:
```
D[2] := ch; 
```
This would result in D containing 'put'.
Replacing a single character using a char literal:
```
D[2] := 'e'; 
```
This would result in D containing 'pet'.
Replacing a single character using a single character from a string variable:
```
D[2] := mystr[2]; 
```
This would result in D containing 'pot'.