Блог о языке программирования Modula-3

Настоящие ассоциативные массивы в Модуле-3

2009-05-13T13:04:00.001+07:00

В предыдущей заметке я описал пример некоторого подобия ассоциативных массивов. Здесь я опишу пример работы с настоящим ассоциативным массивом.

Модула-3 имеет в стандартной библиотеке параметризованный модуль Table, который реализует ассоциативные массивы. Модуль имеет два параметра: тип ключа и тип значения. Для примера, сделаем массив, ключами которого будут строки, а значениями — целые числа. Для этого нужно создать интерфейс и модуль, производные от Table.

(* Файл TextTable.i3 *)
INTERFACE TextTable = Table(Text, Integer) END TextTable.

(* Файл TextTable.m3 *)
MODULE TextTable = Table(Text, Integer) END TextTable.

Теперь можно импортировать этот модуль и использовать его. Для перебора всех элементов массива можно использовать тип Iterator, описанные в модуле Table.

(* Файл Main.m3 *)
MODULE Main;
IMPORT TextTable, IO, Fmt;
VAR
t:=NEW(TextTable.Default);
i: TextTable.Iterator;
k: TEXT;
v: INTEGER;
BEGIN
t:=t.init();
EVAL t.put("a", 1);
EVAL t.put("b", 3);
EVAL t.put("c", 5);
i:=t.iterate();
(* Перебор всех элементов массива *)
WHILE i.next(k, v) DO
IO.Put("Key: " & k & ", Value: " & Fmt.Int(v) & "\n")
END
END Main.

Чтобы сбросить итератор, нужно использовать метод init().

Методы put, get и delete возвращают значение типа BOOLEAN, поэтому вместо EVAL можно делать проверку, насколько успешно прошла операция, с помощью IF. Значение элемента можно получить через второй параметр метода get.

Ассоциативные массивы (словари) в Модуле-3

2009-03-31T09:46:00.000+07:00

Переводя спецификацию языка на русский язык, узнаю новые вещи, о которых и не догадывался. Например, оказывается, Модула-3 поддерживает массивы, индексы которых могут быть не только числовыми или символьными, но и любыми другими, по желанию пользователя (в Смолтоке такие массивы называются словарями). Сразу оговорюсь, что в стандартной библиотеке libm3 есть шаблонный (или обощённый) модуль, который называется Table. Он вводит примерно то же, о чём я сейчас напишу. Но, на мой взгляд, если что-то нужно сделать на скорую руку, то описанный мной способ будет быстрее. Итак, рассмотрим пример. Нужно создать массив, из трёх элементов, который бы имел индексы First, Second и Third. Для этого, нужно задать тип - перечисление:

TYPE Indexes = {First, Second, Third};

Затем, содаём массив целых чисел, использующий эти индексы:

Dic= ARRAY [Indexes.First .. Indexes.Third] OF INTEGER;

Собственно, всё. Можно работать с массивом:

VAR dic: Dic;
...
a[Indexes.First]:=3;
a[Indexes.Second]:=5;
a[Indexes.Third]:=2;

С такими индексами допускается работать и в цикле:

VAR a: Dic; k: INTEGER;
...
k:=1;
FOR i:=Indexes.First TO Indexes.Third DO
a[i]:=k;
INC(k)
END

Иногда может возникнуть необходимость в доступе к элементам массива по числовым индексам. Для этого можно использовать встроенные функции ORD, VAL и NUMBER. ORD возвращает порядковый номер элемента в перечислении. VAL возвращает имя элемента по порядковому номеру. NUMBER возвращает количество элементов в перечислении.

Выражение ORD(Indexes.Second) вернёт 1 (индексация элементов в перечислениях начинается строго с нуля и заканчивается значением NUMBER(имя_типа)-1). Выражение VAL(3, Indexes) вернёт Third.

Пример работы в цикле:

VAR a: Dic;
...
FOR i:=0 TO NUMBER(Indexes)-1 DO
a[VAL(i, Indexes)]:=i+1;
IO.Put(Fmt.Int(a[VAL(i, Indexes)]) & "\n")
END;

Статья в Wikipedia

2009-03-25T12:12:00.000+06:00

