Wtd: /* Hello, Pascal! */

2008-10-14T03:55:48Z

Hello, Pascal!

← Older revision		Revision as of 03:55, 14 October 2008
Line 1:		Line 1:
	== Hello, Pascal! ==		== Hello, Pascal! ==

-	Let me just open my text editor and create a file called hellopascal.pas.	+	Let me just open my text editor and create a file called <tt>hellopascal.pas</tt>.

	<pre>program HelloPascal;		<pre>program HelloPascal;
Line 8:		Line 8:
	end.</pre>		end.</pre>

-	And then assuming I've installed the Free Pascal Compiler, I simply ~~opern~~ my command-line, run "fpc hellopascal", and I'm left with a binary by the same name. I don't need to attach the ".pas" extension. The compiler knows to look for source files with that extension.	+	And then assuming I've installed the [[Free Pascal]] Compiler, I simply open my command-line, run "<tt>fpc hellopascal</tt>", and I'm left with a binary by the same name. I don't need to attach the "<tt>.pas</tt>" extension. The compiler knows to look for source files with that extension.

	== Names for things ==		== Names for things ==

Wtd at 03:54, 14 October 2008

2008-10-14T03:54:06Z

New page

== Hello, Pascal! ==

Let me just open my text editor and create a file called hellopascal.pas.

<pre>program HelloPascal;
begin
writeln('Hello, Pascal!')
end.</pre>

And then assuming I've installed the Free Pascal Compiler, I simply opern my command-line, run "fpc hellopascal", and I'm left with a binary by the same name. I don't need to attach the ".pas" extension. The compiler knows to look for source files with that extension.

== Names for things ==

Let's give that message a name.

<pre>program HelloPascal;
const
greeting = 'Hello, Pascal!';
begin
writeln(greeting)
end.</pre>

It's a tribute to Pascal that what I've done is pretty easy to see. I've started a const clause, in which I define constant values and give them names.

But why the semi-colon ''there''? Pascal uses semi-colons as separators. The semi-colon indicates to the compiler that I wish to separate two things. In thise case, I'm separating the definition of the constant greeting, and the begin keyword. One is not necessary after the call to the writeln procedure because Pascal gives special importance to the "end" keyword.

Let's say that I now wish to give a name to the very action of writing that message. I'll create a procedure, sicne procedures and fucntions are how executable code is primarily grouped and named.

<pre>program HelloPascal;
const
greeting = 'Hello, Pascal!';

procedure WriteMessage;
begin
writeln(greeting)
end;
begin
WriteMessage
end.</pre>

== Greeting anyone ==

A bit of flexibility would be nice. To that end I'll define a greet procedure with a name parameter, and then pass 'world' as its argument when I call it.

<pre>program HelloPascal;
const
greeting = 'Hello, Pascal!';

procedure WriteMessage;
begin
writeln(greeting)
end;

procedure Greet(name: string);
begin
writeln('Hello, ' + name + '!')
end;
begin
WriteMessage;
Greet('world')
end.</pre>

== Let's discriminate ==

<pre>program HelloPascal;
procedure Greet(name: string);
begin
if name = 'wtd' then
writeln(name + '?! That cur!')
else
writeln('Hello, ' + name + '!')
end;
begin
Greet('wtd')
end.</pre>

But that only said one thing to wtd, and that's just not enough.

<pre>program HelloPascal;
procedure Greet(name: string);
begin
if name = 'wtd' then
begin
writeln(name + '?! That cur!');
writeln('Off with the scoundrel''s head!')
end
else
writeln('Hello, ' + name + '!')
end;
begin
Greet('wtd')
end.</pre>

== A quick note ==

Pascal is case-insensitive, so you may see code with If or IF. That's fine. You can define Greet and then use it as greet, and that is also fine. The best advice is to pick a style and stick to it.

== Let's use a type ==

Let's create a record type which contains a more complex name, and a procedure which acts on it.

<pre>program HelloPascal;
type
name = record
first, last : string;
end;

procedure Greet(n : name);
begin
writeln('Hello, ', n.first, ' ', n.last, '!')
end;

var
bobsName : name;
begin
bobsName.first := 'Bob';
bobsName.last := 'Smith';

Greet(bobsName)
end.</pre>

== Let's add a bit of sugar ==

<pre>program HelloPascal;
type
name = record
first, last : string;
end;

procedure Greet(n : name);
begin
with n do
writeln('Hello, ', first, ' ', last, '!')
end;

var
bobsName : name;
begin
bobsName.first := 'Bob';
bobsName.last := 'Smith';

Greet(bobsName)
end.</pre>

== Isn't consistency grand? ==

<pre>program HelloPascal;
type
name = record
first, last : string;
end;

procedure Greet(n : name);
begin
with n do
writeln('Hello, ', first, ' ', last, '!')
end;

