Общая структура программы на языке Паскаль задана жёстко и выглядит так:.

структура программы

__Program__ <правильное имя>;
    // Предложение, содержащее **заголовок программы**. 
    // Данное предложение может отсутствовать, поскольку в системе Free Pascal
    // и большинстве (во всех?) современных версий Паскаля никакой роли не играет.
    // Оно оставлено для совместимости с другими версиями языка
    // Например:
__Program__ //ChoiseSort3v//; 
    // Предложения заканчивается точкой с запятой     
 
__Uses__ <список подключаемых библиотек>;   
    // **Раздел импорта**, который всегда состоит из одного предложения!
    // Данное предложение может отсутствовать, если вы не используете 
    // никаких дополнительных библиотек.
    // Например:
__Uses__ //CRT, OGLgraph//;  
    // Список разделяется запятыми, предложения заканчивается точкой с запятой  
 
<Раздел описаний>                       
    // Раздел глобальных описаний может состоять из нескольких 
    // подразделов, порядок следования которых - свободный, 
    // но все они должны быть здесь - перед кодом. 
    //
    // Этот раздел содержит описание всего, что не задано изначально и не  
    // импортируется из  дополнительных библиотек. 
    //
    // В принципе, тоже может отсутствовать. 
 
__Begin__                                   // Обязательные операторные скобки Begin-end
  <Раздел кода>                         
    // Операторы, составляющие "главную процедуру" - чисто теоретически, их тоже может не быть!
    // Тогда программа честно ничего не делает.
__End.__                                    // Программа кончается точкой 

Обратите внимание на жёсткий порядок следования частей программы на этом уровне детализации её структуры. Все части идут именно в этом порядке и не повторяются. Но некоторые могут отсутствовать совсем.

Раздел описаний может состоять из нескольких подразделов, разбитых по категориям описываемых объектов - типов, переменных, меток и констант. Отдельными подразделами считаются каждая функция или процедура.

раздела описаний

const                    // Начался раздел констант
  n = 10;                // Описание константы
 
var                      // Начался раздел переменных, значит - закончился раздел констант
  i, j : integer;        // 1-е описание переменных
  r, q : real;           // 2-е описание переменных
  k, m : integer;        // 3-е описание переменных - снова integer. Имеем право.
 
  ...                    // Что-то ещё, возможно - ничего
 
  // Где-то здесь кончается раздел переменных
 
  ...                    // Что-то ещё, возможно - ничего
 
  Begin
 
  // Обязательный раздел кода
 
  ...
 
  End.                  // Конец всему (в этой программе)!

Если что-то, описываемое вами, ссылается на что-то другое, то это другое должно быть описано ранее. Например, если вы используете константу для описания массива, то она должна быть описана заранее. Учтите, что библиотечные объекты, т.е. системные или описанные в библиотеках, подключённых с помощью uses, описывать не надо и на них можно ссылаться из любого места.

между объектами

const 
  n = 10;                               // Константа n определяет длину массива
type
  Arr10 = array[1 .. n] of integer;     // Используя n, описываем целый тип массивов 
var
  A,B : Arr10;                          // Используем описание типа Arr10 для описания переменных A, B 

Из этого правила есть единственное исключение, связанное с использованием указателей.

Ниже приведён неправильный код, где ничего не описывается заблаговременно.

нельзя!

var
  A,B : Arr10;                         // А что это?                 
 
type
  Arr10 = array[1 .. n] of integer;    // И сколько же это будет? 
 
const 
  n = 10;
 

В раздел описаний может входить несколько «однотипных» подразделов описаний.

подразделы

var
  i, j : integer;                       // Описали часть переменных
 
const 
  n = 10;                               // Спохватились и описали константу n
 
var
  A,B : array[1 .. n] of integer;       // "Дописали" ещё часть переменных

Данная программа содержит только раздел кода, но он - пуст, так что программа самым честным образом ничего не делает. Ибо и не должна.

1

Begin
                    // Если убрать этот комментарий, то получится 
                    // минимальная правильная программа на Паскале
End.

Данная программа работает (стирает с экрана следы работы предыдущих программ), но не содержит ни одного описания.

2

Uses 
  CRT;                // без CRT не будет работать clrscr ("clearscreen")