Недавно разместил перевод англоязычной статьи в Википедии. Думаю, это послужит популяризации языка среди русскоговорящего населения :)

Русская группа, посвящённая Модуле-3

2009-03-20T09:43:00.000+06:00

Сегодня я открыл группу, посвящённую Модуле-3. Все, кому интересен этот язык, могут писать туда.

Отладка программ.

2009-03-17T08:31:00.000+06:00

Обычно, с большинством компиляторов поставляется отладчик. У компилятора CM3 тоже имеется отладчик, построенный на основе GNU gdb. Называется он m3gdb. Особенность его заключается в том, что работает он, мягко говоря, неудовлетворительно. А версия для NT386MINGNU вообще отсутствует. Надо сказать, что паскаль-подобным языкам редко везёт на отладчики. Например, компилятор FPC пытается использовать всё тот же GNU gdb, но тоже безрезультатно. Большинство программ, написанных на паскале, вызывают у gdb SIGSEGV.

Вообще-то, проблемы в этом нет. Программируя на Паскаль-подобных языках редко возникает надобность использовать указатели. Гораздо чаще используются ссылки, которые не являются потенциально опасными объектами. Поэтому, вполне можно обойтись простым выводом сообщений на экран и проверкой простых условий. Хотя, такая практика принуждает писать лишний код.

Как раз, для этого, в большинстве языков программирования имеется конструкция ASSERT, в которой проверяется некоторое условие. В среде BlackBox Component Builder, если условие отрицательно, появляется окно, под названием Trap. В этом окне, помимо прочей информации, перечислены все переменные и их значения, видимые в блоке, в котором произошло исключение.

В Модуле-3 тоже имеется конструкция ASSERT, которая реализована в виде прагмы. Общий вид такой: <* ASSERT i<5>. Если условие становится ложным, программа аварийно останавливается. При этом, появляется сообщение:

runtime error:
<*ASSERT*> failed.
file "..\Main.m3", line 6

Прямо скажем, не густо. Но всё-таки, временами пригождается и это.

Но что делать, если нужно отследить все изменения значений некоторой переменной? Для этого есть прагма <*TRACE*>, которая помогает отслеживать значения переменной всякий раз, когда эти значения изменяются. После слова TRACE указывается имя процедуры, которая будет вызываться. Процедура должна быть такого типа:

PROCEDURE (name: TEXT; t: Type),

где Type - тип переменной, за которой будет вестись наблюдение; name - это имя переменной, за которой будет вестись наблюдение.

Рассмотрим небольшой пример. Предположим, необходимо отследить изменения значений переменной целого типа. Для этого, нужно сделать небольшой модуль, содержащий процедуру вывода значения на экран.

INTERFACE Debug;

PROCEDURE Int(t: TEXT; i: INTEGER);

END Debug.

MODULE Debug;

IMPORT IO, Fmt;

PROCEDURE Int(t: TEXT; i: INTEGER) =

BEGIN

IO.Put("Debug: " & t & " = " & Fmt.Int(i) & "\n")

END Int;

BEGIN

END Debug.

В отлаживаемой программе мы просто укажем инструкцию <* TRACE Debug.Int *> после переменной, за которой нужно наблюдать.

MODULE Program;

IMPORT Debug; (*импортируем отладочный модуль*)

VAR x: INTEGER <* TRACE Debug.Int *>; (* устанавливаем наблюдение за значениями x *)

BEGIN

x:=0;

FOR i:=1 TO 5 DO

IF i=3 THEN x:=i END

END;

END Program.

Теперь, во время исполнения программы, на экране будут появляться сообщения:

Debug: Program.x = 0

Debug: Program.x = 3

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

Архитектура компилятора CM3 и установка дополнительных компонентов

2009-03-01T12:22:00.000+06:00

Дерево каталогов компилятора CM3 имеет примерно следующий вид (в зависимости от комплектации могут быть незначительные отличия):

bin – исполняемые файлы компилятора и динамические библиотеки (верно для платформы windows);
lib — в unix-like системах в этом каталоге лежат динамические и статические библиотеки;
pkg — каталог, содержащий модули и статические библиотеки. Все они распределены по так называемым пакетам.

