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

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

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

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

ОТДЕЛ Отдел1;
...
КОН Отдел1.

UNIT Unit1;
...
END.

2. Служебное слово ЗАДАЧА используется как для процедур, так и для функций. Функции всегда должны иметь (возможно пустой) список параметров в своих объявлениях и вызовах. Результат функции возвращается явно оператором ВОЗВРАТ вместо присваивания ответа названию функции.

ЗАДАЧА f():ЦЕЛ;
УКАЗ
  ВОЗВРАТ 5   (* из ЗАДАЧИ *)
КОН f;
  ...
  x:=f();

FUNCTION f:INTEGER;
BEGIN
  f:=5
END;
  ...
  x:=f;

3. Название задач (процедур и функций) должно быть повторено в конце их определения после словесной закрывающей скобки КОН:

ЗАДАЧА Точка(x,y:ЦЕЛ);
УКАЗ
  ...
КОН Точка;

PROCEDURE DrawDot(x,y:INTEGER);
BEGIN
  ...
END;

4. Все названия являются регистрозависимыми. Служебные слова записываются заглавными буквами.

ОТДЕЛ Отдел;
ПЕР
  X:ЦЕЛ;

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

UNIT Unit1;
VAR
  X:INTEGER;

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

5. Изменена последовательность объявлений. Вместо
{ ОбъявлениеПостоянных | ОбъявлениеТипов | ОбъявлениеПеременных |
   ОбъявлениеПроцедур
}

будет
{ ОбъявлениеПостоянных | ОбъявлениеТипов | ОбъявлениеПеременных }
{ ОбъявлениеПроцедур }

ВИД
  Вид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;

6. Пояснения (комментарии) возможны только между скобками (* и *) и могут быть вложенными.

(* пояснения (* примечания *) *)

// примечания
(* пояснения *)
{ комментарии }

7. Цикл ПОКА (WHILE) должен заканчиваться словесной операторной скобкой КОН (END).

ПОКА i<10 ВЫП
  Вывод.Цел(i);
  УВЕЛИЧИТЬ(i)
КОН;
...
ПОКА зн<=' ' ВЫП
  зн:=Читать.Знак(п)
КОН;

WHILE i < 10 DO BEGIN
  Writeln(i);
  INC(i)
END;
...
WHILE ch <= ' ' DO
  Read(f,ch);

8. Цикл ОТ (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);

9. Имеется новый оператор цикла КОЛЬЦО и оператор выхода из него ВЫХОД. Цикл КОЛЬЦО закрывается словесной скобкой КОН.

КОЛЬЦО
  ...
  ЕСЛИ выход ТО
    ВЫХОД   (* из КОЛЬЦА *)
  КОН;
  ...
КОН;

WHILE TRUE DO BEGIN
  ...
  IF vyhod THEN BREAK;
  ...


END;

10. Головной ОТДЕЛ (модуль) выделяется не служебным словом PROGRAM, а оконечным знаком '+' при своём названии.

ОТДЕЛ Голова+;
...
КОН Голова.

PROGRAM Program1;
...
END.

11. Для проверки на неравенство вместо меньше-больше <> используется знак #.

ЕСЛИ пД # ПУСТО ТО ...

IF p <> NIL THEN ...

12. Вычисление булева выражения прекращается, как только его результат станет очевидным.