Begin
  clrscr;             // команда очищает экран от результатов предыдущих вводов/выводов     
End.

В данной программе есть все разделы (кроме описания функций), но она не выполняет никаких полезных действий.

3

Program Prog;       // К бессмысленному предложению Program - бесполезное, но правильное имя
// Всё есть и никто ничего не делает.
 
Uses CRT, Graph;    // Собираемся работать и с текстом, и с графикой, но так и не собирёмся
 
Const               // Раздел констант 
  n = 5;            // В данном случае n - не переменная, а другое обозначение 5.
  m : integer = 6;  // Один из ужасов Паскаля. Это - статическая переменная! Без понимания, что к чему, лучше не использовать.
 
Var                 // Раздел переменных
  i:integer;        // Запасная переменная - нам не потребуется
 
Label               // Раздел меток. У меток описывать нечего, но они должны быть перечислены.
  BeeginProgram,  EndProgram;  
 
Procedure Proc(x:integer);
 
 
Begin:
  writeln('Не мешайте работать!')
End;
 
Begin
BeginProgram: 
  goto EndProgram;   // Хватит работать пошли домой
  Proc(n); 
EndProgram:          
  ;  
End.

В данной программе есть все разделы (кроме описания функций), но она не выполняет никаких полезных действий.

переменных

var 
  x, y, z: integer;
  a, b, c: real;

с клавиатуры

var 
  x: integer;
  a: real;
 
begin
  read(x); {Сохранит введенное с клавиатуры в переменную x}
  readln(a); {Сохранит введенное с клавиатуры в переменную a и добавит перевод строки}
end.

При вводе данных, они должны соответствовать «принимающим» переменным, т.е. нельзя ввести бессмысленные в языке Pascal значения, значения в формате другого типа (например, ввести значения 1.34 и даже 2.0 в целочисленную переменную) или выходящие за пределы диапазона значений, разрешённого для переменных указанного типа.

Заметьте, что в строковую переменную можно занести и «Мама мыла раму», и «2.0».

на экран

var 
  x: integer;
  a: real;
 
begin
  x := 2;
  write(x); {Выведет на экран значение переменной x}
  write('x= ', x); 
  writeln(x); {Выведет на экран значение переменной x и перейдет на следующую строку}
  writeln('x= ', x);
 
  a := 0.15;
  writeln(a);
  writeln(a * x);
  writeln(a * x:4:1);
end.

Допустимо сразу выводить на экран значения выражений любой сложности без сохранения их в переменной. Частными случаями выражений являются вызовы функций, переменные и константы.

значений

begin
  write(0.3);
  write( 0.15 * 2.0 );
  writeln( sin(3.14) );
end.

Одним оператором (командой) ввода/вывода можно вводить/выводить значения нескольких аргументов, в том числе - разнотипных.

begin

writeln("Полученное значение ", 0.3);       // Обратите внимание на пробелы

writeln( 100.0:5:2,  '(км/ч)');                               //
writeln( 200.0:5:2,  '(км/ч)');
writeln( 300.0:5:2,  '(км/ч)');

writeln( sin(3.14*1/2):8:4, 
         sin(3.14*1/4):8:4, 
         sin(3.14*1/8):8:4 );

end.

Недопустимо следующее :

ввод

const 
  x=0.3;
 
var 
  y : integer;
  A : array[1..9] of integer;
  F : text;
 
begin
  read (0.3);                            // чтение "в никуда" - нет переменной, которая примет введённое значение. 
  read (x);                              // тоже самое, но константа указана по имени
  readln (0.15 * y);                     // тоже самое, но вместо константы - целое выражение
  readln (A);                            // составной тип данных можно заполнять только по-элементно
  readln (F);                            // "неудачное" чтение из файла F - и файл F не открыт, и не указана 
                                         // переменная-приёмник. Считать же саму файловую переменную F - нельзя!
end.

вывод

var 
  A : array[1..9] of integer;
  F : text;
 
begin
  writeln (x, 0.15 * y, 0.3);             // Вывод - будет, но все выводимые значения сольются в нечто нечитаемое
  writeln (A);                            // составной тип данных можно выводить только по-элементно
  writeln (F);                            // "неудачнае" запись в файл F - и файл F не открыт, и не указано, 
                                          // что выводить. Выводить таким образом у файл F - нельзя!
end.