Те, кто работал со средой BlackBox Component Builder, могли заметить, что так называемые подсистемы среды (или компоненты) находятся в персональных каталогах. Для добавления подсистемы нужно скопировать в каталог со средой подкаталог нужной подсистемы. Чтобы удалить подсистему, нужно просто удалить её подкаталог. На мой взгляд, такое устройство среды очень удобно, т. к. без всяких последствий можно настроить среду под любые нужды.

Примерно такое же устройство имеет компилятор CM3. В каталоге pkg находятся подкаталоги с библиотеками (далее, для понятности я буду называть их пакетами). Например, в подкаталоге libm3 содержатся модули и файлы, которые входят в стандартную библиотеку Модулы-3. Теперь поговорим, как работать с этими подкаталогами.

Как говорилось в одной из предыдущих заметок, для построения готового программного продукта используется сборочный файл m3makefile. В той же заметке я рассказывал, как собрать приложение, используя m3makefile. Чтобы вместо приложения собрать библиотеку, в сборочном файле нужно перечислить все интерфейсы, если они не имеют реализации, а также, все модули. Слово implementation, при этом, не используется. А вместо слова program должно быть указано слово library с именем библиотеки. Теперь, после запуска команды cm3, в каталоге NT386MINGNU, помимо прочих, будут лежать два файла с именем, которое было указано в аргументе команды library в m3makefile. Один из них — динамическая библиотека с расширением dll, а второй — статическая библиотека с расширением lib. Статическая библиотека не содержит ничего, кроме ссылок на динамическую библиотеку. Теперь, если собранную только что библиотеку планируется использовать в других проектах, нужно дать команду cm3 -ship. Эта команда установит только что созданную библиотеку в каталог pkg в виде пакета. А динамическая библиотека dll будет скопирована в каталог bin.

Чтобы собрать приложение, использующее данный пакет, нужно просто импортировать модули этого пакета в модулях приложения c помощью ключевого слова IMPORT. А при сборке приложения в m3makefile нужно импортировать сам пакет командой import("имя_пакета").

Если в какой-то момент возникнет необходимость удалить пакет из состава компилятора, сделать это так же просто, как удалить подсистему из среды BlackBox. Просто удаляем подкаталог с ненужным пакетом из каталога pkg. Также, не забываем удалить dll-библиотеку из каталога bin (или lib в unix).

Хочется ещё обратить внимание на одну особенность компилятора CM3, которой так не хватает компилятору Free Pascal. Динамические библиотеки, созданные описанным выше способом, имеют общий менеджер памяти с программой, которая их вызывает. Это чем-то похоже на динамически загружаемые пакетные библиотеки в Delphi. Очень полезное свойство, которое позволяет не лепить весь код приложения в единый исполняемый файл, а разместить часть кода в динамически загружаемых библиотеках. Только, перед распространением готового программного продукта нужно будет не забыть про эти dll, и скопировать их в каталог с программой. Это же касается и библиотек m3.dll и m3core.dll.

Все вопросы пишите в комментарии. Всем всего доброго!

PS. Мой вопрос по поводу группы, посвящённой Модуле-3, остаётся в силе.

Объектно-ориентированное программирование в Модуле-3

2009-02-26T21:51:00.000+06:00

Язык Модула-3 создавался как объктно-ориентированный язык программирования. В дополнение к составному типу RECORD (запись), был введён расширяемый тип OBJECT. В этом состоит отличие Модулы-3 от языков семейства Оберон, в которых расширяемым типом является RECORD. Особенностью типа OBJECT (в этом заключается ещё одно отличие от Оберона) является то, что этот тип — ссылочный. Аналогом этого типа может быть тип POINTER TO RECORD в Обероне. Не знаю, хорошо ли это, что объектные типы являются ссылочными, ведь это лишняя нагрузка на сборщик мусора.

Наследование реализуется так:
TYPE <название_типа> = <название_типа_предка> OBJECT … END;
Аналогичный тип в Обероне это выглядел бы так:
TYPE <название_типа> = POINTER TO RECORD (<название_типа_предка>) … END;
Методы для объектного типа перечисляются после ключевого слова METHODS. Поля — сразу после слова OBJECT.
TYPE T = OBJECT
field: INTEGER; (* это поле *)
METHODS
method() := Method;
function(x: INTEGER): INTEGER = Function;
END;
Далее в программе идёт реализация процедуры Method, являющейся телом для method.
PROCEDURE Method(t: T) =
BEGIN
(* реализация *)
(* переменная t здесь является ссылкой на объект,
в контексте которого находится метод.
Она является аналогом self в Delphi или this в C++ *)
END Method;

