program HelloWorld;
uses crt;

(* Here the main program block starts *)
begin
   writeln(''Hello, World!'');
   readkey;
end. 

This will produce following result −

Hello, World!

Let us look various parts of the above program −

• The first line of the program program HelloWorld; indicates the name of the program.

• The second line of the program uses crt; is a preprocessor command, which tells the compiler to include the crt unit before going to actual compilation.

• The next lines enclosed within begin and end statements are the main program block. Every block in Pascal is enclosed within a begin statement and an end statement. However, the end statement indicating the end of the main program is followed by a full stop (.) instead of semicolon (;).

• The begin statement of the main program block is where the program execution begins.

• The lines within (*…*) will be ignored by the compiler and it has been put to add a comment in the program.

• The statement writeln(”Hello, World!”); uses the writeln function available in Pascal which causes the message “Hello, World!” to be displayed on the screen.

• The statement readkey; allows the display to pause until the user presses a key. It is part of the crt unit. A unit is like a library in Pascal.

• The last statement end. ends your program.

Compile and Execute Pascal Program

• Open a text editor and add the above-mentioned code.

• Save the file as hello.pas

• Open a command prompt and go to the directory, where you saved the file.

• Type fpc hello.pas at command prompt and press enter to compile your code.

• If there are no errors in your code, the command prompt will take you to the next line and would generate hello executable file and hello.o object file.

• Now, type hello at command prompt to execute your program.

• You will be able to see “Hello World” printed on the screen and program waits till you press any key.

$ fpc hello.pas
Free Pascal Compiler version 2.6.0 [2011/12/23] for x86_64
Copyright (c) 1993-2011 by Florian Klaempfl and others
Target OS: Linux for x86-64
Compiling hello.pas
Linking hello
8 lines compiled, 0.1 sec

$ ./hello
Hello, World!

Make sure that free pascal compiler fpc is in your path and that you are running it in the directory containing source file hello.pas.

Pascal – Basic Syntax

You have seen a basic structure of pascal program, so it will be easy to understand other basic building blocks of the pascal programming language.

Variables

A variable definition is put in a block beginning with a var keyword, followed by definitions of the variables as follows:

var
A_Variable, B_Variable ... : Variable_Type;

Pascal variables are declared outside the code-body of the function which means they are not declared within the begin and end pairs, but they are declared after the definition of the procedure/function and before the begin keyword. For global variables, they are defined after the program header.

Functions/Procedures

In Pascal, a procedure is set of instructions to be executed, with no return value and a function is a procedure with a return value. The definition of function/procedures will be as follows −

Function Func_Name(params...) : Return_Value;
Procedure Proc_Name(params...);

Comments

The multiline comments are enclosed within curly brackets and asterisks as (* … *). Pascal allows single-line comment enclosed within curly brackets { … }.

(* This is a multi-line comments
   and it will span multiple lines. *)

{ This is a single line comment in pascal }

Case Sensitivity

Pascal is a case non-sensitive language, which means you can write your variables, functions and procedure in either case. Like variables A_Variable, a_variable and A_VARIABLE have same meaning in Pascal.

Pascal Statements

Pascal programs are made of statements. Each statement specifies a definite job of the program. These jobs could be declaration, assignment, reading data, writing data, taking logical decisions, transferring program flow control, etc.

For example −

readln (a, b, c);
s := (a + b + c)/2.0;
area := sqrt(s * (s - a)*(s-b)*(s-c));
writeln(area);        

Reserved Words in Pascal

The statements in Pascal are designed with some specific Pascal words, which are called the reserved words. For example, the words, program, input, output, var, real, begin, readline, writeline and end are all reserved words.

Following is a list of reserved words available in Pascal.

Character set and Identifiers in Pascal

The Pascal character set consists of −

• All upper case letters (A-Z)

• All lower case letters (a-z)

• All digits (0-9)