var
bobsName : name;
begin
with bobsName do begin
first := 'Bob';
last := 'Smith';
end;

Greet(bobsName)
end.</pre>

Note how I provided a block of code to the with construct, rather than just a single statement. You should also note that this is how I did the same for conditionals.

== New names are good ==

So let's create a procedure which helps us create them.

<pre>program HelloPascal;
type
name = record
first, last : string;
end;

procedure InitializeName(var n : name; first, last : string);
begin
n.first := first;
n.last := last
end;

procedure Greet(n : name);
begin
with n do
writeln('Hello, ', first, ' ', last, '!')
end;

var
bobsName : name;
begin
InitializeName(bobsName, 'Bob', 'Smith');

Greet(bobsName)
end.</pre>

== There's only one problem... ==

In order to initialize a name, I have to have a name variable. I can't just create a name and use it directly. For that I'd need a function.

<pre>program HelloPascal;
type
name = record
first, last : string;
end;

function NewName(first, last : string) : name;
var
n : name;
begin
n.first := first;
n.last := last;

NewName := n
end;

procedure Greet(n : name);
begin
with n do
writeln('Hello, ', first, ' ', last, '!')
end;

var
bobsName : name;
begin
bobsName := NewName('Bob', 'Smith');

Greet(bobsName)
end.</pre>

Or just:

<pre>program HelloPascal;
type
name = record
first, last : string;
end;

function NewName(first, last : string) : name;
var
n : name;
begin
n.first := first;
n.last := last;

NewName := n
end;

procedure Greet(n : name);
begin
with n do
writeln('Hello, ', first, ' ', last, '!')
end;
begin
Greet(NewName('Bob', 'Smith'))
end.</pre>

== Time for some cleaning up ==

We've got a decent-sized program now, and that's good. But what if I want to use my name type and it's associated routines elsewhere?

Well, let's create a file named nameunit.pas that will contain a unit, or module of code.

<pre>unit NameUnit;

interface

type
name = record
first, last : string;
end;

function NewName(first, last : string) : name;
procedure Greet(n : name);

implementation

function NewName(first, last : string) : name;
var
n : name;
begin
n.first := first;
n.last := last;

NewName := n
end;

procedure Greet(n : name);
begin
with n do
writeln('Hello, ', first, ' ', last, '!')
end;

end.</pre>

And now we'll rewrite our hellopascal.pas program.

<pre>program HelloPascal;
uses
NameUnit;
begin
Greet(NewName('Bob', 'Smith'))
end.</pre>

Much nicer, eh?

Whereas previous programs had been compiled with "fpc hellopascal", this new setup shall be compiled with "fpc hellopascal nameunit".

== A Pointless Array ==

<pre>program HelloPascal;
uses
NameUnit;
var
names : array [1..10] of Name;
begin
names[1] := NewName('Bob', 'Smith');
Greet(names[1])
end.</pre>

== Slightly less pointless ==

<pre>program HelloPascal;
uses
NameUnit;
var
names : array [1..10] of Name;
i : Integer;
begin
for i := 1 to 10 do
names'' := NewName('Bob', 'Smith');

for i := 1 to 10 do
Greet(names[1])
end.</pre>

Or perhaps:

<pre>program HelloPascal;
uses
NameUnit;
var
names : array [1..10] of Name;
i : Integer;
begin
for i := 1 to 10 do
begin
names''.first := 'Bob';
names''.last := 'Smith';
end;

for i := 1 to 10 do
Greet(names[1])
end.</pre>

Or even:

<pre>program HelloPascal;
uses
NameUnit;
var
names : array [1..10] of Name;
i : Integer;
begin
for i := 1 to 10 do
with names'' do
begin
first := 'Bob';
last := 'Smith';
end;

for i := 1 to 10 do
Greet(names[1])
end.</pre>

== Pointers Galore! ==

Arrays are so static. Let's use a linked list instead. That means pointers.

<pre>program HelloPascal;
uses
NameUnit;
type
PNode = ^TNode;

TNode = record
Data : Name;
Next : PNode;
end;
var
list : PNode;

procedure GreetAllInList(list : PNode);
var
current : PNode;
begin
current := list;

while current <> nil do
with current^ do
begin
Greet(data);

current := next;
end;
end;

procedure NewList(var list : PNode; value : Name);
begin
New(list);

with list^ do
begin
data := value;
next := nil;
end;
end;

procedure AppendToList(var list : PNode; value : Name);
var
current, last : PNode;
begin
if list = nil then
NewList(list, value)
else begin
current := list;

while current <> nil do
with current^ do
begin
last := current;
current := next;
end;

NewList(last^.next, value);
end;
end;
begin
AppendToList(list, NewName('Foo', 'Bar'));
AppendToList(list, NewName('Bob', 'Smith'));

GreetAllInList(list);
end.</pre>

== Aren't objects grand? ==