PROCEDURE Function(t: T; x: INTEGER): INTEGER =
BEGIN
(* реализация *)
(* наличие t обязательно, даже если
она не будет использована.
Она говорит о принадлежности метода объекту! *)
RETURN <результат>;
END Function;
То, что стоит после имени метода — называется сигнатурой. В сигнатуре метода не указывается контекстная переменная. Но в сигнатруре реализующей процедуры она обязательна!
Переопределение методов реализуется в блоке OVERRIDES. При этом, сигнатура переопределяемого метода не указывается. Указывается только имя метода.
TYPE NewT = T OBJECT
OVERRIDES
method:=NewMethod;
END;

PROCEDURE NewMethod(nt: NewT) =
BEGIN
(* Новая реализация *)
END NewMethod;
Нужно отметить, что переопределяемые методы являются виртуальными. Кстати, если проводить аналогию между Модулой-3 и С++, то бросается в глаза одно различие. Компилятор С++ автоматически видоизменяет имена методов, благодаря чему становится возможной их перегрузка. Компилятор Модулы-3 никаких видоизменений не производит. Это ему просто не нужно. Программист сам присваивает имени метода имя процедуры, реализующей этот метод.
Теперь переходим к самому интересному. Сокрытие данных и методов в объекте. В качестве примера я приведу программу "Hello World" (а как же иначе? :-). Она проста и понятна. Программа состоит из двух модулей и одного интерфейса. Начнём с описания интерфейса.
(* файл Objs.i3 *)
INTERFACE Objs;
TYPE
Obj <: Public; (* Obj открывает только методы,
перечисленные в Public. Знак <: означает создание
прозрачного типа, который будет реализован
и экспортирован в теле модуля *)
Public = OBJECT (* абстрактный тип, показывающий,
какие поля будут экспортированы *)
METHODS
setName(name: TEXT);
hello();
END;

END Objs.
Теперь опишем модуль Objs. Ключевое слово REVEAL (англ. — открывать) служит для объявления реализации прозрачного типа.
(* файл Objs.m3 *)
MODULE Objs;
IMPORT IO;

REVEAL
Obj = Public BRANDED OBJECT (* Obj представлен как расширение типа Public *)
(* что означает слово BRANDED, я так и не понял.
Но без него программа не компилируется *)
name: TEXT; (* Скрытое поле *)
OVERRIDES
setName:=SetName; (* переопределение методов из типа Public *)
hello:=Hello; (* при переопределении сигнатура процедуры не указывается *)
END;

(* Эти процедуры не видны вне этого модуля *)
PROCEDURE SetName(self: Obj; name: TEXT) =
BEGIN
self.name:=name;
END SetName;

PROCEDURE Hello(self: Obj) =
BEGIN
IO.Put("Hello " & self.name & "!\n");
END Hello;

BEGIN
(* слово BEGIN обязательно пишется,во всех модулях.
* здесь можно инициализировать локальные переменные
* и объекты *)
END Objs.
В главном модуле (Main) реализуется сама программа. Для начала импортируется модуль Objs. Затем, создаётся переменная o объектного типа Objs.Obj.
(* файл Main.m3 *)
MODULE Main;
IMPORT Objs;

VAR o: Objs.Obj; (* объявлние переменной-объекта *)
BEGIN
o:=NEW(Objs.Obj); (* тип OBJECT является ссылочным,
поэтому необходимо выделить для него память *)
o.setName("World");
o.hello();
(* по завершении программы объектная переменная o
* будет автоматически удалена сборщиком мусора *)
END Main.
Если бы мы попытались полю name объекта o присвоить значение напрямую (o.name:="World"), это вызвало бы ошибку. Для того, чтобы создать открытые поля в объектном типе, их нужно указать в абстрактном типе Public.
Вот, собственно, и всё. Если возникнут вопросы, пишите их в комментарии. Всем всего доброго!

Работа с компилятором CM3

2009-02-26T19:42:00.000+06:00

