Отличия Глагола от Турбо Паскаля

Соответствие служебных слов Турбо Паскаля и Глагола

^ ДОСТУП К FOR ОТ OF ИЗ
ABS МОДУЛЬ FALSE ОТКЛ OR ИЛИ
AND И FUNCTION ЗАДАЧА ORD ВЦЕЛ
ARRAY РЯД HALT СТОП PROCEDURE ЗАДАЧА
ASSERT ПРОВЕРИТЬ HIGH МАКС RECORD НАБОР
BEGIN УКАЗ HIGH РАЗМЕР REPEAT ПОВТОРЯТЬ
BOOLEAN КЛЮЧ IF ЕСЛИ ROUND ВШИРЦЕЛ
CASE ВЫБРАТЬ IN В SET МНОЖ
CHAR ЗНАК INC УВЕЛИЧИТЬ SINGLE ВЕЩ
CHR ВЗНАК INT ЦЕЛЧАСТЬ STRING ЦЕПЬ
CONST ПОСТ INTEGER ЦЕЛ THEN ТО
DEC УМЕНЬШИТЬ LENGTH ДЛИНА TO ДО
DIV ДЕЛИТЬ LONGINT ШИРЦЕЛ TRUE ВКЛ
DO ВЫП LOW МИН TYPE ВИД
DOUBLE ШИРВЕЩ MOD ОСТАТОК UNIT ОТДЕЛ
ELSE ИНАЧЕ NEW СОЗДАТЬ UNTIL ДО
END КОН NIL ПУСТО USES ИСПОЛЬЗУЕТ
EXIT ВОЗВРАТ NOT НЕ VAR ПЕР
EVEN ЧЕТ OBJECT НАБОР WHILE ПОКА

Примеры на Глаголе

и они же на Паскале.


Название модуля должно быть повторено перед завершающей точкой.
ОТДЕЛ Отдел1;
...
КОН Отдел1.
UNIT Unit1;
...
END.

Служебное слово ЗАДАЧА используется как для процедур, так и для функций. Функции всегда должны иметь (возможно пустой) список параметров в своих объявлениях и вызовах. Результат функции возвращается явно оператором ВОЗВРАТ вместо присваивания ответа названию функции.
ЗАДАЧА f():ЦЕЛ;
УКАЗ
  ВОЗВРАТ 5
КОН f;
  ...
  x:=f();
FUNCTION f:INTEGER;
BEGIN
  f:=5
END;
  ...
  x:=f;

Название процедур и функций должно быть повторено в конце их определения.
ЗАДАЧА Точка(x,y:ЦЕЛ);
УКАЗ
  ...
КОН Точка;
PROCEDURE DrawDot(x,y:INTEGER);
BEGIN
  ...
END;

Все названия являются регистрозависимыми. Служебные слова записываются заглавными буквами.
ОТДЕЛ Отдел;

ПЕР
  X:ЦЕЛ;

ЗАДАЧА Задача(x:ЦЕЛ);
УКАЗ
  ЕСЛИ x=X ТО ...
UNIT Unit1;

VAR
  X:INTEGER;

PROCEDURE Proc(x:INTEGER);
BEGIN
  IF x=Unit1.X THEN ...

Изменена последовательность объявлений. Вместо { ОбъявлениеПостоянных | ОбъявлениеТипов | ОбъявлениеПеременных | ОбъявлениеПроцедур } будет { ОбъявлениеПостоянных | ОбъявлениеТипов | ОбъявлениеПеременных} { ОбъявлениеПроцедур }
ВИД
  Вид1=ЦЕЛ;
ПОСТ
  пост1=1;
ПЕР
  пер1:Вид1;
ВИД
  Вид2=ЦЕЛ;
ПОСТ
  пост2=2;
ПЕР
  пер2:Вид2;

ЗАДАЧА Задача1;
...
КОН Задача1;

ЗАДАЧА Задача2;
...
КОН Задача2;
TYPE
  Type1=INTEGER;
CONST
  const1=1;
VAR
  var1:Type1;

PROCEDURE Proc1;
...
END;

TYPE
  Type2=INTEGER;
CONST
  const2=2;
VAR
  var2:Type1;

PROCEDURE Proc2;
...
END;

Комментарии возможны только между (* и *) и могут быть вложенными.
(* пояснения (* примечания *) *)
// примечания
(* пояснения *)
{ комментарии }