Wha?! Pascal has objects? Well, yes, Pascal has the ability to work with objects. In the following I'll be using the Free Pascal compiler's OO extension. As a result, I have to compile with the "-S2" option.

<pre>program Test;
uses
Name, NameList;
var
list : TNameList;
begin
list := TNameList.Create;

list.Append(TName.Create('Bob', 'Smith'));
list.Append(TName.Create('Foo', 'Bar'));

list.GreetAll;
end.</pre>

And to make that possible, the following two units.

<pre>unit Name;

interface

type
TName = class
First, Last : String;
public
constructor Create(f, l : String);

function FullName : String;
procedure Greet;
end;

implementation

constructor TName.Create(f, l : String);
begin
First := f;
Last := l;
end;

function TName.FullName : String;
begin
FullName := First + ' ' + Last;
end;

procedure TName.Greet;
begin
writeln('Hello, ', FullName, '!');
end;

end.</pre>

<pre>unit NameList;

interface

uses

Name;

type
PNode = ^TNode;

TNode = record
Data : TName;
Next : PNode;
end;

TNameList = class
Head : PNode;
public
constructor Create;

procedure Append(NewName : TName);
procedure GreetAll;
end;

implementation

constructor TNameList.Create;
begin
Head := nil;
end;

procedure TNameList.Append(NewName : TName);
var
current : PNode;
begin
if Head = nil then
begin
New(Head);
Head^.Data := NewName;
Head^.Next := nil;
end
else
begin
current := Head;

while current^.Next <> nil do
current := current^.Next;

New(current^.Next);
with current^.Next^ do
begin
Data := NewName;
Next := nil;
end;
end;
end;

procedure TNameList.GreetAll;
var
current : PNode;
begin
current := Head;

while current <> nil do
begin
current^.Data.Greet;
current := current^.Next;
end;
end;

end.</pre>

== Objects and interfaces ==

So we've seen that it's possible to have objects in Pascal. But then, some would argue that interfaces are a key concept in object-oriented programming. Pascal can handle that too.

<pre>program InterfaceTest;

type
IHasName = interface
function Name : string;
end;

TName = class(TInterfacedObject, IHasName)
constructor Create(f, l : string);

function First : string;
function Last : string;
function Name : string;
private
FFirst, FLast : string;
end;

TSingleName = class(TInterfacedObject, IHasName)
constructor Create(n : string);

function Name : string;
private
FName : string;
end;

{ The Greet function }

procedure Greet(n : IHasName);
begin
writeln('Hello, ', n.Name, '!');
end;

{ Implement TName }

constructor TName.Create(f, l : string);
begin
FFirst := f;
FLast := l;
end;

function TName.First : string;
begin
First := FFirst;
end;

function TName.Last : string;
begin
Last := FLast;
end;

function TName.Name : string;
begin
Name := FFirst + ' ' + FLast;
end;

{ Implement TSingleName }

constructor TSingleName.Create(n : string);
begin
FName := n;
end;

function TSingleName.Name : string;
begin
Name := FName;
end;

var
Names : array [1..2] of IHasName;
Index : integer;

begin
Names[1] := TName.Create('Bob', 'Smith');
Names[2] := TSingleName.Create('Foo');

for Index := 1 to 2 do Greet(Names[Index]);
end.</pre>

== Abstract Base Classes ==

Of course, we could accomplish much the same with an abstract class.

<pre>program AbstractClassTest;

type
TNameBase = class(TObject)
function Name : string; virtual; abstract;
procedure Greet;
end;

TName = class(TNameBase)
constructor Create(f, l : string);

function First : string;
function Last : string;
function Name : string; override;
private
FFirst, FLast : string;
end;

TSingleName = class(TNameBase)
constructor Create(n : string);

function Name : string; override;
private
FName : string;
end;

{ Implement TNameBase }

procedure TNameBase.Greet;
begin
writeln('Hello, ', Name, '!');
end;

{ Implement TName }

constructor TName.Create(f, l : string);
begin
FFirst := f;
FLast := l;
end;

function TName.First : string;
begin
First := FFirst;
end;

function TName.Last : string;
begin
Last := FLast;
end;

function TName.Name : string;
begin
Name := FFirst + ' ' + FLast;
end;

{ Implement TSingleName }

constructor TSingleName.Create(n : string);
begin
FName := n;
end;

function TSingleName.Name : string;
begin
Name := FName;
end;

var
Names : array [1..2] of TNameBase;
Index : integer;

begin
Names[1] := TName.Create('Bob', 'Smith');
Names[2] := TSingleName.Create('Foo');

for Index := 1 to 2 do Names[Index].Greet;

end.</pre>

== Credits ==

Author: [[Wtd]]

Pascal Whirlwind - Revision history

Wtd: /* Hello, Pascal! */

Wtd at 03:54, 14 October 2008