Для компиляции программ, написанных на языке Modula-3 могут использоваться различные компиляторы. Это может быть PM3, HM3, EZM3 и, лучший из всех возможных — CM3. Лучшим он является потому, что до сих поддерживается и развивается. Последние его версии поддерживают 64-битные платформы.

Теперь, поговорим о том, какие версии компилятора CM3 для Windows имеются на сайте. Их может быть три, и каждая из них использует определённые наборы инструментов (самое главное — это ассемблер и компоновщик) для построения приложения:

NT386 – компилятор, использующий в набор инструментов MS Visual C++;
NT386GNU – компилятор, использующий инструменты CYGWIN (раньше работал с MinGW);
NT386MINGNU – компилятор, работающий с MinGW.

У меня MS Visual C++ нет, т. к. он большой и стоит немалых денег. Можно скачать Express-версию, но для этого нужен «толстый» канал в интернет, которого у меня тоже нет.

CYGWIN меня не устраивает по двум причинам. Во первых, он GPL-ный (а значит, нельзя создавать закрытые платные программы). Во вторых, программы, созданные с его помощью зависят от библиотеки cygwin1.dll.

А вот MinGW – это самый лучший вариант. Он не требует наличия дополнительных библиотек, создаёт компактный и быстрый код, и его лицензия не запрещает создавать с его помощью закрытое ПО. Правда, нужно оговориться, что MinGW должен быть не очень старым. В старой версии компоновщик ld не поддерживает опцию @, которую cm3 активно использует. Лично я использую current-версию gcc 3.4.5.

Теперь нужно решить, какую комплектацию CM3 использовать. Для компиляции простых программ можно обойтись минимальной комплектацией. Скачиваем архив cm3-min-NT386MINGNU-X.X.X.tar.gz и распаковываем его куда-нибудь. После этого в переменной PATH указываем путь к каталогу bin. Если mingw уже установлен на Вашем компьютере, то всё готово, и можно приступать к работе.

Напишем простейшую программу, которая будет выводить на экран все переменные среды и их значения:

MODULE Main; (* Имя файла должно совпадать с именем модуля! *)
IMPORT IO, Env;

PROCEDURE PrintVars() =
VAR name, val: TEXT;
BEGIN
FOR i :=0 TO Env.Count-1 DO
(* Обратите внимание, циклическая переменная i не описана в VAR *)
Env.GetNth(i, name, val);
IO.Put(name & " = " & val & "\n");
END; (* конец цикла *)
END PrintVars;

BEGIN
PrintVars();
END Main.

Многие (в том числе и я) поначалу думают, что cm3cg.exe — это компилятор. На самом деле этот так называемый back-end, т. е. кодогенератор. Об этом говорят буквы cg.

Теперь, когда модуль создан, просто даём в командной строке команду (в том же каталоге, где лежит исходник)

> cm3

Знак «>» - это приглашение командной строки. Собранная программа будет лежать в подкаталоге NT386MINGNU. Пример программы, состоящей из двух модулей можно посмотреть здесь.

Приведённая выше программа была очень простой, и не требовала никаких библиотек, кроме libm3. Для компиляции более сложной программы необходимо создать сборочный файл m3makefile. Рассмотрим пример. Предположим, нам надо собрать программу для работы с базой данных, которая использует пакет odbc (библиотеки у Модулы-3 объединены в пакеты). Сборочный файл будет иметь такой вид:

% это комментарий
% символ «;» в конце строки НЕ СТАВИТСЯ. Его наличие — ошибка!
import("libm3")
import("odbc")
% перечисляем все модули и интерфейсы
interface("InterfaceName")
module("ModuleName")
% главный модуль записывается в слове implementation
implementation("Main")
% задаём имя программы
program("myprog")
Всё, сборочный файл готов. Даём команду:

> cm3

и если не было ошибок в текстах модулей, то программа соберётся.

Для дальнейшего изучения языка можно почитать документацию отсюда, а также, исходники компилятора. Язык очень простой, и исходные тексты читаются очень легко (не в пример языку Си :-). Также, можно посмотреть tutorial и Quake Language Reference (язык программирования, на котором пишется m3makefile).