(* не вызывает ошибки при пД=ПУСТО *)
ЕСЛИ (пД # ПУСТО) И (пД^.имя='Петя') ТО ...

(* в начале проверка на NIL *)
IF (p <> NIL) THEN
  IF (p^.name ='Петя') THEN ...

13. РЯДы (массивы) определены только для диапазона индексов от 0 до РАЗМЕР(А)-1.

ВИД
  А=РЯД 10 ИЗ ЦЕЛ; (* индексы от 0 до 9 *)

TYPE
  A = ARRAY [0..9] OF INTEGER;

14. В объявлении задач (процедур) приёмники ссылок (формальные параметры-переменные) выделяются при помощи оконечных знаков '+' или '-', а приёмники значений (формальные параметры-значения) их не имеют. Знак '-' отмечает приёмники (параметры), доступные только для чтения.

ЗАДАЧА Добавить(x+,y:ЦЕЛ);
УКАЗ
  x:=x+y
КОН Добавить;

ЗАДАЧА Печать(с-:ЦЕПЬ);
  ...

PROCEDURE Add(VAR x:INTEGER; y:INTEGER);
BEGIN
  x:=x+y
END;

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

15. Приёмники значений в объявлении задач (формальные параметры-значения процедур) не могут быть РЯДами (массивами) или НАБОРами (записями). Используйте для такого случая приёмники ссылок (параметры-переменные) и присваивание локальным переменным.

ВИД
  Матрица=РЯД 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);

16. У МНОЖеств нет базового типа. Элементами МНОЖеств являются только целые числа от 0 до 31.

ПЕР
  мн:МНОЖ;

VAR
  m:SET OF (0..31);

17. В конструкторе МНОЖества используются фигурные скобки {} вместо [].

ПЕР
  мн:МНОЖ;
  j,k:ЦЕЛ;
УКАЗ
  ...
  мн:={0..2, 4, j..2*k};

VAR
  st:SET OF BYTE;
  j,k:INTEGER;
BEGIN
  ...
  st:=[0..2, 4, j..2*k];

18. Для МНОЖеств добавлена новая операция '/' (симметрическая разность).

ПЕР
  x,y,z:МНОЖ;
УКАЗ
  ...
  z:=x/y;

VAR
  x,y,z:SET OF (0..31);
BEGIN
  ...
  z:=(x-y)+(y-x);

19. При определении ссылок (указателей) употребляется не оператор разыменования ^ (в Паскале знак "уголок" '^' слева от имени переменной), а служебное словосочетание ДОСТУП К.

ВИД
  P=ДОСТУП К T;

TYPE
  P=^T;

20. Нет оператора DISPOSE. Неиспользуемая более память убирается автоматически. Чтобы явно сообщить системе об освобождении переменной надо присвоить ссылке на эту переменную значение ПУСТО.

ВИД
  Доступ=ДОСТУП К Набор;
                  Набор=НАБОР
    знач:ВЕЩ;
    след:Доступ
                  КОН;

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

УКАЗ
  СОЗДАТЬ(список);
  список^.знач:=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);

21. Оператор разыменования '^' при обращении к полям вида НАБОР может быть опущен.

список.след.знач:=2;

list^.next^.value:=2;

22. Немного изменена запись порядка ВЕЩественных ПОСТоянных (констант).

ПОСТ
  (* только заглавная E *)
  k=1.38066E-23;
  (* или заглавная D для двойной точности *)
  e=1.60219D-19;

CONST
  (* строчная E *)
  k=1.38066e-23;
  (* или заглавная E *)
  e=1.60219E-19;