Цикл WHILE должен заканчиваться операторной скобкой END (КОН).
ПОКА i < 10 ВЫП
  Вывод.Цел(i);
  УВЕЛИЧИТЬ(i)
КОН;
...
ПОКА зн <= ' ' ВЫП
  зн:=Читать.Знак(п)
КОН;
WHILE i < 10 DO BEGIN
  Writeln(i);
  INC(i)
END;
...
WHILE ch <= ' ' DO
  Read(f,ch);

Цикл FOR всегда заканчивается операторной скобкой END (КОН) и может использовать любое константное выражение в качестве приращения (положительного или отрицательного).
ОТ i:=0 ДО 15 (* ПО 1 *) ВЫП
  Вывод.Цел(i)
КОН;
ОТ i:=15 ДО 0 ПО -1 ВЫП
  Вывод.Цел(i)
КОН;
FOR i:=0 TO 15 DO BEGIN
  Writeln(i)
END;
FOR i:=15 DOWNTO 0 DO
  Writeln(i);

Имеется новый оператор цикла КОЛЬЦО и оператор выхода из него ВЫХОД. Конец цикла обозначается словом КОН.
КОЛЬЦО
  ...
  ЕСЛИ выход ТО ВЫХОД КОН;
  ...
КОН;
WHILE TRUE DO BEGIN
  ...
  IF vyhod THEN BREAK;
  ...
END;

Головной модуль выделяется не служебным словом PROGRAM, а знаком '+' при своём названии.
ОТДЕЛ Голова+;
...
КОН Голова.
PROGRAM Program1;
...
END.

Вместо <> для проверки на неравенство используется знак #.
ЕСЛИ p # ПУСТО ТО ...
IF p <> NIL THEN ...

