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

ИЮЛ | МАР | апр
| 13 |
2012 | 2013 | 2014

35 captures 20 апр 04 - 13 мар 13 |

Close Help

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

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

^ | ДОСТУП К | 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);

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