Budowa programu tworzonego w języku Pascal

Program pisany w języku Pascal składa się z dwóch części:

I. deklaracyjnej
II. wykonawczej

{część deklaracyjna}
BEGIN
{część wykonawcza}
END.

W części deklaracyjnej możemy zaimplementować:

1. Nazwę programu
2. Deklaracja modułów
3. Etykiety
4. Stałe
5. Typy danych
6. Zmienne
7. Procedury i funkcje

Zaś w części wykonawczej podajemy instrukcje, które nasz program będzie wykonywał w odpowiedniej kolejności.

{

Początek części deklaracyjnej}

PROGRAM Nazwa_Programu; {Nagłówek programu}
USES {Deklaracja modułów}
LABEL
CONST
TYPE
VAR
PROCEDURE
FUNCTION
{Koniec części deklaracyjnej}
BEGIN
{Część wykonawcza programu}
END.

Każdy program musi zawierać słowo kluczowe program, BEGIN i END zakończone kropką, natomiast pozostałe elementy są
opcjonalne.
Dlatego bardzo prosty program może mieć następującą formę:

{Legendarny program wypisujący na ekranie monitora słowa HALLO WORLD}
PROGRAM pierwszy_program;
BEGIN
write(‘HALLO WORLD! :)’);
END.

Podstawowe konwencje obowiązujące w języku Pascal:

1. Po każdej instrukcji musi występować średnik ";", ale z małymi wyjątkami, którym między innymi jest słowo BEGIN

po którym nic nie piszemy.

2. Kropkę zaś stawiamy po słowie END kończącym część wykonawczą.
3. Dowolny tekst ujęty w znaki {} lub (* *) traktowana jest jako komentarz - czyli jest ignorowany przez kompilator.

Pojedynczą linia będzie traktowana jako komentarz gdy na początku umieścimy znak
//. Komentarze nie są wymagane, jednak poprawiają
czytelność programu dlatego należy je stosować.

4.

Identyfikator czyli nazwa typu, stałej, zmiennej, funkcji, procedury i programu musi zaczynać się od litery i nie może
zawierać operatorów arytmetycznych i innych znaków specjalnych. Może zawierać litery, cyfry i znak "_". Małe i duże
litery zarówno w nazwach jak i słowach kluczowych nie są rozróżniane.

5. Składnia języka Pascal nie wymusza podziału programu na wiersze (oprócz deklaracji zmiennych łańcuchowych) i cały

program może być dowolnie podzielony na linie. Istotne jest tylko, aby poszczególne słowa kluczowe i identyfikatory
były oddzielone separatorem (dowolna ilość spacji lub znaku końca wiersza, średnik. nawias,+, -, :, =, >, <). Ponadto
wiersz programu nie może zawierać więcej niż 127 znaków.

6. Podczas wykonywania działań na zmiennych lub stałych należy uważać aby wszystkie elementy były zgodne z tym

samym typem.

Opis elementów stanowiących szkielet programu:

W nagłówku programu podaje się zwykle jego nazwę.
--------------------------------------------------------------------------------------------------------------------------------------------------------
------------

Za pomocą deklaracji modułów (ang. USES) określa się moduły standardowe i moduły zdefiniowane przez użytkownika, np.

USES CRT,DOS;

Powyższa deklaracja dołącza dla naszego programu dwa standardowe moduły DOS i CRT.
--------------------------------------------------------------------------------------------------------------------------------------------------------
------------

Etykiety (ang. LABEL) powodują skok do określonej części programu - wywołujemy je słowem kluczowym GOTO, np.

LABEL skok_1,skok_2;
...
BEGIN
GOTO skok_1;
...
...{Jakieś funkcje czy procedury.}
...
skok_1: Writeln('Skok do etykiety skok_1');
skok_2: Writeln('Skok do etykiety skok_2');
END.

Powyższy przykład obrazuje skok do etykiety skok_1. Podczas tej operacji omijane są wszelkie instrukcje, procedury i
funkcje znajdujące się w wykropkowanych miejscach.
--------------------------------------------------------------------------------------------------------------------------------------------------------
------------