Вычисление булева выражения прекращается, как только его результат станет очевидным.
(* не вызывает ошибки при p=ПУСТО *)
ЕСЛИ (p # ПУСТО) И (p^.имя = 'Петя') ТО ...
(* в начале проверка на NIL *)
IF (p <> NIL) THEN
  IF (p^.name = 'Петя') THEN ...

Массивы определены только для диапазона индексов от 0 до РАЗМЕР-1.
ВИД
  A = РЯД 10 ИЗ ЦЕЛ; (* индексы от 0 до 9 *)
TYPE
  A = ARRAY [0..9] OF INTEGER;

При объявлении формальных параметров параметры переменные выделяются при помощи оконечных знаков '+' или '-'. Знак '-' отмечает параметры, доступные только для чтения.
ЗАДАЧА Добавить(x+,y:ЦЕЛ);
УКАЗ
  x:=x+y
КОН Добавить;

ЗАДАЧА Печать(с-:ЦЕПЬ);
  ...
PROCEDURE Add(VAR x:INTEGER; y:INTEGER);
BEGIN
  x:=x+y
END;

PROCEDURE Print(VAR s:STRING);
  ...

У множеств нет базового типа. Элементами множеств являются только целые числа от 0 до 31.
ПЕР
  м:МНОЖ;
VAR
  m:SET OF (0..31);

В конструкторе множества используются { } вместо [ ].
ПЕР
  мн:МНОЖ;
  j,k:ЦЕЛ;
УКАЗ
  ...
  мн:={0..2, 4, j..2*k};
VAR
  st:SET OF BYTE;
  j,k:INTEGER;
BEGIN
  ...
  st:=[0..2, 4, j..2*k];

Для множеств добавлена новая операция '/' (симметрическое вычитание).
ПЕР
  x,y,z:МНОЖ;
УКАЗ
  ...
  z:=x/y;
VAR
  x,y,z:SET OF (0..31);
BEGIN
  ...
  z:=(x-y)+(y-x);

Для записи ссылок употребляется не знак '^', а служебное словосочетание ДОСТУП К.
ВИД
  P=ДОСТУП К T;
TYPE
  P=^T;

Нет оператора DISPOSE. Неиспользуемая более память убирается автоматически. Чтобы явно сообщить системе об освобождении переменной надо присвоить ссылке на эту переменную значение NIL (ПУСТО).
ВИД
  Доступ=ДОСТУП К Набор;
  Набор=НАБОР
    знач:ВЕЩ;
    след:Доступ
  КОН;

ПЕР
  список:Доступ;

УКАЗ
  СОЗДАТЬ(список);
  список^.знач:=1;
  СОЗДАТЬ(список^.след);
  список^.след^.знач:=2;
  ...
  список:=ПУСТО;
TYPE
  PRecord=^Record1;
  Record1=RECORD
    value:REAL;
    next:PRecord
  END;

VAR
  list:PRecord;

BEGIN
  NEW(list);
  list^.value:=1;
  NEW(list^.next);
  list^.next^.value:=2;
  ...
  DISPOSE(list^.next);
  DISPOSE(list);

Оператор разыменования '^' может быть опущен.
список.след.знач:=2;
list^.next^.value:=2;

Немного изменена запись порядка вещественных констант.
ПОСТ
  (* только заглавная E *)
  k=1.38066E-23;
  (* или D для двойной точности *)
  e=1.60219D-19;
CONST
  (* строчная E *)
  k=1.38066e-23;
  (* заглавная E *)
  e=1.60219E-19;

В качестве разделителя случаев в операторе CASE вместо ";" используется "|".
ВЫБРАТЬ i*3-1 ИЗ
  0:
    Вывод.Цепь('нуль')
| 1..9:
    Вывод.Цепь('от 1 до 9')
| 10,20:
    Вывод.Цепь('10 или 20')
ИНАЧЕ
    Вывод.Цепь('что-то ещё')
КОН;
CASE i*3-1 OF
  0:
    Write('нуль');
  1..9:
    Write('от 1 до 9');
  10,20:
    Write('10 или 20')
ELSE
    Write('что-то ещё')
END;

Строки-константы могут заключаться и в двойные кавычки ("), и в одинарные ('). Для одной строки открывающая и закрывающая кавычки должны совпадать.
цепь:="Программа 'Время'";
str:='Программа ''Время''';

Строки-константы единичной длины могут присваиваться символьным переменным.
зн:="*";
зн:='*';
ch:='*';

Для объявления процедур и функций, которые используются до их полного определения, вместо служебного слова FORWARD используется знак '^'.
ЗАДАЧА ^Proc;
PROCEDURE Proc; FORWARD;

Оператор IF всегда заканчивается операторной скобкой END (КОН) и может разветвляться.
ЕСЛИ (зн>="A") И (зн<="Z") ТО
  ЧитЗн(зн); Название()
АЕСЛИ (зн>="0") И (зн<="9") ТО
  ЧитЗн(зн); Число()
АЕСЛИ (зн="'") ИЛИ (зн='"') ТО
  ЧитЗн(зн); Цепочка()
ИНАЧЕ
  Ошибка()
КОН;
IF (ch>="A") AND (ch<="Z") THEN BEGIN
  ReadCh(ch); Identifier()
END ELSE IF (ch>="0") AND (ch<="9") THEN BEGIN
  ReadCh(ch); Number()
END ELSE IF (ch="'") OR (ch='"') THEN BEGIN
  ReadCh(ch); String()
END ELSE
  Error();

Поглощение числовых типов позволяет присваивать значения узкого типа переменной более широкого типа. Присваивание же в обратном направлении требует применения встроенной функции УЗК.
ПЕР
  цел:ЦЕЛ;
  шцел:ШИРЦЕЛ;
УКАЗ
  ...
  шцел:=цел;
  цел:=УЗК(шцел);
VAR
  int:INTEGER;
  lint:LONGINT;
BEGIN
  ...
  lint:=int;
  int:=lint; (* возможное усечение *)

Изменена запись шестнадцатеричных чисел.
ПЕР
  ц:ЦЕЛ;
УКАЗ
  ц:=0FFH;
VAR
  i:INTEGER;
BEGIN
  i:=$FF;

Для представления кода символов и строк используется шестнадцатеричная система счисления.
ПЕР
  зн:ЗНАК;
  цепь:ЦЕПЬ[20];
УКАЗ
  зн:=0DX; (* ВК *)
  цепь:='#22В кавычках#22';
VAR
  ch:CHAR;
  str:STRING[20];
BEGIN
  ch:=#13; (* CR *)
  str:=#34'В кавычках'#34;

Добавлены встроенные функции МАКС, МИН, РАЗМЕР, ДЛИНА.
ПЕР
  ц,макс,мин,размер,длина:ЦЕЛ;
  р:РЯД 10 ИЗ ЦЕЛ;
  с:ЦЕПЬ[30];
УКАЗ
  с:='один';
  макс:=МАКС(ц);    (* = 2^31 *)
  мин:=МИН(ц);      (* =-2^31 *)
  размер:=РАЗМЕР(р);(* = 10   *)
  длина:=ДЛИНА(с);  (* = 4    *)
  размер:=РАЗМЕР(с);(* = 30   *)
VAR
  i,max,min,size,len:INTEGER;
  a:ARRAY [0..9] OF INTEGER;
  s:STRING[30];
BEGIN
  s:='один';
  max:=HIGH(i);   (* = 2^31 *)
  min:=LOW(i);    (* =-2^31 *)
  size:=HIGH(a)+1;(* = 10   *)
  len:=length(s); (* = 4    *)
  size:=HIGH(s)+1;(* = 30   *)

Символьные массивы могут сравниваться с помощью операций =, #, <, >, <= и >=.
ПЕР
  ц1:РЯД 20 ИЗ ЗНАК;
  ц2:ЦЕПЬ[20];
УКАЗ
  ...
  ЕСЛИ ц1 = ц2 ТО ...
VAR
  s1:STRING[20];
  s2:STRING[20];
BEGIN
  ...
  IF s1 = s2 THEN ...

Можно определять массивы, не указывая их размера.
ВИД
  Матрица = ДОСТУП К РЯД ИЗ РЯД ИЗ ВЕЩ;

ЗАДАЧА Умножить(столбец,строка:РЯД ИЗ ВЕЩ):Матрица;
ПЕР
  ответ:Матрица;
  i,j,M,N:ЦЕЛ;
УКАЗ
  M:=РАЗМЕР(столбец);
  N:=РАЗМЕР(строка);
  СОЗДАТЬ(ответ,M,N);
  ОТ i:=0 ДО M-1 ВЫП
    ОТ j:=0 ДО N-1 ВЫП
      ответ[i,j]:=столбец[i]*строка[j]
    КОН
  КОН;
  ВОЗВРАТ ответ
КОН;

Названия, объявленные с метками общедоступности (знак '-' или '+'), могут быть доступны и другим модулям. Причём знак '+' отмечает элементы, доступные и для записи.
ОТДЕЛ Отдел1;

ВИД
  Вид1-=НАБОР
    x+,y-,z:ЦЕЛ
  КОН;
  Вид2 =ЦЕЛ;
ПОСТ
  пост1-=1;
  пост2 =2;
ПЕР
  пер1+:Вид1;
  x+,y-,z:ЦЕЛ;

ЗАДАЧА Задача1-;
...
КОН Задача1;

ЗАДАЧА Задача2;
...
КОН Задача2;

КОН Отдел1.
UNIT Unit1;
    INTERFACE
TYPE
  Type1=RECORD
    x,y,z:INTEGER
  END;
CONST
  const1=1;
VAR
  var1:Type1;
  x,y:INTEGER;
PROCEDURE Proc1; FORWARD;
    IMPLEMENTATION
TYPE
  Type2=INTEGER;
CONST
  const2=2;
VAR
  var2:Type2;
  z:INTEGER;

PROCEDURE Proc1;
...
END;

PROCEDURE Proc2;
...
END;

END.

Список используемых внешних модулей задаётся после названия текущего модуля. При употреблении названий из внешних модулей их всегда необходимо предварять названием соответствующего внешнего модуля и точкой.
ОТДЕЛ Отдел2;
ИСПОЛЬЗУЕТ Отдел1;

ПЕР
  пер1:Отдел1.Вид1;
  x,y,z:ЦЕЛ;

УКАЗ
  x:=Отдел1.пост1;
  Отдел1.Задача1;

  Отдел1.x:=x;
(*Отдел1.y:=y; недопустимо,
              т.к 'Отдел1.y'
              только для чтения *)
(*Отдел1.z:=z; недопустимо,
              т.к 'Отдел1.z'
              скрыто *)

  пер1.x:=0;
  пер1.y:=0;
(*пер1.z:=0; недопустимо,
            т.к 'пер1.z' скрыто *)

  пер1:=Отдел1.пер1;
(* равнозначно присваиваниям:
  пер1.x:=Отдел1.пер1.x;
  пер1.y:=Отдел1.пер1.y;
  пер1.z:=Отдел1.пер1.z; *)
UNIT Unit2;
USES Unit1;

VAR
  var1:Unit1.Type1;
  x,y,z:INTEGER;

BEGIN
  x:=Unit1.const1;
  Unit1.Proc1;

  Unit1.x:=x;







  var1.x:=0;
  var1.y:=0;



  var1:=Unit1.var1;

Есть возможность указывать путь к используемым внешним модулям (как в Делфи).
ОТДЕЛ Отдел2;
ИСПОЛЬЗУЕТ Отдел1 ИЗ "..\Подпрограммы\";
UNIT Unit2;
USES Unit1 FROM "..\Подпрограммы\Unit1.pas";

Нет упакованных структур.
Нет записей с вариантами.
Нет GOTO.
Нет WITH.
Операторная скобка BEGIN (УКАЗ) не может появляться внутри последовательности операторов.

Нет ограниченных типов. Используйте один из целых типов.
ВИД
  Час=ЦЕЛ;
TYPE
  Hour=0..23;

Нет перечислимых типов. Используйте целые типы совместно с целыми константами.
ВИД
  Месяц=ЦЕЛ;
ПОСТ
  январь=1; февраль=2; ..., декабрь=12;
TYPE
  Month=(january, february, ..., december);

Нет файловых типов, встроенных средств ввода/вывода и математических функций. Вся эта работа осуществляется через библиотечные функции.
ИСПОЛЬЗУЕТ Вывод,Матем;
...
УКАЗ
  S:=Матем.ПИ*Матем.кв(r);
  Вывод.Вещ('Площадь круга = %f',S);
...
BEGIN
  S:=Pi*Sqr(r);
  Writeln('Площадь круга = ',S);

Формальные параметры-значения процедур не могут быть массивами и записями. Используйте параметры-переменные и присваивание локальным переменным.
ВИД
  Матрица=РЯД 3,3 ИЗ ВЕЩ;
...
ЗАДАЧА Умножить(a-,b-,c+:Матрица);
ПЕР
  a0,b0:Матрица;
УКАЗ
  a0:=a;
  b0:=b;
...
КОН Умножить;
...
  Умножить(a,a,a);
TYPE
  Matrix=ARRAY[0..2,0..2] OF REAL;
...
PROCEDURE Multiply(a0,b0:Matrix; VAR c:Matrix);
BEGIN
...
END;
...
  Multiply(a,a,a);

Операторы условной компиляции задаются в <* *> скобках. В качестве условий эти операторы могут использовать любые постоянные выражения.
ИСПОЛЬЗУЕТ Настрой;
...
ВИД
<* ЕСЛИ Настрой.Точность = 2 ТО *>
  Вещ = ШИРВЕЩ;
<* ИНАЧЕ *>
  Вещ = ВЕЩ;
<* КОН *>
{$DEFINE DvTochnost}
...
TYPE
{$IFDEF DvTochnost}
  Vesch = DOUBLE;
{$ELSE}
  Vesch = SINGLE;
{$ENDIF}

Типы записей могут быть расширены.
ВИД
  Набор1=НАБОР
    x:ВЕЩ
  КОН;

  Набор2=НАБОР(Набор1)
    y:ВЕЩ
  КОН;

  Набор3=НАБОР(Набор1)
    z:ВЕЩ
  КОН;
TYPE
  Record1=OBJECT
    x:REAL
  END;

  Record3=OBJECT(Record1)
    z:REAL
  END;

  Record2=OBJECT(Record1)
    y:REAL
  END;

Отношение п ЯВЛЯЕТСЯ Т выясняет, является ли размещённый тип переменной п типом Т или расширением типа Т. Оператор ДЛЯ является локальной охраной типа. Подробнее см. описание языка Глагол.
ЗАДАЧА Обнулить(н+:Набор1);
УКАЗ
  н.x:=0;
  ДЛЯ н ВИДА
    Набор2: н.y:=0
  | Набор3: н.z:=0
  КОН
КОН Обнулить;

ЗАДАЧА Задача;
ПЕР
  н1:Набор1;
  н2:Набор2;
УКАЗ
  ...
  Обнулить(н1);
  Обнулить(н2);


    Сделано в России