.PAS File Format – Procedures and functions

Declaring a routine

procedure Swap(var A, B: Integer);
var T: Integer;
begin
  T := A; A := B; B := T;
end;

function Max(A, B: Integer): Integer;
begin
  if A > B then Result := A else Result := B;   { Object Pascal: Result }
  { Max := A;  ISO 7185 and Turbo Pascal: assign to the function name }
end;

A procedure does something; a function also gives back a value of the type after the colon. The body is a block: declarations, then begin … end;. A routine may declare other routines inside its own declaration part (nested routines), which can use its variables and parameters but are visible only inside it.

• The function result is set by assigning to the function’s name (the only way in ISO 7185 and Turbo Pascal), or to Result (Delphi and Free Pascal in their Object Pascal modes; the result mode switch), or with Exit(Value). The function name on the right side of an assignment calls the function again, so recursion reads the result variable as Result and not by name.
• A function may return any type except a file type. In ISO 7185 and in older Turbo Pascal a function cannot return a structured type, only a simple type or a pointer; Turbo Pascal also allows strings and records.
• A function that is called without its result being used is allowed with {$X+}.

Parameters

Parameters of one type are grouped: (A, B: Integer; const S: string). A parameter list separates groups with semicolons and the names within one with commas. In a call, the arguments are separated by commas.

Directives

After the heading and its semicolon, words that say more about the routine may follow, each ended by a semicolon.

Calling conventions

The table gives the 32-bit Intel conventions; on 64-bit systems there is one native convention and the names are accepted. {$CALLING name} in Free Pascal sets the default for a section of code.

Overloading, default parameters

function Add(A, B: Integer): Integer; overload;
function Add(A, B: Double): Double; overload;
function Add(const S, T: string): string; overload;

procedure Log(const Msg: string; Level: Integer = 0);

Routines of one name may be overloaded with the overload directive on each. The compiler picks by the number and types of the arguments, and reports an ambiguity as an error. Free Pascal’s Reference guide describes the cases where the directive can be left out.

Operator overloading

{ Free Pascal }
operator + (A, B: TVec) R: TVec;
begin
  R.X := A.X + B.X; R.Y := A.Y + B.Y;
end;

{ Delphi (and Free Pascal advanced records) }
type TVec = record
  X, Y: Double;
  class operator Add(const A, B: TVec): TVec;
  class operator Implicit(const V: Double): TVec;
end;

Free Pascal’s operator declares a global operator with a result name. Delphi and Free Pascal (in advanced records) declare class operator members of a record or class with names such as Add, Subtract, Multiply, Divide, Equal, NotEqual, LessThan, GreaterThan, GreaterThanOrEqual, LessThanOrEqual, Negative, Positive, LogicalNot, Inc, Dec, In, Implicit, Explicit, Round, Trunc, IntDivide, Modulus, LeftShift, RightShift, LogicalAnd, LogicalOr, LogicalXor, BitwiseAnd, BitwiseOr and BitwiseXor. Implicit and Explicit define conversions to and from the type.

Nested, anonymous and recursive routines

• A nested routine is declared in the declaration part of another and can use its variables. A procedural variable may point at a nested routine only with nestedprocvars in Free Pascal.
• An anonymous method (Delphi 2009 and later) is an unnamed routine written where a value is needed: procedure begin … end or function(X: Integer): Integer begin … end. It captures the variables around it, extending their life as needed. It is assigned to a reference to type.
• A routine may call itself (recursion); the forward directive allows mutual recursion.

Methods

A routine that belongs to a class, object or record is a method and is declared in the type, then defined with the type’s name in front: procedure TFoo.Bar;. Constructors, destructors, virtual methods, class methods and the rest are on Classes and objects.