23. В качестве разделителя случаев в операторе ВЫБРАТЬ (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;

24. Цепочки знаков (строки-константы) могут заключаться и в двойные кавычки ("), и в одинарные ('). Для одной цепочки открывающая и закрывающая кавычки должны совпадать.

цепь:="Программа 'Время'";

str:='Программа ''Время''';

25. Цепочки знаков (строки-константы) единичной длины могут присваиваться символьным переменным (вида ЗНАК).

зн:="*";

ch:='*';

26. Для опережающего объявления задач, к которым есть обращение до их полного определения, вместо служебного слова FORWARD используется знак '^'.

ЗАДАЧА^ Proc; (* опережающее определение
                    или заготовка задачи *)

PROCEDURE Proc; FORWARD;

27. Оператор ЕСЛИ (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();

28. Поглощение числовых ВИДов (типов) позволяет присваивать значения узкого ВИДа (типа) переменной более широкого ВИДа (типа). Присваивание же в обратном направлении требует применения встроенной задачи (функции) УЗК.

ПЕР
  цел:ЦЕЛ;
  шцел:ШИРЦЕЛ;
УКАЗ
  ...
  шцел:=цел;
  цел:=УЗК(шцел);

VAR
  int:INTEGER;
  lint:LONGINT;
BEGIN
  ...
  lint:=int;
  int:=lint; (* возможное усечение *)

29. Изменена запись шестнадцатеричных чисел.

ПЕР
  ц:ЦЕЛ;
УКАЗ
  ц:=0FFH;

VAR
  i:INTEGER;
BEGIN
  i:=$FF;

30. Для представления внутреннего содержимого ЗНАКов (символов) и цепочек (строк) используется шестнадцатеричная система счисления.

ПЕР
  зн:ЗНАК;
  цепь:ЦЕПЬ[20];
УКАЗ
  зн:=0DX; (* ВК - ВозвратКаретки 
      т.е. переход на новую строку при печати на экран *)
  цепь:='#22В кавычках#22';

VAR
  ch:CHAR;
  str:STRING[20];
BEGIN
  ch:=#13; (* CR *)

  str:=#34'В кавычках'#34;

31. Добавлены встроенные задачи (функции) МАКС, МИН, РАЗМЕР, ДЛИНА.

ПЕР
  ц,макс,мин,размер,длина:ЦЕЛ;
  р:РЯД 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   *)

32. РЯДы знаков (символьные массивы), т.е. цепочки, могут сравниваться с помощью операций =, #, <, >, <=, >=.

ПЕР
  цепь1:РЯД 20 ИЗ ЗНАК;
  цепь2:ЦЕПЬ[20];
УКАЗ
  ...
  ЕСЛИ цепь1=цепь2 ТО ...

VAR
  s1:STRING[20];
  s2:STRING[20];
BEGIN
  ...
  IF s1 = s2 THEN ...

33. Можно определять РЯДы (массивы), не указывая их размера, т.е. открытые ряды.

ВИД
  Матрица=ДОСТУП К РЯД ИЗ РЯД ИЗ ВЕЩ;

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

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

ОТДЕЛ Отдел1;

ВИД
  Вид1-=НАБОР
    x+,y-,z:ЦЕЛ   (* x,y  доступны внешним отделам *)
  КОН;
  Вид2=ЦЕЛ;    (* Вид2 не доступна внешним отделам *)
ПОСТ
  пост1-=1;
  пост2 =2;   (* пост2 не доступна внешним отделам *)
ПЕР
  пер1+:Вид1;
  x+,y-,z:ЦЕЛ;









...
...
...
...
ЗАДАЧА^ Задача2; (* опережающее определение
                       или заготовка задачи *)
ЗАДАЧА Задача1;
...
  Задача2;
...
КОН Задача1;

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

ЗАДАЧА Задача3-; (* Задача3 доступна внешним отделам *)
...
  Задача1;
...
КОН Задача3;

КОН Отдел1.

UNIT Unit1;
    INTERFACE
TYPE              (* доступны другим модулям *)
  Type1=RECORD
    x,y,z:INTEGER
  END;

CONST
  const1=1;

VAR
  var1:Type1;
  x,y:INTEGER;

PROCEDURE Proc3;

    IMPLEMENTATION
TYPE        (* НЕ доступны другим модулям *)
  Type2=INTEGER;
CONST
  const2=2;
VAR
  var2:Type2;
  z:INTEGER;
...
...
PROCEDURE Proc2; FORWARD;

PROCEDURE Proc1;
...
  Proc2;
...
END;

PROCEDURE Proc2;
...
END;

PROCEDURE Proc3;
...
  Proc1;
...
END;

END.

35. Список используемых внешних ОТДЕЛов (модулей) задаётся сразу после названия текущего ОТДЕЛа. При употреблении названий из внешних ОТДЕЛов их всегда необходимо предварять названием соответствующего внешнего отдела и точкой.

ОТДЕЛ Отдел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;

36. Есть возможность указывать путь к используемым внешним ОТДЕЛам (модулям), как в Делфи.

ОТДЕЛ Отдел2;
ИСПОЛЬЗУЕТ
  Отдел1 ИЗ "..\Подпрограммы\";

UNIT Unit2;
USES Unit1 FROM "..\Подпрограммы\Unit1.pas";

37. Есть СЖАТЫЙ НАБОР (вместо упакованной структуры), см. описание языка Глагол.

38. Нет НАБОРов (записей) с вариантами.

39. Нет GOTO (безусловный переход).

40. Нет WITH для вида RECORD (НАБОР). Зато есть ДЛЯ п ВИДА..КОН.

41. Операторная скобка УКАЗ (BEGIN) не может появляться внутри последовательности операторов.

42. Нет ограниченных ВИДов (т.е. типа диапазон). Используйте один из ЦЕЛых ВИДов.

ВИД
  Час=ЦЕЛ;

TYPE
  Hour=0..23;

43. Нет перечислимых ВИДов (типов). Используйте ЦЕЛые ВИДы (типы) совместно с целыми ПОСТоянными (константами).

ВИД
  Месяц=ЦЕЛ;
ПОСТ
  январь=1; февраль=2; ... декабрь=12;

TYPE
  Month=(january, february, ..., december);

44. Нет файловых ВИДов (типов), встроенных средств ввода/вывода и математических функций. Вся эта работа осуществляется через общедоступные задачи (библиотечные функции). Подробнее см. Задачница языка Глагол.

ИСПОЛЬЗУЕТ
  Вывод,Матем;
...
УКАЗ
  S:=Матем.ПИ*Матем.кв(r);
  Вывод.Вещ('Площадь круга = %f',S);

...
BEGIN
  S:=Pi*Sqr(r);
  Writeln('Площадь круга = ',S);

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

ИСПОЛЬЗУЕТ Настрой;
...
ВИД
<* ЕСЛИ Настрой.Точность=2 ТО *>
  Вещ=ШИРВЕЩ;
<* ИНАЧЕ *>
  Вещ=ВЕЩ;
<* КОН *>

{$DEFINE DvTochnost}
...
TYPE
{$IFDEF DvTochnost}
  Vesch = DOUBLE;
{$ELSE}
  Vesch = SINGLE;
{$ENDIF}

46. ВИДы НАБОРов (типы записей) могут быть расширены (это аналог наследования при ООП в других языках программирования).

ВИД
  Набор1=НАБОР(* одномерная точка с координатой x *)
    x:ВЕЩ
  КОН;
            (* 2-х мерная точка с координатами x,y *)
  Набор2=НАБОР(Набор1)
    y:ВЕЩ
  КОН;
            (* 3-х мерная точка с координатами x,y,z *)
  Набор3=НАБОР(Набор2)
    z:ВЕЩ
  КОН;

TYPE
  Record1=OBJECT
    x:REAL
  END;

  Record2=OBJECT(Record1)
    y:REAL
  END;

  Record3=OBJECT(Record2)
    z:REAL
  END;

47. Отношение 'п ЯВЛЯЕТСЯ Вп' выясняет, является ли размещённый (в памяти во время работы приложения) вид (тип) переменной 'п' видом 'Вп' или же он расширение вида 'Вп'. Оператор ДЛЯ п ВИДА является локальной охраной ВИДа (типа) переменной 'п'. Подробнее см. описание языка Глагол.

ЗАДАЧА Обнулить(н+:Набор1);
УКАЗ
            н.x:=0;
  ДЛЯ н ВИДА
  | Набор2: н.y:=0
  | Набор3: н.y:=0; н.z:=0
  КОН
КОН Обнулить;

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