• Special symbols – + * / := , . ;. () [] = {} ` white space

The entities in a Pascal program like variables and constants, types, functions, procedures and records, etc., have a name or identifier. An identifier is a sequence of letters and digits, beginning with a letter. Special symbols and blanks must not be used in an identifier.

Pascal – Data Types

Data types of an entity indicates the meaning, constraints, possible values, operations, functions and mode of storage associated with it.

Integer, real, Boolean and character types are referred as standard data types. Data types can be categorized as scalar, pointer and structured data types. Examples of scalar data types are integer, real, Boolean, character, subrange and enumerated. Structured data types are made of the scalar types; for example, arrays, records, files and sets. We will discuss the pointer data types later.

Pascal Data Types

Pascal data types can be summarized as below in the following diagram −

Type Declarations

The type declaration is used to declare the data type of an identifier. Syntax of type declaration is −

 type-identifier-1, type-identfier-2 = type-specifier;

For example, the following declaration defines the variables days and age as integer type, yes and true as Boolean type, name and city as string type, fees and expenses as real type.

type
days, age = integer;
yes, true = boolean;
name, city = string;
fees, expenses = real;

Integer Types

Following table gives you details about standard integer types with its storage sizes and value ranges used in Object Pascal −

Constants

Use of constants makes a program more readable and helps to keep special quantities at one place in the beginning of the program. Pascal allows numerical, logical, string and character constants. Constants can be declared in the declaration part of the program by specifying the const declaration.

Syntax of constant type declaration is follows −

const
Identifier = contant_value;

Following are some examples of constant declarations −

VELOCITY_LIGHT = 3.0E=10;
PIE = 3.141592;
NAME = ''Stuart Little'';
CHOICE = yes;
OPERATOR = ''+'';

All constant declarations must be given before the variable declaration.

Enumerated types

Enumerated data types are user-defined data types. They allow values to be specified in a list. Only assignment operators and relational operators are permitted on enumerated data type. Enumerated data types can be declared as follows −

type
enum-identifier = (item1, item2, item3, ... )

Following are some examples of enumerated type declarations −

type
SUMMER = (April, May, June, July, September);
COLORS = (Red, Green, Blue, Yellow, Magenta, Cyan, Black, White);
TRANSPORT = (Bus, Train, Airplane, Ship);

The order in which the items are listed in the domain of an enumerated type defines the order of the items. For example, in the enumerated type SUMMER, April comes before May, May comes before June, and so on. The domain of enumerated type identifiers cannot consist of numeric or character constants.

Subrange Types

Subrange types allow a variable to assume values that lie within a certain range. For example, if the age of voters should lie between 18 to 100 years, a variable named age could be declared as −

var
age: 18 ... 100;

We will look at variable declaration in detail in the next section. You can also define a subrange type using the type declaration. Syntax for declaring a subrange type is as follows −

type
subrange-identifier = lower-limit ... upper-limit;

Following are some examples of subrange type declarations −

const
P = 18;
Q = 90;
type
Number = 1 ... 100;
Value = P ... Q;

Subrange types can be created from a subset of an already defined enumerated type, For example −

type
months = (Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec);
Summer = Apr ... Aug;
Winter = Oct ... Dec;

Pascal – Variable Types

A variable is nothing but a name given to a storage area that our programs can manipulate. Each variable in Pascal has a specific type, which determines the size and layout of the variable”s memory; the range of values that can be stored within that memory; and the set of operations that can be applied to the variable.

The name of a variable can be composed of letters, digits, and the underscore character. It must begin with either a letter or an underscore. Pascal is not case-sensitive, so uppercase and lowercase letters mean same here. Based on the basic types explained in previous chapter, there will be following basic variable types −

Basic Variables in Pascal

Pascal programming language also allows defining various other types of variables, which we will cover in subsequent chapters like Pointer, Array, Records, Sets, and Files, etc. For this chapter, let us study only basic variable types.

Variable Declaration in Pascal

All variables must be declared before we use them in Pascal program. All variable declarations are followed by the var keyword. A declaration specifies a list of variables, followed by a colon (:) and the type. Syntax of variable declaration is −

var
variable_list : type;

Here, type must be a valid Pascal data type including character, integer, real, boolean, or any user-defined data type, etc., and variable_list may consist of one or more identifier names separated by commas. Some valid variable declarations are shown here −

var
age, weekdays : integer;
taxrate, net_income: real;
choice, isready: boolean;
initials, grade: char;
name, surname : string;

In the previous tutorial, we have discussed that Pascal allows declaring a type. A type can be identified by a name or identifier. This type can be used to define variables of that type. For example,

type
days, age = integer;
yes, true = boolean;
name, city = string;
fees, expenses = real;

Now, the types so defined can be used in variable declarations −

var
weekdays, holidays : days;
choice: yes;
student_name, emp_name : name;
capital: city;
cost: expenses;

Please note the difference between type declaration and var declaration. Type declaration indicates the category or class of the types such as integer, real, etc., whereas the variable specification indicates the type of values a variable may take. You can compare type declaration in Pascal with typedef in C. Most importantly, the variable name refers to the memory location where the value of the variable is going to be stored. This is not so with the type declaration.

Variable Initialization in Pascal

Variables are assigned a value with a colon and the equal sign, followed by a constant expression. The general form of assigning a value is −

variable_name := value;

By default, variables in Pascal are not initialized with zero. They may contain rubbish values. So it is a better practice to initialize variables in a program. Variables can be initialized (assigned an initial value) in their declaration. The initialization is followed by the var keyword and the syntax of initialization is as follows −

var
variable_name : type = value;

Some examples are −

age: integer = 15;
taxrate: real = 0.5;
grade: char = ''A'';
name: string = ''John Smith'';

Let us look at an example, which makes use of various types of variables discussed so far −

program Greetings;
const
message = '' Welcome to the world of Pascal '';

type
name = string;
var
firstname, surname: name;

begin
   writeln(''Please enter your first name: '');
   readln(firstname);
   
   writeln(''Please enter your surname: '');
   readln(surname);
   
   writeln;
   writeln(message, '' '', firstname, '' '', surname);
end.

Please enter your first name:
John
Please enter your surname:
Smith
Welcome to the world of Pascal John Smith

var
var1, var2, ...  : enum-identifier;

type
months = (January, February, March, April, May, June, July, August, September, October, November, December);
Var
m: months;
...
M := January;

program exEnumeration;
type
beverage = (coffee, tea, milk, water, coke, limejuice);

var
drink:beverage;

begin
   writeln(''Which drink do you want?'');
   drink := limejuice;
   
   writeln(''You can drink '', drink);
end.

Which drink do you want?
You can drink limejuice

var
subrange-name : lowerlim ... uperlim;

var
marks: 1 ... 100;
grade: ''A'' ... ''E'';
age: 1 ... 25;

program exSubrange;
var
marks: 1 .. 100;
grade: ''A'' .. ''E'';

begin
   writeln( ''Enter your marks(1 - 100): '');
   readln(marks);
   
   writeln( ''Enter your grade(A - E): '');
   readln(grade);
   
   writeln(''Marks: '' , marks, '' Grade: '', grade);
end.

Enter your marks(1 - 100): 
100
Enter your grade(A - E):
A
Marks: 100 Grade: A

const
identifier = constant_value;

program const_circle (input,output);
const
PI = 3.141592654;

var
r, d, c : real;   {variable declaration: radius, dia, circumference}

begin
   writeln(''Enter the radius of the circle'');
   readln(r);
   
   d := 2 * r;
   c :=  PI * d;
   writeln(''The circumference of the circle is '',c:7:2);
end.

Enter the radius of the circle
23
The circumference of the circle is 144.51

function name(argument(s): type1; argument(s): type2; ...): function_type;
local declarations;

begin
   ...
   < statements >
   ...
   name:= expression;
end;

(* function returning the max between two numbers *)
function max(num1, num2: integer): integer;

var
   (* local variable declaration *)
   result: integer;

begin
   if (num1 > num2) then
      result := num1
   
   else
      result := num2;
   max := result;
end;

function name(argument(s): type1; argument(s): type2; ...): function_type;

function max(num1, num2: integer): integer;

program exFunction;
var
   a, b, ret : integer;

(*function definition *)
function max(num1, num2: integer): integer;
var
   (* local variable declaration *)
   result: integer;

begin
   if (num1 > num2) then
      result := num1
   
   else
      result := num2;
   max := result;
end;

begin
   a := 100;
   b := 200;
   (* calling a function to get max value *)
   ret := max(a, b);
   
   writeln( ''Max value is : '', ret );
end.

Max value is : 200 

procedure name(argument(s): type1, argument(s): type 2, ... );
   < local declarations >
begin
   < procedure body >
end;

procedure findMin(x, y, z: integer; var m: integer); 
(* Finds the minimum of the 3 values *)

begin
   if x < y then
      m := x
   else
      m := y;
   
   if z <m then
      m := z;
end; { end of procedure findMin }  

procedure name(argument(s): type1, argument(s): type 2, ... );

procedure findMin(x, y, z: integer; var m: integer);

program exProcedure;
var
   a, b, c,  min: integer;
procedure findMin(x, y, z: integer; var m: integer); 
(* Finds the minimum of the 3 values *)

begin
   if x < y then
      m:= x
   else
      m:= y;
   
   if z < m then
      m:= z;
end; { end of procedure findMin }  

begin
   writeln('' Enter three numbers: '');
   readln( a, b, c);
   findMin(a, b, c, min); (* Procedure call *)
   
   writeln('' Minimum: '', min);
end.

Enter three numbers:
89 45 67
Minimum: 45

n! = n*(n-1)!
   = n*(n-1)*(n-2)!
      ...
   = n*(n-1)*(n-2)*(n-3)... 1

program exRecursion;
var
   num, f: integer;
function fact(x: integer): integer; (* calculates factorial of x - x! *)

begin
   if x=0 then
      fact := 1
   else
      fact := x * fact(x-1); (* recursive call *)
end; { end of function fact}

begin
   writeln('' Enter a number: '');
   readln(num);
   f := fact(num);
   
   writeln('' Factorial '', num, '' is: '' , f);
end.

Enter a number:
5
Factorial 5 is: 120

program recursiveFibonacci;
var
   i: integer;
function fibonacci(n: integer): integer;

begin
   if n=1 then
      fibonacci := 0
   
   else if n=2 then
      fibonacci := 1
   
   else
      fibonacci := fibonacci(n-1) + fibonacci(n-2);
end; 

begin
   for i:= 1 to 10 do
   
   write(fibonacci (i), ''  '');
end.

0 1 1 2	3 5 8 13 21 34

program exLocal; 
var
   a, b, c: integer;

begin
   (* actual initialization *)
   a := 10;
   b := 20;
   c := a + b;
   
   writeln(''value of a = '', a , '' b =  '',  b, '' and c = '', c);
end.

value of a = 10 b = 20 c = 30

program exLocal;
var
   a, b, c: integer;
procedure display;

var
   a, b, c: integer;
begin
   (* local variables *)
   a := 10;
   b := 20;
   c := a + b;
   
   writeln(''Winthin the procedure display'');
   writeln(''value of a = '', a , '' b =  '',  b, '' and c = '', c);
end;

begin
   a:= 100;
   b:= 200;
   c:= a + b;
   
   writeln(''Winthin the program exlocal'');
   writeln(''value of a = '', a , '' b =  '',  b, '' and c = '', c);
   display();
end.

Within the program exlocal
value of a = 100 b = 200 c = 300
Within the procedure display
value of a = 10 b = 20 c = 30

program exGlobal;
var
   a, b, c: integer;
procedure display;
var
   x, y, z: integer;

begin
   (* local variables *)
   x := 10;
   y := 20;
   z := x + y;
   
   (*global variables *)
   a := 30;
   b:= 40;
   c:= a + b;
   
   writeln(''Winthin the procedure display'');
   writeln('' Displaying the global variables a, b, and c'');
   
   writeln(''value of a = '', a , '' b =  '',  b, '' and c = '', c);
   writeln(''Displaying the local variables x, y, and z'');
   
   writeln(''value of x = '', x , '' y =  '',  y, '' and z = '', z);
end;

begin
   a:= 100;
   b:= 200;
   c:= 300;
   
   writeln(''Winthin the program exlocal'');
   writeln(''value of a = '', a , '' b =  '',  b, '' and c = '', c);
   
   display();
end.

Within the program exlocal
value of a = 100 b = 200 c = 300
Within the procedure display
Displaying the global variables a, b, and c
value of a = 30 b = 40 c = 70
Displaying the local variables x, y, and z
value of x = 10 y = 20 z = 30

program exGlobal;
var
   a, b, c: integer;
procedure display;

var
   a, b, c: integer;

begin
   (* local variables *)
   a := 10;
   b := 20;
   c := a + b;
   
   writeln(''Winthin the procedure display'');
   writeln('' Displaying the global variables a, b, and c'');
   
   writeln(''value of a = '', a , '' b =  '',  b, '' and c = '', c);
   writeln(''Displaying the local variables a, b, and c'');
   
   writeln(''value of a = '', a , '' b =  '',  b, '' and c = '', c);
end;

begin
   a:= 100;
   b:= 200;
   c:= 300;
   
   writeln(''Winthin the program exlocal'');
   writeln(''value of a = '', a , '' b =  '',  b, '' and c = '', c);   
   
   display();
end.

Within the program exlocal
value of a = 100 b = 200 c = 300
Within the procedure display
Displaying the global variables a, b, and c
value of a = 10 b = 20 c = 30
Displaying the local variables a, b, and c
value of a = 10 b = 20 c = 30

program exString;
var
   greetings: string;
   name: packed array [1..10] of char;
   organisation: string[10];
   message: pchar;

begin
   greetings := ''Hello '';
   message := ''Good Day!'';
   
   writeln(''Please Enter your Name'');
   readln(name);
   
   writeln(''Please Enter the name of your Organisation'');
   readln(organisation);
   
   writeln(greetings, name, '' from '', organisation);
   writeln(message); 
end.

Please Enter your Name
John Smith
Please Enter the name of your Organisation
Infotech
Hello John Smith from Infotech

program exString;
uses sysutils;
var
   str1, str2, str3 : ansistring;
   str4: string;
   len: integer;

begin
   str1 := ''Hello '';
   str2 := ''There!'';
   
   (* copy str1 into str3 *)
   str3 := str1;
   writeln(''appendstr( str3, str1) :  '', str3 );
   
   (* concatenates str1 and str2 *)
   appendstr( str1, str2);
   writeln( ''appendstr( str1, str2) '' , str1 );
   str4 := str1 + str2;
   writeln(''Now str4 is: '', str4);
   
   (* total lenghth of str4 after concatenation  *)
   len := byte(str4[0]);
   writeln(''Length of the final string str4: '', len); 
end.

appendstr( str3, str1) : Hello
appendstr( str1, str2) : Hello There!
Now str4 is: Hello There! There!
Length of the final string str4: 18

var
boolean-identifier: boolean;

var
choice: boolean;

program exBoolean;
var
exit: boolean;

choice: char;
   begin
   writeln(''Do you want to continue? '');
   writeln(''Enter Y/y for yes, and N/n for no'');
   readln(choice);

if(choice = ''n'') then
   exit := true
else
   exit := false;

if (exit) then
   writeln('' Good Bye!'')
else
   writeln(''Please Continue'');

readln;
end.

Do you want to continue?
Enter Y/y for yes, and N/n for no
N
Good Bye!
Y
Please Continue

type
   array-identifier = array[index-type] of element-type;

type
   vector = array [ 1..25] of real;
var
   velocity: vector;

type
   vector = array [ 0..24] of real;
var
   velocity: vector;

type
   temperature = array [-10 .. 50] of real;
var
   day_temp, night_temp: temperature;

type
   ch_array = array[char] of 1..26;
var
   alphabet: ch_array;

type
   color = ( red, black, blue, silver, beige);
   car_color = array of [color] of boolean;
var
   car_body: car_color;

type
   ch_array = array[char] of 1..26;
var
   alphabet: ch_array;
   c: char;

begin
   ...
   for c:= ''A'' to ''Z'' do
   alphabet[c] := ord[m];  
   (* the ord() function returns the ordinal values *)

a: integer;
a: = alphabet[''A''];

program exArrays;
var
   n: array [1..10] of integer;   (* n is an array of 10 integers *)
   i, j: integer;

begin
   (* initialize elements of array n to 0 *)        
   for i := 1 to 10 do
       n[ i ] := i + 100;   (* set element at location i to i + 100 *)
    (* output each array element''s value *)
   
   for j:= 1 to 10 do
      writeln(''Element['', j, ''] = '', n[j] );
end.

Element[1] = 101
Element[2] = 102
Element[3] = 103
Element[4] = 104
Element[5] = 105
Element[6] = 106
Element[7] = 107
Element[8] = 108
Element[9] = 109
Element[10] = 110

type
   ptr-identifier = ^base-variable-type;

var
   p1, p2, ... : ptr-identifier;

type
   Rptr = ^real;
   Cptr = ^char;
   Bptr = ^ Boolean;
   Aptr = ^array[1..5] of real;
   date-ptr = ^ date;
      Date = record
         Day: 1..31;
         Month: 1..12;
         Year: 1900..3000;
      End;
var
   a, b : Rptr;
   d: date-ptr;

rptr^ := 234.56;

program exPointers;
var
   number: integer;
   iptr: ^integer;

begin
   number := 100;
   writeln(''Number is: '', number);
   
   iptr := @number;
   writeln(''iptr points to a value: '', iptr^);
   
   iptr^ := 200;
   writeln(''Number is: '', number);
   writeln(''iptr points to a value: '', iptr^);
end.

Number is: 100
iptr points to a value: 100
Number is: 200
iptr points to a value: 200

program exPointers;
var
   number: integer;
   iptr: ^integer;
   y: ^word;

begin
   number := 100;
   writeln(''Number is: '', number);
   iptr := @number;
   writeln(''iptr points to a value: '', iptr^);
   
   iptr^ := 200;
   writeln(''Number is: '', number);
   writeln(''iptr points to a value: '', iptr^);
   y := addr(iptr);
   writeln(y^); 
end.

Number is: 100
iptr points to a value: 100
Number is: 200
iptr points to a value: 200
45504

program exPointers;
var
   number: integer;
   iptr: ^integer;
   y: ^word;

begin
   iptr := nil;
   y := addr(iptr);
   
   writeln(''the vaule of iptr is '', y^);
end.

The value of ptr is 0

if(ptr <> nill )then     (* succeeds if p is not null *)
if(ptr = nill)then    (* succeeds if p is null *)

type
record-name = record
   field-1: field-type1;
   field-2: field-type2;
   ...
   field-n: field-typen;
end;

type 
Books = record
   title: packed array [1..50] of char;
   author: packed array [1..50] of char;
   subject: packed array [1..100] of char;
   book_id: integer;
end;

var
   r1, r2, ... : record-name;

var
Books : record
   title: packed array [1..50] of char;
   author: packed array [1..50] of char;
   subject: packed array [1..100] of char;
   book_id: integer;
end;

program exRecords;
type
Books = record
   title: packed array [1..50] of char;
   author: packed array [1..50] of char;
   subject: packed array [1..100] of char;
   book_id: longint;
end;

var
   Book1, Book2: Books; (* Declare Book1 and Book2 of type Books *)

begin
   (* book 1 specification *)
   Book1.title  := ''C Programming'';
   Book1.author := ''Nuha Ali ''; 
   Book1.subject := ''C Programming Tutorial'';
   Book1.book_id := 6495407;

   (* book 2 specification *)
   Book2.title := ''Telecom Billing'';
   Book2.author := ''Zara Ali'';
   Book2.subject := ''Telecom Billing Tutorial'';
   Book2.book_id := 6495700;
 
   (* print Book1 info *)
   writeln (''Book 1 title : '', Book1.title);
   writeln(''Book 1 author : '', Book1.author);
   writeln( ''Book 1 subject : '', Book1.subject);
   writeln( ''Book 1 book_id : '', Book1.book_id);
   writeln; 

   (* print Book2 info *)
   writeln (''Book 2 title : '', Book2.title);
   writeln(''Book 2 author : '', Book2.author);
   writeln( ''Book 2 subject : '', Book2.subject);
   writeln( ''Book 2 book_id : '', Book2.book_id);
end.

Book 1 title : C Programming
Book 1 author : Nuha Ali
Book 1 subject : C Programming Tutorial
Book 1 book_id : 6495407

Book 2 title : Telecom Billing
Book 2 author : Zara Ali
Book 2 subject : Telecom Billing Tutorial
Book 2 book_id : 6495700

program exRecords;
type
Books = record
   title: packed array [1..50] of char;
   author: packed array [1..50] of char;
   subject: packed array [1..100] of char;
   book_id: longint;
end;

var
   Book1, Book2: Books; (* Declare Book1 and Book2 of type Books *)

(* procedure declaration *)
procedure printBook( var book: Books );

begin
   (* print Book info *)
   writeln (''Book  title : '', book.title);
   writeln(''Book  author : '', book.author);
   writeln( ''Book  subject : '', book.subject);
   writeln( ''Book book_id : '', book.book_id);
end;

begin
   (* book 1 specification *)
   Book1.title  := ''C Programming'';
   Book1.author := ''Nuha Ali ''; 
   Book1.subject := ''C Programming Tutorial'';
   Book1.book_id := 6495407;
   
   (* book 2 specification *)
   Book2.title := ''Telecom Billing'';
   Book2.author := ''Zara Ali'';
   Book2.subject := ''Telecom Billing Tutorial'';
   Book2.book_id := 6495700;
   
   (* print Book1 info *)
   printbook(Book1);
   writeln; 

   (* print Book2 info *)
   printbook(Book2);
end.

Book 1 title : C Programming
Book 1 author : Nuha Ali
Book 1 subject : C Programming Tutorial
Book 1 book_id : 6495407

Book 2 title : Telecom Billing
Book 2 author : Zara Ali
Book 2 subject : Telecom Billing Tutorial
Book 2 book_id : 6495700

type
record-ptr = ^ record-name;
record-name = record
   field-1: field-type1;
   field-2: field-type2;
   ...
   field-n: field-typen;
end;

var
   r1, r2, ... : record-ptr;

new(r1);
new(r2);

r1^.feild1 := value1;
r1^.feild2 := value2;
...
r1^fieldn := valuen;

dispose(r1);
dispose(r2);

program exRecords;
type
BooksPtr = ^ Books;
Books = record
   title: packed array [1..50] of char;
   author: packed array [1..50] of char;
   subject: packed array [1..100] of char;
   book_id: longint;
end;

var
  (* Declare Book1 and Book2 of pointer type that refers to Book type *)
   Book1, Book2: BooksPtr; 

begin
   new(Book1);
   new(book2);
   
   (* book 1 specification *)
   Book1^.title  := ''C Programming'';
   Book1^.author := ''Nuha Ali ''; 
   Book1^.subject := ''C Programming Tutorial'';
   Book1^.book_id := 6495407;
   
   (* book 2 specification *)
   Book2^.title := ''Telecom Billing'';
   Book2^.author := ''Zara Ali'';
   Book2^.subject := ''Telecom Billing Tutorial'';
   Book2^.book_id := 6495700;
   
   (* print Book1 info *)
   writeln (''Book 1 title : '', Book1^.title);
   writeln(''Book 1 author : '', Book1^.author);
   writeln( ''Book 1 subject : '', Book1^.subject);
   writeln( ''Book 1 book_id : '', Book1^.book_id);
   
   (* print Book2 info *)
   writeln (''Book 2 title : '', Book2^.title);
   writeln(''Book 2 author : '', Book2^.author);
   writeln( ''Book 2 subject : '', Book2^.subject);
   writeln( ''Book 2 book_id : '', Book2^.book_id);
   
   dispose(Book1); 
   dispose(Book2);
end.

Book 1 title : C Programming
Book 1 author : Nuha Ali
Book 1 subject : C Programming Tutorial
Book 1 book_id : 6495407

Book 2 title : Telecom Billing
Book 2 author : Zara Ali
Book 2 subject : Telecom Billing Tutorial
Book 2 book_id : 6495700

   (* book 1 specification *)
   Book1.title  := ''C Programming'';
   Book1.author := ''Nuha Ali ''; 
   Book1.subject := ''C Programming Tutorial'';
   Book1.book_id := 6495407;

(* book 1 specification *)
With Book1 do
begin
   title  := ''C Programming'';
   author := ''Nuha Ali ''; 
   subject := ''C Programming Tutorial'';
   book_id := 6495407;
end;

var
   v: variant;

type  
   color = (red, black, white);  
var  
   v : variant;  
   i : integer;  
   b : byte;  
   w : word;  
   q : int64;  
   e : extended;  
   d : double;  
   en : color;  
   as : ansistring;  
   ws : widestring;  

begin  
   v := i;  
   v := b;  
   v := w;  
   v := q;  
   v := e;  
   v := en;  
   v := d:  
   v := as;  
   v := ws;  
end;

Program exVariant;

uses variants;
type
   color = (red, black, white);

var
   v : variant;
   i : integer;
   r: real;
   c : color;
   as : ansistring;


begin
   i := 100;
   v:= i;
   writeln(''Variant as Integer: '', v);

   r:= 234.345;
   v:= r;
   writeln(''Variant as real: '', v);

   c := red;
   v := c;
   writeln(''Variant as Enumerated data: '', v);

   as:= '' I am an AnsiString'';
   v:= as;
   writeln(''Variant as AnsiString: '', v);
end.

Variant as Integer: 100
Variant as real: 234.345
Variant as Enumerated data: 0
Variant as AnsiString: I am an AnsiString

type
set-identifier = set of base type;

var
s1, s2, ...: set-identifier;

s1, s2...: set of base type;

type
Days = (mon, tue, wed, thu, fri, sat, sun);
Letters = set of char;
DaySet = set of days;
Alphabets = set of ''A'' .. ''Z'';
studentAge = set of 13..20;

program setColors;
type  
color = (red, blue, yellow, green, white, black, orange);  
colors = set of color;  
 
procedure displayColors(c : colors);  
const  
names : array [color] of String[7]  
  = (''red'', ''blue'', ''yellow'', ''green'', ''white'', ''black'', ''orange'');  
var  
   cl : color;  
   s : String;  

begin  
   s:= '' '';  
   for cl:=red to orange do  
      if cl in c then  
      begin  
         if (s<>'' '') then s :=s +'' , '';  
         s:=s+names[cl];  
      end;  
   writeln(''['',s,'']'');  
end;  
 
var  
   c : colors;  
 
begin  
   c:= [red, blue, yellow, green, white, black, orange];
   displayColors(c);

   c:=[red, blue]+[yellow, green]; 
   displayColors(c);  

   c:=[red, blue, yellow, green, white, black, orange] - [green, white];     
   displayColors(c);    

   c:= [red, blue, yellow, green, white, black, orange]*[green, white];     
   displayColors(c);  

   c:= [red, blue, yellow, green]><[yellow, green, white, black]; 
   displayColors(c);  
end.

[ red , blue , yellow , green , white , black , orange]
[ red , blue , yellow , green]
[ red , blue , yellow , black , orange]
[ green , white]
[ red , blue , white , black]

type
file-name = file of base-type;

var
f1, f2,...: file-name;

type
   rfile = file of real;
   ifile = file of integer;
   bfile = file of boolean;
   datafile = file of record
   arrfile = file of array[1..4] of integer;

var
   marks: arrfile;
   studentdata: datafile;
   rainfalldata: rfile;
   tempdata: ifile;
   choices: bfile;

program DataFiles;
type
   StudentRecord = Record
      s_name: String;
      s_addr: String;
      s_batchcode: String;
   end;

var
   Student: StudentRecord;
   f: file of StudentRecord;

begin
   Assign(f,''students.dat'');
   Rewrite(f);
   Student.s_name := ''John Smith'';
   Student.s_addr := ''United States of America'';
   Student.s_batchcode := ''Computer Science'';
   Write(f,Student);
   Close(f);
end.

program DataFiles;
type
   StudentRecord = Record
      s_name: String;
      s_addr: String;
      s_batchcode: String;
   end;

var
   Student: StudentRecord;
   f: file of StudentRecord;

begin
   assign(f, ''students.dat'');
   reset(f); 
   while not eof(f) do
   
   begin
      read(f,Student);
      writeln(''Name: '',Student.s_name);
      writeln(''Address: '',Student.s_addr);
      writeln(''Batch Code: '', Student.s_batchcode);
   end;
   
   close(f);
end.

Name: John Smith
Address: United States of America
Batch Code: Computer Science

program addFiledata;
const
   MAX = 4;
type
   raindata = file of real;

var
   rainfile: raindata;
   filename: string;
procedure writedata(var f: raindata);

var
   data: real;
   i: integer;

begin
   rewrite(f, sizeof(data));
   for i:=1 to MAX do
   
   begin
      writeln(''Enter rainfall data: '');
      readln(data);
      write(f, data);
   end;
   
   close(f);
end;

procedure computeAverage(var x: raindata);
var
   d, sum: real;
   average: real;

begin
   reset(x);
   sum:= 0.0;
   while not eof(x) do
   
   begin
      read(x, d);
      sum := sum + d;
   end;
   
   average := sum/MAX;
   close(x);
   writeln(''Average Rainfall: '', average:7:2);
end;

begin
   writeln(''Enter the File Name: '');
   readln(filename);
   assign(rainfile, filename);
   writedata(rainfile);
   computeAverage(rainfile);
end.

Enter the File Name:
rainfall.txt
Enter rainfall data:
34
Enter rainfall data:
45
Enter rainfall data:
56
Enter rainfall data:
78
Average Rainfall: 53.25

type
file-name = text;

program exText;
var
   filename, data: string;
   myfile: text;

begin
   writeln(''Enter the file name: '');
   readln(filename);
   
   assign(myfile, filename);
   rewrite(myfile);
   
   writeln(myfile, ''Note to Students: '');
   writeln(myfile, ''For details information on Pascal Programming'');
   writeln(myfile, ''Contact: Tutorials Point'');
   writeln(''Completed writing''); 
   
   close(myfile);
end.

Enter the file name:
contact.txt 
Completed writing

program exAppendfile;
var
   myfile: text;
   info: string;

begin
   assign(myfile, ''contact.txt'');
   append(myfile);
   
   writeln(''Contact Details'');
   writeln(''[email protected]'');
   close(myfile);
   
   (* let us read from this file *)
   assign(myfile, ''contact.txt'');
   reset(myfile);
   while not eof(myfile) do
   
   begin
      readln(myfile, info);
      writeln(info);
   end;
   close(myfile);
end.

Contact Details
[email protected]
Note to Students:
For details information on Pascal Programming
Contact: Tutorials Point

var
name: array[1..100] of char;

program exMemory;
var
name: array[1..100] of char;
description: ^string;

begin
   name:= ''Zara Ali'';
   
   new(description);
      if not assigned(description) then
         writeln('' Error - unable to allocate required memory'')
      else
         description^ := ''Zara ali a DPS student in class 10th'';
   writeln(''Name = '', name );
   writeln(''Description: '', description^ );
end.

Name = Zara Ali
Description: Zara ali a DPS student in class 10th

procedure Getmem(
   out p: pointer;
   Size: PtrUInt
);

function GetMem(
   size: PtrUInt
):pointer;

program exMemory;
var
name: array[1..100] of char;
description: ^string;

begin
   name:= ''Zara Ali'';
   
   description := getmem(200);
      if not assigned(description) then
         writeln('' Error - unable to allocate required memory'')
      else
         description^ := ''Zara ali a DPS student in class 10th'';
   writeln(''Name = '', name );
   writeln(''Description: '', description^ );
   
   freemem(description);
end.

Name = Zara Ali
Description: Zara ali a DPS student in class 10th

procedure Freemem(
   p: pointer;
  Size: PtrUInt
);

function Freemem(
   p: pointer
):PtrUInt;

function ReAllocMem(
   var p: pointer;
   Size: PtrUInt
):pointer;   

program exMemory;
var
name: array[1..100] of char;
description: ^string;
desp: string;

begin
   name:= ''Zara Ali'';
   desp := ''Zara ali a DPS student.'';
   
   description := getmem(30);
      if not assigned(description) then
         writeln(''Error - unable to allocate required memory'')
      else
         description^ := desp;

   (* Suppose you want to store bigger description *)
   description := reallocmem(description, 100);
   desp := desp + '' She is in class 10th.'';
   description^:= desp; 
   
   writeln(''Name = '', name );
   writeln(''Description: '', description^ );
   
   freemem(description);
end.

Name = Zara Ali
Description: Zara ali a DPS student. She is in class 10th

program myprog;
uses crt;

Program Calculate_Area (input, output);
uses crt;
var 
   a, b, c, s, area: real;

begin
   textbackground(white); (* gives a white background *)
   clrscr; (*clears the screen *)
   
   textcolor(green); (* text color is green *)
   gotoxy(30, 4); (* takes the pointer to the 4th line and 30th column) 
   
   writeln(''This program calculates area of a triangle:'');
   writeln(''Area = area = sqrt(s(s-a)(s-b)(s-c))'');
   writeln(''S stands for semi-perimeter'');
   writeln(''a, b, c are sides of the triangle'');
   writeln(''Press any key when you are ready'');
   
   readkey;
   clrscr;
   gotoxy(20,3);
   
   write(''Enter a: '');
   readln(a);
   gotoxy(20,5);
   
   write(''Enter b:'');
   readln(b);
   gotoxy(20, 7);
   
   write(''Enter c: '');
   readln(c);

   s := (a + b + c)/2.0;
   area := sqrt(s * (s - a)*(s-b)*(s-c));
   gotoxy(20, 9);
   
   writeln(''Area: '',area:10:3);
   readkey;
end.

unit calculateArea;

unit CalculateArea;
interface

function RectangleArea( length, width: real): real;
function CircleArea(radius: real) : real;
function TriangleArea( side1, side2, side3: real): real;

implementation

function RectangleArea( length, width: real): real;
begin
   RectangleArea := length * width;
end;

function CircleArea(radius: real) : real;
const
   PI = 3.14159;
begin
   CircleArea := PI * radius * radius;
end;

function TriangleArea( side1, side2, side3: real): real;
var
   s, area: real;

begin
   s := (side1 + side2 + side3)/2.0;
   area := sqrt(s * (s - side1)*(s-side2)*(s-side3));
   TriangleArea := area;
end;

end.

program AreaCalculation;
uses CalculateArea,crt;

var
   l, w, r, a, b, c, area: real;

begin
   clrscr;
   l := 5.4;
   w := 4.7;
   area := RectangleArea(l, w);
   writeln(''Area of Rectangle 5.4 x 4.7 is: '', area:7:3);

   r:= 7.0;
   area:= CircleArea(r);
   writeln(''Area of Circle with radius 7.0 is: '', area:7:3);

   a := 3.0;
   b:= 4.0;
   c:= 5.0;
  
   area:= TriangleArea(a, b, c);
   writeln(''Area of Triangle 3.0 by 4.0 by 5.0 is: '', area:7:3);
end.

Area of Rectangle 5.4 x 4.7 is: 25.380
Area of Circle with radius 7.0 is: 153.938
Area of Triangle 3.0 by 4.0 by 5.0 is: 6.000

program TimeDemo;
uses sysutils;

begin
   writeln (''Current time : '',TimeToStr(Time));
end.

Current time : 18:33:08

Program DateDemo;
uses sysutils;
var
   YY,MM,DD : Word;

begin
   writeln (''Date : '',Date);
   DeCodeDate (Date,YY,MM,DD);
   writeln (format (''Today is (DD/MM/YY): %d/%d/%d '',[dd,mm,yy]));
end.

Date: 4.111300000000000E+004
Today is (DD/MM/YY):23/7/2012

Program DatenTimeDemo;
uses sysutils;
begin
   writeln (''Date and Time at the time of writing : '',DateTimeToStr(Now));
end.

Date and Time at the time of writing : 23/7/2012 18:51:

type TTimeStamp = record
   Time: Integer;
   Date: Integer;
end;

Program DatenTimeDemo;
uses sysutils;
var
year, month, day, hr, min, sec, ms: Word;

begin
   writeln (''Date and Time at the time of writing : '',DateTimeToStr(Now));
   writeln(''Today is '',LongDayNames[DayOfWeek(Date)]);
   writeln;
   writeln(''Details of Date: '');
   
   DecodeDate(Date,year,month,day);
   writeln (Format (''Day: %d'',[day]));
   writeln (Format (''Month: %d'',[month]));
   writeln (Format (''Year: %d'',[year]));
   writeln;
   writeln(''Details of Time: '');
   
   DecodeTime(Time,hr, min, sec, ms);
   writeln (format(''Hour: %d:'',[hr]));
   writeln (format(''Minutes: %d:'',[min]));
   writeln (format(''Seconds: %d:'',[sec]));
   writeln (format(''Milliseconds: %d:'',[hr]));
end.

Date and Time at the time of writing : 7/24/2012 8:26:
Today is Tuesday
Details of Date:
Day:24
Month:7
Year: 2012
Details of Time:
Hour: 8
Minutes: 26
Seconds: 21
Milliseconds: 8

type object-identifier = object  
   private
   field1 : field-type;  
   field2 : field-type;  
   ...
   public
   procedure proc1;  
   function f1(): function-type;
   end;  
var objectvar : object-identifier;

type 
   Rectangle = object  
   private  
      length, width: integer; 
   
   public  
      constructor init;  
      destructor done;  
      
      procedure setlength(l: inteter);  
      function getlength(): integer;  
      
      procedure setwidth(w: integer);  
      function getwidth(): integer;  
      
      procedure draw;
end;
var
   r1: Rectangle;
   pr1: ^Rectangle;

r1.setlength(3);
r1.setwidth(7);

writeln('' Draw a rectangle: '', r1.getlength(), '' by '' , r1.getwidth());
r1.draw;
new(pr1);
pr1^.setlength(5);
pr1^.setwidth(4);

writeln('' Draw a rectangle: '', pr1^.getlength(), '' by '' ,pr1^.getwidth());
pr1^.draw;
dispose(pr1);

program exObjects;
type 
   Rectangle = object  
   private  
      length, width: integer; 
   
   public  
      procedure setlength(l: integer);
      function getlength(): integer;  
      
      procedure setwidth(w: integer);  
      function getwidth(): integer;  
      
      procedure draw;
end;
var
   r1: Rectangle;
   pr1: ^Rectangle;

procedure Rectangle.setlength(l: integer);
begin
   length := l;
end;

procedure Rectangle.setwidth(w: integer);
begin
   width :=w;
end;

function Rectangle.getlength(): integer;  
begin
   getlength := length;
end;

function Rectangle.getwidth(): integer;  
begin
   getwidth := width;
end;

procedure Rectangle.draw;
var 
   i, j: integer;
begin
   for i:= 1 to length do
   begin
     for j:= 1 to width do
        write('' * '');
     writeln;
   end;
end;

begin
   r1.setlength(3);
   r1.setwidth(7);
   
   writeln(''Draw a rectangle:'', r1.getlength(), '' by '' , r1.getwidth());
   r1.draw;
   new(pr1);
   pr1^.setlength(5);
   pr1^.setwidth(4);
   
   writeln(''Draw a rectangle:'', pr1^.getlength(), '' by '' ,pr1^.getwidth());
   pr1^.draw;
   dispose(pr1);
end.

Draw a rectangle: 3 by 7
* * * * * * *
* * * * * * *
* * * * * * *
Draw a rectangle: 5 by 4
* * * *
* * * *
* * * *
* * * *
* * * *

program exObjects;
type 
   Rectangle = object  
   private  
      length, width: integer; 
   public  
      constructor init(l, w: integer);
      destructor done;
      
      procedure setlength(l: integer);
      function getlength(): integer;  
      
      procedure setwidth(w: integer);  
      function getwidth(): integer;  
      
      procedure draw;
end;

var
   r1: Rectangle;
   pr1: ^Rectangle;

constructor Rectangle.init(l, w: integer);
begin
   length := l;
   width := w;
end;

destructor Rectangle.done;
begin
   writeln('' Desctructor Called'');
end; 

procedure Rectangle.setlength(l: integer);
begin
   length := l;
end;

procedure Rectangle.setwidth(w: integer);
begin
   width :=w;
end;

function Rectangle.getlength(): integer;  
begin
   getlength := length;
end;

function Rectangle.getwidth(): integer;  
begin
   getwidth := width;
end;

procedure Rectangle.draw;
var 
   i, j: integer;
begin
   for i:= 1 to length do
   begin
      for j:= 1 to width do
         write('' * '');
      writeln;
   end;
end;

begin
   r1.init(3, 7);
   writeln(''Draw a rectangle:'', r1.getlength(), '' by '' , r1.getwidth());
   r1.draw;
   new(pr1, init(5, 4));
   
   writeln(''Draw a rectangle:'', pr1^.getlength(), '' by '',pr1^.getwidth());
   pr1^.draw;
   pr1^.init(7, 9);
   
   writeln(''Draw a rectangle:'', pr1^.getlength(), '' by '' ,pr1^.getwidth());
   pr1^.draw;
   dispose(pr1);
   r1.done;
end.

Draw a rectangle: 3 by 7
* * * * * * *
* * * * * * *
* * * * * * *
Draw a rectangle: 5 by 4
* * * *
* * * *
* * * *
* * * *
* * * *
Draw a rectangle: 7 by 9
* * * * * * * * *
* * * * * * * * *
* * * * * * * * *
* * * * * * * * *
* * * * * * * * *
* * * * * * * * *
* * * * * * * * *
Destructor Called

program exObjects;
type 
   Rectangle = object  
   private  
      length, width: integer; 
   public  
      procedure setlength(l: integer);  
      function getlength(): integer;  
      procedure setwidth(w: integer);  
      function getwidth(): integer;  
      procedure draw;
end;

TableTop = object (Rectangle)
   private
     material: string;
   public
      function getmaterial(): string;
      procedure setmaterial( m: string);
      procedure displaydetails;
      procedure draw;
end;

var
   tt1: TableTop;

procedure Rectangle.setlength(l: integer);
begin
   length := l;
end;

procedure Rectangle.setwidth(w: integer);
begin
   width :=w;
end;

function Rectangle.getlength(): integer;  
begin
   getlength := length;
end;

function Rectangle.getwidth():integer;
begin
   getwidth := width;
end;

procedure Rectangle.draw;
var 
   i, j: integer;
begin
   for i:= 1 to length do
   begin
      for j:= 1 to width do
         write('' * '');
      writeln;
  end;
end;

function TableTop.getmaterial(): string;
begin
   getmaterial := material;
end;

procedure TableTop.setmaterial( m: string);
begin
   material := m;
end;

procedure TableTop.displaydetails;
begin
   writeln(''Table Top: '', self.getlength(), '' by '' , self.getwidth());
   writeln(''Material: '', self.getmaterial());
end;

procedure TableTop.draw();
var
   i, j: integer;
begin
   for i:= 1 to length do
   begin
      for j:= 1 to width do
         write('' * '');
   writeln;
   end;
   writeln(''Material: '', material);
end;

begin
   tt1.setlength(3);
   tt1.setwidth(7);
   tt1.setmaterial(''Wood'');
   tt1.displaydetails();
   writeln;
   writeln(''Calling the Draw method'');
   tt1.draw();
end.

Table Top: 3 by 7
Material: Wood

Calling the Draw Method 
* * * * * * *
* * * * * * *
* * * * * * *
Material: Wood

type class-identifier = class  
   private
      field1 : field-type;  
      field2 : field-type;  
        ...
   
   public
      constructor create();
      procedure proc1;  
      function f1(): function-type;
end;  
var classvar : class-identifier;

type
   Rectangle = class
   private
      length, width: integer;
   
   public
      constructor create(l, w: integer);
      procedure setlength(l: integer);
      function getlength(): integer;
      procedure setwidth(w: integer);
      function getwidth(): integer;
      procedure draw;
end;

{$mode objfpc} // directive to be used for defining classes
{$m+}		   // directive to be used for using constructor

program exClass;
type
   Rectangle = class
   private
      length, width: integer;
   
   public
      constructor create(l, w: integer);
      procedure setlength(l: integer);
      
      function getlength(): integer;
      procedure setwidth(w: integer);
      
      function getwidth(): integer;
      procedure draw;
end;
var
   r1: Rectangle;

constructor Rectangle.create(l, w: integer);
begin
   length := l;
   width := w;
end;

procedure Rectangle.setlength(l: integer);
begin
   length := l;
end;

procedure Rectangle.setwidth(w: integer);
begin
   width :=w;
end;

function Rectangle.getlength(): integer;
begin
   getlength := length;
end;

function Rectangle.getwidth(): integer;
begin
   getwidth := width;
end;

procedure Rectangle.draw;
var
   i, j: integer;
begin
   for i:= 1 to length do
   begin
      for j:= 1 to width do
         write('' * '');
      writeln;
   end;
end;

begin
   r1:= Rectangle.create(3, 7);
   
   writeln('' Draw Rectangle: '', r1.getlength(), '' by '' , r1.getwidth());
   r1.draw;
   r1.setlength(4);
   r1.setwidth(6);
   
   writeln('' Draw Rectangle: '', r1.getlength(), '' by '' , r1.getwidth());
   r1.draw;
end.

Draw Rectangle: 3 by 7
* * * * * * *
* * * * * * *
* * * * * * *
Draw Rectangle: 4 by 6
* * * * * * 
* * * * * * 
* * * * * * 
* * * * * * 

program classExample;

{$MODE OBJFPC} //directive to be used for creating classes
{$M+} //directive that allows class constructors and destructors
type
   Books = Class 
   private 
      title : String; 
      price: real;
   
   public
      constructor Create(t : String; p: real); //default constructor
      
      procedure setTitle(t : String); //sets title for a book
      function getTitle() : String; //retrieves title
      
      procedure setPrice(p : real); //sets price for a book
      function getPrice() : real; //retrieves price
      
      procedure Display(); // display details of a book
end;
var
   physics, chemistry, maths: Books;

//default constructor 
constructor Books.Create(t : String; p: real);
begin
   title := t;
   price := p;
end;

procedure Books.setTitle(t : String); //sets title for a book
begin
   title := t;
end;

function Books.getTitle() : String; //retrieves title
begin
   getTitle := title;
end;

procedure Books.setPrice(p : real); //sets price for a book
begin
   price := p;
end;

function Books.getPrice() : real; //retrieves price
begin
   getPrice:= price;
end;

procedure Books.Display();
begin
   writeln(''Title: '', title);
   writeln(''Price: '', price:5:2);
end;

begin 
   physics := Books.Create(''Physics for High School'', 10);
   chemistry := Books.Create(''Advanced Chemistry'', 15);
   maths := Books.Create(''Algebra'', 7);
   
   physics.Display;
   chemistry.Display;
   maths.Display;
end.

Title: Physics for High School
Price: 10
Title: Advanced Chemistry
Price: 15
Title: Algebra
Price: 7

type
childClas-identifier = class(baseClass-identifier) 
< members >
end; 

program inheritanceExample;

{$MODE OBJFPC} //directive to be used for creating classes
{$M+} //directive that allows class constructors and destructors

type
   Books = Class 
   protected 
      title : String; 
      price: real;
   
   public
      constructor Create(t : String; p: real); //default constructor
      
      procedure setTitle(t : String); //sets title for a book
      function getTitle() : String; //retrieves title
      
      procedure setPrice(p : real); //sets price for a book
      function getPrice() : real; //retrieves price
      
      procedure Display(); virtual; // display details of a book
end;
(* Creating a derived class *)

type
   Novels = Class(Books)
   private
      author: String;
   
   public
      constructor Create(t: String); overload;
      constructor Create(a: String; t: String; p: real); overload;
      
      procedure setAuthor(a: String); // sets author for a book
      function getAuthor(): String; // retrieves author name
      
      procedure Display(); override;
end;
var
   n1, n2: Novels;

//default constructor 
constructor Books.Create(t : String; p: real);
begin
   title := t;
   price := p;
end;

procedure Books.setTitle(t : String); //sets title for a book
begin
   title := t;
end;

function Books.getTitle() : String; //retrieves title
begin
   getTitle := title;
end;

procedure Books.setPrice(p : real); //sets price for a book
begin
   price := p;
end;

function Books.getPrice() : real; //retrieves price
begin
   getPrice:= price;
end;

procedure Books.Display();
begin
   writeln(''Title: '', title);
   writeln(''Price: '', price);
end;

(* Now the derived class methods  *)
constructor Novels.Create(t: String);
begin
   inherited Create(t, 0.0);
   author:= '' '';
end;

constructor Novels.Create(a: String; t: String; p: real);
begin
   inherited Create(t, p);
   author:= a;
end;

procedure Novels.setAuthor(a : String); //sets author for a book
begin
   author := a;
end;

function Novels.getAuthor() : String; //retrieves author
begin
   getAuthor := author;
end;

procedure Novels.Display();
begin
   writeln(''Title: '', title);
   writeln(''Price: '', price:5:2);
   writeln(''Author: '', author);
end;

begin 
   n1 := Novels.Create(''Gone with the Wind'');
   n2 := Novels.Create(''Ayn Rand'',''Atlas Shrugged'', 467.75);
   n1.setAuthor(''Margaret Mitchell'');
   n1.setPrice(375.99);
   n1.Display;
   n2.Display;
end.

Title: Gone with the Wind
Price: 375.99
Author: Margaret Mitchell
Title: Atlas Shrugged
Price: 467.75
Author: Ayn Rand

type  
   Mail = Interface  
      Procedure SendMail;  
      Procedure GetMail;  
   end;  
   
   Report = Class(TInterfacedObject,  Mail)  
      Procedure SendMail;  
      Procedure GetMail;  
   end;  

type
   Shape = ABSTRACT CLASS (Root)
      Procedure draw; ABSTRACT;
      ...
   end;

program StaticExample;
{$mode objfpc}
{$static on}
type
   myclass=class
      num : integer;static;
   end;
var
   n1, n2 : myclass;
begin
   n1:= myclass.create;
   n2:= myclass.create;
   n1.num := 12;
   writeln(n2.num);
   n2.num := 31;
   writeln(n1.num);
   writeln(myclass.num);
   myclass.num := myclass.num + 20;
   writeln(n1.num);
   writeln(n2.num);
end.

12
31
31
51
51