Modulo with negative dividend

Standard Pascal has an Euclidean-like definition of the mod operator whereas Delphi uses a truncated definition.

Nested comments

Standard Pascal requires that the comment delimiters { and the bigramm (*, as well as } and *) are synonymous to each other.^[2] In Delphi, however, a block comment started by { must be closed with a }.^[3] The bigramm *) will only close any comment that started with (*.^[3] This scheme allows for nested comments at the expense of compiler complexity.

Procedural data types

The way procedures and functions can be passed as parameters differs: Delphi requires explicit procedural types to be declared where Standard Pascal does not.^[4]

program proceduralDataType(output);
	{ `printYIntersect` has one procedural parameter: }
	procedure printYIntersect(function f(x: real): real);
		begin
			writeLn(f(0.0));
		end;
	{ Standard Pascal does not have procedural “pointers.” }
	function f(x: real): real;
		begin
			f := cos(x);
		end;
	{ ─── MAIN ───────────────────────────────────────────── }
	begin
		printYIntersect(f);
	end.

type
	TFunc = function(x: real): real;

procedure printYIntersect(f: TFunc);
	begin
		writeLn(f(0.0));
	end;

function f(x: real): real;
	begin
		f := cos(x);
	end;
// ─── MAIN ─────────────────────────────────────────────
begin
	printYIntersect(@f);
end.

Conversion of newline characters

Various computer systems show a wide variety how to indicate a newline. This affects the internal representation of text files which are composed of a series of “lines”. In order to relieve the programmer from any associated headaches, Standard Pascal mandates that reading an “end-of-line character” returns a single space character. To distinguish such an “end-of-line” space character from a space character that is actually genuine payload of the line, EOLn becomes true.

Delphi does not show this behavior. Reading a newline will return whatever character sequence represents a newline on the current host system, for example two char values chr(13) (carriage return) plus chr(10) (line feed).^[3]

Global goto

Standard Pascal permits a goto to any label defined in scope. In Delphi a goto must be within the current routine, i. e. may not leave the begin … end-frame.^[3]

program jumpAround;
	label
		999;
	procedure foo;
		begin
			{ This is not permitted in Delphi: }
			goto 999;
		end;
	begin
		foo;
		999: ;
	end.

Buffer variables

Delphi does not support buffer variables and associated standard routines get and put.^[3]

program copy(input, output);
	begin
		while not EOF(input) do
		begin
			{ Copy file buffers. Not supported by Delphi }
			output↑ := input↑;
			
			{ Input↑ contains a space if a new-line occurred. }
			if EOLn(input) then
			begin
				writeLn(output);
			end
			else
			begin
				put(output);
			end;
			
			{ Advance reading cursor. }
			get(input);
		end;
	end.

Discriminated variant record allocation

In Standard Pascal allocating memory for a variant record may indicate a specific variant. This allows implementations to allocate the least amount of really necessary memory. Delphi does not support this.^[3]

program variantRecord;
	type
		sex = (female, male);
		clothingMeasures = record
				girth: real;
				case gender: sex of
					female: (underbust: real);
					male: ( );
			end;
	var
		size: clothingMeasures;
	begin
		{ NB: No space allocated for `underbust`. }
		new(size, male);
	end.

Temporary files

In Delphi any file must be backed by a file in the file system. That means any file needs to be associated with a file name with Delphi’s assign procedure. In contrast, Standard Pascal is usable without file names. The following will produce a run-time error with Delphi.^[3]

program temporaryFile(output);
	var
		FD: text;
	begin
		rewrite(FD);
		writeLn(FD, 'Hello world!');
	end.

Packing

Delphi does not implement the standard procedures pack and unpack.^[3] Regardless, transferring data between packed and unpacked data types is an easy feat, although the implementation might not be as efficient as a compiler vendor supplied implementation would be.

Missing default write width

Delphi does not associate the data type Boolean with a default width if specified as write/writeLn parameters.^[3] Delphi demonstrates the behavior as usual for character-strings.

Overloading

Delphi permits overloading routines. In Standard Pascal identifiers must be unique in every block.

function f(x: integer): real;
begin
	result := sin(x);
end;

function f(x: real): real;
begin
	result := cos(x);
end;
// ─── MAIN ─────────────────────────────────────────────
begin
	// Note the different data types.
	writeLn(f(3));
	writeLn(f(3.0));
end.

Default parameter values

Delphi permits default parameters.

Standard write width

In Pascal, if the destination file is a text file, the parameters to write/writeLn have an implemention-defined default total width. In Delphi, for integer values this is simply 1. That means always the least amount of space is occupied.^[3] Other compilers have shown default widths of, for example, 20 allowing for a fine tabular look at no cost of extra code.

writeLn(1);
writeLn(23456789);

          1
   23456789

1
23456789