На этом всё. Все вопросы пишите в комментариях. В ближайшее время я планирую написать статью с примером объектно-ориентированного программирования. В ней будет рассказано, как реализуется сокрытие данных и методов в объекте.

И ещё, вопрос ко всем, кто заинтересовался языком Модула-3. Может быть стоит создать группу (наподобие форума) на Google Groups, посвящённую Модуле-3? Ответ пишите в комментариях.

Отличия Модулы-3 от Оберона-2

2009-02-14T08:32:00.000+06:00

Языки Модула-3 и Оберон-2 являются родственными языками. Это и не удивительно, ведь во время разработки Модулы-3 велись консультации с Никлаусом Виртом, который в это время занимался разработкой языка Оберон-2. Цитата:

The Modula-3 project started in November 1986 when Maurice Wilkes wrote to Niklaus Wirth with some ideas for a new version of Modula. <...> Wirth had already moved on to Oberon, but had no problems with Wilkes's team continuing development under the Modula name.

Хотелось бы представить некоторые отличия между двумя этими языками. Основное отличие Модулы-3 от Оберона-2 заключается в том, что расширяемым типом является не запись (RECORD), а объект (OBJECT). Причём, объект является ссылочным типом. Работать с ним можно так же, как и с записями в Обероне (первой версии) и Ada95, а можно и по-своему:

TYPE
Obj = OBJECT
METHODS
some() = Some;
END;

PROCEDURE Some(o: Obj) =
BEGIN
(* Что-то *)
END Some;

То есть, раздел METHODS в объекте можно и не указывать, а пользоваться процедурой Some, как это принято в Аде95 и Обероне-1.

Указатель на тип в Модуле-3 записывается так:

TYPE A = REF ARRAY OF INTEGER;

вместо

TYPE A = POINTER TO ARRAY OF INTEGER;

в Обероне.

Статические массивы создаются так же, как это принято в Паскале и Модуле-2:

TYPE A = ARRAY [1..10] OF INTEGER;

В описании процедуры, после её сигнатуры ставится знак "=" вместо ";".

Чтобы узнать длину массива, нужно использовать функцию NUMBER(a) вместо LEN(a). Причём, чтобы узнать длину динамического массива, нужно использовать разыменование указателя - NUMBER(a^), иначе будет ошибка.

При описании модуля в Модуле-3 используется интерфейс модуля и его тело. Это качество было позаимствовано из Модулы-2 (DEFINITION MODULE).

В Модуле-3 имеется поддержка обобщённого программирования (Generics). Как и у Ады95, обобщения реализованы на уровне модуля, а не на уровне расширяемого типа, как это сделано в C++, Java или Delphi.

Также, в Модуле-3 имеются исключения. Внешне они похожи на исключения в Delphi. Основное отличие заключается в том, что объект исключения не является переменной расширяемого типа. Для описания исключений имеется ключевое слово EXCEPTION.

Начало

2009-02-13T18:05:00.000+06:00

В этом блоге я планирую писать статьи о замечательном языке программирования Modula-3. Так случилось, что при всех его достоинствах, этот язык был практически забыт. Сейчас он используется преимущественно в зарубежных университетах, как инструмент для обучения студентов основам программирования. Если этот блог хоть как-то повлияет на популярность Модулы-3, хотя бы на территории России, я буду только рад. Ведь, исторически сложилось, что в России и, возможно, на территории стран бывшего СССР, языки Pascal-семейства пользуются популярностью.

Примечательно, что к разработке Модулы-3 приложил руку и сам отец языков славного Pascal-семейства - профессор университета в Цюрихе, Никлаус Вирт. И, как и положено языкам этого семейства, Модула-3 отличается мощью, не уступающей (а в чём-то и превосходящей) языкам семейства Си, и простотой, сравнимой с языками Оберон/Оберон-2.

В ближайшее время я постараюсь опубликовать краткую историю создания Модулы-3 на русском языке. Где-то в обозримом будущем, также, планирую выложить в свободный доступ компилятор CM3 в стандартной редакции для платформы Win32.

Пока же, если кто-то интересуется этим языком, пишите комментарии. Буду только рад!

PS. CM3 - это открытый и свободный даже для коммерческого использования, полнофункциональный компилятор Модулы-3. Поставляется с большим количеством библиотек.