Gdy w programie deklarujemy Stałe (ang. CONST), to przypisana im wartość nie może zostać zmieniona w dalszej części
programu

CONST
identyfikator = wartość;

lub

identyfikator : type = wartość;

W drugiej wersji Type oznacza dowolny typ danych, wtedy wartość stałej przypisujemy zgodnie z typem.
Przykłady:

CONST MaxWysokosc = 100;

MaxPredkosc = 10.5;

lub

CONST MaxWysokosc : Integer = 100;
MaxPredkosc : Real = 10.5;

--------------------------------------------------------------------------------------------------------------------------------------------------------
------------
Zbiór wartości które może przyjmować zmienna nazywa się typem.
Typy dzielimy na standardowe (predefiniowane, nie wymagające opisu) i niestandardowe (definiowane przez programistę)
Deklaracje typów definiowanych przez programistę umieszczamy w sekcji Typy (ang. TYPE)

TYPE Dzien = (pon, wt, sr, czw, pt, sob, nie);
Numer = Integer;

--------------------------------------------------------------------------------------------------------------------------------------------------------
-------------

Każdą zmienną w programie zanim będziemy używać należy wcześniej zadeklarować w sekcji Zmienne (ang. VAR)
Deklaracja polega na określeniu nazwy zmiennej oraz jej typu.

VAR nazwa_zmiennej: typ_zmiennej;

Wartości deklarowanych zmiennych mogą być w programie modyfikowane (przypisanie nowej wartości) w przedziale
akceptowanym przez typ zmiennej.
Dopuszczalne są także deklaracje kilku zmiennych jednego typu w pojedynczym wyrażeniu.
Sekcja VAR może występować wiele razy w programie.
Przykład:

VAR x, y, wynik: integer;

...
BEGIN
wynik:=0; {Wartość początkowa}
...
wynik:=10; {Wartość przypisana później}
END.

--------------------------------------------------------------------------------------------------------------------------------------------------------
------------
Procedura (ang. PROCEDURE) i funkcja (ang. FUNCTION) to wyodrębnione części programu, stanowiące pewną całość,
posiadające jednoznaczną nazwę i ustalony sposób wymiany informacji z pozostałymi częściami programu. Procedury i
funkcje są stosowane do wykonania czynności, które mogą być wykorzystane w różnych programach lub do wykonania
czynności wielokrotnie powtarzanych przez dany program. Różnica pomiędzy procedurą a funkcją polega na sposobie
przekazywania wartości. Zadaniem procedury jest wykonanie pewnej sekwencji czynności, polegających zwykle na
obliczaniu jednej lub wielu wartości. Natomiast zadaniem funkcji jest obliczenie jednej wartości (typu prostego lub
wskaźnikowego), która jako wynik wywołania funkcji zwracana jest za pomocą słowa kluczowego RESULT do bloku
programu z którego nastąpiło wywołanie funkcji. Odmienne są też sposoby wywołania procedur i funkcji, np.
Definicja procedury:

PROCEDURE Nazwa_Procedury(lista_parametrów);

...Część_opisowa
BEGIN
...Ciąg_instrukcji
END;

W definicji procedury listę parametrów możemy pominąć.

Definicja funkcji:

FUNCTION Nazwa_Funkcji(lista_parametrów): Typ_wyniku;

...Część_opisowa
BEGIN
...Ciąg_instrukcji
Result := ...;
END;

W obu przypadkach lista parametrów zawiera deklarację parametrów, przy czym poszczególne deklaracje oddziela się
średnikami. W przypadku funkcji w ciągu instrukcji musi wystąpić co najmniej jedna instrukcja przypisania w postaci:

Nazwa_Funkcji:=Wyrażenie

powodująca przypisanie wartości pod nazwę funkcji, przy czym co najmniej jedna z tych instrukcji musi być wykonana po
wywołaniu funkcji. Typ wyniku funkcji jest określony za pomocą identyfikatora typu.