texts
stringlengths 0
715k
| names
stringlengths 8
91
|
|---|---|
i21sysListings
DEFINITION i21sysListings;
PROCEDURE Files (IN subsystem: ARRAY OF CHAR);
PROCEDURE Modules (IN subsystem: ARRAY OF CHAR);
PROCEDURE ModulesAsLinks (IN subsystem: ARRAY OF CHAR);
PROCEDURE Subsystems;
END i21sysListings.
Процедуры для создания списков модулей в разных форматах:
PROCEDURE Subsystems;
Печатает в Log список имен подсистем -- точнее, папок в рабочей папке Блэкбокса).
Пример:
i21sysListings.Subsystems
PROCEDURE Files (IN folder: ARRAY OF CHAR);
Печатает в Log список файлов в папке folder. Если папка folder находится внутри рабочей папки Блэкбокса, то печатаются соответствующие относительные пути. Иначе печатаются абсолютные пути.
Примеры:
"i21sysListings.Files('i21sys/Mod')"
"i21sysListings.Files('c:/temp')"
PROCEDURE Modules (IN subsystem: ARRAY OF CHAR);
Печатает в Log список имен модулей подсистемы subsystem (точнее, файлов .odc в папке subsystem/Mod).
Пример:
"i21sysListings.Modules('i21sys')"
PROCEDURE ModulesAsLinks (IN subsystem: ARRAY OF CHAR);
Печатает в Log список гиперлинков к файлам в папке subsystem/Mod/.
Пример:
"i21sysListings.ModulesAsLinks('i21sys')"
| i21sys/Docu/ru/Listings.odc |
i21sysScanner
DEFINITION i21sysScanner;
TYPE
String = ARRAY 257 OF CHAR;
VAR
current-: RECORD
folder-: ARRAY 2000 OF CHAR;
fileName-: ARRAY 256 OF CHAR
END;
done-: BOOLEAN;
string-: String;
PROCEDURE Next;
PROCEDURE Open (folder: ARRAY OF CHAR; name: ARRAY OF CHAR);
PROCEDURE Restart;
END i21sysScanner.
Используется для считывания словариков.
Примеры словариков: i21sys/Rsrc/keywords.odc i21sys/Rsrc/ru/vocab.odc
Изначально модуль сделан для использования в i21sysVocabulary и i21sysEdit, но является достаточно универсальным.
Словарики это текстовые документы Блэкбокса.
Слова это string в смысле TextMappers.Scanner.
Любая вьюшка означает конец словаря (обычно это вьюшка , которая вставляется посредством Shift+Ctrl+Q).
Комментарии начинаются с литеры % и завершаются литерой конца строки (Enter) или параграфа или концом документа или вьюшкой, ограничивающей словарь.
NB Гиперссылки, складки и т.п. содержат вьюшки, поэтому их нельзя использовать в комментариях кроме как в самом последнем.
Слова разделяются "белыми литерами" (Tab, Enter, пробелы).
Смысл слов определяется приложением.
TYPE String
Тип переменных для хранения считываемых слов.
VAR
current-: RECORD
folder-: ARRAY 2000 OF CHAR;
fileName-: ARRAY 256 OF CHAR
END;
Информация о словарике, открытом в данный момент.
VAR done-: BOOLEAN;
Успех очередного считывания. ~done = достигнут конец списка.
VAR string-: String;
Результат последнего успешного s.Scan.
PROCEDURE Next
Прочесть очередное слово, пропуская комментарии.
Если done, то результат хранится в string.
PROCEDURE Open (folder: ARRAY OF CHAR; name: ARRAY OF CHAR)
Открыть для чтения словарик name в папке folder.
POST
done: словарик открыт успешно
PROCEDURE Restart
Встать в начало читаемого словарика (чтобы начать читать его снова).
Примеры процедур, считывающих словарики: i21sysScannerTest
-----
info21, 2011-12-22, последние правки 2012-11-06 | i21sys/Docu/ru/Scanner.odc |
i21sysScript
DEFINITION i21sysScript;
PROCEDURE CreateVbs;
END i21sysScript.
Обслуживание серверного режима, когда разные проекты помещаются в собственных рабочих папках вне основной папки Блэкбокса и таким образом изолируются друг от друга и от основной инсталляции Блэкбокса; подробнее см. документ
Орабочихпапкахисерверномрежиме.
PROCEDURE CreateVbs
Процедура создает vbs-скрипт (текстовый файл с расширением .vbs, который может интерпретироваться операционной системой) для запуска Блэкбокса в т.наз. серверном режиме.
Скрипт создается с расширением .vbs в основной папке Блэкбокса для данной его инсталляции, имя скрипта задаётся в ресурсном файле i21sys/Rsrc/Strings.odc (параметр StartupBlackBox).
Чтобы команда сработала, Блэкбокс должен быть запущен в своей основной папке (двойным кликом по BlackBox.exe).
Для запуска этой процедуры в меню может быть предусмотрена специальная команда (например, Help -> Create vbs или Справка -> Создать файл-пускач).
После создания скрипта лучше переименовать его, чтобы различать скрипты для запуска разных инсталляций Блэкбокса.
Для использования созданного скрипта достаточно его скопировать в выбранную рабочую папку и запускать там двойным кликом. Это обеспечит запуск Блэкбокса в серверном режиме с данной папкой в качестве рабочей. | i21sys/Docu/ru/Script.odc |
Обзор подсистемы i21sys
Подсистема содержит набор простых, но полезных средств, отсутствующих в стандартном дистрибутиве Блэкбокса, а также средства поддержки локализации, в частности, возможности использования ключевых слов в кириллице.
Чтобы открыть документацию к модулю на русском языке, выделить имя (например, двойным кликом) и выполнить команду меню Info, Документация (или правый клик мышкой, Документация).
i21sysBitmaps команда сохранения вьюшек в формате BMP
i21sysCalls вызов внешних программ и файлов
i21sysCharacters интерфейсный модуль, предоставляющий информацию о допустимых буквах в идентификаторах и т.п.
i21sysCompiler компонент ("фасад") для компилятора, обслуживающий учебный процесс (программы с ключевыми словами на национальных языках,
управление автоматическим контролем отступов)
i21sysCyrillic конкретные реализации для кириллических языков средств, предусмотренных в модуле i21sysCharacters (ср. ниже i21sysLatin1)
i21sysDesktop сохранение и восстановление положения открытых окон
i21sysEdit редактор, умеющий раскрывать синтаксические конструкции по первым буквам, в том числе при работе с ключевыми словами на национальных языках
i21sysFiles некоторые средства для работы с файловой системой
i21sysIn ввод данных из текстовых документов
i21sysInfo поддержка работы по linux/wine
i21sysKoi8r перевод из кодировки KOI8-R
i21sysLatin1 "затычка" для i21sysCharacters вместо i21sysCyrillic;
при использовании этого модуля компилятор Блэкбокс ведёт себя в отношении набора литер в соответствии с международным оригиналом Сообщения о языке, т.е. в идентификаторах допускаются только буквы из Latin-1
i21sysListings примеры создания списков модулей и файлов
i21sysScanner средство чтения словариков, используемых для ключевых слов на национальных языках
i21sysScript создание запускающего vbs-файла для поддержки серверного режима
i21sysText дополнительные команды работы с текстами (в частности, возможность форматирования простых формул)
i21sysUnicodeTools простые примеры инструментов для решения задач, возникающих из-за возможного присутствия в текстах Блэкбокса литер как Юникода, так и из диапазона расширенного ASCII
i21sysVocabulary вспомогательные средства для работы с ключевыми словами на национальных языках
i21sysWindows управление окнами документов
Команда компиляции всех модулей подсистемы:
DevCompiler.CompileThis
i21sysInfo i21sysBitmaps i21sysCalls
i21sysCharacters i21sysLatin1 i21sysCyrillic
i21sysScanner i21sysScannerTest i21sysVocabulary i21sysCompiler
i21sysDesktop i21sysEdit i21sysFiles i21sysIn i21sysInПримеры
i21sysListings i21sysKoi8r i21sysHello i21sysProgram0 i21sysProgram1
i21sysScript i21sysText i21sysUnicodeTools i21sysWindows Config
В модуль Config добавляется пара настроек Блэкбокса для использования этих модулей.
Ф.В.Ткачев, 2009-10-06, для проекта Информатика-21.
Последние модификации 2012-09-28. | i21sys/Docu/ru/Sys-Map.odc |
Пакет команд для работы с текстами. Возможные команды меню:
MENU "Text" ("TextViews.View")
"Raise" "^*F8" "i21sysText.Raise" "TextCmds.SelectionGuard"
"Lower" "^F8" "i21sysText.Lower" "TextCmds.SelectionGuard"
"Zero Offset" "" "i21sysText.Offset0" "TextCmds.SelectionGuard"
END
PROCEDURE Lower
"Опустить"
Выделенный текст опускается на полпункта относительно базовой линии (офсет уменьшается).
PROCEDURE Offset0
Выделенный текст "ставится" на базовую линию (офсет обнуляется).
PROCEDURE Raise
"Поднять"
Выделенный текст поднимается на полпункта относительно базовой линии (офсет увеличивается).
| i21sys/Docu/ru/Text.odc |
i21sysUnicodeTools
DEFINITION i21sysUnicodeTools;
IMPORT TextModels;
PROCEDURE ExamineSelection;
PROCEDURE NextEASCII;
PROCEDURE NextUnicode;
PROCEDURE SelToEASCII;
PROCEDURE SelToUnicode;
END i21sysUnicodeTools.
Модуль предоставляет инструменты для преобразования литер в выделенных фрагментах текстовых документов из верхней половины расширенного ASCII (EASCII) в Юникод и обратно.
Соответствия, используемые для преобразования EASCII <-> Unicode, определяются модулем Ch в списке импорта исходника. Литеры, не имеющие таких соответствий, не преобразуются.
Распознавание конкретных диапазонов литер в кодировке Юникод (кириллический и т.п.) "зашито" в исходник модуля (процедура ExamineSelection).
Модуль предназначен для решения двух классов задач:
1. Тексты могут содержать смесь русских букв и, скажем, немецких с умляутами, и тогда важно проследить, чтобы преобразовывались только нужные фрагменты.
2. При копировании имен файлов и папок из некоторых файловых менеджеров в документы Блэкбокса могло произойти преобразование кодировок.
(Например, это может случиться при подготовке компьютерного класса.)
Тогда нужно преобразовать соответствующие фрагменты текста в нужную кодировку (EASCII или Unicode).
PROCEDURE ExamineSelection;
Выдаёт в рабочий журнал информацию о литерах в выделенном фрагменте.
PROCEDURE NextEASCII;
Найти (после курсора или выделенного фрагмента) очередной отрезок литер EASCII, причем в отрезке допускаются также пробелы, знаки препинания, цифры и спецлитеры из чистого ASCII.
PROCEDURE NextUnicode;
Найти (после курсора или выделенного фрагмента) очередной отрезок юникода, причем в отрезке допускаются также пробелы, знаки препинания, цифры и спецлитеры из чистого ASCII.
PROCEDURE SelToEASCII;
Преобразовать литеры в выделенном фрагменте из Юникода в EASCII.
PROCEDURE SelToUnicode;
Преобразовать литеры в выделенном фрагменте из EASCII в Юникод.
Возможные команды меню:
"Показать коды литер" "" "i21sysUnicodeTools.ExamineSelection" "TextCmds.FocusGuard"
"Выделенное в EASCII" "" "i21sysUnicodeTools.SelToEASCII" "TextCmds.FocusGuard"
"Выделенное в Unicode" "" "i21sysUnicodeTools.SelToUnicode" "TextCmds.FocusGuard"
"Найти след. отрезок EASCII" "" "i21sysUnicodeTools.NextEASCII" "TextCmds.FocusGuard"
"Найти след. отрезок Unicode" "" "i21sysUnicodeTools.NextUnicode" "TextCmds.FocusGuard"
Доступ к командам модуля из диалога:
"StdCmds.OpenToolDialog('i21sys/Rsrc/UnicodeTools','EASCII -- Юникод')"
----
info21
2012-10-22 | i21sys/Docu/ru/UnicodeTools.odc |
i21sysVocabulary
DEFINITION i21sysVocabulary;
IMPORT TextModels, i21sysScanner;
VAR
language-: ARRAY 100 OF CHAR;
PROCEDURE AllCapsToUnicode (IN in: i21sysScanner.String; OUT out: i21sysScanner.String);
PROCEDURE ConvertFocus;
PROCEDURE ConvertText (t0: TextModels.Model; OUT t1: TextModels.Model);
PROCEDURE IsImport (IN s: ARRAY OF CHAR): BOOLEAN;
PROCEDURE IsModule (IN s: ARRAY OF CHAR): BOOLEAN;
PROCEDURE OriginalPos (pos: INTEGER): INTEGER;
PROCEDURE Retranslate (IN na: i21sysScanner.String; OUT en: i21sysScanner.String);
PROCEDURE SetLanguage (lang: ARRAY OF CHAR);
PROCEDURE Show;
PROCEDURE Translate (IN en: i21sysScanner.String; OUT na: i21sysScanner.String);
END i21sysVocabulary.
Поддержка использования ключевых слов на родном языке.
Обычно речь идёт о переводе ключевых слов языка Оберон/Компонентный Паскаль, но на самом деле механизм может работать с произвольными идентификаторами..
Команды компиляции программ с ключевыми словами на родном языке в модуле i21sysCompiler.
Модуль i21sysVocabulary выделен из i21sysCompiler, чтобы не привязывать DevDebug к DevCompiler через i21sysCompiler. Такая привязка создаёт проблемы при экспериментировании с компилятором.
Принцип работы модуля подразумевает, что модуль хранит словарик для перевода некоторого набора (ключевых) слов, установленный последним вызовом процедуры SetLanguage;
к этому словарику обращаются процедуры Translate и Retranslate.
Кроме того, модуль помнит информацию о позициях слов, подвергшихся переводу в последнем вызове ConvertFocus или ConvertText. Это позволяет узнавать, какой позиции в исходном тексте соответствует та или иная позиция в переведённом тексте (функция OriginalPos).
VAR language-: ARRAY 100 OF CHAR;
Значение параметра lang, использованное в последнем вызове установки языка ключевых слов (SetLanguage). При этом словарики берутся из подпапки language в папке i21sys/Rsrc/.
По умолчанию language = 'en', при этом словарик пуст и перевода не делается.
PROCEDURE AllCapsToUnicode (IN in: i21sysScanner.String; OUT out: i21sysScanner.String);
Если цепочка in состоит из одних заглавных литер (допустимых в данной локализации), то она переводится в Уникод (результат в out), в противном случае просто копируется в out.
PROCEDURE ConvertText (t0: TextModels.Model; OUT t1: TextModels.Model);
Транслирует текст t0 в текст t1, используя текущий словарик.
Экспортирована для поддержки гиперссылок на исходник в окошках ТРАПов (модуль DevDebug).
PROCEDURE ConvertFocus;
Берёт текст в переднем окне (в фокусе), переводит его, вызывая ConvertText, а затем открывает переведённый текст в новом окне.
PROCEDURE IsModule (IN s: ARRAY OF CHAR): BOOLEAN;
Является ли s$ ключевым словом MODULE или его нац. соответствием.
Используется в информационном аппарате (DevDebug, DevReferences, ...).
PROCEDURE IsImport (IN s: ARRAY OF CHAR): BOOLEAN;
Является ли s$ ключевым словом IMPORT или его нац. соответствием.
Используется в информационном аппарате (DevDebug, DevReferences, ...).
PROCEDURE OriginalPos (pos: INTEGER): INTEGER;
Длина слов при переводе меняется, однако незатронутые переводом фрагменты текста в исходном документе и в переводе находятся во взаимно-однозначном соответствии.
Для каждой позиции в незатронутых фрагментах в переводе можно узнать соответствующую позицию в исходном документе это и позволяет сделать данная функция.
Это нужно, например, для корректной вставки маркеров ошибок компиляции в исходную программу с ключевыми словами на родном языке. А также для обеспечения гиперссылок на такую программу в окошках ТРАПов (модуль DevDebug).
PROCEDURE Translate (IN en: i21sysScanner.String; OUT na: i21sysScanner.String)
Попытка перевести по словарику слово en с английского на национальный язык. Результат возвращается в параметре na.
PROCEDURE Retranslate (IN na: i21sysScanner.String; OUT en: i21sysScanner.String)
Обратное действие к Translate: попытка перевести по словарику слово na с родного на английский язык. Результат возвращается в параметре en.
PROCEDURE SetLanguage (lang: ARRAY OF CHAR);
Установка нового словарика перевода.
В качестве входных данных берется файл с именем vocab.odc в подпапке lang в папке
i21sys/Rsrc/.
Пример словарика документ i21sys/Rsrc/ru/vocab.odc для русскоязычных ключевых слов (lang='ru'). Полезно помнить, что словарик не обязан быть полным, то есть не обязан содержать переводы всех ключевых слов Компонентного Паскаля: в учебном контексте это обычно и не нужно.
Установку словарика (вызов процедуры SetLanguage) для школьных нужд проще всего прописать в процедуре Setup модуля Config (дважды кликнуть по имени модуля и нажать Ctrl+0 (цифра 0), чтобы открыть исходник для редактирования).
В папку i21sys/Rsrc/ можно добавить подпапки со словариками для любых языков и активировать их с помощью вызовов вида i21sysVocabulary.SetLanguage('ru').
Если lang = '' или lang = 'en' или файл не обнаруживается, то словарик очищается, переменная language устанавливается в 'en', и никакого перевода не делается до установки нового словарика.
PROCEDURE Show
Печать активного словарика в рабочий журнал.
______________
info21 2010-09-30; последнее обновление: 2012-04-23 | i21sys/Docu/ru/Vocabulary.odc |
i21sysWindows
DEFINITION i21sysWindows;
PROCEDURE AlignTopLeft;
PROCEDURE AlignTopRight;
PROCEDURE SetPos (xnew, ynew: INTEGER);
PROCEDURE SetSize (w, h: INTEGER);
END i21sysWindows.
Простые операции с окнами в ОС MS Windows.
Возможная команда меню:
MENU "Info"
"&Open Log" "" "StdLog.Open;i21sysWindows.AlignTopLeft" ""
END
Команды работают с передним окном.
Для использования в процедурах нужно иметь в виду, что только что открытое окно является передним.
PROCEDURE AlighTopLeft
Перемещает переднее окно в верхний левый угол экрана.
PROCEDURE AlignTopRight
Перемещает переднее окно в верхний правый угол экрана.
PROCEDURE SetPos (xnew, ynew: INTEGER)
Перемещает переднее окно в положение с указанными координатами (в пикселях) левого верхнего угла. Здесь речь о полном окне с учетом рамки.
PROCEDURE SetSize (w, h: INTEGER)
Устанавливает размеры переднего окна по горизонтали и вертикали в w и h пикселей, соответственно. Здесь речь о размере внутреннего видимого поля окна без учета рамки, полос прокрутки и т.п.
| i21sys/Docu/ru/Windows.odc |
Поддержка национальных литер в идентификаторах в учебных сборках Блэкбокса
Речь о сборках Блэкбокса от проекта Информатика-21, способных поддерживать национальные алфавиты в идентификаторах. Для этого служат модули i21sysCharacters, i21sysLatin1, i21sysCyrillic и т.п.
Где сосредоточено знание о литерах, допустимых в идентификаторах
Все служебные модули Блэкбокса, которые должны знать, какие литеры допустимы в идентификаторах, поправлены так, чтобы получать всё это знание из модуля i21sysCharacters. Другими словами, если, например, в каком-то модуле Блэкбокса диапазон допустимых литер задавался в явном виде перечислением в логическом выражении, то теперь там просто стоит обращение к соответствующей функции из модуля i21sysCharacters.
Сам модуль i21sysCharacters интерфейсный и переадресует вызовы процедур модулю для конкретного национального алфавита, указанному в его списке импорта.
Например, для поддержки кириллицы i21sysCharacters импортирует модуль i21sysCyrillic.
Чтобы привести в действие соглашения оригинальной конфигурации Блэкбокса (в идентификаторах допускаются только литеры набора Latin-1), то нужно вместо i21sysCyrillic указать i21sysLatin1.
Модули i21sysCyrillic, i21sysLatin1 и другие, которые могут быть построены по их образцу для поддержки других национальных языков, формально автономны и могут, например, использоваться как независимые компоненты при работе в оригинальной конфигурации Блэкбокса. (Например, можно представить себе, что работа ведется в оригинальной конфигурации Блэкбокса, и в программах нужно обрабатывать текстовые данные с учетом специфики национальных алфавитов.)
Создание BlackBox.exe с поддержкой национального языка
Предположим, что по образцу i21sysCyrillic сделан модуль i21sys<National> для поддержки некоторого национального языка.
Тогда для создания BlackBox.exe нужно будет использовать следующие коммандеры.
Их лучше вызывать в рабочей папке (серверный режим Блэкбокса).
Не забыть сделать резервную копию Блэкбокса, прежде чем играть в эти игры!
1. Пишется/редактируется исходник модуля i21sys<National>, где сосредоточивается необходимая информация о национальном алфавите.
2. Исходник модуля i21sysCharacters редактируется так, чтобы в списке импорта фигурировал i21sys<National>.
3. Выполняется компиляция с помощью следующего коммандера:
DevCompiler.CompileThis i21sys<National> i21sysCharacters Kernel HostFiles
4. Создается BlackBoxN.exe:
DevLinker.Link
BlackBoxN.exe := i21sys<National> i21sysCharacters Kernel$+ Files HostFiles StdLoader
1 Applogo.ico 2 Doclogo.ico 3 SFLogo.ico 4 CFLogo.ico 5 DtyLogo.ico
1 Move.cur 2 Copy.cur 3 Link.cur 4 Pick.cur 5 Stop.cur 6 Hand.cur 7 Table.cur
5. Блэкбокс закрывается.
6. Сохранив старый BlackBox.exe (например, переименовав его), скопировать вновь созданный BlackBoxN.exe в основную папку (если он был создан в отдельной рабочей папке) и переименовать на BlackBox.exe.
И можно запускать новый BlackBox.exe.
Если что-то пошло не так, достаточно вернуть на место старый BlackBox.exe.
-----------
[email protected]
2012-09-15 | i21sys/Docu/ru/Национальные литеры в идентификаторах.odc |
Ввод данных в программу с помощью средств модуля i21sysIn
В Блэкбоксе (как и во всех Оберонах) роль командной строки может сыграть любой текст. Эта идея известна под названием тексткакинтерфейс.
Мы уже знаем, что команду можно вызвать из любого текста, где видно её имя (с помощью коммандера , приставленного непосредственно перед именем команды, или через меню: Dev, Execute, если предварительно имя выделить мышкой).
Но входные данные тоже можно брать из текстовых документов. А именно:
1) Набор вводимых данных входной поток может быть частью любого текста. Для одной и той же программы может быть приготовлено несколько таких наборов в разных текстовых документах.
2) Есть способы указать, какой именно фрагмент и в каком именно тексте будет считаться входным потоком, начиная с данного момента.
3) Программа использует некоторые стандартные способы получения доступа ко входному потоку и его чтения.
Эта идея реализована в модуле i21sysIn, имеющемся во всех комплектах Блэкбокса от проекта Информатика-21.
Более ограниченный вариант модуль In, описанный в старой книге Вирта и Райзера по программированию на Обероне и включенный в качестве примера в дистрибуцию Блэкбокса. Все программы, использующие модуль In, будут корректно работать и с модулем i21sysIn, для этого в списке импорта достаточно вместо In указать In := i21sysIn.
Ниже даны некоторые пояснения, а полное описание возможностей модуля i21sysIn дано в его документации.
(В учебных комплектах, ориентированных на школу, имеется сокращённый вариант этого модуля i21eduВвод, в котором все видимые имена переведены на русский язык.)
В дальнейшем будем предполагать, что список импорта (подключения внешних библиотек) содержит In := i21sysIn (в школьном варианте Ввод := i21eduВвод).
Простейший пример ввода пары чисел для простейшей программы турбопаскалевского типа показан здесь. Там реализован один из описываемых ниже способов определения входного потока.
Модуль i21sysIn предоставляет несколько таких способов.
Первый способ самый простой и удобный, например, для школьных уроков. Здесь поток ввода определяется вручную до выполнения программы, и его не надо повторно определять при повторном запуске программы:
мышкой выделяется нужный фрагмент текста (в любом открытом документе);
нажимается Shift+F1 (или мышкой через меню: 1-Школьное, Открыть поток ввода или Текст, Открыть поток ввода или Text, Open Input).
После этого окно с потоком ввода можно даже закрыть.
Программа в этом случае использует команду In.Restart (в школьном варианте Ввод.Сначала), чтобы начать чтение потока с начала, а также обычные команды чтения вроде In.Int(...) (в школьном варианте Ввод.Цел(...)).
Программа может возвращаться к началу потока ввода столько раз, сколько нужно.
Достоинство этого способа полное разделение выполнения программы и процедуры задания входного потока.
Во втором способе входной поток должен быть выделен мышкой на момент вызова программы, а программа должна использовать команду In.OpenSelection, и если при выполнении последней выделенного фрагмента не обнаруживается, то логическая переменная In.done (Ввод.сделано) устанавливается в FALSE.
Это способ удобен, когда нужно много раз выполнять программу с разными данными на входе.
Третий способ применяется при вызове программы с помощью коммандера. В этом случае программа открывает входной поток, вызывая процедуру In.OpenCommander, и тогда входным потоком считается текст сразу за коммандером (точнее, за именем вызываемой процедуры после коммандера).
Гибридный способ: программа открывает входной поток, вызывая процедуру In.Open, и тогда на роль входного потока сначала ищется выделенный фрагмент (как во втором способе), а если такого нет, то входным потоком считается текст после коммандера (как в третьем).
Последний способ: программа открывает входной поток, вызывая процедуру In.OpenFocus, и тогда входным потоком будет весь текстовый документ в переднем окне. Этот способ имеет смысл только для программ, вызываемых через меню.
Программный способ: можно программно заставить этот модуль читать данные из любого фрагмента любого объекта типа TextModels.Model, открыв поток ввода вызовом процедуры In.OpenText. См. подробности в документации. Отметим только, что открытие потока ввода и его обработка могут быть реализованы в виде разных процедур и даже в разных модулях.
Некоторые примеры даны здесь.
Нужно обратить внимание на следующее:
В самом начале модуля в инструкции импорта (начинается с ключевого слова IMPORT) должно появиться имя модуля или его сокращенный вариант.
После каждой операции ввода нужно проверять, что она завершилась успешно, с помощью проверки ASSERT( In.done )
или в школьном варианте УБЕДИТЬСЯ( Ввод.сделано );
Проверка корректности ввода должна быть автоматической привычкой.
Считываемые значения могут разделяться любыми белыми литерами в любом количестве и любых комбинациях (пробелы, концы строк, табуляции, ...).
Например, вводимые данные можно для наглядности группировать по строкам или как-то форматировать с помощью табуляции.
Если значения разделяются, например, запятыми, то для пропуска запятых можно использовать процедуру In.Char.
Типы вводимых значений во входном потоке должны совпадать с тем, что ожидают в данный момент команды чтения (целые для In.Int и т.д.).
В противном случае In.done будет установливаться в FALSE, а в дальнейшем будут происходить аварийные остановки (потому что ввод нужно проверять).
После такой аварийной остановки достаточно закрыть открывшееся окошко TRAP/ТРАП, исправить программу или данные, и повторить попытку.
Важное исключение составляет процедура чтения In.Char, которая просто берёт из входного потока очередную литеру.
Другое исключение процедура In.Real, которая правильно прочтёт не только вещественное значение (с десятичной точкой), но и целое, и преобразует его в вещественное. Этот случай безопасен в том смысле, что не влечёт потери информации, поэтому он разрешён.
Входной поток можно в любой момент начать читать с начала. Для этого в программе вызывается In.Restart. Например, так можно определить количество целых чисел во входном потоке и разместить массив соответствующей длины для их хранения в программе.
Если вводится литерная цепочка (процедура In.String), то она должна либо быть заключена в кавычки, либо не содержать белых литер.
Все процедуры, кроме In.Char, пропускают белые литеры до следующего элемента данных. In.Char этого не делает. В частности, если программа вызывается с помощью коммандера, поток ввода открывается с помощью In.Open, и первой операцией чтения стоит In.Char, то она прочтёт белую литеру, которая ограничивает имя команды. Например, если команда и поток ввода оформлены так:
Module.Procedure x
то прочтен будет пробел, а не "x".
Аналогично вызов In.Char сразу после успешного чтения целого числа посредством In.Int прочтет первую белую литеру сразу за последней цифрой числа.
Модуль i21sysIn экспортирует сканер i21sysIn.scanner, имеющий тип TextMappers.Scanner, который подключён к текущему входному потоку. Это позволяет сканировать входной поток, используя весь арсенал средств сканера (определять атрибуты текста и т.п.).
На самом деле модуль i21sysIn создаёт скрытую копию того фрагмента текста, который задаётся в качестве входного потока. Поэтому сам тот текст защищён от модификаций через сканер i21sysIn.scanner (последний даёт доступ к сканируемому тексту, который можно изменить штатными средствами Блэкбокса).
________________
[email protected]
последние изменения: 2012-09-24 | i21sys/Docu.Полезные сведения/Ввод данных (In).odc |
О комментариях в Компонентном Паскале
Комментарии в тексте программ на Компонентном Паскале оформляются составными скобками (* и *). Между ними может быть любой текст.
Комментарии могут быть вложенными. Например:
(* (* это комментарий *) в другом комментарии *)
При этом баланс открывающих и закрывающих скобок должен быть сохранен.
Это защищает от ошибок, когда в комментарий берется кусок программного текста, содержащий другой комментарий, в котором тоже скрыт кусок программного текста.
Полезно иметь в виду, что длинные комментарии можно прятать в так называемых складках (folds; см. меню Инструменты, группу команд, начиная с Создать складку и т.д., а также документацию к модулю StdFolds).
________________
[email protected]
последние изменения: 2010-10-23 | i21sys/Docu.Полезные сведения/О комментариях.odc |
О компиляции
Ниже объясняется, как компилировать модуль в различных ситуациях.
1.
Пусть текст модуля находится в открытом документе Блэкбокса.
Обычно текст модуля располагается в самом начале документа.
Если это так, то для компиляции модуля достаточно нажать на клавиатуре Ctrl+K (латинское K, переключать с русской раскладки на латинскую не обязательно),
или из меню Разработка > Компилировать.
В этом случае компилятор проигнорирует все, что находится за текстом модуля там удобно ставить коммандеры для вызова процедур модуля, хранить программные фрагменты и т.п.
2.
Если текст модуля находится в середине документа, то достаточно выделить мышкой начало модуля (например, дважды кликнуть по слову MODULE, с которого начинается текст модуля) и выполнить команду меню Разработка > Компилировать выделенное. Будет скомпилирован весь модуль.
Если это приходится делать часто, то лучше модифицировать меню, указав там нужную клавишу (keyboard shortcut) по стандартным правилам Блэкбокса. (При подготовке текстов с компилируемыми модулями удобно вставить такую команду в контекстное меню -- меню со зведочкой в конце файла Text/Rsrc/Menus.odc.)
3.
Если исходники модулей хранятся в соответствии с правилами Блэкбокса, то можно скомпилировать сразу несколько модулей, не открывая их.
Для этого в любом тексте ставится такой коммандер:
DevCompiler.CompileThis i21sysIn i21sysInПримеры
После коммандера идёт список имён компилируемых модулей через пробелы или любые другие белые литеры. Заканчиваться список может, например, cпец. вьюшкой (Ctrl+Shift+Q) или просто другим коммандером.
Если один из модулей не скомпилировался, то остальные модули не компилируются.
В списке модулей важно учитывать связи по экспорту-импорту: импортирующий модуль должен стоять после импортируемого (т.к. компилировать импортирующий бессмысленно до компиляции импортируемого).
Существует аналогичная команда выгрузки списка модулей:
DevDebug.UnloadThis i21sysInПримеры i21sysIn
Но порядок выгрузки должен быть обратным к порядку компиляции.
________________
[email protected]
последние изменения: 2010-10-23 | i21sys/Docu.Полезные сведения/О компиляции.odc |
О подсистемах Блэкбокса
Рекомендуется хранить файлы с исходниками модулей в соответствии с определенными правилами, иначе в процессе разработки программ Блэкбокс не сможет выполнить некоторые полезные команды (например, найти исходник и показать то место, в котором произошла аварийная остановка).
, , .. , BlackBox; : Comm, Ctl, ... Xhtml.
(, Comm TCP/IP; Text , ..; ..)
(, MODULE) ; . .
5 , Form:
Mod (modules) ики , составляющих ; ; .odc. , Form 5 , . . , , , .. (. ). , , Cmds Forms: Cmds.odc BlackBox\Forms\Mod\.
Code (code files) .. или бинарники ( .ocf), . , Cmds, Cmds.odc Mod, Cmds.ocf Code.
( (DLL) MS Windows, , , .)
Sym (symbol files) .. ( .osf), .
, Cmds Cmds.osf Sym.
header- C/C++, , , . , . , , , .
, - , . .
, , , , . .
Code Sym . Mod, .
Docu (documentation) : , Docu. , Cmds Cmds.odc Docu. , , , .
Переводы на русский язык лежат в подпапках Docu/ru/ с теми же именами, что и английские оригиналы.
Docu.
Rsrc (resources) , .. , Errors.odc Rsrc Dev. . , . Rsrc , Docu.
, , . , .
, , .
BlackBox Code Sym, . , в которых нельзя выделить имени подсистемы.
, подсистем
. , , , , . , .
, .
Имя модуля это любой идентификатор (последовательность из букв, цифр и символов подчеркивания, начинающаяся с буквы или символа подчеркивания, причем большие и малые буквы различаются, а символ подчеркивания трактуется как малая буква).
Когда Блэкбокс встречает при компиляции и т.п. имя модуля (идентификатор), он пытается разбить его на две части: имя подсистемы и имя файла.
Грубо говоря, имя подсистемы это начало имени модуля до первого "скачка" к большим буквам после малых букв или цифр. Всё остальное это имя файла.
Примеры:
StdLog > имя подсистемы Std, имя файла Log;
ПошаговаяПростые > имя подсистемы Пошаговая, имя файла Простые;
ПодсистемаДлинноеИмяФайла > Подсистема, ДлинноеИмяФайла;
тестТест2 > тест, Тест2;
_123ИмяФайла > _123, ИмяФайла.
CommObxStreamsClient > Comm, ObxStreamsClient.
Если не удалось разбить имя модуля таким образом (например, имя модуля проверочный123), то Блэкбокс применяет особые правила, которые будут рассмотрены отдельно.
Обычно в и подсистем . Среди исключений имена подсистем i21sys, i21edu и т.п.
Comm/Mod/ObxStreamsClient.odc,
Comm/Code/ObxStreamsClient.ocf,
Comm/Sym/ObxStreamsClient.ocf.
Для новой подсистемы
достаточно сначала создать папку для подсистемы (например, i21прим) и в ней папку Mod для исходников.
Например, модуль с именем i21примПростые следует хранить в файле
i21прим\Mod\Простые.odc
При первой успешной компиляции модуля i21примПростые Блэкбокс создает еще две папки рядом с папкой Mod: папку Code для бинарников и Sym для символьных файлов. Автоматическое создание папок сопровождается информационными сообщениями вроде
Будет создана папка c:\BlackBox\i21прим\Code
В итоге при компиляции модуля i21примПростые будут созданы два следующих файла:
i21прим\Code\Простые.ocf (бинарник)
i21прим\Sym\Простые.osf (символьный файл)
Напомним, что кодовый файл это двоичный файл с машинными командами результат компиляции исходного текста. Он загружается в память для непосредственного выполнения.
Символьный файл содержит всю информацию о внешних связях модуля по экспорту-импорту. Он подобен header-файлам в C.
Кодовый и символьный файлы создаются компилятором автоматически, и их место в файловой системе фиксировано и однозначно определяется именем модуля.
Именно поэтому в Блэкбоксе любой успешно скомпилированный модуль становится частью системы в том смысле, что как файл с машинным кодом, так и соответствующий символьный файл немедленно становятся доступными для импорта из других модулей, вызова процедур из меню Блэкбокса и т.п.
Если модуль успешно скомпилирован и отлажен, то его исходник можно перенести в другое место для использования откомпилированного модуля нужны только его символьный и кодовый файлы.
В папке для каждой подсистемы, кроме папок Code, Mod, Sym, обычно бывают еще папки
Docu документация для модулей; имя файла с документацией должно совпадать с именем файла для исходника;
Docu/ru переводы на русский язык документов из Docu; имя файла с документацией должно совпадать с именем файла для исходника;
Rsrc различные "ресурсы" данной подсистемы, например, меню, формы диалогов и т.п.
Если в имени модуля не удаётся выделить имя подсистемы (например, "Модуль1"), то Блэкбокс ожидает, что исходник будет храниться в папке Mod в основной папке (т.е. эта папка Mod будет находиться в ряду с Form, Text и т.д.), а кодовый и символьный файл будут попадать в папки Code и Sym, находящиеся на том же уровне, что и указанная папка Mod.
Если Блэкбокс был запущен в некоторой рабочей папке в серверном режиме, то создаваться все новые папки и файлы будут в рабочей папке с точно такими же именами, как и в основной.
________________
[email protected]
последние изменения: 2010-10-23; 2012-12-04 | i21sys/Docu.Полезные сведения/О подсистемах.odc |
О порядке определения процедур в модуле
В Обероне/Компонентном Паскале есть одна тонкость, связанная с порядком следования процедур в модуле. Эта тонкость требует некоторого (впрочем, минимального) внимания со стороны программиста, но имеет то капитальное положительное следствие, что компилятор удается сохранить чрезвычайно быстрым (однопроходным).
Тонкость состоит в следующем. Предположим, что в модуле стоят подряд две процедуры (неважно, помечены они знаками экспорта или нет):
MODULE Пример;
PROCEDURE Первая ( x: INTEGER );
VAR
BEGIN
Вторая( x + 1 )
END Первая;
PROCEDURE Вторая ( y: REAL );
VAR
BEGIN
(* сделать что-нибудь *)
END Вторая;
END Пример.
Попытка скомпилировать этот модуль даст ошибку с сообщением "необъявленный идентификатор" после идентификатора Вторая в теле первой процедуры (выделен цветом).
Причина в том, что по правилам Компонентного Паскаля диапазон видимости идентификатора распространяется от точки его объявления до конца той структурной единицы (модуля или процедуры), в которой этот идентификатор объявлен. В данном случае идентификатор процедуры Вторая появляется в тексте после процедуры Первая и его диапазон видимости распространяется от заголовка процедуры Вторая до конца модуля. Соответственно та точка, где стоит вызов процедуры Вторая, находится за пределами диапазона видимости идентификатора Вторая, откуда и ошибка.
Обойти эту трудность позволяет т.наз. "упреждающее объявление" процедуры (forward declaration): скопируем заголовок процедуры Вторая перед процедурой Первая и пометим его значком ^ после ключевого слова PROCEDURE:
MODULE Пример;
PROCEDURE^ Вторая ( y: REAL );
PROCEDURE Первая ( x: INTEGER );
VAR
BEGIN
Вторая( x + 1 )
END Первая;
PROCEDURE Вторая ( y: REAL );
VAR
BEGIN
(* сделать что-нибудь *)
END Вторая;
END Пример.
Теперь модуль компилируется без ошибок.
Важно, чтобы упреждающее определение совпадало с заголовком соответствующей процедуры (за исключением символа ^) литера в литеру. Проще всего это обеспечить простым копированием.
Вообще проектные решения такого рода учитывая не только чисто технические, но и более широкие "социальные" аспекты такого феномена как язык программирования достаточно нетривиальны, т.к. просчитать все, в том числе отдаленные последствия таких решений практически невозможно.
Есть много примеров того, как простые и на первый взгляд очевидно разумные решения оборачиваются в конечном счете потерями, далеко перевешивающими тот выигрыш, который при принятии решения кажется очевидным. Учитывая, что добавить в язык программирования новую "фичу" легко, а устранить неудачную почти невозможно [это неоднократно подчеркивал Н.Вирт], оптимальной стратегией в этих вопросах следует считать здоровый консерватизм.
________________
[email protected]
последние изменения: 2010-10-23 | i21sys/Docu.Полезные сведения/О порядке процедур.odc |
О процедурах и модулях
*Простейшаяпрограммадляшкольногоурока
Какаяпроцедураглавная?
Чтотакоемодуль
Экспортпроцедуризмодуля
*Простейшийспособвызовапроцедурпокомандепрограммиста
Импортпроцедур
Загрузкамодулей
Выгрузкамодулей
Каквызыватьпроцедурыспараметрами
Простейшая программа для школьного урока
Сначала покажем два простейших примера, эквивалентных обычным программам в Турбо Паскале: Program0 и Program1 (примеры открываются кликом по гиперссылкам). В учебных сборках Блэкбокса от проекта Информатика-21 предусмотрена горячая клавиша Ctrl+F9, при нажатии которой происходит компиляция и выполнение программы (только компиляция вызывается нажатием Ctrl+K, где K латинское). В большинстве школьных ситуаций больше ничего знать не надо; сообщения Блэкбокса в Рабочем журнале вроде старый модуль ... выгружен, появляющиеся при нажатии Ctrl+F9, можно просто игнорировать.
Однако Блэкбокс предоставляет большую гибкость в организации программ. Это бывает полезно даже в занятиях на школьном уровне, когда серия упражнений размещается в виде последовательности процедур в одном модуле, причём каждую из этих процедур можно вызвать средствами Блэкбокса. Об этом рассказано далее в этом документе. Здесь только отметим, что с точки зрения штатного режима работы в Блэкбоксе в двух примерах применён искусственный прием, заключающийся в том, чтобы поместить программу в секцию инициализации модуля и форсировать её выполнение перезагрузкой модуля.
Какая процедура главная?
В старых системах программирования, когда говорят о программе, подразумевают некоторую главную процедуру (program, main и т.п.), которой подчинены подпрограммы вспомогательные процедуры и функции.
Для новичков непривычно, что в обероноподобных системах понятия главной процедуры, вообще говоря, нет. Та или иная процедура (или секция инициализации модуля) может становиться главной лишь в конкретной ситуации.
Понятие главной (main) процедуры в старых языках программирования пережиток старины, т.е. времён операционных систем пакетной обработки, когда программы готовились на перфокартах, перевязывались резинкой и отдавались девушкам-операторам на компиляцию и выполнение. Поэтому операционная система всегда должна была точно знать, с какого места начать исполнение программы.
В наше время программисты (включая сюда многих продвинутых пользователей) работают, как правило, в непосредственном диалоге с компьютером, и поэтому естественно дать им возможность произвольно вызывать любую процедуру.
В самом деле, когда пишут программу для решения не слишком простой задачи, то речь чаще всего идет о целом классе задач, и решение в виде единственной процедуры, пусть и с параметрами, может оказаться недостаточно гибким.
Тогда фокус внимания программиста переносится на создание набора команд-процедур, комбинируя которые например, в диалоговом режиме можно было бы решить любую задачу из этого класса.
Например, нередко в рамках даже небольшого программного проекта создают несколько процедур тестирования для разных целей: одни для тестирования особых случаев, другие для тестирования типичных сценариев использования создаваемой программной системы (англ: use cases), и еще третьи для замеров времени выполнения и профилирования с целью выявления узких мест в алгоритмах.
Ни про одну из таких процедур тестирования нельзя сказать, что она главнее другой. Та процедура, которую программист вызывает к исполнению, и является в тот момент главной в старом смысле специально выделять одну из них как главную просто излишне.
И лишь в простейших ситуациях (например, в школьном курсе программирования старого, турбопаскалевского типа) может оказаться достаточным работать с программами, помещаемыми в секцию инициализации модуля, без использования процедур-подпрограмм, как было указано в началедокумента.
Что такое модуль
Итак, вместо главной процедуры появляется важное понятие модуля.
Понятие модуля настолько важно, что непосредственный предшественник Оберона язык Модула-2 (см. историюэтихязыков) получил свое название из-за того, что среди всех его отличий от старого Паскаля именно модули были наиболее принципиальным новшеством.
Модуль своего рода упаковка, контейнер для процедур, скрывающий от внешнего мира (в том числе от других модулей) как их внутреннее устройство, так и вспомогательные процедуры.
Это выражают, говоря, что модуль единица инкапсуляции.
Обычно процедуры из одного модуля логически связаны. В этом смысле модуль похож на обычную библиотеку программ. Однако связь между процедурами из одного модуля может быть более тесной, чем в обычной библиотеке.
Именно модуль компилируют, т.е. модуль единица компиляции.
Именно модуль загружают и выгружают из оперативной памяти (т.е. модуль единица загрузки; о загрузке модулей см. ниже).
В общем случае программа в Компонентном Паскале это несколько модулей (в простейших случаях модуль может быть один), а разработка программы состоит в поочередной разработке таких модулей.
Каждый очередной готовый (скомпилированный) модуль становится частью системы, расширяя ее возможности и таким образом обеспечивая основу для разработки и добавления дальнейших модулей.
Сам Блэкбокс не что иное, как совокупность модулей. Причем нет никакой принципиальной разницы между модулями самого Блэкбокса и модулями, написанными и скомпилированными пользователем. Например, если выполнить команду меню Инфо, Загруженные модули, то откроется список модулей, находящихся в памяти компьютера в активном состоянии, т.е. ждущих вызова своих процедур (о вызове процедур см. ниже). Например, модули с именами, начинающимися на Ole или Host, являются родными модулями Блэкбокса, т.е. были написани его авторами (компанией Oberon microsystems, Inc.). А, например, модули с именами на i21 написаны участниками проекта Информатика-21 и содержат дополнительные средства, удобные в учебном процессе.
Еще раз подчеркнем, что компилируются и загружаются модули в сущности независимо друг от друга, а их связь (возможность вызывать процедуры одного модуля из процедур другого) полностью определяется и контролируется программистом (см. ниже об экспорте-импорте процедур из модулей).
Это позволяет полноценно реализовать при создании программных систем важнейший принцип проектирования РАЗДЕЛЯЙ И ВЛАСТВУЙ.
Этот принцип был известен еще в античном мире (лат: divide et impera, англ: divide and rule). О нём обычно вспоминают в негативном политическом ключе (ср. другой английский вариант перевода divide and conquer, т.е. разделяй и завоёвывай). Однако принцип имеет универсальное значение при проектировании сложных систем. Подробнее о нём можно почитать, например, на сайте проекта Информатика-21.
Заметим, что ни в одной из широко распространенных систем программирования начиная от старых фортрана, Паскаля, C/C++ и кончая новыми Java и C# нет такого же четкого и полноценного средства, как модули в Обероне/Компонентном Паскале. Попытки обойтись без модулей ещё ни разу не увенчались полным успехом всё равно приходится вводить дополнительные понятия вроде пространства имен (англ: namespace), и всё равно полноценной замены модулям не получается.
Например, не имея привязки процедуры к конкретному модулю, в том же Турбо Паскале получаем настоящую головную боль, когда изучаем текст какой-то программы, видим там вызов процедуры и пытаемся найти, в каком именно файле эта процедура определена.
В Обероне/Компонентном Паскале вызов процедуры всегда сопровождается именем соответствующего модуля: ИмяМодуля.ИмяПроцедуры, и для открытия соответствующего исходника обычно достаточно выделить имя модуля двойным кликом и нажать Ctrl+0 (или Ctrl+Shift+D для открытия документации к модулю).
Независимость модулей проявляется в том, что компилятор каждый раз перемалывает в машинные команды исходный текст единственного модуля, не обращаясь к исходникам других модулей.
Исходный текст модуля является единой синтаксической конструкцией, которая подчиняется правилам, описанным в Сообщении о языке Компонентный Паскаль (см. меню Справка > Сообщение о языке ...). Это объясняет смысл утверждения, что модуль является единицей компиляции.
Все модули должны иметь разные имена. Обычно лучше каждый модуль хранить в отдельном документе (файле с расширением .odc сокращение от Oberon DoCument).
В Блэкбоксе принята определенная дисциплина организации модулей: они группируются в так называемые подсистемы. Эта дисциплина не задаётся языком программирования и не является обязательной, это просто удобно. Подробнее об этом написано отдельно.
Текст модуля удобно помещать в начале документа. В Блэкбоксе обычно компилятор игнорирует все, что находится после текста модуля (т.е. после точки, закрывающей модуль), так что пространство после текста модуля в нашем полном распоряжении (там можно помещать команды вызова процедур модуля, а также хранить фрагменты программных текстов).
Экспорт процедур из модуля
По умолчанию процедура, содержащаяся в модуле, невидима извне, т.е. не может быть выполнена по команде пользователя или из других модулей.
Чтобы сделать ее видимой извне, она должна быть экспортирована из своего модуля т.е. отмечена значком экспорта (звездочка *) после имени процедуры в ее заголовке.
Экспортированы могут быть любые из процедур модуля, и любая из экспортированных процедур может быть вызвана для непосредственного исполнения например, с помощью т.наз. коммандера (см. об этом чутьниже), или использована в других модулях.
И наоборот: те процедуры, которые не отмечены специально значком экспорта, не видны за пределами данного модуля они спрятаны: при компиляции других модулей компилятор их не видит и поэтому их невозможно вызвать из других модулей. Обычно это вспомогательные процедуры (подпрограммы).
Внутри модуля все процедуры видят и могут вызывать друг друга.
Вне модуля видно только то, что его разработчик сделал видимым.
Это раскрывает смысл фразы о том, что модуль является единицей упрятывания информации.
Когда компилятор компилирует некоторый модуль, то он создает для него особый символьный файл, в котором записана вся информация о всех экспортированных и только экспортированных процедурах. Такой файл создается автоматически в двоичном формате, не предназначенном для модификации вручную. Такие файлы имеют расширение .osf от Oberon Symbol File. Почитать информацию из символьного файла можно, открыв его в Блэкбоксе. При компиляции других модулей компилятор обращается только к символьным файлам уже скомпилированных модулей.
Символьный файл создается компилятором автоматически и проверяется тоже автоматически. Этим символьные файлы отличаются от header-файлов языков C и C++, где их надо создавать и использовать вручную, причем компилятор не имеет средств контролировать корректность этих файлов. При создании больших систем неизбежные ошибки в определении и использовании header-файлов являются причиной колоссальной головной боли программистов.
В языках семейства Оберон эта проблема исключена в принципе.
Важно, что по умолчанию процедура спрятана. Чтобы сделать ее видимой, нужно выполнить специальное действие экспортировать ее.
Это важный элемент защиты от случайных ошибок: только разработчик модуля имеет право определять, к каким процедурам допустить внешних клиентов:
Во-первых, неконтролируемый доступ к вспомогательным процедурам чреват ошибками.
Во-вторых, защищая вспомогательные процедуры от несанкционированного доступа, разработчик сохраняет возможность перелопатить внутренность модуля (например, если он придумает более быстрые алгоритмы) и при этом не опасаться, что перестанут работать другие программы.
Поэтому не нужно приобретать дурную привычку ставить знак экспорта на все процедуры подряд.
Посмотреть, что экспортирует некоторый модуль, можно следующим образом: найти (или напечатать) в любом документе Блэкбокса имя модуля (например, StdLog); выделить его (например, двойным кликом мышки); с клавиатуры выполнить команду Ctrl+D. Откроется новое окошко, в котором будет представлена информация об объектах, экспортированных из данного модуля.
Простейший способ вызова процедур по команде программиста
Экспортированную процедуру (предполагается, что соответствующий модуль был успешно скомпилирован) можно вызывать извне, в частности, по команде программиста. Для этого прежде всего нужно уметь однозначно указать нужную процедуру. Это достигается с помощью полного (или квалифицированного) имени процедуры: оно составляется из имени модуля, в котором определена процедура, и имени процедуры внутри модуля, причем два имени должны быть разделены (или соединены, кому какое слово больше нравится) обычной точкой. Например, StdLog.Clear полное имя процедуры Clear из модуля StdLog. Таким образом, имя модуля играет роль фамилии для членов одного семейства процедур: две процедуры из двух разных модулей могут иметь одинаковые собственные имена, но т.к. имена разных модулей (фамилии) всегда различны, то полные имена процедур тоже различны.
Рассмотрим вызов процедур без параметров. С такими процедурами работать проще всего и значительная часть команд меню реализована именно такими процедурами. Для них в Блэкбоксе есть специальное название команды.
Покажем, как их вызывать с помощью т.наз. коммандера (commander).
В любом текстовом документе Блэкбокса (обычно в том же документе, где хранится текст модуля, после точки, заканчивающей модуль, на новой строке) нужно нажать Ctrl+Q что приведет к появлению в месте курсора черного кружка и затем сразу полное имя процедуры-команды (т.е. процедуры, не имеющей параметров). После этого клик мышкой по коммандеру вызывает процедуру. Разумеется, модуль должен быть уже откомпилирован.
Например, в Блэкбоксе есть откомпилированный модуль StdLog, в котором собраны процедуры, управляющие рабочим журналом. В частности, в нем есть процедура-команда Clear, очищающая рабочий журнал. Вот конструкция с коммандером, позволяющая выполнить эту процедуру:
StdLog.Clear
Простейший способ вызвать процедуру с параметрами добавить в тот же модуль (например, в конце текста модуля, после всех других процедур) простую вспомогательную процедуру без параметров, в которой зашиты нужные фактические параметры для вызова желаемой процедуры, и вызывать эту вспомогательную процедуру уже с помощью коммандера. Коммандер тогда удобно ставить в том же документе, в котором хранится модуль, в любом месте после точки, закрывающей модуль.
Если нужно поменять параметры, то достаточно поменять их в тексте вспомогательной процедуры и перекомпилировать модуль, а затем вызвать вспомогательную процедуру с помощью коммандера, при этом одновременно с кликом мышки нужно нажимать клавишу Ctrl (это объясняется ниже).
Тот же самый прием вызов кликом по коммандеру с нажатой клавишей Ctrl применяется, если вся разрабатываемая программа состоит из единственного модуля, когда нужно выполнить новую версию процедуры после внесения в модуль каких-нибудь изменений и перекомпиляции.
О других способах вызывать процедуры с параметрами рассказано ниже.
Импорт процедур
Итак, экспорт позволяет сделать процедуру P видимой за пределами ее модуля M. Но чтобы использовать ее в процедурах другого модуля M2, этот другой модуль должен импортировать модуль M. Это делается с помощью оператора импорта, стоящего в самом начале модуля, что выглядит примерно так:
MODULE M2;
IMPORT M, Math, StdLog;
и далее следует остальной текст модуля M2.
(Об определении оператора импорта см. Сообщение о языке ... в меню Справка.)
Присутствие имени модуля M в списке импорта модуля M2 делает все экспортированные процедуры модуля M доступными для использования во всех процедурах внутри M2.
В Модуле-2 каждую процедуру нужно было импортировать отдельно. Практика показала, что такое усложнение себя не оправдывает.
Говорят, что модуль M2 является клиентом модуля M (ведь M посредством своих процедур предоставляет некий сервис, которым и пользуется M2 поэтому о нем можно говорить как о клиенте).
Вся информация об импорте данного модуля тоже указывается в его символьном файле. Благодаря этому система имеет возможность определять, какие модули могут потребовать модификации, если изменить что-то в одном из модулей системы. Если в нашем примере изменится модуль M, то модуль M2 также может потребовать соответствующей модификации.
Может иметь место и косвенная связь между модулями: если модуль M3 импортирует M2, то он тоже может потребовать модификации при модификации M. Другими словами, M3 связан с M косвенно, через M2. В любом случае система может отследить все связи между модулями по экспорту-импорту.
Кстати, циклические связи по импорту в Блэкбоксе запрещены.
Обратно, если модуль M4 не связан с модулем M по экспорту-импорту ни прямо, ни косвенно, то изменения в M никак не затронут M4, что весьма приятно, т.к. в противном случае пришлось бы модифицировать все модули системы вообще весь смысл разделения системы на независимые кубики-модули был бы потерян.
Загрузка модулей
Нужно отчетливо понимать следующие важные свойства модулей:
1 Модуль не программа, которую выполняют, а контейнер для процедур, который целиком загружается в оперативную память, прежде чем вызываются его процедуры.
2 Модуль M загружается в память автоматически при определенных условиях (например, при первом вызове одной из его процедур с помощью коммандера, как уже описывалось; полный алгоритм загрузки модулей дан ниже).
3 После загрузки модуль остается в памяти до выгрузки по явной команде программиста.
Впрочем, Блэкбокс устроен так, что всё, что можно сделать через меню и с помощью горячих клавиш, можно выполнить и из программы на Компонентном Паскале.
4 Если вызывается процедура из модуля, который уже находится в памяти, то повторной загрузки модуля не происходит он уже загружен, а просто вызывается нужная процедура.
5 Компиляция новой версии модуля вызывает замену откомпилированного модуля на диске но не в оперативной памяти: там будет оставаться старая версия модуля, если она была загружена и еще не выгружена.
Отсюда следует, что нужно уметь выгружать модуль из памяти. К этому мы вернёмся ниже.
Здесь подробнее рассмотрим алгоритм загрузки модулей:
1) Чтобы загрузить модуль M, система сначала проверяет, нет ли его уже в оперативной памяти. Если он там есть, то загрузка на этом и заканчивается.
2) В противном случае нужно сначала обеспечить, чтобы были загружены все модули, указанные в инструкции IMPORT/ПОДКЛЮЧИТЬ, стоящей в начале модуля M. С этой целью для каждого модуля в списке импорта выполняется загрузка по этому же алгоритму (процедура загрузки не может зациклиться, так как циклический импорт в Обероне/Компонентном Паскале запрещён, и выполнение этого требования проверяется ещё компилятором).
В случае школьных программ из одного модуля все нужные модули чаще всего уже находятся в памяти, так что этот шаг сводится к проверке присутствия нужных модулей в памяти.
3) После того, как все модули из списка импорта M найдены/загружены в память, происходит собственно загрузка M.
Именно в этот момент выполняется т.наз. связывание или редактирование внешних связей модуля M (linking). После этого процедуры модуля M знают реальные адреса в памяти всех процедур из других модулей, к которым они обращаются, так что вызов этих процедур из M не требует никаких накладных расходов по сравнению со старой схемой, применяемой в фортране, С и т.д. и известной как статическое связывание (static linking) в отличие от только что описанного и применяемого в обероноподобных системах динамического связывания (dynamic linking).
Приведенный алгоритм загрузки активизируется при попытке вызвать процедуру из модуля M с помощью коммандера (как описывалось выше) или через меню Блэкбокса. Если такой вызов происходит из процедуры в уже загруженном модуле B, то M уже заведомо находится в памяти.
Выгрузка модулей
Выгрузить модуль из памяти означает, грубо говоря, стереть его из памяти так, чтобы место, которое он занимает, можно было использовать, например, для загрузки каких-то других модулей или для загрузки новой, усовершенствованной версии этого же модуля.
Как мы уже говорили, модуль остается в памяти после того, как закончено выполнение процедур, ради которых он был загружен. Но при разработке нового модуля нужно уметь вызывать новые версии этого модуля взамен старых, уже находящися в памяти. Для этого надо уметь выгружать модуль из памяти.
Простейший случай. Мы уже рассматривали простейший случай, когда с самого начала работают с единственным модулем, а процедуры из него выполняют с помощью коммандера. В этом случае тонкостей загрузки и выгрузки знать не надо, а достаточно просто при клике по коммандеру нажимать клавишу Ctrl это эквивалентно приказу системе выгрузить разрабатываемый модуль из памяти перед вызовом желаемой процедуры. Вот пример вызова некоторой процедуры из уже скомпилированного модуля (её смысл нам здесь не важен):
i21sysHello.Do
Если кликнуть по коммандеру, то в рабочем журнале будет что-то напечатано.
Если теперь кликнуть по коммандеру при нажатой клавише Ctrl, то в рабочем журнале сначала появится строка:
i21sysHello unloaded
или
i21sysHello выгружен
которая означает, что указанный модуль выгружен из памяти (попросту говоря, стёрт оттуда). А дальше в рабочем журнале будет повторено то же самое, что процедура напечатала в первый раз что и не удивительно, ведь мы её не меняли.
Типичное затруднение новичков при работе с Блэкбоксом: после компиляции новой версии модуля делается попытка вызвать новую версию процедуры, а вызывается старая.
Причина: старая версия модуля не была выгружена из памяти.
Неправильное решение: сохранить модуль, закрыть Блэкбокс, снова запустить Блэкбокс, запустить процедуру из новой версии модуля.
Правильное решение: прижать клавишу Ctrl и, не отпуская её, кликнуть по коммандеру. Это вызовет предварительную выгрузку из памяти вызываемого модуля.
Однако если в дело вовлечено два и более модулей, связанных отношениям экспорта-импорта, то ситуация сложнее.
Сложные случаи. Прежде всего нужно четко уяснить, что выгрузить можно только модуль, у которого нет клиентов в памяти. Напомним, что если модуль A импортирует модуль M, то A называется клиентом модуля M.
Если M находится в памяти, то вовсе не обязательно, что A тоже находится в памяти. Если A нет в памяти, то модуль M выгрузить можно. Но если A загружен в память, то выгрузить M нельзя предварительно нужно выгрузить модуль A.
В этом и заключается трудность, которую мы здесь обсуждаем.
Как проверить, какие модули находятся в памяти?
Для этого есть команда меню Инфо > Загруженные модули.
По этой команде открывается окошко, в котором дан список всех модулей в памяти, причем в третьей колонке указано количество находящихся в памяти клиентов данного модуля.
В этот момент можно выгружать только те модули, у которых в третьей колонке стоит 0.
Закрыть окошко (как и все окошки в Блэкбоксе) можно обычным способом нажав на клавиатуре комбинацию двух клавиш Ctrl+F4.
Выгрузить группу модулей, связанных отношениями экспорта-импорта, можно несколькими способами. Один из самых удобных и простых для объяснения состоит в следующем.
Пусть мы работаем с двумя модулями M и A, причем A является клиентом M (т.е. список импорта в A содержит M).
Например, M содержит процедуру сортировки, а модуль A содержит для нее тесты.
Пусть мы выполняли тесты, так что оба модуля находятся в памяти.
Предположим, что других клиентов у M в памяти нет.
Далее пусть мы обнаружили ошибку в M, исправили ее в исходном тексте модуля и скомпилировали модуль.
Чтобы выполнить новую версию, нужно выгрузить сначала A, потом M.
Простейший способ сделать это состоит в том, чтобы в любом документе Блэкбокса (можно в новом, а можно в том же, где хранится текст модуля A, после точки, закрывающей текст модуля) поставить следующую конструкцию:
DevDebug.UnloadThis A M
Здесь между двумя коммандерами стоят: полное имя некой специальной процедуры Блэкбокса, а затем через пробелы имена тех модулей, которые мы хотим выгрузить, в правильном порядке. То есть если A импортирует M (M появляется в списке импорта A), то A стоит сначала.
Правый коммандер играет просто роль ограничителя указывает конец списка выгружаемых модулей.
Клик мышкой по левому коммандеру вызовет выгрузку сначала A, потом M.
Следует внимательно просмотреть сообщения в рабочем журнале после выполнения выгрузки, чтобы удостовериться в успешном её выполнении.
Если работают более чем с двумя модулями и нужно их все выгрузить, то имена всех модулей следует вставить, разделяя пробелами, там же, где стоят A и M.
Важно только соблюдать порядок: если A клиент модуля M, то A должен стоять левее, чем M. В остальном порядок произволен.
Обратим внимание еще на следующее.
В ситуациях, подобных описанной (модуль сортировки M и модуль с тестами A), после перекомпиляции M обычно нет нужды заново компилировать модуль-клиент A, если в нем ничего не менялось. Но если изменились оба модуля, то компилировать их нужно точно в обратном порядке по сравнению с выгрузкой: сначала M, потом его модуль-клиент A.
Вот полезная конструкция, аналогичная приведенной для выгрузки, которая позволяет одним кликом мышки перекомпилировать пару модулей:
DevCompiler.CompileThis M A
Устроена она точно так же, но имена модулей стоят в обратном порядке.
Нужно только помнить, что процедура DevCompiler.CompileThis сумеет найти тексты модулей только в том случае, если они хранятся на диске в соответствии с правилами, принятыми в Блэкбоксе (см. здесь).
Как вызывать процедуры с параметрами
Во-первых, можно делать дополнительную интерфейсную процедуру без параметров, в которую зашиты фактические параметры для тех процедур, которые мы хотим выполнять. Например, можно включить такую процедуру в отдельный модуль, назовем его T.
Такой отдельный модуль будет компилироваться очень быстро.
Нужно только не забывать нажимать Ctrl при вызове процедур из T с помощью коммандера после изменения данных в T и его перекомпиляции (основной модуль ни перекомпилировать, ни выгружать не нужно разумеется, если там не нужно исправлять ошибки).
Фактически модуль здесь играет роль диалоговой формы, в которую впечатываются значения параметров. Это возможно только благодаря быстроте компилятора и возможности динамической (пере)загрузки модулей.
Во-вторых, некоторые возможности для вызова процедур с параметрами дают коммандеры. Коммандеры по замыслу вспомогательное средство при разработке программ. Поэтому возможности вызова процедур с параметрами с помощью коммандера ограничены.
С помощью коммандера можно вызывать процедуры, у которых:
нет возвращаемого значения;
всего не более четырех параметров, из них
не более двух параметров типа ARRAY OF CHAR, передаваемых по значению или определенных с атрибутом IN, а также
не более двух параметров типа INTEGER;
причем параметры типа ARRAY OF CHAR должны идти до параметров типа INTEGER.
Все возможные комбинации параметров явно перечислены в документации к модулю StdInterpreter (двойной клик по имени модуля, правый клик, Документация).
В этом случае достаточно после коммандера в кавычках поставить вызов нужной процедуры с параметрами в скобках точно в таком виде, как в программе на Компонентном Паскале:
"StdLog.String('эта цепочка литер напечатается в рабочем журнале')"
Пример возможных проблем. В случае клика по следующему коммандеру:
"StdLog.Int(123)"
в рабочем журнале вместо целого числа 123 будет напечатано сообщение об ошибке.
Причина: процедура StdLog.Int требует параметра типа LONGINТ, а коммандеры "умеют" вызывать только процедуры с параметрами типа INTEGER.
В тексте программы такая команда допустима, так как компилятор "умеет" обеспечивать вызовы любых процедур, допустимых в языке.
Третий и самый гибкий способ передать данные в программу непосредственно из текста, например, после коммандера основан на использовании средств модуля In (или i21sysIn).
По этому поводу см. здесь, а также документациюкмодулюi21sysIn.
________________
[email protected]
последние уточнения: 2012-10-22 | i21sys/Docu.Полезные сведения/О процедурах и модулях.odc |
О рабочих папках и серверном режиме
Что такое серверный режим
Как включать серверный режим
Как подготовить файл-пускач
Автоматическая подготовка
Подготовка вручную
Что приятно в серверном режиме
Главная (основная) папка Блэкбокса это та папка, где лежит BlackBox.exe. Это может быть папка на сетевом диске, открытая только для чтения.
Рабочая папка любая папка вне главной, куда пользователь имеет право записывать файлы. Разные рабочие папки назначают разным проектам или учащимся. Обычно рабочую папку нужно подготовить для запуска Блэкбокса в особом серверном режиме.
Что такое серверный режим
Это когда создается иллюзия, что рабочая папка и есть главная, и все новые файлы записываются в рабочую папку.
Дело в том, что Блэкбокс все свои штатные операции выполняет, оперируя относительными путями (когда компилирует модули, ищет исходники, документацию и т.п.).
Но при простом запуске (двойным кликом по BlackBox.exe) эти относительные пути отсчитываются от главной папки, а при запуске в серверном режиме от рабочей.
При этом все файлы записываются только в рабочей папке по штатным правилам Блэкбокса (с соответствующими относительными путями), а читаться они могут и из главной папки, если в рабочей папке нужного файла нет.
То есть любой файл в рабочей папке как бы заслоняет собой файл в главной папке с таким же относительным путем, но незаслонённые файлы из главной папки как будто лежат прямо в рабочей.
В частности, в рабочей папке можно менять, перекомпилировать и перезагружать штатные модули Блэкбокса (скажем, DevCompiler). При этом создается иллюзия, что работа идет в главной папке, в которой эти файлы заменены. Но на самом деле главная папка остается нетронутой.
Таким способом нельзя подменить только BlackBox.exe и скомпилированные модули, в него скомпонованные: Kernel, Files, HostFiles, StdLoader.
Осторожно! Если файл извне рабочей папки открыт в Блэкбоксе с помощью Ctrl+O или перетаскиванием мышью из окна файлового менеджера на окно Блэкбокса, то штатные правила Блэкбокса неприменимы, и Блэкбокс оперирует с таким файлом, используя его абсолютный адрес в системе. И все изменения тоже будут сохраняться по этому абсолютному адресу. Поэтому не стоит так открывать, например, исходники штатных модулей из главной папки Блэкбокса. Хотя бинарники, создаваемые компилятором, будут в любом случае сохраняться в рабочей папке по штатным правилам.
Прелесть тут в том, что разные активации Блэкбокса в разных рабочих папках ничего друг о друге не знают и даже не знают, где на самом деле находится главная папка, если не используют внештатные средства (то есть прямые обращения к операционной системе).
Как включать серверный режим
В конечном счете для запуска в серверном режиме нужно задать некоторые параметры командной строки при запуске Блэкбокса. Это можно сделать разными способами используя подготовленный ярлык, разные файлы-пускачи (сценарии/скрипты) и т.п.
Недостаток ярлыка для каждой рабочей папки (т.е. для каждого учащегося!) нужно настраивать отдельную копию ярлыка. Поэтому ниже этот вариант не обсуждается (в главной папке Блэкбокса на всякий случай есть пример такого ярлыка BlackBox.lnk).
Опыт показал, что проще всего использовать специальный файл-пускач текстовый файл с расширением .vbs. Такой файл достаточно подготовить один раз для данной инсталляции Блэкбокса, а затем просто копировать в любую рабочую папку, запуская
в ней Блэкбокс двойным кликом по этой копии.
В хороших файловых менеджерах можно обойтись вообще без копирования пускача. Например, в программах-клонах легендарного Norton Commander'а достаточно поставить в меню Start вызов единственного файла-пускача, остающегося лежать в главной папке.
Как подготовить файл-пускач
Это текстовый файл с расширением vbs, подготовить который можно в Блокноте (Notepad). Он должен содержать такой текст:
Option Explicit
Dim prg
'-----------------------------------------------
prg = """C:\BlackBox\BlackBox.exe"""
'-----------------------------------------------
Dim sh
Set sh = WScript.CreateObject("WScript.Shell")
sh.Run prg & " " & "/use """ & sh.CurrentDirectory & """", 1, false
С одиночной кавычки начинаются строки комментариев.
Настраивать нужно строку prg = ..., прописывая там полный путь к BlackBox.exe, но не трогая три двойных кавычки слева и справа (благодаря им в именах папок можно использовать пробелы).
Автоматическая подготовка
Чтобы создать пускач для конкретной инсталляции Блэкбокса, в комплектах Блэкбокса от проекта Информатика-21 предусмотрена специальная команда меню (Help -> Create vbs или Справка -> Создать файл-пускач).
Команда создаёт файл с расширением .vbs в главной папке Блэкбокса.
Этот файл правильно настроен для данной инсталляции и обычно имеет имя StartupBlackBox.vbs или пускач Блэкбокса.vbs
Чтобы команда сработала, Блэкбокс должен быть запущен в главной папке (двойным кликом по BlackBox.exe).
После создания файла лучше переименовать его, чтобы различать пускачи для запуска разных инсталляций Блэкбокса.
См. также документацию.
Подготовка вручную
Вручную приходится готовить файл в том случае, когда главная и рабочие папки находятся на разных компьютерах в локальной сети. Тогда в пускаче, предназначенном для копирования в рабочую папку, в параметре prg нужно прописать полный сетевой путь к файлу BlackBox.exe так, как он виден из данной рабочей папки.
Что приятно в серверном режиме
Можно иметь СКОЛЬКО УГОДНО рабочих папок ГДЕ УГОДНО на одном компе, достаточно в каждую скопировать подготовленный пускач.
Можно ОДНОВРЕМЕННО запустить в разных рабочих папках разные активации одной и той же инсталляции Блэкбокса -- они в нормальном режиме работы друг о друге не узнают и мешать друг другу не будут.
Можно в одной рабочей папке запускать РАЗНЫЕ ИНСТАЛЛЯЦИИ Блэкбокса (на одном компе таких инсталляций может быть сколько угодно; например, оригинальная инсталляция версии 1.5, ее школьный вариант с модифицированным инструментарием, новая бета-версия 1.6 и т.п.).
Можно ПЕРЕМЕСТИТЬ рабочие папки в любое другое место на компе -- файл-пускач будет продолжать правильно работать, пока не изменится местоположение файла BlackBox.exe на данном компе.
Можно ПЕРЕНОСИТЬ свою рабочую папку на флэшке целиком с компа на комп (из класса/офиса домой и обратно) для этого достаточно иметь в этой рабочей папке по одному файлу-пускачу для каждого компа и на каждом компе вызывать Блэкбокс соответствующим пускачом.
В учебных комплектах могут быть дополнительные инструменты для организации компьютерных классов.
________________
[email protected]
последние изменения: 2010-10-23 | i21sys/Docu.Полезные сведения/О рабочих папках и серверном режиме.odc |
О складках (folds)
текст пока не написан | i21sys/Docu.Полезные сведения/О складках.odc |
О постановке точки с запятой в Компонентном Паскале
По сравнению со старым Паскалем, в Компонентном Паскале правила постановки точки с запятой немного упрощены. Теперь в конце любого оператора можно ставить точку с запятой независимо от того, стоит ли за этим ключевое слово вроде END.
Пример:
PROCEDURE Сорт* ( VAR a: ARRAY OF INTEGER );
VAR i: INTEGER;
BEGIN
FOR i := 1 TO LEN(a) - 1 DO
Вставить( );
END;
END Сорт;
Это удобно, так как часто приходится переносить вперёд-назад строки программы целиком, и удобней, чтобы синтаксическая корректность, например, вышеприведённого цикла не зависела от того, что именно стоит после него.
Формально говоря, эта возможность обеспечена тем, что правила Компонентного Паскаля допускают пустые операторы, и считается, что между ; и END стоит такой пустой оператор, так что программа сохраняет корректность.
По этой же причине в исполняемом теле процедуры может идти подряд несколько ;;; (и тогда считается, что между каждой парой ;; находится пустой оператор). Но в разделе объявлений это не допускается, т.к. там никаких операторов быть не может, в том числе и пустых.
________________
[email protected]
последние изменения: 2010-10-23; 2012-12-04 | i21sys/Docu.Полезные сведения/О точке с запятой.odc |
Об использовании цвета в программах на Обероне/Компонентном Паскале
Чтобы "раскрасить" фрагмент текста достаточно выделить его мышкой и затем применить одну из команд меню Атрибуты (здесь имеются в виду атрибуты текста). Стандартным способом, описанным в документации Блэкбокса, можно добавить другие команды в это меню для новых цветов.
Цвет очень мощное средство визуальной разметки текста, очень хорошо сочетающееся с методом пошаговой детализации.
Дизайн Оберона/Компонентного Паскаля позволяте использовать его с существенно большей пользой, чем в других языках программирования, в том числе старом Паскале.
В других системах программирования цветом нередко выделяют ключевые слова. После этого уже невозможно использовать цвет для других целей. В Компонентном Паскале, различающем большие и малые буквы, ключевые слова пишутся только заглавными буквами, так что они и так очень четко выделены.
Поэтому не следует пытаться раскрашивать ключевые слова по образцу других систем программирования там это вынужденная мера, а в Компонентном Паскале это не только бессмысленно, но и вредно, т.к. теряется возможность использовать цвет с настоящей пользой.
(Как минимум двое профессиональных программистов, начинавших работать на Блэкбоксе, по инерции сделали себе средства подсвечивания синтаксиса и быстро от них отказались. Кстати, ломание копий вокруг подсветки синтаксиса у новичков в Блэкбоксе прекрасный пример того, насколько живучи бывают привычки, даже когда они потеряли всякий смысл.)
Поскольку компилятор игнорирует цвет (как и другие атрибуты текста подчеркивание и т.д.), его можно с гораздо большей пользой применить для выделения мета-структуры программы:
Например, цветами можно выделять вновь добавляемые и еще не проверенные части программы. В примерах мы использовали красный цвет для окраски временного фрагмента-"затычки", который был нужен для промежуточной компиляции программы, но требовавший замены в окончательной версии. Красный цвет позволяет легко найти все такие фрагменты.
Можно специальными цветами выделять комментарии, а также программные фрагменты, временно вводимые для целей отладки, и так далее.
Однако нужно соблюдать известную осторожность, чтобы текст не становился слишком пестрым: это только затруднит работу с программой.
Кроме того, многие люди жалуются на чрезмерное зрительное напряжение при чтении текстов, содержащих фрагменты, раскрашенные чистыми цветами. Именно такие цвета использует "голый" Блэкбокс без модификаций. Поэтому в комплекте, предлагаемом в проекте Информатика-21, команды меню для раскрашивания текста оперируют не чистыми цветами. Модифицируя меню, нетрудно подправить эти цвета под любой вкус, а также добавить новые.
Практический совет. Если нужно покрасить в какой-то цвет несколько фрагментов в одном или разных текстах, то можно поступить так. Сначала один фрагмент окрашивается в нужный цвет обычным порядком через меню. Чтобы окрасить второй фрагмент в тот же цвет, нужно сначала сделать так, чтобы оба фрагмента были видны пусть и в разных окнах или даже в разных документах (второе окно на тот же документ можно открыть командой меню Окна > Новое окно). После этого второй фрагмент нужно выделить мышкой, а затем, нажимая Alt, "бросить" его мышкой на уже окрашенный фрагмент. В результате второй фрагмент приобретает все текстовые атрибуты первого (в том числе и цвет).
________________
[email protected]
последние изменения: 2010-10-23 | i21sys/Docu.Полезные сведения/О цвете.odc |
О цикле Дейкстры
Из книги Н.Вирт. Алгоритмыиструктурыданных. ДМКПресс, 2010
Приложение C. Цикл Дейкстры
Дейкстра [C.1] (см. также [C.2]) ввел многоветочный вариант цикла WHILE, обосновав его в своей теории систематического вывода императивных программ. Этот цикл оказывается удобным для выражения и, главное, верификации алгоритмов, обычно записываемых через вложенные циклы, позволяя резко снизить усилия по отладке.
В версии языка Оберон, известной как Оберон-07 и представленной в [C.3], синтаксис этого цикла определяется следующим правилом:
WhileStatement
= WHILE логическое выражение DO
последовательность операторов
{ELSIF логическое выражение DO
последовательность операторов}
END.
Если вычисление любого из логических выражений (охран) дает TRUE, то выполняется соответствующая последовательность операторов. Вычисление охран и выполнение соответствующих последовательностей повторяется до тех пор, пока все охраны не будут давать FALSE. Таким образом, постусловием для этого цикла является конъюнкция отрицаний всех охран.
Пример:
WHILE m > n DO m := m - n
ELSIF n > m DO n := n - m
END
Постусловие: ~(m > n) & ~(n > m), что эквивалентно n = m.
Инвариант цикла должен выполняться в начале и в конце каждой ветви.
Грубо говоря, обычно n-веточный цикл Дейкстры соответствует конструкциям из n обычных циклов, каким-то образом вложенных друг в друга.
Удобство цикла Дейкстры обусловлено тем, что вся логика сколь угодно сложного цикла выводится на один уровень и радикально проясняется, причём алгоритмы с разными случаями запутанных циклов трактуются совершенно единообразно.
Эффективный способ построения такого цикла состоит в том, чтобы перечислять все возможные ситуации, которые могут возникнуть, описывая их соответствующими охранами, и для каждой из них независимо от остальных строить операции, обеспечивающие продвижение по данным, вместе с операциями, обеспечивающими восстановление инварианта. Перечисление ситуаций заканчивается, когда дизъюнкция (или) всех охран покроет предполагаемое предусловие цикла. При этом задача корректного построения цикла облегчается, если отложить беспокойство о порядке вычисления охран и выполнения ветвей, экономии операций при вычислении охран и т.п. до тех пор, пока цикл не будет корректно построен. Такие мелкие оптимизации редко по-настоящему важны, а их реализация сильно облегчается, когда корректность сложного цикла уже обеспечена.
Хотя в теории Дейкстры последовательность выбора ветвей цикла и вычисления соответствующих охран не определена, в этой книжке принято, что охраны вычисляются в текстуальном порядке.
Во многих языках программирования цикл Дейкстры приходится моделировать. Встарых версиях Оберона, включая Компонентный Паскаль, достаточно использовать цикл LOOP, тело которого состоит из многоветочного условного оператора с оператором выхода в ветке ELSE:
LOOP IF логическое выражение THEN
последовательность операторов
{ELSIF логическое выражение THEN
последовательность операторов}
ELSE EXIT END END.
В других языках конструкция может быть более громоздкой, но это с лихвой окупается упрощением построения и отладки сложных циклов.
Полезность цикла Дейкстры при построении алгоритмов можно видеть из раздела 1.9 об алгоритмах поиска в тексте; см. ссылку в начале документа. Вот прямые ссылки на исходники соответствующих примеров: ADruS191_Простой, ADruS192_KMP, ADruS193_БМ.
Более сложный пример шестиветочного цикла Дейкстры, корректно заработавшего безо всякой отладки, процедура ConvertText в модуле i21sysVocabulary.
Литература
[C.1] E.W.Dijkstra. A Discipline of Programming. Prentice-Hall, 1976. (Имеется перевод: Дейкстра Э. Дисциплина программирования. М: Мир, 1978.)
[C.2] D.Gries. The Science of Programming. Springer-Verlag, 1981. (Имеется перевод: Д.Грис. Наука программирования. М: Мир, 1984.).
[C.3] N.Wirth. The Programming Language Oberon. Revision 1.9.2007.
| i21sys/Docu.Полезные сведения/О цикле Дейкстры.odc |
Об использовании клавиши F5
В Компонентном Паскале постоянно возникает необходимость печатать ключевые слова, состоящие только из заглавных букв.
Кроме того, очень удобно иметь возможность сразу получать скелет сложных синтаксических конструкций типа IF .. THEN .. ELSE .. END и т.п.
Обе эти возможности добавлены в виде команд, которые вызываются либо при нажатии клавиш F5 или Shift+F5, либо, соответственно, через меню: Text -> Capitalize and expand (Текст > Заглавные и раскрыть) или Text -> Capitalize (Текст > Заглавные).
Например, предположим, что при написании какой-то процедуры нужно написать условный оператор. Наберем в соответствующем месте тела процедуры слово if маленькими буквами:
PROCEDURE Do ( n: INTEGER );
VAR
BEGIN
if
END Do;
и сразу после этого (пока курсор стоит сразу после if) нажмем F5. Получим:
PROCEDURE Do ( n: INTEGER );
VAR
BEGIN
IF THEN
ELSE
END;
END Do;
Заметим, что при этом сохранена структура отступов, что важно и удобно. Правильное число отступов вставлено и в пустые строки.
Важно: правильная структура отступов будет возникать только в том случае, если в той строке, где стояло if, отступы были сделаны с помощью табуляций, а не пробелов!
Если нажать Shift+F5, то if превратится в IF без раскрытия в целую конструкцию.
По команде F5 (Shift+F5) превращение претерпевает цепочка малых букв и цифр, непосредственно предшествующая курсору.
Можно также выделить отрезок текста и вызвать команду. Тогда команда применяется к выделенному тексту.
Если слово из малых букв не соответствует никакому начальному ключевому слову, то просто слово из малых букв превращается в слово из больших.
В некоторых случаях происходит дополнительное форматирование: например, return превращается в RETURN, т.к. выполнение этого оператора прерывает поток управления по сравнению с текстуальным порядком, и это полезно отмечать.
Если включена поддержка ключевых слов на национальном языке (см. документацию к модулю i21sysVocabulary), то F5 автоматически будет работать правильно и на национальном языке.
Нетрудно изменить действие этой команды под свой стиль и вкус. Об этом в следующем разделе.
Как это устроено и где это менять
Оригинальная дистрибуция Блэкбокса содержит в подсистеме Obx пример превращения маленьких букв в большие.
Процедуры, выполняющие команды, вызываемые по F5 и т.д., написаны на Компонентном Паскале с использованием библиотек Блэкбокса и находятся в модуле i21sysEdit.
Нажатием F5 вызывается процедура CapitalizeExpand, а нажатием Shift+F5 вызывается процедура Capitalize.
Списки ключевых слов и алгоритмы, раскрывающие синтаксические конструкции, можно модифицировать под свои нужды.
При этом можно добавлять литерные цепочки и отсутствующие в Компонентном Паскале (например, h128 -> HALT(128) и т.п.).
Можно начать с изучения документа i21sys/Rsrc/simples и аналогичного документа для национального языка, например, для русского языка i21sys/Rsrc/ru/simples. Управление угадыванием раскрываемых слов по первым буквам осуществляется с помощью списков keywords и hints в тех же папках. Там же содержатся необходимые пояснения.
Чтобы посмотреть, как процедуры Capitalize и CapitalizeExpand подцеплены в меню и посажены на функциональные клавиши, достаточно открыть документ с описанием меню для подсистемы Text (это обычный документ в стандартном формате Блэкбокса).
Он находится по адресу Text/Rsrc/Menus (данная гиперссылка открывает его только для чтения, на всякий случай).
Чтобы добавить новые команды, работающие с текстом, достаточно скопировать в нужное место меню, скажем, строчку для команды Заглавные и модифицировать ее нужным образом.
Исправленное меню активизируется командой Инфо > Обновить меню (Info > Update Menus) перезапускать Блэкбокс для этого не нужно.
Нужно не забыть сохранить документ (Ctrl+S), чтобы исправленные меню автоматически активизировались при следующих запусках Блэкбокса.
________________
[email protected]
последние изменения: 2012-10-06 | i21sys/Docu.Полезные сведения/Об F5.odc |
Полезные сведения о работе в системе Блэкбокс
Кусочки текста, выделенные синим цветом с подчеркиванием, работают как обычные гиперссылки на страничках в Сети: клик мышкой открывает соответствующий документ в отдельном окошке.
Опроцедурахимодулях (как вызывать процедуры и почему нет главных процедур)
Оподсистемах (правила хранения модулей)
Окомпиляции
Окомментариях
Оточкесзапятой
ОбиспользованииклавишиF5дляпечатиключевыхсловиззаглавныхбукв
Вводданныхспомощьюсредствмодуля(i21sys)In
Обиспользованиицветавпрограммах
Опорядкепроцедур
Оскладках
При первоначальном знакомстве с Блэкбоксом рекомендуется прочесть примеры в учебных сборках Блэкбокса.
См. также
Орабочихпапкахисерверномрежиме
Обзорподсистемыi21sys
Тексткакинтерфейс
ОциклеДейкстры
_______________
[email protected]
2010-09-26 | i21sys/Docu.Полезные сведения/Полезные сведения.odc |
Текст как интерфейс
Текст как интерфейс, документо-ориентированный подход и т.п. приблизительные описания подхода к организации взаимодействия человека и компьютера, существенные аспекты которого были реализованы в Системе Оберон Н.Виртом и Ю.Гуткнехтом во второй половине 1980-х гг. Там был полноценно воплощен целый ряд идей, позволяющих заметно повысить эффективность взаимодействия человека с компьютером по сравнению с более архаичными подходами, несущими печать времён пакетной обработки (см. статью Михаэля Франца в сборнике The School of Niklaus Wirth. The Art of Simplicity, ed. L.Boszormenyi, dpunkt.verlag, 2000). Ряд идей из числа реализованных еще тогда в Системе Оберон вошли в мейнстрим (ср. распространённость гипертекстовых документов). Другие еще ждут своего часа.
Большой класс задач требует, чтобы человек, работающий за компьютером, мог проинспектировать данные (либо приготовляемые в качестве входных, либо получаемые как результат работы каких-то процедур) и принять решение о дальнейших действиях, причем после инспекции данные могут тут же подвергаться дальнейшей обработке то есть служить входными данными для других процедур.
Хорошо знакомый пример собственно работа с текстом (многократные замены и т.п.). Но, как это часто и бывает, этот пример слишком привычен, чтобы задуматься, и слишком специфичен, чтобы увидеть за ним универсальную схему.
Однако обработка последовательностей чисел (и не только) постоянный элемент в исследовательской работе прикладников (ср. всякого рода статистические задачи в физике, химии, эконометрике и т.п.).
Работа с данными здесь характеризуется высокой интерактивностью.
Файловый ввод-вывод в таких ситуациях (как и при редактировании текстов, а также, например, в начале курса программирования для юных начинающих) инструмент слишком громоздкий.
Наиболее удобно в таких ситуациях построить взаимодействие человека и компьютера по схеме текст как интерфейс.
Действительно, сами текстовые документы, находящиеся, что называется, перед глазами, могут служить источниками и приемниками данных.
Пусть, например, фрагмент текста содержит массив чисел, подлежащих обработке.
Тогда его можно посредством вызова команды меню или нажатия горячих клавиш назначить на роль потока ввода, который и служит источником входных данных вызываемой вслед за этим процедуре. Заметим, что, например, команды Блэкбокса скомпилировать или открыть исходник модуля, имя которого выделено в тексте, следуют той же общей схеме: входными данными здесь являются выделенные литеры, составляющие имя нужного модуля.
Точно так же можно было бы назначить точку в другом тексте (обычно открытом в другом окне), в качестве приемника результатов очередной вызываемой процедуры, причём результаты выводятся тоже в виде понятного человеку текста.
Впрочем, на практике появляется некоторое неравноправие между вводом и выводом: вывод данных сразу в точку конечного назначения не всегда удобен, так как с первой попытки желаемые результаты могут не получиться или, скажем, требовать правки вручную. Поэтому часто удобно просто выводить данные в конец Рабочего журнала, где их можно проинспектировать, поправить, а затем переместить в нужный документ.
Обратим внимание ещё вот на что. Зашивать формат результатов в программу, их вычисляющую (что было когда-то неизбежным), часто неудобно: заранее, ещё не видя результатов, не всегда легко принять необходимые решения, да и настраивать формат косвенно, через программный код, противоестественно по сравнению с непосредственной манипуляцией. Здесьтоже человеческому интеллекту удобно вклиниться в процесс обработки. Вподобных случаях достаточно типично при выводе просто разделять выводимые числа символами табуляции, а затем дооформить полученный фрагмент текста вручную, например подобрав подходящие позиции выравнивания чисел (в документах Блэкбокса это легко делать, вставляя в документ специальные объекты-линейки; см.документацию).
Наконец, понятно, что в такой схеме, ориентированной на вмешательство человека в процесс обработки, чтение потока ввода и вывод сформатированных результатов должны осуществляться с помощью естественного набора процедур высокого уровня, избавляющих от необходимости подсчитывать литеры, преобразовывать числа и т.п. (Разумеется, для неучебных ситуаций остается возможность управлять форматом ввода и вывода.)
Подробнее об организации ввода из текстовых документов в Блэкбоксе можно узнать здесь.
О выводе в Рабочий журнал см. документацию к модулю StdLog.
Для учебных целей могут иметься упрощенные варианты этих модулей.
________________
[email protected]
2010-09-28 | i21sys/Docu.Полезные сведения/Текст как интерфейс.odc |
Вызов DLL из Блэкбокса
Приводимые ниже примеры используют некоторые из DLL, описанных в документе СозданиеDLLвБлэкбоксе. Если упоминаемых ниже DLL нет в папке Блэкбокса, нужно выполнить действия, описанные в указанном документе..
Для компиляции любого модуля Блэкбокса в нижеследующем тексте нужно выделить текст модуля (или просто ключевого слова MODULE, например, двойным кликом) и выполнить команду меню Dev, Compile Selection.
Как обычно с DLL, сначала для каждой функции, которую требуется вызывать, нужно выяснить:
ее сигнатуру;
используемые ею соглашения о передаче параметров (stdcall или ccall);
ее точное имя или порядковый номер в DLL (имя в списке экспорта DLL может отличаться от имени в соответствующем исходнике).
Последнее делается с помощью такого инструмента, как DependencyWalker.
В общем случае есть два способа загрузить DLL для использования любой программой: статически и динамически.
Статическая загрузка обсуждается в документации Блэкбокса (см. Особенностиплатформы).
Мы только отметим, что наши тесты показывают, что в отличие от сказанного в Особенностиплатформы можно указывать полный путь для DLL в заголовке интерфейсного модуля.
Например, если anyname.dll еще не находится в папке Блэкбокса, создадим ее, следуя инструкциям в Примере 0 документа СозданиеDLLвБлэкбоксе, из модуля Epse21Dll0. Затем скопируем ее, например, в папку c:\!\. Затем по очереди скомпилируем следующие два модуля:
MODULE Epse21Dll0Interface ["c:\!\anyname.dll"];
PROCEDURE Add* ( a, b: INTEGER ): INTEGER;
END Epse21Dll0Interface.
MODULE Epse21Dll0Test;
IMPORT StdLog, Dll := Epse21Dll0Interface;
PROCEDURE Do*;
VAR a, b: INTEGER;
BEGIN
a := 1;
FOR b := 0 TO 1000 DO
a := Dll.Add( a, b )
END;
StdLog.Int( a ); StdLog.Ln
END Do;
END Epse21Dll0Test.
Теперь вызовем Epse21Dll0Test.Do и убедимся, что пример работает.
NB Если после выполнения теста сделаны изменения в DLL, нужно будет перезапустить Блэкбокс, чтобы провести тест с новой версией DLL. Это единственый способ выгрузить старые версии DLL, если они были загружены статически. Эта проблема обходится динамической загрузкой.
Динамическая загрузка DLL
Прежде всего, Блэкбокс разрешает только использование соглашений stdcall для динамически загружаемых DLL (на момент написания данного текста, т.е. в марте 2004). Поэтому может понадобиться перекомпилировать DLL с соответствующими опциями компилятора.
Если исходники недоступны, а DLL использует соглашения ccall, то возможна только статическая загрузка.
Динамическая загрузка имеет следующие преимущества:
1) DLL может находиться где угодно;
2) DLL может быть выгружена без выхода из Блэкбокск с DLL можно экспериментировать;
3) имена загружаемых DLL и выполняемых процедур могут быть определены во время выполнения.
Предположим, что была создана anyname.dll, как описано в примере 0 в СозданиеDLLвБлэкбоксе, и скопирована, скажем, в папку c:\!\. Напомним, что anyname.dll содержит функцию со следующей сигнатурой:
PROCEDURE Add (a, b: INTEGER): INTEGER;.
Следующий модуль показывает, что нужно сделать, чтобы загрузить эту DLL, вызвать Add, а затем выгрузить DLL:
MODULE Epse21DllDyn0;
IMPORT SYSTEM, WinApi, Log := StdLog;
TYPE ProcType = PROCEDURE ( a, b: INTEGER ): INTEGER;
PROCEDURE Do*;
VAR
dll: WinApi.HINSTANCE;
MyProc: ProcType;
a, b, c, res: INTEGER;
BEGIN
(* загрузка DLL: *)
dll := WinApi.LoadLibrary( "anyname.dll" );
ASSERT( dll # 0, 100 );
(* получение доступа к нужной функции: *)
MyProc := SYSTEM.VAL( ProcType, WinApi.GetProcAddress( dll, "Add" ) );
(* работа с функцией: *)
a := 1; b := 3;
c := MyProc( a, b );
Log.Int( a ); Log.Int( b ); Log.Int( c ); Log.Ln;
(* выгрузка DLL: *)
res := WinApi.FreeLibrary( dll )
END Do;
END Epse21DllDyn0.
Epse21DllDyn0.Do
NB Поскольку полный путь к DLL не указан в инструкции загрузки, ОС ищет DLL по правилам, описанным в документе Особенности платформа.
В команде загрузки путь можно указать следующим образом:
dll := WinApi.LoadLibrary( "c:\!\anyname.dll" );
Указание процедур посредством их порядковых номеров
MODULE Epse21DllDyn1;
IMPORT SYSTEM, WinApi, Log := StdLog;
TYPE ProcType = PROCEDURE ( a, b: INTEGER ): INTEGER;
PROCEDURE Do*;
VAR
dll: WinApi.HINSTANCE;
ord: INTEGER;
MyProc: ProcType;
a, b, c, res: INTEGER;
BEGIN
(* загрузка DLL: *)
dll := WinApi.LoadLibrary( "anyname.dll" );
ASSERT( dll # 0, 100 );
(* получение доступа к нужной функции: *)
ord := 1; (* the required procedure's ordinal *)
MyProc := SYSTEM.VAL( ProcType, WinApi.GetProcAddress( dll, SYSTEM.VAL( WinApi.PtrSTR, ord ) ) );
(* работа с функцией: *)
a := 1; b := 3;
c := MyProc( a, b );
Log.Int( a ); Log.Int( b ); Log.Int( c ); Log.Ln;
(* выгрузка DLL: *)
res := WinApi.FreeLibrary( dll )
END Do;
END Epse21DllDyn1.
Epse21DllDyn1.Do
Для c должна быть напечатана сумма a и b, т.к. процедура с номером 1 это Add.
| i21sys/Docu.Работа с DLL/calling-from-BB.odc |
Вызов DLL из C++
Microsoft Visual C++ 6.0
Напомним, что DLL можно загружать статически и динамически. Мы рассмотрим только динамическую загрузку.
Есть два способа импортировать функцию из DLL: (1) по имени; (2) по порядковому номеру в DLL.
Подобно процедуре, описанному в документе ВызовDLLизБлэкбокса, нужно выполнить следующие шаги:
Загрузить DLL с помощью функции Windows API, называющейся LoadLibrary().
Вызвать GetProcAddress() для получения указателя на функцию, которую нужно вызвать.
Когда DLL больше не нужна, выгрузить ее с помощью FreeLibrary().
Чтобы вызвать вышеуказанные функции Windows API functions, нужно вставить следующие директивы в начале программы:
#include <windows.h>
Пример, которыей использует anyname.dll, созданную в первом примере в СозданиеDLLвБлэкбоксе, может быть таким:
#include <iostream.h>
#include <windows.h>
int ( __stdcall *Add ) ( int, int );
void main( void )
{
int a = 1, b = 3, c;
// Get a handle to the DLL module:
HINSTANCE dllInstance = LoadLibrary( "c:\!\anyname.dll" );
cout << endl << "dllInstance = " << long( dllInstance ) << endl << endl;
// If the handle is valid, try to get the function address:
if ( dllInstance != NULL )
{
Add = ( int ( __stdcall* ) ( int, int ) )GetProcAddress( dllInstance, "Add" );
// If the function address is valid, call the function:
if (Add != NULL)
c = ( *Add )( a, b );
else
cout << "Error 1 : Add = NULL" << endl;
// Free the DLL module.
fFreeResult = FreeLibrary( dllInstance );
}
else
cout << "Error 0 : the DLL file is not loaded " << endl;
cout << "a = " << a << endl
<< "b = " << b << endl
<< "a + b = " << c << endl;
} // End main();
//==============================================
| i21sys/Docu.Работа с DLL/calling-from-C++.odc |
Создание DLL в Блэкбоксе
Для компиляции любого модуля Блэкбокса в нижеследующем тексте нужно выделить текст модуля (или просто ключевого слова MODULE, например, двойным кликом) и выполнить команду меню Dev, Compile Selection.
Здесь главный источник информации документациядлямодуляDevLinker.
Инструкции, приводимые ниже, содержат некоторое избыточное количество деталей в расчете на неопытных пользователей Блэкбокса.
NB По умолчанию Блэкбокс использует для передачи параметров соглашеия stdcall. Об этом важно помнить для правильного вызова DLL, созданных в Блэкбоксе, из C/C++.
Пример 0. Простая DLL
Предположим, нужно создать DLL с одной функцией из следующего модуля:
MODULE Epse21Dll0;
PROCEDURE Add* (a, b: INTEGER): INTEGER;
BEGIN
RETURN a + b
END Add;
END Epse21Dll0.
Команда создания DLL из этого модуля такова:
DevLinker.LinkDll anyname.dll := Epse21Dll0# ~
Имя DLL (anyname.dll) не чувствительно к регистру. Это соглашение в MS Windows.
Тильда (~) отмечает конец списка модулей, которые должны быть скомпонованы в DLL.
Символ # указывает, что процедуры, экспортированные из этого модуля (в соответствии с правилами Блэкбокса) должны быть добавлены к списку экспорта получающейся DLL.
Вновь созданная DLL находится в папке Блэкбокса, и ее можно изучить с помощью программы DependencyWalker:
На картинке обведено имя экспортированной процедуры.
Замечания
1. Имя процедуры, экспортированной из DLL, чувствительно к регистру. Если изменить Add на ADD, то имя в списке экспорта DLL тоже будет состоять из заглавных букв ADD.
2. В списке экспорта получающейся DLL отсутствует информация об имени модуля. Это проектное решение Блэкбокса.
3. Модуль может содержать любое количество экспортированных процедур: они все появятся в списке экспорта DLL.
4. Отсутствует явное указание на то, что функция использует для передачи параметров соглашение stdcall.
Пример 1. DLL из двух модулей
Создадим DLL из вышеприведенного и следующего модулей:
MODULE Epse21Dll1;
IMPORT SYSTEM;
PROCEDURE Add* (a, b: INTEGER): INTEGER;
BEGIN
RETURN a - b
END Add;
END Epse21Dll1.
Если нужно включить процедуру Sub в список экспорта DLL, то имя второго модуля тоже должно быть отмечено символом # в команде компоновщика:
DevLinker.LinkDll dll1.dll := Epse21Dll0# Epse21Dll1# ~
Программа Dependency Walker покажет в списке экспорта DLL как процедуру Add из первого модуля, таки Sub из второго (обведены):
Замечания
1. DLL выглядит в Dependency Walker так, как если бы она была создана из единственного модуля с двумя экспортированными функциями.
2. Если маркер # опустить после любого из имен двух модулей, то их экспортированные процедуры (экспортированные в смысле Компонентного Паскаля) не появятся списке экспорта DLL (это удобно, если в процедурах вызываются модули Блэкбокса, такие как Math).
3. Если переименовать Sub в Add, то список экспорта DLL будет содержать две функции с одинаковым именем:
NB Порядковые номера у двух функций разные, поэтому в принципе их можно различить в вызывающей программе.
Пример 1ccall. Создание DLL с соглашением ccall
Если создается DLL для использования в программах на C/C++, то тогда может иметь смысл использование соглашения ccall. Тогда модуль на Компонентном Паскале должен импортировать SYSTEM, а перед именем процедуры нужно поставить [ccall]:
MODULE Epse21Dll1ccall;
IMPORT SYSTEM;
PROCEDURE [ccall] Sub* (a, b: INTEGER): INTEGER;
BEGIN
RETURN a - b
END Sub;
END Epse21Dll1ccall.
DevLinker.LinkDll dll1ccall.dll := Epse21Dll1ccall# ~
Пример 2. DLL из модуля, использующего NEW
Предположим, что нужно создать DLL, процедуры в котором используют оператор NEW для размещения в куче записей и массивов.
Пусть, например, процедура Add в нижеприведенном модуле размещает несколько мегабайт памяти при каждом вызове:
MODULE Epse21Dll2;
PROCEDURE Add* (a, b: INTEGER): INTEGER;
VAR i: INTEGER; t: POINTER TO ARRAY OF INTEGER;
BEGIN
FOR i := 0 TO 1000 DO
NEW( t, 1000 + i )
END;
RETURN a + b
END Add;
END Epse21Dll2.
Тогда в список модулей компоновщика нужно включить Kernel+ :
DevLinker.LinkDll dll2.dll := Kernel+ Epse21Dll2# ~
Заметим, что программа Dependence Walker выдает предупреждение для этой DLL. Однако, тест, приводимый ниже, должен работать.
Чтобы проверить, что получившаяся DLL не вызовет аварийной остановки, сделаем следующеее (см. подробнее ВызовDLLизБлэкбокса).
Скомпилируем следующий интерфейсный модуль для вызова получающейся DLL:
MODULE Epse21Dll2Interface ["dll2"];
PROCEDURE Add* ( a, b: INTEGER ): INTEGER;
END Epse21Dll2Interface.
Следующий модуль проверяет DLL (можно следить за показанием Allocated Memory в правой половине статусной полоски Блэкбокса; убедитесь, что выбрана опция Double в диалоге Edit, Preferences...).
MODULE Epse21Dll2Test;
IMPORT Dll2 := Epse21Dll2Interface, StdLog;
PROCEDURE Do*;
VAR a, b: INTEGER;
BEGIN
a := 1;
FOR b := 0 TO 1000 DO
a := Dll2.Add( a, b )
END;
StdLog.Int( a ); StdLog.Ln
END Do;
END Epse21Dll2Test.
NB Прежде чем кликать по черному коммандеру ниже по тексту, заметим, что как только DLL загружен описываемым способом, ее уже нельзя выгружить. Поэтому если нужно изменить DLL, придется перезапустить весь Блэкбкос. (Чтобы избежать этого, см. раздел о динамической загрузке DLL в ВызовDLLизБлэкбокса.)
Epse21Dll2Test.Do
Пример 3. Массивы в качестве параметров
Рассмотрим функцию, возвращающую сумму элементов массива.
Обычно процедура будет выглядеть примерно так:
PROCEDURE Sum* ( IN a: ARRAY OF REAL ): REAL;
VAR i: INTEGER; s: REAL;
BEGIN
s := 0;
FOR i := 0 TO LEN(a) - 1 DO
s := s + a[i]
END;
RETURN s
END Sum;
Однако при работе с массивами Блэкбокс использует скрытые дескрипторы, содержащие информацию о длине массива, размере и типе его элементов, и т.п. При этом в качестве аргумента в Sum передается адрес дескриптора, и именно поэтому длина массива может быть определена в коде с помощью LEN(a).
Другие системы программирования могут иметь другие соглашения. В фортране, C, C++ и т.п. массивы передаются в процедуры через адрес первого элемента.
Это влечет две вещи:
1) длина массива должна передаваться в Блэкбокс через дополнительный параметр;
2) компилятору Блэкбокса нужно сообщить, что массив придет без обычного блэкбоксовского десприптора.
Тогда модуль может быть таким:
MODULE Epse21Dll3;
IMPORT SYSTEM;
PROCEDURE Sum* ( IN a: ARRAY [untagged] OF REAL; len: INTEGER ): REAL;
VAR i: INTEGER; s: REAL;
BEGIN
s := 0;
FOR i := 0 TO len - 1 DO
s := s + a[i]
END;
RETURN s
END Sum;
END Epse21Dll3.
DevLinker.LinkDll dll3.dll := Epse21Dll3# ~
Замечания
1. Нумерация элементов в других языках может отличаться от используемой в Компонентном Паскале.
2. Вышеописанный механизм также работает с массивами, передаваемыми чере VAR/OUT параметры (например, когда массив нужно отсортировать и т.п.).
3. Тип REAL в Компонентном Паскале соответствует вещественным типам с двойной точностью в фортране и C/C++. Тип с одинарной точностью в КП SHORTREAL.
4. Многомерные массивы в фортране располагаются в памяти по столбцам, т.е. a[0,0], a[1,0], и т.д. (первый индекс изменяется быстрее всех), тогда как в Блэкбоксе они хранятся по рядам, т.е. a[0,0], a[0,1], и т.д. (быстрее меняется последний индекс).
5. Нужна осторожность с тем, как передаются скалярные параметры вроде len: по значению или по ссылке. Если имеет место второе (что обычно для фортрана), то второй параметр должен быть объявлен с VAR:
MODULE Epse21Dll3var;
IMPORT SYSTEM;
PROCEDURE Sum* ( IN a: ARRAY [untagged] OF REAL; VAR len: INTEGER ): REAL;
VAR i: INTEGER; s: REAL;
BEGIN
s := 0;
FOR i := 0 TO len - 1 DO
s := s + a[i]
END;
RETURN s
END Sum;
END Epse21Dll3var.
DevLinker.LinkDll dll3var.dll := Epse21Dll3var# ~
NB По поводу более сложных случае (невыровненные записи полей и т.п.) следует обратиться к документу Особенностиплатформы.
| i21sys/Docu.Работа с DLL/creating-in-BB.odc |
Создание DLL в C++
Общее замечание: подобно сказанному о доступе к COMMON-блокам в фортране, может понадобиться сделать косметические изменения к интерфейсам процедур в исходниках на C++, например, дописать дополнительные процедуры для доступа к глобальным переменным и т.п.
Создание DLL в Microsoft Visual C++
Создадим новый Проект (File, New, Project). Дадим ему имя (скажем, project_name) и выберем ему тип как Win32 Dynamic-Link Library.
В поле Location можно указать путь к папке, где будут сохраняться файлы проекта. Кликнем OK.
Появится диалог, в котором выставим флажок A simple DLL project. (Не следует оставлять опцию по умолчанию An empty DLL project!)
Будут созданы все необходимые файлы, среди которых будет project_name.CPP,
в конце которого нужно вставить код для нужных процедур/функций.
Отметим те из них, которые должны появиться в списке экспорта DLL модификатором __declspec(dllexport) [см. примеры ниже].
Если нужно, чтобы имена процедур в списке экспорта DLL оставались в минимальной степени искажены по сравнению с исходником, тогда следует включить модификатор extern "C" :
extern "C" __declspec(dllexport) void __stdcall swap( int& a, int& b )
{
int temp;
temp = a;
a = b;
b = temp;
}
Заметим также, что здесь требуется выполнение соглашений stdcall.
Наконец, нажмем кнопку Build (F7).
NB Если вместо этого нажать Compile (Ctrl + F7), то появится следующее сообщение об ошибке: fatal error C1083: Cannot open precompiled header file: 'Debug/ project_name.pch': No such file or directory].
Будут созданы два файла project_name.dll и project_name.lib в папке \project_nameта\Debug или \project_name\Release.
Второй файл (*.lib) подобен символьному файлу, который автоматически создается в Блэкбоксе.
Сигнатура для вышеприведенной процедуры в Компонентном Паскале будет такой:
PROCEDURE swap* ( VAR a, b: INTEGER );
Если процедура на C++ модифицирует массив, например,
extern "C" __declspec(dllexport) void __stdcall sort( int* a, int len )
то соответствующая сигнатура в Блэкбоксе будет такой:
PROCEDURE sort* ( VAR a: ARRAY [untagged] OF INTEGER, len: INTEGER ); | i21sys/Docu.Работа с DLL/creating-in-C++.odc |
Создание DLL в фортране
Для компиляции любого модуля Блэкбокса в нижеследующем тексте нужно выделить текст модуля (или просто ключевого слова MODULE, например, двойным кликом) и выполнить команду меню Dev, Compile Selection.
Общие замечания
Обычно в фортране параметры передаются по ссылке, так что соответствующие параметры в Блэкбоксе должны объявляться как VAR (или IN/OUT, если имеется полное понимание того, что делает соответствующая подпрограмма).
Фортрановские типы float и real*4 соответствуют типу SHORTREAL в Блэкбоксе, а double и real*8 типу REAL.
Если в фортране параметр является массивом, то соответствующий параметр-массив в Блэкбоксе должен быть объявлен с системным флагом [untagged] (об этом см. Особенностиплатформы). Тогда длина массива передается через отдельный параметр.
Массивы размещаются в памяти в фортране по-другому по сравнению с Блэкбоксом: первый индекс меняется быстрее всего: a(0,0), a(1,0), и т.д., ... тогда как в Блэкбоксе a[0,0], a[0,1], и т.д..
Если нужен доступ к переменным в COMMON-блоках, нужно добавить соответствующие процедуры в исходник на фортране.
Мы создадим DLL с именем BBtest.dll из следующих двух подпрограмм на фортране:
SUBROUTINE proc1 ( a, res )
INTEGER a
DOUBLE PRECISION res
res = a + res
END
SUBROUTINE proc2 ( a, res )
INTEGER a
DOUBLE PRECISION res
res = a
END
Соответствующий интерфейсный модуль для вызова получающейся DLL из Блэкбокса имеет следующий вид
MODULE Epse21DllFortran ["BBtest"];
PROCEDURE Add* ["proc1"] ( VAR a: INTEGER; VAR res: REAL );
PROCEDURE Assign* ["proc2"] ( VAR a: INTEGER; VAR res: REAL );
END Epse21DllFortran.
Скомпилируем его. Работа с DLL через такой интерфейсный модуль соответствует статической загрузке DLL.
Для проверки скомпилируем следующий модуль и выполним процедуру Do кликом по черному коммандеру, стоящему за модулем:
MODULE Epse21DllFortranTest;
IMPORT Log := StdLog, Math, In := Epse21SysIn, For := Epse21DllFortran;
PROCEDURE Do*;
VAR a: INTEGER; res: REAL;
BEGIN
a := 5; res := 7;
Log.Int( a ); Log.Real( res ); Log.Ln;
For.Add( a, res );
Log.Int( a ); Log.Real( res ); Log.Ln;
For.Assign( a, res );
Log.Int( a ); Log.Real( res ); Log.Ln;
END Do;
END Epse21DllFortranTest.
Epse21DllFortranTest.Do
Compaq/Digital Visual Fortran 6.1.A
Это компилятор, доступный в CERN во время написания данного документа. Эта система (в дальнейшем VF) родственна Visual C++. Главный источник информации документация VF, разделы Creating Fortran DLLs, Building Dynamic-Link Libraries, Programming with Mixed Languages.
В VF, создадим (Ctrl+N) новый проект класса Dynamic Link Library, назовем его BBtest и укажем для него местонахождение всё в одном диалоге. Кликнем OK.
В следующем диалоге, которые появится, выберем опцию "A DLL application with exported symbols". Кликнем по Finish.
Система создает проект с единственным исходником с именем BBTEST.f90.
Дважды кликнем по нему в левой части окна.
В правой части будет показано следующее:
! BBtest.f90
!
! FUNCTIONS/SUBROUTINES exported from BBTEST.dll:
! BBTEST - subroutine
!
subroutine BBTEST
! Expose subroutine BBTEST to users of this DLL
!
!DEC$ ATTRIBUTES DLLEXPORT::BBTEST
! Variables
! Body of BBTEST
end subroutine BBTEST
Изменим текст, скопировав две фортрановские подпрограммы, стерев подпрограмму BBTEST и вставив для каждой подпрограммы строчку ATTRIBUTES следующим образом:
! BBtest.f90
!
! FUNCTIONS/SUBROUTINES exported from BBTEST.dll:
!
SUBROUTINE proc1 ( a, res )
!DEC$ ATTRIBUTES STDCALL, REFERENCE, DLLEXPORT::proc1
INTEGER a
DOUBLE PRECISION res
res = a + res
END
SUBROUTINE proc2 ( a, res )
!DEC$ ATTRIBUTES STDCALL, REFERENCE, DLLEXPORT::proc2
INTEGER a
DOUBLE PRECISION res
res = a
END
Смысл опций ATTRIBUTES:
REFERENCE означает, что параметры передаются по ссылке (что соответствует VAR в Блэкбоксе).
STDCALL означает, что будут использоваться соглашения о передаче параметров StdCall; важно использовать STDCALL, если DLL будет загружаться динамически. (В языке Си по умолчанию используется соглашение ccall вместо STDCALL.)
DLLEXPORT указывает имя соответствующей подпрограммы в таблице экспорта DLL.
Выполним команду меню Build, Build BBtest.dll.
Это создает BBtest.dll в папке Debug или Release в папке проекта, указанной ранее (Debug или Release в зависимости от соотв. установки в диалоге Build, Set Active Configuration...).
Скопируем DLL, например, в папку Блэкбокса (в этом случае не нужно указывать полный путь для этой DLL в интерфейсном модуле в Блэкбоксе).
Для проверки DLL из Блэкбокса скомпилируем и выполним пару модулей Epse21DllFortran и Epse21DllFortranTest (см. выше).
Fortran Power Station 4.0
Это более старая версия VF. Главный источник информации документация FPS, раздел Mixed-Language Programming.
В FPS, создадим новое workspace класса Dynamic Link Library, назовем его BBtest, и создадим в нем единственный файл prog.f, в который скопируем вышеприведенный фортрановский код.
В начале файла добавим две мета-инструкции, под одной на каждую процедуру:
!MS$ATTRIBUTES STDCALL, REFERENCE, ALIAS:'proc1' :: proc1
!MS$ATTRIBUTES STDCALL, REFERENCE, ALIAS:'proc2' :: proc2
Каждая из них должна начинаться в первой позиции строки (в отличие от инструкций фортрана).
REFERENCE означает, что параметры должны передаваться по ссылке (что соответствует VAR в Блэкбоксе).
STDCALL означает, что при передаче параметров будет использоваться соглашение StdCall; важно использовать STDCALL, если DLL будет загружаться динамически.
Далее нужно обеспечить, чтобы две процедуры появились в списке экспорта DLL.
Для этого откроем меню Build, Settings ... и найдем закладку Link.
В конце содержимого Project Options, добавим
/export:"proc1" /export:"proc2"
как на следующей картинке:
(Если окно серое, это вероятно потому, что в левой части выделены обе строчки; должна быть только одна нужная.)
Нажмем OK.
Выполним команду меню Build, Build ... Это создаст BBtest.dll.
Скопируем созданную DLL, например, в папку Блэкбокса (тогда не нужно указывать ее полный путь в интерфейсном модуле в Блэкбоксе). Для проверки скомпилируем и выполним два модуля Блэкбокса, приведенные в начале документа.
| i21sys/Docu.Работа с DLL/creating-in-Fortran.odc |
Использование программы Dependency Walker
Программа Dependency Walker позволяет исследовать DLL, в частности, определить имена и порядковые номера процедур в списке экспорта DLL.
(В системе Win 2000, DLL можно также исследовать с помощью Quick View; эта опция недоступна в Win XP.)
Программа Dependency Walker имеется в составе Microsoft Visual Studio.
Она также доступна бесплатно в виде zi-файла с сайта http://www.dependencywalker.com/.
Просто раззипуйте ее в любую папку и запустите depends.exe. Можно связать depends.exe с файлами *.dll для автоматического вызова двойным кликом по файлу DLL.
Запустите depends.exe, выполните команду меню File, Open, и найдите нужную DLL.
В качестве примера можно открыть KERNEL32.DLL в папке the c:\winnt\system32.
Программа Dependency Walker покажет 5 окон (здесь используется версия 2.1):
Верхнее левое окно содержит имя открытого файла DLL вместе с именами DLL, которые он использует.
Важное окно находится справа, второе сверху. В нем показаны точные имена функций в столбце Function.
NB Если DLL была написана на C++, то важно, чтобы кнопка [с++] (6-я слева на полоске инструментов; Undecorate C++ Functions) была НЕ нажата!
Столбец Ordinal в том же окне показывает порядковые номера экспортируемых функций. В ниижнем окне дается список обнаруженных ошибок.
Полные пути для DLL можно видеть, нажав кнопку [c:\] (5-я слева на полоске инструментов). | i21sys/Docu.Работа с DLL/Dependency-Walker.odc |
Введение в DLL
DLL (Dynamic Link Library) это файл с расширением *.dll , который содержит выполняемый код для набора процедур.
DLL содержит список экспорта, в котором для каждой процедуры даны:
ее имя чувствительная к регистру цепочка литер расширенной кодировки ASCII;
ее порядковый номер целое число >=1, которое однозначно идентифицирует фукнцию из DLL.
NB Две процедуры в DLL могут иметь одинаковое имя, но у них всегда разные порядковые числа.
Компиляторы обычно допускают создание DLL вместо обычного EXE. См. документацию к конкретному компилятору.
В данном документации обсуждаются Блэкбокс, PowerStation Fortran и MS Visual C++.
Соглашения о передаче параметров
Процедуры в DLL могут придерживаться одного из двух соглашений о передаче параметров ccall или stdcall (имена могут чуть отличаться в разным системах программирования).
По умолчанию Блэкбокс использует соглашения stdcall, а C/C++ соглашения ccall; поведение по умолчанию может быть изменено с помощью специальных опций.
Важно правильно указать соглашение для каждой процедуры, создавая и используя DLL.
Функции Windows API используют соглашение stdcall.
Имена и порядковые номера
Функции из DLL могут быть идентифицированы либо по имени, либо по их порядковым числам.
Имена функций в DLL могут отличаться от их имен в исходнике. Это зависит от конкретного компилятора. Поэтому для использования функции из DLL важно точно определить ее имя.
Чтобы определить точные имена экспортированных функций в DLL, можно использовать бесплатную утилиту Dependency Walker (depends.exe; http://www.dependencywalker.com/); см. этотдокумент.
В ОС Windows NT можно сделать правый клик по файлу DLL и выбрать Quick View.
Загрузка DLL
DLL могут быть загружены двумя способами: статически и динамически.
Статическая загрузка означает, что DLL загружается автоматически при запуске программы, ее вызывающей. Это более простой способ и обычно обеспечиватеся компилятором и компоновщиком.
Динамическая загрузка означает, что DLL загружается во время выполнения программы, и выгружается после использования. в то время как основная программа продолжает работать. Это более гибкий способ, но требует обращений к функциям Windows API во время выполнения:
LoadLibrary() для загрузки DLL в память;
GetProcAddress() для получения указателя на нужную функцию из DLL;
FreeLibrary() для выгрузки DLL из памяти, когда она больше не нужна.
Чтобы узнать, какие DLL загружены, можно выполнить (Start, Run...) msinfo21 и выбрать Software Environment, Loaded Modules.
| i21sys/Docu.Работа с DLL/Intro.odc |
Работа с унаследованным ПО через DLL
Данный материал был первоначально подготовлен на английском языке для физической аудитории на cовещаниии Oberon Day @ CERN, проведенного в марте 2004 г. в CERN, Женева.
(С) Ф.В.Ткачев и С.О.Чумаков, 2004.
(С) Русский перевод для проекта Информатика-21: Ф.В.Ткачев, 2009.
Учитывая историю фортрана в научном мире, физикам при работе с Блэкбоксом важно иметь возможность использовать имеющиеся библиотеки на фортране (а также C/C++). Наплатформе Windows простейший способ для этого без полного переписывания исходников на фортране/C/C++ состоит в перекомпиляции их в т.наз. DLL.
DLL это файл с расширением *.dll, который содержит исполняемый код для набора процедур (в какой-то степени подобный модулям Компонентного Паскаля). Поскольку DLL являются стандартным механизмом на платформе Windows любой приличный компилятор имеет соответствующую опцию. Может понадобиться произвести косметические модификации для интерфейсов процедур, компилируемых в DLL. В большинстве случаев это не вызывает затруднений, хотя в общем случае здесь требуется хорошее понимание соответствия типов и параметров в разных языках, правил выравнивания полей записей и т.п.
ВведениевDLL
ИспользованиепрограммыDependencyWalkerдляисследованияDLL
Создание DLL для использования из Блэкбокса:
вфортране,
C++,
вБлэкбоксе (для полноты).
Вызов DLL, созданных в фортране или C++ из Блэкбокса.
Блэкбокс тоже допускает создание DLL, так что алгоритмы, разработанные в Блэкбоксе и обладающие соответствующими свойствами безопасности (автоматическое управление памятью), могут быть предоставлены в форме DLL для использования из внешних программ, написанных на других языках (фортран, C/C++ и т.д.). Предполагается, что гуру, способные работать с внешними DLL из, скажем, C++, не нуждаются в советах (некоторые замечания можно найти здесь).
| i21sys/Docu.Работа с DLL/Map.odc |
MODULE i21sysBitmaps;
(* переименовано для проекта Информатика-21 ФВТ 2008-02-16 *)
(* renamed from ToolsBitmaps provided by Ominc, by FVT 2006-03-01 *)
IMPORT Files, Converters, Views, Containers, HostBitmaps, WinOle;
PROCEDURE SaveSingleton*;
VAR v: Views.View; loc: Files.Locator; n: Files.Name; bmp: Converters.Converter; res: INTEGER;
BEGIN
v := Containers.FocusSingleton();
IF v # NIL THEN
n := "";
bmp := Converters.list;
WHILE (bmp # NIL) & (bmp.fileType # "bmp") DO bmp := bmp.next END;
Views.Register(HostBitmaps.ViewToBitmap(v, 24), Views.ask, loc, n, bmp, res)
END
END SaveSingleton;
PROCEDURE ExportD* (
v: Views.View; w, h, x, y: INTEGER; isSingle: BOOLEAN; VAR med: WinOle.STGMEDIUM
);
BEGIN
ASSERT(v # NIL, 20);
HostBitmaps.ExportDBitmap(HostBitmaps.ViewToBitmap(v, 24), w, h, x, y, isSingle, med)
END ExportD;
END i21sysBitmaps.
Include into some Menu:
"Save As Bitmap..." "" "i21sysBitmaps.SaveSingleton" "StdCmds.SingletonGuard"
Include into Config:
OleData.Register("", "i21sysBitmaps.ExportD", "BITMAP", "", {})
---------------------------------------------------------------------
From: [email protected] (Tech-Support (BlackBox))
To: Blackbox Mailing-List [[email protected]]
Cc: Blackbox Tech-Support [[email protected]]
Bcc:
Subject: RE: Pasting bitmaps
Time: 2004-04-19 at 07:26
Message: Dear BlackBox user,
two weeks ago, we discussed the problem of pasting a selected BlackBox view
as a bitmap into PowerPoint and similar applications.
In the meantime we've thrown together the small module ToolsBitmaps.
This program may help you to copy and paste selected views via OLE into other applications.
Additionally there is also a command that saves arbitrary views as bitmaps on disk.
We hope this solution satisfies most of your requirements.
Cheers
Marc
Oberon microsystems, Inc.
ToolsBitmaps:
MODULE ToolsBitmaps;
IMPORT Files, Converters, Views, Containers, HostBitmaps, WinOle;
PROCEDURE SaveSingleton*;
VAR v: Views.View; loc: Files.Locator; n: Files.Name; bmp: Converters.Converter; res: INTEGER;
BEGIN
v := Containers.FocusSingleton();
IF v # NIL THEN
n := "";
bmp := Converters.list;
WHILE (bmp # NIL) & (bmp.fileType # "bmp") DO bmp := bmp.next END;
Views.Register(HostBitmaps.ViewToBitmap(v, 24), Views.ask, loc, n, bmp, res)
END
END SaveSingleton;
PROCEDURE ExportD* (
v: Views.View; w, h, x, y: INTEGER; isSingle: BOOLEAN; VAR med: WinOle.STGMEDIUM
);
BEGIN
ASSERT(v # NIL, 20);
HostBitmaps.ExportDBitmap(HostBitmaps.ViewToBitmap(v, 24), w, h, x, y, isSingle, med)
END ExportD;
END ToolsBitmaps.
Include into some Menu:
"Save As Bitmap..." "" "ToolsBitmaps.SaveSingleton" "StdCmds.SingletonGuard"
Include into Config:
OleData.Register("", "ToolsBitmaps.ExportD", "BITMAP", "", {})
| i21sys/Mod/Bitmaps.odc |
MODULE i21sysCalls; (** **)
(*
2010-10-18 Е.Э.Темиргалеев -- исправления для корректной работы под wine+linux
2008-05-19 ..
-- BlackBox-Mailing List
*)
IMPORT SYSTEM, WinApi, HostDialog, Services, i21sysInfo;
TYPE
Action = POINTER TO RECORD ( Services.Action )
fileName: POINTER TO ARRAY OF SHORTCHAR;
END;
ActionExe = POINTER TO RECORD ( Services.Action )
fileName: POINTER TO ARRAY OF SHORTCHAR;
END;
PROCEDURE ( a: Action ) Do;
VAR
hwnd: WinApi.HWND;
lpOperation, lpFile, lpParameters, lpDirectory: WinApi.PtrSTR;
nShowCmd: INTEGER;
hinst: WinApi.HINSTANCE;
win_fileName, win_params, win_workDir: ARRAY [untagged] 5000 OF SHORTCHAR;
BEGIN
(* http://habrahabr.ru/blogs/development/88907/ *)
IF i21sysInfo.platform = i21sysInfo.wine THEN
win_fileName := "winebrowser " + a.fileName$
ELSE
win_fileName := a.fileName$
END;
win_params := '';
win_workDir := '';
lpOperation := "open";
lpFile := win_fileName;
lpParameters := win_params;
lpDirectory := win_workDir;
nShowCmd := WinApi.SW_SHOW;
hinst := WinApi.ShellExecute( hwnd, lpOperation, lpFile, lpParameters, lpDirectory, nShowCmd );
(*
ErrorOut( hinst );
Log.Bool( hinst > 32 ); Log.Ln; (* RETURN hinst > 32; *)
*)
END Do;
PROCEDURE ( a: ActionExe ) Do;
VAR
BEGIN
HostDialog.Start( a.fileName$ )
END Do;
PROCEDURE Start* ( exeName: ARRAY OF CHAR ); (** (EXE); , notepad.exe; ; . ме **)
VAR a: ActionExe;
BEGIN
NEW( a );
NEW( a.fileName, LEN( exeName$) + 1 );
a.fileName^ := SHORT( exeName$ );
Services.DoLater( a, Services.now ); (* Action, .. EXE. *)
END Start;
PROCEDURE Open* ( fileName: ARRAY OF CHAR ); (** MS Windows () , ; , .WAV WinAmp, .WAV; ; . ме **)
VAR a: Action;
BEGIN
NEW( a );
NEW( a.fileName, LEN( fileName$) + 1 );
a.fileName^ := SHORT( fileName$ );
Services.DoLater( a, Services.now ); (* Action, .. EXE. *)
END Open;
END i21sysCalls.
"i21sysCalls.Start('notepad.exe')"
"i21sysCalls.Start('C:\!BlackBox\exe\blackbox15i21base\BlackBox.exe /Use C:\!BlackBox\!projects\!texts\')"
"i21sysCalls.Open('C:\!BlackBox\!projects\!texts\Mathtype\Docu\SDK\docs\APIDoc.htm')"
"i21sysCalls.Open('http://www.inr.ac.ru/~info21/')"
********************************************************************************
:
MODULE PrivCallExe;
IMPORT Log := StdLog, WinApi, SYSTEM;
PROCEDURE Do*;
VAR res, uCmdShow: INTEGER; cmd: ARRAY 1000 OF SHORTCHAR;
adr: RECORD [union]
val: INTEGER;
lpCmdLine: WinApi.PtrSTR
END;
BEGIN
cmd := "c:\Program Files\HIEW.EXE";
adr.val := SYSTEM.ADR( cmd[0] );
uCmdShow := 1; (* to start the program in a window *)
res := WinApi.WinExec ( adr.lpCmdLine, uCmdShow );
END Do;
END PrivCallExe.
PrivCallExe.Do | i21sys/Mod/Calls.odc |
MODULE i21sysCharacters;
(** This module is part of the educational versions of BlackBox 1.5 provided by the project "Informatika-21".
Its purpose is to extend support in the identifiers of Component Pascal of characters from the Extended ASCII range beyond the Latin-1 subset. The Latin-1 limitation is specified in the Language Report.
This module (together with the imported one) replaces the module National formerly used in the Russian versions of BlackBox and adds a functionality similar to that of Strings, that was previously provided by i21sysConv.
The source of the old National is retained for compatibility reasons; it is in the folder System/Mod/
**)
(**
project = "Информатика-21 / Informatika-21"
contributors = "I.N.Goryachev, F.V.Tkachov"
changes = "
- 20111214, F.V.Tkachov, redesign, see comments above
- 20050519, I.N.Goryachev, the initial version under name National
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
(* IMPORT x := i21sysLatin1; *)
IMPORT x := i21sysCyrillic;
VAR
HostFontsCHARSET-: INTEGER; (* used in HostFonts *)
charSetName-: ARRAY 64 OF CHAR;
Cap-: PROCEDURE (ch: CHAR): CHAR;
ExtendedAsciiOf-: PROCEDURE (ch: CHAR): CHAR;
IsCap-: PROCEDURE (ch: CHAR): BOOLEAN;
IsDigit-: PROCEDURE (ch: CHAR): BOOLEAN;
IsFirstIdentChar-: PROCEDURE (ch: CHAR): BOOLEAN;
IsIdentChar-: PROCEDURE (ch: CHAR): BOOLEAN;
IsLetter-: PROCEDURE (ch: CHAR): BOOLEAN;
Lower-: PROCEDURE (ch: CHAR): CHAR;
ToExtendedAscii-: PROCEDURE (IN in: ARRAY OF CHAR; OUT out: ARRAY OF CHAR);
ToUnicode-: PROCEDURE (IN in: ARRAY OF CHAR; OUT out: ARRAY OF CHAR);
ToUpper-: PROCEDURE (IN in: ARRAY OF CHAR; OUT out: ARRAY OF CHAR);
UnicodeOf-: PROCEDURE (ch: CHAR): CHAR;
Upper-: PROCEDURE (ch: CHAR): CHAR;
PROCEDURE Init;
BEGIN
HostFontsCHARSET := x.HostFontsCHARSET;
charSetName := x.charSetName$;
Cap := x.Cap;
ExtendedAsciiOf := x.ExtendedAsciiOf;
IsCap := x.IsCap;
IsDigit := x.IsDigit;
IsFirstIdentChar := x.IsFirstIdentChar;
IsIdentChar := x.IsIdentChar;
IsLetter := x.IsLetter;
Lower := x.Lower;
ToExtendedAscii := x.ToExtendedAscii;
ToUnicode := x.ToUnicode;
ToUpper := x.ToUpper;
UnicodeOf := x.UnicodeOf;
Upper := x.Upper;
END Init;
BEGIN
Init
END i21sysCharacters.
i21sysCharacters3.Do
| i21sys/Mod/Characters.odc |
MODULE i21sysCompiler;
(**
project = "Информатика-21 / Informatika-21"
contributors = "F.V.Tkachov, E.E.Temirgaleev"
changes = "
- 20121106, F.V.Tkachov, Models.BeginScript EndScript added
- 20111212, F.V.Tkachov, a different separation into modules
- 20090309, F.V.Tkachov, a piece of advice by E.E.Temirgaleev
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
IMPORT Log := StdLog, Files, Converters, Views, Stores, Models,
M := TextModels, TextViews, TextControllers, TextMappers, DevMarkers, Dialog,
Kernel, DevCompiler, DevCPT, DevCPS, V := i21sysVocabulary;
VAR
error-: BOOLEAN;
off-, indentGuard: BOOLEAN;
PROCEDURE NextMarker ( rd: M.Reader; OUT v: Views.View ); (* продвинуть rd до след. маркера ошибок в t *)
(* употребить ReadView -- совет Е.Э.Темиргалеева 2009-03-11 *)
BEGIN
rd.ReadView( v );
WHILE ~rd.eot & ~( v IS DevMarkers.View ) DO rd.ReadView( v ) END;
END NextMarker;
PROCEDURE InsertErrorMarkers ( c: TextControllers.Controller; t: M.Model );
VAR
rd: M.Reader; m, copy, first: Views.View;
n: INTEGER; (* число уже вставленных маркеров ошибок -- доп. сдвиг *)
pos0, pos, pos1: INTEGER; wr: M.Writer;
BEGIN
n := 0;
pos1 := -1;
wr := c.text.NewWriter( NIL ); (* объект записи ("писатель"), через который идет запись в оригинальный текст *)
rd := t.NewReader( NIL );
NextMarker( rd, m );
WHILE ~rd.eot DO
pos := rd.Pos() - 1 - n; (* позиция данного маркера, как если бы предыдущих маркеров не было *)
(* вставить маркер m из позиции pos в тексте t в позицию pos0 в c.text *)
(* сначала найти позицию pos0 в c.text, соответствующую pos в t *)
pos0 := V.OriginalPos( pos ); (* без учета маркеров ошибок *)
pos0 := pos0 + n; (* т.к. было вставлено n маркеров *)
(* вставка копии маркера: *)
wr.SetPos( pos0 ); (* установили писателя в правильную позицию в оригинальном тексте *)
copy := Views.CopyOf( m, Views.deep ); (* новая полная ("глубокая") копия маркера *)
wr.WriteView( copy, rd.w, rd.h ); (* писатель вставляет копию маркера в своей текущей позиции *)
(* маркер вставлен! *)
IF n = 0 THEN
first := copy; (* запомним первый маркер, чтобы показать в окне именно его *)
pos1 := wr.Pos(); (* чтобы в конце поставить курсор на первый маркер *)
END;
INC( n );
NextMarker( rd, m );
END;
IF pos1 >= 0 THEN c.SetCaret( pos1 ) (* поставили курсов в pos1 *) END;
c.MakeViewVisible( first ); (* требуем показать в окне маркер first -- он соответствует первой ошибке *)
END InsertErrorMarkers;
PROCEDURE Compile*;
VAR c: TextControllers.Controller; t: M.Model; script: Stores.Operation;
BEGIN
DevMarkers.UnmarkErrors;
(* взять текст в фокусе *)
c := TextControllers.Focus();
IF c # NIL THEN
ASSERT( c.text # NIL ); (* c.text = нужный текст *)
IF V.language # 'en' THEN
(* преобразовать c.text в t, заменяя ключевые слова *)
V.ConvertText( c.text, t );
ELSE
t := c.text
END;
(* компилировать t: *)
DevCompiler.CompileText( t, 0, error );
IF error & ( V.language # 'en' ) THEN (* вставить маркеры ошибок в c.text *)
Models.BeginScript (c.text, "Insert compile error markers", script); (* все действия до EndScript будут отменяться как целое при нажатии Ctrl+Z *)
InsertErrorMarkers( c, t );
Models.EndScript (c.text, script);
END;
END;
END Compile;
PROCEDURE CompileAndReload*; (* указал И.А.Дехтяренко (Trurl) *)
VAR
BEGIN
DevCompiler.CompileAndUnload;
Kernel.LoadMod( DevCPT.SelfName$ );
END CompileAndReload;
PROCEDURE ConvertCompileAndReload*;
VAR res: INTEGER;
BEGIN
Compile;
IF ~error THEN
Dialog.Call( 'DevDebug.Unload', '', res );
Kernel.LoadMod( DevCPT.SelfName$ ); (* указал указал И.А.Дехтяренко (Trurl) *)
END;
END ConvertCompileAndReload;
PROCEDURE LogMessage( res: INTEGER; in: ARRAY OF CHAR );
VAR out: ARRAY 100 OF CHAR;
BEGIN
IF res = 0 THEN
Dialog.MapString( in, out );
Log.String( out ); Log.Ln;
indentGuard := TRUE
ELSE
Log.String('Indentation checks are not possible with this version of DevCPP, DevCPS'); Log.Ln;
indentGuard := FALSE
END;
END LogMessage;
PROCEDURE ToggleIndentChecks*;
CONST dev0 = 'DevCPS.IndentChecks'; msg0 = '#i21sys:IndentChecks';
VAR res: INTEGER; app, dev, msg: ARRAY 100 OF CHAR;
BEGIN
IF off THEN
app := 'On';
ELSE
app := 'Off';
END;
dev := dev0 + app;
msg := msg0 + app;
off := ~off;
Dialog.Call( dev, '', res ); (* вызов через Dialog.Call обходит проблему с переключением на оригинальный DevCPS, в котором нет этой команды *)
LogMessage( res, msg )
END ToggleIndentChecks;
PROCEDURE IndentGuard* ( VAR par: Dialog.Par );
VAR
BEGIN
par.disabled := ~indentGuard;
IF off THEN
par.label := '#i21sys:IndentMenuOn'
ELSE
par.label := '#i21sys:IndentMenuOff'
END;
END IndentGuard;
PROCEDURE Init;
VAR res: INTEGER;
BEGIN
off := TRUE;
indentGuard := TRUE;
Dialog.Call( 'DevCPS.IndentChecksOff', '', res ); (* вызов через Dialog.Call обходит проблему с переключением на оригинальный DevCPS, в котором нет этой команды *)
indentGuard := ( res = 0 )
END Init;
BEGIN Init
END i21sysCompiler.
i21sysCompiler.Compile
(*на себе должно ломаться: *)
i21sysCompiler.CompileAndReload
i21sysCompiler.ConvertCompileAndReload
DevDebug | i21sys/Mod/Compiler.odc |
МОДУЛЬ i21sysCompilerTest; (* info21 2010-04-07; last modified 2010-09-22 *)
ПОДКЛЮЧИТЬ In, Log;
ПРОЦЕДУРА Do*;
ПЕРЕМЕННЫЕ ц: ЦЕЛОЕ;
НАЧАЛО
In.Open; УБЕДИТЬСЯ( In.Done И ~In.Done );
In.Int( ц ); УБЕДИТЬСЯ( In.Done ); Log.Int( ц ); Log.Ln;
In.Int( ц ); УБЕДИТЬСЯ( In.Done ); Log.Int( ц ); Log.Ln;
In.Int( ц ); УБЕДИТЬСЯ( In.Done ); Log.Int( ц ); Log.Ln;
КОНЕЦ Do;
НАЧАЛО
Log.String('bu-bu-bu'); Log.Ln;
КОНЕЦ i21sysCompilerTest.Do 4 5 6 dfgh
"i21sysVocabulary.SetLanguage('ru')"
"i21sysVocabulary.SetLanguage('')" по умолчанию -- англ
i21sysVocabulary.ConvertFocus
i21sysCompiler.Compile --должна корректно компилировать при ru
i21sysCompiler.CompileAndReload --не должна работать с ru ОК
i21sysCompiler.ConvertCompileAndReload --должна работать с ru ОК
i21sysCompiler.ToggleIndentChecks
| i21sys/Mod/CompilerTest.odc |
ч;
Вывод := StdLog, Ввод := i21sysIn;
.
портить и кликать:
i21sysCompiler.Compile
а также показывать интерфейсы и открывать документацию по коротким псевдонимам модулей.
| i21sys/Mod/CompilerTest0.odc |
МОДУЛЬ i21sysCompilerTest1; (* info21 2010-04-07; last modified 2010-09-22 *)
ПОДКЛЮЧИТЬ In, Log;
ПРОЦЕДУРА Do*;
ПЕРЕМЕННЫЕ ц: ЦЕЛОЕ;
НАЧАЛО
In.Open; УБЕДИТЬСЯ( In.Done И ~In.Done );
In.Int( ц ); УБЕДИТЬСЯ( In.Done ); Log.Int( ц ); Log.Ln;
In.Int( ц ); УБЕДИТЬСЯ( In.Done ); Log.Int( ц ); Log.Ln;
In.Int( ц ); УБЕДИТЬСЯ( In.Done ); Log.Int( ц ); Log.Ln;
КОНЕЦ Do;
НАЧАЛО
Log.String('bu-bu-bu'); Log.Ln;
КОНЕЦ i21sysCompilerTest1.Do 4 5 6 dfgh
"i21sysEdit.SetLanguage('ru')"
"i21sysVocabulary.SetLanguage('')" по умолчанию -- англ
i21sysVocabulary.ConvertFocus
i21sysCompiler.Compile --должна корректно компилировать при ru
i21sysCompiler.CompileAndReload --не должна работать с ru ОК
i21sysCompiler.ConvertCompileAndReload --должна работать с ru ОК
i21sysCompiler.ToggleIndentChecks
| i21sys/Mod/CompilerTest1.odc |
ч;
Вывод := StdLog, Ввод := i21sysIn;
ч.
i21sysCompiler.Compile | i21sys/Mod/CompilerTest2.odc |
МОДУЛЬ i21sysCompilerTestIndent; (* info21 2010-04-07 *)
ПОДКЛЮЧИТЬ In,
Log;
ПРОЦЕДУРА ч;
ПЕРЕМЕННЫЕ ч: ЦЕЛАЯ;
я: ЦЕЛАЯ;
НАЧАЛО
ч:=-0;
FOR ч := 0 TO 9 DO
;
END;
КОНЕЦ ч;
КОНЕЦ i21sysCompilerTestIndent.
MODULE x;
IMPORT Log := StdLog, In := i21sysIn, Math;
PROCEDURE y;
VAR z: INTEGER;
z1: INTEGER;
BEGIN
z := 0;
z := 0;
IF z = 0 THEN
z := 0; z := 9;
ELSE
z := 8;
END;
END y;
END x.
i21sysCompiler.Compile
i21sysCompiler.CompileAndReload (не должно работать)
i21sysCompiler.ConvertCompileAndReload (должно)
"i21sysVocabulary.SetLanguage('ru')"
"i21sysVocabulary.SetLanguage('')" --только англ.
i21sysVocabulary.ConvertFocus
проверка отступов
включить DevCPS.IndentChecksOn
выключить DevCPS.IndentChecksOff
отключить на эту компиляцию:
"DevCPS.IndentChecksOff;i21sysCompiler.Compile;DevCPS.IndentChecksOn"
"DevCompiler.CompileThis" DevCPS DevCPP
DevDebug.UnloadThis i21sysCompiler DevCompiler DevCPP DevCPS
"DevCompiler.CompileThis" i21sysCPS15 i21sysCPP15 <включены в Dev>
| i21sys/Mod/CompilerTestIndent.odc |
MODULE i21sysCyrillic;
(** This module is part of the educational versions of BlackBox 1.5 provided by the project "Informatika-21".
It may be used together with i21sysCharacters.
Or it can be used separately in the original BlackBox.
**)
(**
project = "Информатика-21 / Informatika-21"
contributors = "I.N.Goryachev, F.V.Tkachov"
changes = "
- 20120423, F.V.Tkachov, derived from National by I.N.Goryachev.
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
CONST
HostFontsCHARSET* = 1;
CONST uBase = 400H; uRange = 100H;
VAR
charSetName-: ARRAY 64 OF CHAR;
ru1251, eastSlav1251, cyr1251: RECORD
E, e, U, u: ARRAY 128 OF CHAR;
name: ARRAY 64 OF CHAR;
END;
VAR
ascii: ARRAY 256 OF RECORD
isCap, isLetter, isFirstIdentChar, isIdentChar: BOOLEAN;
cap, low, unicode: CHAR;
END;
unicode: ARRAY uRange OF RECORD
isCap, isLetter: BOOLEAN;
cap, low, ascii: CHAR;
END;
PROCEDURE IsCap* (ch: CHAR): BOOLEAN;
VAR res: BOOLEAN; i: INTEGER;
BEGIN
IF ORD(ch) < 256 THEN
res := ascii[ORD(ch)].isCap
ELSE
i := ORD(ch) - uBase;
IF (0 <= i) & (i < uRange) THEN
res := unicode[i].isCap
ELSE
res := FALSE
END
END;
RETURN res
END IsCap;
PROCEDURE IsDigit* (ch: CHAR): BOOLEAN;
BEGIN
RETURN ("0" <= ch) & (ch <= "9")
END IsDigit;
PROCEDURE IsLetter* (ch: CHAR): BOOLEAN;
VAR res: BOOLEAN; i: INTEGER;
BEGIN
IF ORD(ch) < 256 THEN
res := ascii[ORD(ch)].isLetter
ELSE
i := ORD(ch) - uBase;
IF (0 <= i) & (i < uRange) THEN
res := unicode[i].isLetter
ELSE
res := FALSE
END
END;
RETURN res
END IsLetter;
PROCEDURE IsFirstIdentChar* (ch: CHAR): BOOLEAN;
BEGIN
RETURN (ORD(ch) < 256) & ascii[ORD(ch)].isFirstIdentChar
END IsFirstIdentChar;
PROCEDURE IsIdentChar* (ch: CHAR): BOOLEAN;
BEGIN
RETURN (ORD(ch) < 256) & ascii[ORD(ch)].isIdentChar
END IsIdentChar;
PROCEDURE Cap* (ch: CHAR): CHAR;
VAR res: CHAR; i: INTEGER;
BEGIN
IF ORD(ch) < 256 THEN
res := ascii[ORD(ch)].cap
ELSE
i := ORD(ch) - uBase;
IF (0 <= i) & (i < uRange) THEN
res := unicode[i].cap
ELSE
res := ch
END
END;
RETURN res
END Cap;
PROCEDURE Upper* (ch: CHAR): CHAR; (* as in Strings *)
BEGIN RETURN Cap(ch)
END Upper;
PROCEDURE Lower* (ch: CHAR): CHAR; (* is used in Kernel *)
VAR res: CHAR; i: INTEGER;
BEGIN
IF ORD(ch) < 256 THEN
res := ascii[ORD(ch)].low
ELSE
i := ORD(ch) - uBase;
IF (0 <= i) & (i < uRange) THEN
res := unicode[i].low
ELSE
res := ch
END
END;
RETURN res
END Lower;
PROCEDURE UnicodeOf* (ch: CHAR): CHAR; (* unicode chars unaffected *)
VAR res: CHAR;
BEGIN
IF ORD(ch) < 128 THEN
res := ch
ELSIF ORD(ch) < 256 THEN
res := ascii[ORD(ch)].unicode
ELSE
res := ch
END;
RETURN res
END UnicodeOf;
PROCEDURE ExtendedAsciiOf* (ch: CHAR): CHAR;
VAR res: CHAR; i: INTEGER;
BEGIN
IF ORD(ch) < 256 THEN
res := ch
ELSE
i := ORD(ch) - uBase;
IF ( 0 <= i ) & ( i < uRange ) THEN
res := unicode[i].ascii
ELSE
res := '?'
END
END;
RETURN res
END ExtendedAsciiOf;
PROCEDURE ToUpper* (IN in: ARRAY OF CHAR; OUT out: ARRAY OF CHAR);
VAR len, i: INTEGER;
BEGIN
len := LEN(in$); i := 0;
WHILE i < len DO out[i] := Cap(in[i]); INC(i) END;
out[i] := 0X
END ToUpper;
PROCEDURE ToLower* (IN in: ARRAY OF CHAR; OUT out: ARRAY OF CHAR);
VAR len, i: INTEGER;
BEGIN
len := LEN(in$); i := 0;
WHILE i < len DO out[i] := Lower(in[i]); INC(i) END;
out[i] := 0X
END ToLower;
PROCEDURE ToUnicode* (IN in: ARRAY OF CHAR; OUT out: ARRAY OF CHAR); (* used in (Host)Dialog *)
VAR len, i: INTEGER;
BEGIN
len := LEN(in$); i := 0;
WHILE i < len DO out[i] := UnicodeOf(in[i]); INC(i) END;
out[i] := 0X
END ToUnicode;
PROCEDURE ToExtendedAscii* (IN in: ARRAY OF CHAR; OUT out: ARRAY OF CHAR);
VAR len, i: INTEGER;
BEGIN
len := LEN(in$); i := 0;
WHILE i < len DO out[i] := ExtendedAsciiOf(in[i]); INC(i) END;
out[i] := 0X
END ToExtendedAscii;
PROCEDURE Init;
VAR i: INTEGER;
BEGIN
(* Russian only *)
ru1251.name := 'Russian subset of CP1251';
ru1251.E := "АБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ";
ru1251.e := "абвгдежзийклмнопрстуфхцчшщъыьэюя";
FOR i := 0 TO 31 DO
ru1251.U[i] := CHR( 0410H + i );
ru1251.u[i] := CHR( 0410H + 32 + i );
END;
(* CYRILLIC IO *)
ru1251.E[i] := 0A8X;
ru1251.e[i] := 0B8X;
ru1251.U[i] := 0401X;
ru1251.u[i] := 0451X;
INC(i);
ru1251.E[i] := 0X;
ru1251.e[i] := 0X;
ru1251.U[i] := 0X;
ru1251.u[i] := 0X;
(* East Slavic = Byelorussian + Russian + Ukrainian *)
eastSlav1251 := ru1251;
eastSlav1251.name := 'East Slavic subset of CP1251';
i := LEN( eastSlav1251.U$ );
(* CYRILLIC SHORT U *)
eastSlav1251.E[i] := 0A1X;
eastSlav1251.e[i] := 0A2X;
eastSlav1251.U[i] := 040EX;
eastSlav1251.u[i] := 045EX;
INC(i);
(* CYRILLIC BYELORUSSIAN-UKRAINIAN I *)
eastSlav1251.E[i] := 0B2X;
eastSlav1251.e[i] := 0B3X;
eastSlav1251.U[i] := 0406X;
eastSlav1251.u[i] := 0456X;
INC(i);
(* CYRILLIC UKRAINIAN IE *)
eastSlav1251.E[i] := 0AAX;
eastSlav1251.e[i] := 0BAX;
eastSlav1251.U[i] := 0404X;
eastSlav1251.u[i] := 0454X;
INC(i);
(* CYRILLIC YI *)
eastSlav1251.E[i] := 0AFX;
eastSlav1251.e[i] := 0BFX;
eastSlav1251.U[i] := 0407X;
eastSlav1251.u[i] := 0457X;
INC(i);
(* CYRILLIC GHE WITH UPTURN *)
eastSlav1251.E[i] := 0A5X;
eastSlav1251.e[i] := 0B4X;
eastSlav1251.U[i] := 0490X;
eastSlav1251.u[i] := 0491X;
INC(i);
eastSlav1251.E[i] := 0X;
eastSlav1251.e[i] := 0X;
eastSlav1251.U[i] := 0X;
eastSlav1251.u[i] := 0X;
(* complete Cyrillic CP1251 *)
cyr1251 := eastSlav1251;
cyr1251.name := "Cyrillic CP1251";
i := LEN( cyr1251.U$ );
(* CYRILLIC DJE *)
cyr1251.E[i] := 080X;
cyr1251.e[i] := 090X;
cyr1251.U[i] := 0402X;
cyr1251.u[i] := 0452X;
INC(i);
(* CYRILLIC GJE *)
cyr1251.E[i] := 081X;
cyr1251.e[i] := 083X;
cyr1251.U[i] := 0403X;
cyr1251.u[i] := 0453X;
INC(i);
(* CYRILLIC LJE *)
cyr1251.E[i] := 08AX;
cyr1251.e[i] := 09AX;
cyr1251.U[i] := 0409X;
cyr1251.u[i] := 0459X;
INC(i);
(* CYRILLIC NJE *)
cyr1251.E[i] := 08CX;
cyr1251.e[i] := 09CX;
cyr1251.U[i] := 040AX;
cyr1251.u[i] := 045AX;
INC(i);
(* CYRILLIC KJE *)
cyr1251.E[i] := 08DX;
cyr1251.e[i] := 09DX;
cyr1251.U[i] := 40CX;
cyr1251.u[i] := 45CX;
INC(i);
(* CYRILLIC TSHE *)
cyr1251.E[i] := 08EX;
cyr1251.e[i] := 09EX;
cyr1251.U[i] := 40BX;
cyr1251.u[i] := 45BX;
INC(i);
(* CYRILLIC DZHE *)
cyr1251.E[i] := 08FX;
cyr1251.e[i] := 09FX;
cyr1251.U[i] := 40FX;
cyr1251.u[i] := 45FX;
INC(i);
(* CYRILLIC JE *)
cyr1251.E[i] := 0A3X;
cyr1251.e[i] := 0BCX;
cyr1251.U[i] := 408X;
cyr1251.u[i] := 458X;
INC(i);
(* CYRILLIC DZE *)
cyr1251.E[i] := 0BDX;
cyr1251.e[i] := 0BEX;
cyr1251.U[i] := 405X;
cyr1251.u[i] := 455X;
INC(i);
(*
(* CYRILLIC *)
cyr1251.E[i] := ;
cyr1251.e[i] := ;
cyr1251.U[i] := ;
cyr1251.u[i] := ;
INC(i);
*)
cyr1251.E[i] := 0X;
cyr1251.e[i] := 0X;
cyr1251.U[i] := 0X;
cyr1251.u[i] := 0X;
END Init;
PROCEDURE Set ( IN E, e, U, u: ARRAY OF CHAR; name: ARRAY OF CHAR );
VAR i, icap, ilow, j: INTEGER;
BEGIN
ASSERT( (LEN(E$)=LEN(e$)) & (LEN(E$)=LEN(U$)) & (LEN(E$)=LEN(u$)), 20 );
FOR i := 0 TO LEN(E$)-1 DO
ASSERT( (128 <= ORD(E[i])) & (ORD(E[i]) < 256), 21 );
ASSERT( (128 <= ORD(e[i])) & (ORD(e[i]) < 256), 22 );
ASSERT( ORD(U[i]) >= 128, 23 ); (* not >=256 to allow for U=E, u=e, etc.*)
ASSERT( ORD(u[i]) >= 128, 24 );
END;
charSetName := name$;
FOR j := 0 TO 255 DO
ascii[j].cap := CHR(j); (* self *)
ascii[j].low := CHR(j); (* self *)
ascii[j].isCap := FALSE;
ascii[j].isLetter := FALSE;
ascii[j].isFirstIdentChar := FALSE;
ascii[j].isIdentChar := FALSE;
END;
j := ORD('_');
ascii[j].isFirstIdentChar := TRUE;
ascii[j].isIdentChar := TRUE;
FOR j := ORD("0") TO ORD("9") DO
ascii[j].isIdentChar := TRUE
END;
FOR icap := ORD("A") TO ORD("Z") DO ilow := icap+32;
ascii[icap].low := CHR(ilow);
ascii[ilow].cap := CHR(icap);
ascii[icap].isCap := TRUE;
ascii[icap].isLetter := TRUE;
ascii[ilow].isLetter := TRUE;
ascii[icap].isFirstIdentChar := TRUE;
ascii[ilow].isFirstIdentChar := TRUE;
ascii[icap].isIdentChar := TRUE;
ascii[ilow].isIdentChar := TRUE;
END;
FOR i := 0 TO 255 DO
ascii[i].unicode := CHR(i) (* self by default *)
END;
FOR i := 0 TO uRange-1 DO
unicode[i].ascii := '?';
unicode[i].cap := CHR(i + uBase); (* self by default *)
unicode[i].low := CHR(i + uBase); (* self by default *)
unicode[i].isCap := FALSE;
unicode[i].isLetter := TRUE;
END;
FOR i := 0 TO LEN(E$)-1 DO
ascii[ORD( E[i] )].isLetter := TRUE;
ascii[ORD( e[i] )].isLetter := TRUE;
ascii[ORD( E[i] )].isCap := TRUE;
ascii[ORD( E[i] )].low := e[i];
ascii[ORD( e[i] )].cap := E[i];
ascii[ORD( E[i] )].unicode := U[i];
ascii[ORD( e[i] )].unicode := u[i];
unicode[ORD(U [i]) - uBase].ascii := E[i];
unicode[ORD(u [i]) - uBase].ascii := e[i];
unicode[ORD(u [i]) - uBase].cap := U [i];
unicode[ORD(U [i]) - uBase].low := u [i];
unicode[ORD(U [i]) - uBase].isCap := TRUE;
unicode[ORD(U [i]) - uBase].isLetter := TRUE;
unicode[ORD(u [i]) - uBase].isLetter := TRUE;
END;
FOR i := 128 TO 255 DO
ascii[i].isFirstIdentChar := ascii[i].isLetter;
ascii[i].isIdentChar := ascii[i].isLetter;
END;
END Set;
(*
PROCEDURE Show ( IN cs: Charset );
BEGIN
Log.Ln;
Log.String(cs.name); Log.Ln;
Log.String(cs.E); Log.Ln;
Log.String(cs.e); Log.Ln;
Log.String(cs.U); Log.Ln;
Log.String(cs.u); Log.Ln;
END Show;
PROCEDURE Tests*;
VAR j: INTEGER; ch: CHAR;
BEGIN
Show(Ru1251);
Show(EastSlav1251);
(*
Show(Cyr1251);
*)
Log.Ln;
Log.String('active charset:'); Log.Ln;
Log.Ln;
Show(active);
Log.String('Characters allowed in identifiers:'); Log.Ln;
FOR j := 128 TO 255 DO
ch := CHR(j);
IF IsLetter( ch ) THEN
Log.Char( ch ); Log.Char('-');
END;
END;
FOR j := 0 TO 255 DO
ch := CHR(j);
ASSERT( ExtendedAsciiOf( UnicodeOf(ch) ) = ch )
END;
FOR j := uBase TO uBase + uRange - 1 DO
ch := ExtendedAsciiOf( CHR(j) );
ASSERT( (ch = '?') OR ( UnicodeOf(ch) = CHR(j) ) )
END;
END Tests;
*)
BEGIN
Init;
(* Set( ru1251.E, ru1251.e, ru1251.U, ru1251.u, ru1251.name ); *)
Set( eastSlav1251.E, eastSlav1251.e, eastSlav1251.U, eastSlav1251.u, eastSlav1251.name );
(* Set( cyr1251.E, cyr1251.e, cyr1251.U, cyr1251.u, cyr1251.name ); *)
END i21sysCyrillic.
**************************************
**************************************
**************************************
**************************************
**************************************
**************************************
MODULE y;
IMPORT Log := StdLog, In := i21sysIn, Math, i21sysCyrillics;
PROCEDURE Do*;
VAR ch: CHAR;
BEGIN
ch := "ё";
Log.Char( ch );
ch := i21sysCyrillics.UnicodeOf( ch );
Log.Char( ch );
ch := i21sysCyrillics.Cap( ch );
Log.Char( ch );
(* сербская строчная буковка, при включенной поддержке вост-слав. букв должна давать Cap, равный себе: *)
ch := CHR( 459H );
Log.Char( ch );
ch := i21sysCyrillics.Cap( ch );
Log.Char( ch );
Log.Ln;
END Do;
END y.Do | i21sys/Mod/Cyrillic.odc |
MODULE i21sysDesktop; (* FVT 2009-03-17; last changed: 2010-09-21 *)
(* Derived from PrivDesktop by
Bruno Essmann ([email protected]),
Guy Laden ([email protected]),
Iain Scott ([email protected]);
see also Desktop at http://www.zinnamturm.eu.
This version by Fyodor Tkachov is an attempt to simpify and clarify the original. *)
IMPORT Strings, Files, Stores, Views, TextViews, TextControllers,
Dialog, Converters, StdCmds, Log := StdLog,
Windows, Documents, WinApi, HostFiles, HostWindows, HostCmds, HostMenus;
CONST
magic = 'Информатика-21'; version = 1;
minimized = 0; maximized = 1; (* Window states *)
logTitle = "#Dev:Log";
saveType = "i21";
VAR
saveName-: Files.Name;
savePath-: ARRAY 2000 OF CHAR;
list: Link;
failed: BOOLEAN;
TYPE
Window = Windows.Window;
Path = POINTER TO ARRAY OF CHAR;
Link = POINTER TO RECORD ( Stores.Store )
next: Link;
level: INTEGER; (* > 0; номер окна во внутр. списке ОСи; XP переводит фокус в голову списка *)
win: Window;
title: Views.Title;
w, h: INTEGER; (* ширина и высота вьюшки в пикселях *)
l, t, r, b: INTEGER; (* позиция окна (с рамками и т.п.) на экране в пикселях *)
state: SET;
i: Info;
e: Extension;
END;
Info = POINTER TO ABSTRACT RECORD ( Stores.Store ) END;
LogInfo = POINTER TO RECORD ( Info )
END;
DocInfo = POINTER TO RECORD ( Info )
path: Path;
name: Files.Name;
conv: Converters.Converter;
END;
TempInfo = POINTER TO RECORD ( Info )
flags: SET;
doc: Documents.Document;
dirty: BOOLEAN;
title: Views.Title; (* копия соотв. Link.title *)
END;
SubInfo = POINTER TO RECORD ( Info )
parent: INTEGER;
END;
Extension = POINTER TO ABSTRACT RECORD ( Stores.Store ) END;
TextExt = POINTER TO RECORD ( Extension )
rangeBeg, rangeEnd: INTEGER; (* visible range *)
caretPos: INTEGER; (* position of caret *)
selBeg, selEnd: INTEGER; (* selection settings *)
END;
SubTextExt = POINTER TO RECORD ( Extension )
rangeBeg, rangeEnd: INTEGER; (* visible range *)
END;
PROCEDURE GetPath ( loc: Files.Locator; OUT isLocal: BOOLEAN; OUT path: Path );
(* returns relative path w.r.t. (secondary) BlackBox path, unless loc is external *)
VAR bbpath, absolute: Path; pos: INTEGER;
BEGIN
ASSERT( loc # NIL );
NEW( bbpath, LEN( Files.dir.This('')( HostFiles.Locator ).path$ ) + 1 );
bbpath^ := Files.dir.This('')( HostFiles.Locator ).path$;
NEW( absolute, LEN( loc( HostFiles.Locator ).path$ ) + 1 );
absolute^ := loc( HostFiles.Locator ).path$;
NEW( path, LEN( absolute ) );
path^ := absolute$;
Strings.Find( path, bbpath, 0, pos );
isLocal := ( pos = 0 );
IF isLocal THEN (* можно "оторвать" bbpath от начала path *)
Strings.Replace( path, 0, LEN( bbpath$ ) + 1, '' );
END;
END GetPath;
PROCEDURE WriteConverter ( VAR wr: Stores.Writer; c: Converters.Converter );
VAR
BEGIN
IF c # NIL THEN
wr.WriteString( c.imp );
wr.WriteString( c.exp );
wr.WriteString( c.storeType );
wr.WriteString( c.fileType );
wr.WriteSet( c.opts )
ELSE
wr.WriteString(''); wr.WriteString(''); (* sentinel *)
END
END WriteConverter;
PROCEDURE ReadConverter ( VAR rd: Stores.Reader; OUT conv: Converters.Converter );
VAR imp, exp: Dialog.String;
storeType: Stores.TypeName; fileType: Files.Type; opts: SET;
c: Converters.Converter;
BEGIN
rd.ReadString( imp );
rd.ReadString( exp );
IF ( imp = '' ) & ( exp = '' ) THEN conv := NIL; RETURN END;
rd.ReadString( storeType );
rd.ReadString( fileType );
rd.ReadSet( opts );
Converters.Register( imp, exp, storeType, fileType, opts );
c := Converters.list;
WHILE ( c # NIL ) &
~( ( c.imp = imp ) & ( c.exp = exp ) &
( c.storeType = storeType ) & ( c.fileType = fileType ) & ( c.opts = opts ) )
DO
c := c.next
END;
conv := c
END ReadConverter;
PROCEDURE IsLog ( win: Windows.Window ): BOOLEAN;
VAR title: Views.Title;
BEGIN
win.GetTitle( title );
RETURN title = logTitle
END IsLog;
(*
PROCEDURE LogList ( s: ARRAY OF CHAR );
VAR l: Link;
BEGIN
Log.Ln; Log.String('*********** LogList, ' + s ); Log.Ln;
l := list;
WHILE l # NIL DO
Log.Int( l.level );
Log.String( ' ' + l.title );
IF l.i IS SubInfo THEN Log.String(' --вторичное') END;
Log.Ln;
Log.Int( l.w ); Log.Int( l.h ); Log.Ln;
Log.Int( l.l ); Log.Int( l.t ); Log.Int( l.r ); Log.Int( l.b ); Log.Ln;
Log.Set( l.state ); Log.Ln;
Log.Ln;
l := l.next
END;
END LogList;
*)
PROCEDURE NewLink ( win: Window ): Link;
VAR l: Link; wh: WinApi.HANDLE; ret: WinApi.BOOL; wp: WinApi.WINDOWPLACEMENT;
BEGIN
ASSERT( win # NIL );
NEW( l );
win.GetTitle( l.title );
win.GetSize( l.w, l.h ); (* вроде внутренние размеры окна в пикселях *)
wh := win( HostWindows.Window ).wnd;
ret := WinApi.GetWindowPlacement( wh, wp ); (* relative position in app window *)
l.l := wp.rcNormalPosition.left;
l.t := wp.rcNormalPosition.top;
l.r := wp.rcNormalPosition.right;
l.b := wp.rcNormalPosition.bottom;
l.state := {};
IF WinApi.IsIconic ( wh ) = 1 THEN INCL( l.state, minimized ) END;
IF WinApi.IsZoomed ( wh ) = 1 THEN INCL( l.state, maximized ) END;
RETURN l
END NewLink;
PROCEDURE ( l: Link ) Restore ( win: Window ), NEW;
VAR wh: WinApi.HANDLE; ret: WinApi.BOOL; x, y, w, h: INTEGER;
BEGIN
win.SetTitle( l.title );
win.SetSize( l.w, l.h ); (* ? вроде ниже тоже устанавливается *)
wh := win( HostWindows.Window ).wnd;
x := l.l; w := l.r - l.l;
y := l.t; h := l.b - l.t;
ret := WinApi.MoveWindow( wh, x, y, w, h, 1 );
END Restore;
PROCEDURE RestoreState ( win: Window; state: SET );
VAR wh: WinApi.HANDLE; ret: WinApi.BOOL;
BEGIN
wh := win( HostWindows.Window ).wnd;
IF minimized IN state THEN ret := WinApi.ShowWindow( wh, 6 ) END;
IF maximized IN state THEN ret := WinApi.ShowWindow( wh, 3 ) END;
END RestoreState;
PROCEDURE ( l: Link ) Externalize ( VAR wr: Stores.Writer );
BEGIN
wr.WriteStore( l.i );
wr.WriteStore( l.e );
wr.WriteInt( l.level );
wr.WriteString( l.title );
wr.WriteInt( l.w ); wr.WriteInt( l.h );
wr.WriteInt( l.l );
wr.WriteInt( l.t );
wr.WriteInt( l.r );
wr.WriteInt( l.b );
wr.WriteSet( l.state );
wr.WriteStore( l.next )
END Externalize;
PROCEDURE ( l: Link ) Internalize ( VAR rd: Stores.Reader );
VAR s: Stores.Store;
BEGIN
rd.ReadStore( s );
l.i := s( Info );
rd.ReadStore( s );
IF s # NIL THEN l.e := s( Extension ) END;
rd.ReadInt( l.level );
rd.ReadString( l.title );
rd.ReadInt( l.w ); rd.ReadInt( l.h );
rd.ReadInt( l.l );
rd.ReadInt( l.t );
rd.ReadInt( l.r );
rd.ReadInt( l.b );
rd.ReadSet( l.state );
rd.ReadStore( s );
IF s # NIL THEN l.next := s( Link ) END;
END Internalize;
PROCEDURE ( i: Info ) Init ( win: Windows.Window ), NEW, ABSTRACT;
PROCEDURE ( i: Info ) NewWindow (): Windows.Window, NEW, ABSTRACT;
PROCEDURE ( i: LogInfo ) Init ( win: Windows.Window );
BEGIN
END Init;
PROCEDURE ( info: LogInfo ) NewWindow (): Windows.Window;
VAR win: Windows.Window;
BEGIN
Log.Open;
win := Windows.dir.First();
WHILE ( win # NIL ) & ~IsLog( win ) DO
win := Windows.dir.Next( win )
END;
ASSERT( win # NIL );
RETURN win
END NewWindow;
PROCEDURE ( i: DocInfo ) Init ( win: Windows.Window );
VAR isLocal: BOOLEAN;
BEGIN
ASSERT( win # NIL, 20 );
IF win.loc # NIL THEN
GetPath( win.loc, isLocal, i.path ); (* isLocal not used ... yet? *)
i.name := win.name;
i.conv := win.conv;
ELSE
END;
END Init;
PROCEDURE ( i: DocInfo ) NewWindow (): Windows.Window;
VAR loc: Files.Locator; v: Views.View; win: Windows.Window;
BEGIN
loc := Files.dir.This( i.path );
v := Views.Old( Views.dontAsk, loc, i.name, i.conv );
IF v # NIL THEN
Views.Open( v, loc, i.name, i.conv );
win := Windows.dir.First();
WHILE ( win # NIL ) & ~( win.doc.ThisView() = v ) DO
win := Windows.dir.Next( win )
END;
ASSERT( win # NIL );
ELSE
win := NIL;
Dialog.ShowParamMsg( "#i21sys:UnableToRestoreDocument", i.name, "", "");
(* ws.type := AlienWindow *)
END;
RETURN win
END NewWindow;
PROCEDURE ( i: TempInfo ) Init ( win: Windows.Window );
BEGIN
ASSERT( win # NIL, 20 );
i.flags := win.flags;
i.doc := win.doc;
win.GetTitle( i.title );
i.dirty := ~( Windows.neverDirty IN win.flags ) & win.seq.Dirty();
END Init;
PROCEDURE ( i: TempInfo ) NewWindow (): Windows.Window;
VAR win: Windows.Window;
BEGIN
win := Windows.dir.New();
Windows.dir.OpenSubWindow( win, i.doc, i.flags, i.title );
win.SetSpec( NIL, '', NIL );
IF i.dirty THEN win.seq.SetDirty( TRUE ) END;
RETURN win
END NewWindow;
PROCEDURE ( i: SubInfo ) Init ( win: Windows.Window );
BEGIN
END Init;
PROCEDURE ( i: SubInfo ) NewWindow (): Windows.Window;
VAR l: Link; win: Windows.Window;
BEGIN
l := list;
WHILE ( l # NIL ) & ~( l.level = i.parent ) DO l := l.next END;
ASSERT( ( l # NIL ) & ( l.level = i.parent ) );
IF l.win # NIL THEN
Windows.dir.Select( l.win, Windows.eager );
StdCmds.NewWindow();
win := Windows.dir.Focus( FALSE );
ELSE
win := NIL
END;
RETURN win
END NewWindow;
PROCEDURE NewInfo ( win: Window ): Info;
VAR i: Info; log: LogInfo; doc: DocInfo; tmp: TempInfo; sub: SubInfo;
parent: Window; l: Link;
BEGIN
IF ~win.sub THEN
IF win.name # '' THEN
NEW( doc ); i := doc;
ELSIF IsLog( win ) THEN
NEW( log ); i := log;
ELSE
NEW( tmp ); i := tmp;
END;
ELSE
parent := win.link;
WHILE parent.sub DO parent := parent.link END;
l := list;
WHILE ( l # NIL ) & ~( l.win = parent ) DO l := l.next END;
ASSERT( ( l # NIL ) & ( l.win = parent ) );
NEW( sub ); sub.parent := l.level; i := sub
END;
RETURN i
END NewInfo;
PROCEDURE ( i: LogInfo ) Externalize ( VAR wr: Stores.Writer );
BEGIN
END Externalize;
PROCEDURE ( i: LogInfo ) Internalize ( VAR rd: Stores.Reader );
BEGIN
END Internalize;
PROCEDURE ( i: DocInfo ) Externalize ( VAR wr: Stores.Writer );
BEGIN
wr.WriteString( i.path );
wr.WriteString( i.name );
WriteConverter( wr, i.conv );
END Externalize;
PROCEDURE ( i: DocInfo ) Internalize ( VAR rd: Stores.Reader );
VAR string: ARRAY 2000 OF CHAR;
BEGIN
rd.ReadString( string ); NEW( i.path, LEN( string$ ) + 1 ); i.path^ := string$;
rd.ReadString( i.name );
ReadConverter( rd, i.conv );
END Internalize;
PROCEDURE ( i: TempInfo ) Externalize ( VAR wr: Stores.Writer );
VAR wr1: Stores.Writer;
BEGIN
wr.WriteSet( i.flags );
wr.WriteBool( i.dirty );
wr.WriteString( i.title );
wr1.ConnectTo( wr.rider.Base() ); (* иначе проблема с Domain *)
wr1.SetPos( wr.Pos() );
wr1.WriteStore( i.doc );
wr.SetPos( wr1.Pos() );
wr1.ConnectTo( NIL );
END Externalize;
PROCEDURE ( i: TempInfo ) Internalize ( VAR rd: Stores.Reader );
VAR s: Stores.Store; rd1: Stores.Reader;
BEGIN
rd.ReadSet( i.flags );
rd.ReadBool( i.dirty );
rd.ReadString( i.title );
rd1.ConnectTo( rd.rider.Base() ); (* иначе проблема с Domain *)
rd1.SetPos( rd.Pos() );
rd1.ReadStore( s );
rd.SetPos( rd1.Pos() );
i.doc := s( Documents.Document );
rd1.ConnectTo( NIL );
END Internalize;
PROCEDURE ( i: SubInfo ) Externalize ( VAR wr: Stores.Writer );
BEGIN
wr.WriteInt( i.parent );
END Externalize;
PROCEDURE ( i: SubInfo ) Internalize ( VAR rd: Stores.Reader );
BEGIN
rd.ReadInt( i.parent );
END Internalize;
PROCEDURE NewExtension ( v: Views.View; sub: BOOLEAN ): Extension;
VAR e: Extension; t: TextExt; s: SubTextExt;
BEGIN
e := NIL;
IF v # NIL THEN
WITH v: TextViews.View DO
IF sub THEN
NEW( s ); e := s;
ELSE
NEW( t ); e := t;
END;
ELSE
END;
END;
RETURN e
END NewExtension;
PROCEDURE ( e: Extension ) Init ( v: Views.View; f: Views.Frame ), NEW, ABSTRACT;
PROCEDURE ( e: Extension ) Restore ( v: Views.View; f: Views.Frame ), NEW, ABSTRACT;
PROCEDURE ( e: TextExt ) Init ( v: Views.View; f: Views.Frame );
VAR c: TextControllers.Controller;
BEGIN
WITH v: TextViews.View DO
v.GetRange( f, e.rangeBeg, e.rangeEnd );
c := v.ThisController()( TextControllers.Controller );
e.caretPos := c.CaretPos();
c.GetSelection( e.selBeg, e.selEnd );
END;
END Init;
PROCEDURE ( e: TextExt ) Restore ( v: Views.View; f: Views.Frame );
VAR c: TextControllers.Controller; len: INTEGER;
BEGIN
IF v # NIL THEN
WITH v: TextViews.View DO
len := v.ThisModel().Length();
IF e.rangeEnd <= len THEN
v.ShowRangeIn( f, e.rangeBeg, e.rangeEnd );
END;
c := v.ThisController()( TextControllers.Controller );
IF ( 0 <= e.caretPos ) & ( e.caretPos <= len ) THEN
c.SetCaret( e.caretPos );
END;
IF ( e.selBeg <= e.selEnd ) & ( e.selEnd <= len ) THEN
c.SetSelection( e.selBeg, e.selEnd );
END;
END;
END;
END Restore;
PROCEDURE ( e: SubTextExt ) Init ( v: Views.View; f: Views.Frame );
BEGIN
WITH v: TextViews.View DO
v.GetRange( f, e.rangeBeg, e.rangeEnd );
END;
END Init;
PROCEDURE ( e: SubTextExt ) Restore ( v: Views.View; f: Views.Frame );
BEGIN
WITH v: TextViews.View DO
v.ShowRangeIn( f, e.rangeBeg, e.rangeEnd );
END;
END Restore;
PROCEDURE ( e: TextExt ) Externalize ( VAR wr: Stores.Writer );
BEGIN
wr.WriteInt( e.rangeBeg );
wr.WriteInt( e.rangeEnd );
wr.WriteInt( e.selBeg );
wr.WriteInt( e.selEnd );
wr.WriteInt( e.caretPos );
END Externalize;
PROCEDURE ( e: TextExt ) Internalize ( VAR rd: Stores.Reader );
BEGIN
rd.ReadInt( e.rangeBeg );
rd.ReadInt( e.rangeEnd );
rd.ReadInt( e.selBeg );
rd.ReadInt( e.selEnd );
rd.ReadInt( e.caretPos );
END Internalize;
PROCEDURE ( e: SubTextExt ) Externalize ( VAR wr: Stores.Writer );
BEGIN
wr.WriteInt( e.rangeBeg );
wr.WriteInt( e.rangeEnd );
END Externalize;
PROCEDURE ( e: SubTextExt ) Internalize ( VAR rd: Stores.Reader );
BEGIN
rd.ReadInt( e.rangeBeg );
rd.ReadInt( e.rangeEnd );
END Internalize;
PROCEDURE InitListFromWindows;
VAR new: Link; win: Window; level, sub: INTEGER; v: Views.View;
BEGIN
list := NIL;
(* обрабатываем сначала (sub=1) первичные, потом (sub=2) вторичные окна: *)
FOR sub := 1 TO 2 DO
level := 0; win := Windows.dir.First();
WHILE win # NIL DO
INC( level );
IF ( sub = 2 ) = win.sub THEN
new := NewLink( win );
new.level := level;
new.win := win;
new.i := NewInfo( win );
new.i.Init( win );
v := win.doc.ThisView();
new.e := NewExtension( v, win.sub );
IF new.e # NIL THEN
new.e.Init( v, win.frame );
END;
new.next := list; list := new;
END;
win := Windows.dir.Next( win );
END;
END;
END InitListFromWindows;
PROCEDURE RestoreWindowsFromList;
VAR new, l: Link; nwin, level: INTEGER;
BEGIN
(* обратить list *)
nwin := 0;
new := NIL;
l := list;
WHILE l # NIL DO INC( nwin );
list := list.next;
l.next := new; new := l;
l := list
END;
list := new;
(* LogList( 'после обращения' ); (* нарушает порядок окон? *) *)
(* восстанавливаем окна с содержимым, не заботясь о расположении;
список в данный момент устроен так, что сначала идут основные окна, потом вторичные *)
l := list;
WHILE l # NIL DO
l.win := l.i.NewWindow();
IF l.win # NIL THEN
ELSE
Dialog.ShowParamMsg( "#i21sys:UnableToRestoreDocument", l.title, "", "");
END;
l := l.next;
END;
(* InitListFromWindows; LogList( 'после восстановления, без расположения' ); *)
(* восстанавливаем расположение, с конца по level *)
level := nwin;
WHILE level > 0 DO
l := list;
WHILE ( l # NIL ) & ~( l.level = level ) DO l := l.next END;
IF l.win # NIL THEN
Windows.dir.Select( l.win, Windows.eager ); (* поднимаем окно наверх *)
l.Restore( l.win );
IF l.e # NIL THEN
l.e.Restore( l.win.doc.ThisView(), l.win.frame );
END;
RestoreState( l.win, l.state );
END;
DEC( level );
END;
(* InitListFromWindows; LogList( 'после восстановления' ); *)
END RestoreWindowsFromList;
PROCEDURE Init;
BEGIN
savePath := ''; saveName := 'desktop.' + saveType;
END Init;
PROCEDURE Unsaved (): Windows.Window;
VAR w: Windows.Window;
BEGIN
w := Windows.dir.First();
WHILE (w # NIL) & ~( w.seq.Dirty() & ~(Windows.neverDirty IN w.flags) ) DO
w := Windows.dir.Next(w)
END;
RETURN w
END Unsaved;
PROCEDURE Save*;
VAR loc: Files.Locator; file: Files.File; wr: Stores.Writer; res: INTEGER;
BEGIN
IF Unsaved() # NIL THEN
Dialog.ShowMsg('#i21sys:CannotSave');
Windows.dir.Select( Unsaved(), Windows.lazy )
ELSE
InitListFromWindows; (* LogList( 'prior to writing to disk' ); *)
loc := Files.dir.This( savePath ); ASSERT( loc # NIL );
file := Files.dir.New( loc, Files.dontAsk ); ASSERT( loc.res = 0 ); ASSERT( file # NIL );
wr.ConnectTo( file );
wr.WriteString( magic );
wr.WriteByte( version );
wr.WriteStore( list );
wr.ConnectTo( NIL );
file.Register( saveName, '', Files.dontAsk, res ); ASSERT( res = 0 );
END;
END Save;
PROCEDURE SaveAs*;
VAR ok: BOOLEAN; loc: Files.Locator; fileName: Files.Name;
BEGIN
IF Unsaved() # NIL THEN
Dialog.ShowMsg('#i21sys:CannotSave');
Windows.dir.Select( Unsaved(), Windows.lazy )
ELSE
loc := Files.dir.This( savePath );
fileName := '';
Dialog.GetExtSpec( fileName, saveType, loc, fileName );
ok := loc # NIL;
IF ok THEN
savePath := loc( HostFiles.Locator ).path$;
saveName := fileName;
Save;
(* Init; *)
END
END
END SaveAs;
PROCEDURE SaveGuard (VAR par: Dialog.Par);
(** checks that there are no unsaved documents **)
BEGIN
par.disabled := ( Unsaved() # NIL )
END SaveGuard;
PROCEDURE CloseAllWindows (): BOOLEAN;
VAR win, prec: Windows.Window;
BEGIN
prec := NIL; win := Windows.dir.First();
WHILE ( win # NIL ) & ( win # prec ) DO
Windows.dir.Select( win, FALSE );
HostCmds.Close();
prec := win; win := Windows.dir.First();
END;
RETURN win = NIL
END CloseAllWindows;
PROCEDURE Exit*;
BEGIN
HostCmds.SaveAll;
IF Unsaved() # NIL THEN
Dialog.ShowMsg('#i21sys:CannotExit');
Windows.dir.Select( Unsaved(), Windows.lazy )
ELSE
Save;
HostMenus.Exit
END
END Exit;
PROCEDURE Close*;
VAR ok: BOOLEAN;
BEGIN
IF Unsaved() # NIL THEN
Dialog.ShowMsg('#i21sys:CannotExit');
Windows.dir.Select( Unsaved(), Windows.lazy )
ELSE
Save;
ok := CloseAllWindows();
END
END Close;
PROCEDURE RestoreFromFile ( file: Files.File );
VAR rd: Stores.Reader; s: Stores.Store; mag: ARRAY 100 OF CHAR; v: BYTE; ok: BOOLEAN;
BEGIN
ASSERT( file # NIL, 20 );
rd.ConnectTo( file );
rd.ReadString( mag );
ok := ( mag = magic );
IF ok THEN
rd.ReadByte( v );
ok := ( v = version );
END;
IF ok THEN
rd.ReadStore( s ); IF s # NIL THEN list := s( Link ) END;
(* LogList( 'just from disk' ); *)
RestoreWindowsFromList;
END;
rd.ConnectTo( NIL );
END RestoreFromFile;
PROCEDURE RestoreFrom* ( name: ARRAY OF CHAR );
VAR loc: Files.Locator; file: Files.File; ok: BOOLEAN;
BEGIN
loc := Files.dir.This('');
ok := loc # NIL;
IF ok THEN
file := Files.dir.Old( loc, name$, Files.shared );
ok := ( loc.res = 0 ) & ( file # NIL );
END;
IF ok THEN
RestoreFromFile( file );
END;
END RestoreFrom;
PROCEDURE Restore*;
VAR loc: Files.Locator; file: Files.File; ok: BOOLEAN;
BEGIN
loc := Files.dir.This( savePath );
ok := loc # NIL;
IF ok THEN
file := Files.dir.Old( loc, saveName, Files.shared );
ok := ( loc.res = 0 ) & ( file # NIL );
END;
IF ok THEN
RestoreFromFile( file );
END;
END Restore;
PROCEDURE Open*;
VAR ok: BOOLEAN; loc: Files.Locator; fileName: Files.Name;
BEGIN
loc := Files.dir.This( savePath );
fileName := saveName;
Dialog.GetIntSpec( saveType, loc, fileName );
ok := loc # NIL;
(*
IF ok THEN
ok := CloseAllWindows();
END;
Log.Ln; Log.Bool( ok ); Log.Ln;
*)
IF ok THEN
savePath := loc( HostFiles.Locator ).path$;
saveName := fileName$; (* здесь оно возвращается с расширением *)
Restore;
(* Init; *)
END;
END Open;
BEGIN Init
END i21sysDesktop.
i21sysDesktop.Save
i21sysDesktop.Restore
i21sysDesktop.SaveAs
i21sysDesktop.Open
i21sysDesktop.Close | i21sys/Mod/Desktop.odc |
MODULE i21sysEdit; (** **)
(* 2011-12-19 Ф.В.Ткачев сортировки etc. *)
(* 2010-09-30 Ф.В.Ткачев полная отвязка от национального языка *)
(* 2010-04-11 Ф.В.Ткачев радикальная переделка *)
(* 2008-03-23 Ф.В.Ткачев очищено от дорусификационных артефактов *)
(* 2000-11-20 Ф.В.Ткачев первая версия *)
IMPORT Ports, Strings, Fonts, Views, Stores, Models, Files, Converters,
M := TextModels, TextControllers, TextViews, TextMappers, Log := StdLog,
Ch := i21sysCharacters, Sc := i21sysScanner, Vo := i21sysVocabulary;
TYPE
String = Sc.String;
Formatter = TextMappers.Formatter;
What = PROCEDURE (translate: BOOLEAN; tabs: INTEGER; VAR fm: Formatter; OUT pos: INTEGER);
TYPE Keyword = POINTER TO RECORD (Vo.Entry) END; (* key = keyword *)
VAR keywords: Vo.Vocabulary; (* ключ. слова для угадывания по начальным буквам *)
TYPE Hint = POINTER TO RECORD (Vo.Entry)
(* key = short version of keyword *)
keyword: String; (* full version *)
END;
VAR hints: Vo.Vocabulary; (* подсказки для разрешения двусмысленностей в соответствии с удобством; проверяются до попытки восстановить полное слово по списку words *)
TYPE Simple = POINTER TO RECORD (Vo.Entry)
(* key = keyword *)
expansion0: String; (* исходная цепочка с "|" *)
expansion: String; (* подставляемая цепочка без "|" *)
back: INTEGER; (* на сколько позиций назад вернуть курсор после подстановки *)
END;
VAR simples: Vo.Vocabulary; (* простые подстановки *)
TYPE
Complex = POINTER TO RECORD (Vo.Entry)
Do: What; (* процедура, создающая конструкцию *)
END;
VAR complexes: Vo.Vocabulary; (* слова, раскрывающиеся в сложные конструкции *)
(* keywords *)
PROCEDURE LogKeywords*;
BEGIN keywords.Log
END LogKeywords;
PROCEDURE AddKeyword ( s: String; replace: BOOLEAN );
VAR k: Keyword;
BEGIN
NEW( k );
keywords.Insert( k, s$, replace );
END AddKeyword;
PROCEDURE AddKeywords* ( lan: ARRAY OF CHAR; name: ARRAY OF CHAR );
BEGIN
Sc.Open( lan, name$ );
IF Sc.done THEN Sc.Next END;
WHILE Sc.done DO
AddKeyword( Sc.string, Vo.dontReplace );
Sc.Next
END;
END AddKeywords;
PROCEDURE GuessKeyword (VAR s: String); (* Ищем среди keywords что-нибудь, начинающееся на s$; если находим, то заменяем s на найденное. *)
VAR e: Vo.Entry; j, l: INTEGER; complete: String;
BEGIN
e := keywords.Find(s, FALSE);
IF e # NIL THEN
complete := e.key;
(* является ли s началом complete: *)
j := 0; l := LEN(s$);
WHILE (j < l) & (s[j] = complete[j]) DO INC(j) END;
IF j = l THEN
s := complete
END
END;
END GuessKeyword;
(* hints *)
PROCEDURE ( e: Hint ) Log;
BEGIN Log.Tab; Log.String( e.keyword );
END Log;
PROCEDURE LogHints*;
BEGIN hints.Log
END LogHints;
PROCEDURE AddHints* ( lan: ARRAY OF CHAR; name: ARRAY OF CHAR );
VAR h: Hint; i: INTEGER;
BEGIN
Sc.Open(lan, name$);
IF Sc.done THEN Sc.Next END;
WHILE Sc.done DO
NEW(h);
hints.Insert(h, Sc.string, Vo.replace );
Sc.Next; ASSERT( Sc.done );
h.keyword := Sc.string;
AddKeyword( h.keyword, Vo.dontReplace );
Sc.Next
END;
END AddHints;
PROCEDURE ExpandHint (VAR w: String; OUT done: BOOLEAN);
VAR i: Vo.Entry;
BEGIN
i := hints.Find( w, TRUE );
done := ( i # NIL );
IF done THEN
w := i( Hint ).keyword;
END
END ExpandHint;
(* simples *)
PROCEDURE ( e: Simple ) Log;
BEGIN Log.Tab; Log.String( e.expansion0 );
END Log;
PROCEDURE LogSimples*;
BEGIN simples.Log
END LogSimples;
PROCEDURE Extract (from: String; OUT to: String; OUT back: INTEGER);
VAR i, l: INTEGER;
BEGIN
l := LEN(from$);
i := 0;
WHILE (i < l) & ~(from[i] = '|') DO to[i] := from[i]; INC(i) END;
IF i < l THEN
back := l - 1 - i;
WHILE i < l DO to[i] := from[i+1]; INC(i) END;
ASSERT( Strings.Valid(to) & (LEN(to$) = l-1) & (back >= 0) );
ELSE
back := 0;
to[l] := 0X;
END;
END Extract;
PROCEDURE AddSimples* ( lan: ARRAY OF CHAR; name: ARRAY OF CHAR );
VAR s: Simple; i: INTEGER; k: Keyword;
BEGIN
Sc.Open(lan, name$);
IF Sc.done THEN Sc.Next END;
WHILE Sc.done DO
NEW(s);
simples.Insert( s, Sc.string, Vo.replace );
Sc.Next; ASSERT( Sc.done ); (* дочитали пару *)
s.expansion0 := Sc.string;
Extract( s.expansion0, s.expansion, s.back );
AddKeyword( s.key, Vo.dontReplace );
Sc.Next
END;
END AddSimples;
PROCEDURE SimpleExpansion (VAR w: String; OUT done: BOOLEAN; OUT back: INTEGER);
VAR i: Vo.Entry;
BEGIN
i := simples.Find( w, TRUE );
done := i # NIL;
IF done THEN
w := i( Simple ).expansion;
back := i( Simple ).back;
END
END SimpleExpansion;
(* Сложные расширения, включающие в себя
переносы строк ИЛИ изменение атрибутов текста. *)
PROCEDURE NewLine (tabs: INTEGER; VAR fm: Formatter);
VAR i: INTEGER;
BEGIN fm.WriteLn; i := tabs; WHILE i > 0 DO fm.WriteTab; DEC(i) END;
END NewLine;
PROCEDURE Module (translate: BOOLEAN; tabs: INTEGER; VAR fm: Formatter; OUT pos: INTEGER);
VAR m, i, b, e: String;
BEGIN
m := 'MODULE';
i := 'IMPORT';
b := 'BEGIN';
e := 'END';
IF translate THEN
Vo.ToNational(m);
Vo.ToNational(i);
Vo.ToNational(b);
Vo.ToNational(e)
END;
fm.WriteString(m); fm.WriteString(" ;"); pos := fm.Pos() - 1;
NewLine(tabs+1, fm); fm.WriteString(i);
IF translate & (Vo.language = 'ru') THEN
fm.WriteString(" Вывод := i21eduВывод, Ввод := i21eduВвод;");
ELSE
fm.WriteString(" Log := StdLog, In := i21sysIn, Math;");
END;
NewLine(tabs, fm); fm.WriteTab;
(* NewLine(tabs, fm); fm.WriteString(b); *)
NewLine(tabs, fm); fm.WriteString(e); fm.WriteChar(".");
END Module;
PROCEDURE Procedure (translate: BOOLEAN; tabs: INTEGER; VAR fm: Formatter; OUT pos: INTEGER);
VAR p, v, b, e: String;
BEGIN
p := 'PROCEDURE';
v := 'VAR';
b := 'BEGIN';
e := 'END';
IF translate THEN
Vo.ToNational(p);
Vo.ToNational(v);
Vo.ToNational(b);
Vo.ToNational(e);
END;
fm.WriteString(p); fm.WriteString(" ;"); pos := fm.Pos() - 1;
NewLine(tabs+1, fm); fm.WriteString(v); fm.WriteString(" ");
NewLine(tabs, fm); fm.WriteString(b);
NewLine(tabs, fm); fm.WriteTab;
NewLine(tabs, fm); fm.WriteString(e); fm.WriteChar(';');
END Procedure;
PROCEDURE If (translate: BOOLEAN; tabs: INTEGER; VAR fm: Formatter; OUT pos: INTEGER);
VAR i, t, else, e: String;
BEGIN
i := 'IF';
t := 'THEN';
else := 'ELSE';
e := 'END';
IF translate THEN
Vo.ToNational(i);
Vo.ToNational(t);
Vo.ToNational(else);
Vo.ToNational(e)
END;
fm.WriteString(i + ' '); pos := fm.Pos();
fm.WriteString(' ' + t);
NewLine(tabs, fm); fm.WriteTab;
NewLine(tabs, fm); fm.WriteString(else);
NewLine(tabs, fm); fm.WriteTab;
NewLine(tabs, fm); fm.WriteString(e + ';')
END If;
PROCEDURE While (translate: BOOLEAN; tabs: INTEGER; VAR fm: Formatter; OUT pos: INTEGER);
VAR w, d, e: String;
BEGIN
w := 'WHILE';
d := 'DO';
e := 'END';
IF translate THEN
Vo.ToNational(w);
Vo.ToNational(d);
Vo.ToNational(e);
END;
fm.WriteString(w + ' '); pos := fm.Pos();
fm.WriteString(' ' + d);
NewLine(tabs, fm); fm.WriteTab;
NewLine(tabs, fm); fm.WriteString(e + ';')
END While;
PROCEDURE For (translate: BOOLEAN; tabs: INTEGER; VAR fm: Formatter; OUT pos: INTEGER);
VAR f, t, d, e: String;
BEGIN
f := 'F'+'OR'; (*чтобы в этом тексте не заменялось*)
t := 'TO';
d := 'DO';
e := 'END';
IF translate THEN
Vo.ToNational(f); (*чтобы в этом тексте не заменялось*)
Vo.ToNational(t);
Vo.ToNational(d);
Vo.ToNational(e)
END;
fm.WriteString(f + ' '); pos := fm.Pos();
fm.WriteString(' := ' + t + ' ' + d);
NewLine(tabs, fm); fm.WriteTab;
NewLine(tabs, fm); fm.WriteString(e + ';')
END For;
PROCEDURE Forbidden (translate: BOOLEAN; tabs: INTEGER; VAR fm: Formatter; OUT pos: INTEGER);
(* для отучения некоего 8-классника от FOR; подставляется вместо For в нижеследующем списке *)
VAR
BEGIN
NewLine(tabs, fm); fm.WriteString('МУЖИК ЧТО БЫК: ВТЕМЯШИТСЯ ');
NewLine(tabs, fm); fm.WriteString('В БАШКУ КАКАЯ БЛАЖЬ ');
NewLine(tabs, fm); fm.WriteString('КОЛОМ ЕЕ ОТТУДОВА');
NewLine(tabs, fm); fm.WriteString('НЕ ВЫБЬЕШЬ.');
NewLine(tabs, fm); fm.WriteString(' Н.А.Некрасов');
pos := fm.Pos();
END Forbidden;
PROCEDURE Return (translate: BOOLEAN; tabs: INTEGER; VAR fm: Formatter; OUT pos: INTEGER);
VAR r: String; a, bold: M.Attributes;
BEGIN
r := 'RETURN'; IF translate THEN Vo.ToNational(r) END;
a := fm.rider.attr;
bold := M.NewWeight(a, Fonts.bold);
fm.rider.SetAttr(bold);
fm.WriteString(r);
fm.rider.SetAttr(a);
fm.WriteString(' '); pos := fm.Pos()
END Return;
PROCEDURE Exit (translate: BOOLEAN; tabs: INTEGER; VAR fm: Formatter; OUT pos: INTEGER);
VAR e: String; a, bold: M.Attributes;
BEGIN
e := 'EXIT'; IF translate THEN Vo.ToNational(e) END;
a := fm.rider.attr;
bold := M.NewWeight(a, Fonts.bold);
fm.rider.SetAttr(bold);
fm.WriteString(e);
fm.rider.SetAttr(a);
fm.WriteString(' '); pos := fm.Pos()
END Exit;
PROCEDURE With (translate: BOOLEAN; tabs: INTEGER; VAR fm: Formatter; OUT pos: INTEGER);
VAR w, d, e: String;
BEGIN
w := 'WITH';
d := 'DO';
e := 'END';
IF translate THEN
Vo.ToNational(w);
Vo.ToNational(d);
Vo.ToNational(e);
END;
fm.WriteString(w + ' '); pos := fm.Pos();
fm.WriteString(' ' + d);
NewLine(tabs, fm); fm.WriteTab;
NewLine(tabs, fm); fm.WriteString(e + ';')
END With;
PROCEDURE Case (translate: BOOLEAN; tabs: INTEGER; VAR fm: Formatter; OUT pos: INTEGER);
VAR c, o, e: String;
BEGIN
c := 'CASE';
o := 'OF';
e := 'END';
IF translate THEN
Vo.ToNational(c);
Vo.ToNational(o);
Vo.ToNational(e);
END;
fm.WriteString(c + ' '); pos := fm.Pos();
fm.WriteString(' ' + o);
NewLine(tabs, fm); fm.WriteString('| : ');
NewLine(tabs, fm); fm.WriteString(e + ';')
END Case;
PROCEDURE Record (translate: BOOLEAN; tabs: INTEGER; VAR fm: Formatter; OUT pos: INTEGER);
VAR r, e: String;
BEGIN
r := 'RECORD';
e := 'END';
IF translate THEN
Vo.ToNational(r);
Vo.ToNational(e);
END;
fm.WriteString(r);
NewLine(tabs+1, fm); pos := fm.Pos();
NewLine(tabs, fm); fm.WriteString(e + ';')
END Record;
PROCEDURE Repeat (translate: BOOLEAN; tabs: INTEGER; VAR fm: Formatter; OUT pos: INTEGER);
VAR r, u: String;
BEGIN
r := 'REPEAT'; u := 'UNTIL';
IF translate THEN
Vo.ToNational(r); Vo.ToNational(u);
END;
fm.WriteString(r);
NewLine(tabs, fm); fm.WriteTab;
NewLine(tabs, fm); fm.WriteString(u + ' '); pos := fm.Pos(); fm.WriteString(';');
END Repeat;
PROCEDURE Loop (translate: BOOLEAN; tabs: INTEGER; VAR fm: Formatter; OUT pos: INTEGER);
VAR l, e: String;
BEGIN
l := 'LOOP'; e := 'END';
IF translate THEN
Vo.ToNational(l); Vo.ToNational(e);
END;
fm.WriteString(l);
NewLine(tabs+1, fm); pos := fm.Pos();
NewLine(tabs, fm); fm.WriteString(e + ';');
END Loop;
PROCEDURE Dijkstra (translate: BOOLEAN; tabs: INTEGER; VAR fm: Formatter; OUT pos: INTEGER);
VAR l, e: String; a, c: M.Attributes;
BEGIN
a := fm.rider.attr;
c := M.NewStyle(a, { Fonts.italic });
c := M.NewColor(c, Ports.RGBColor(00H, 70H, 60H));
fm.rider.SetAttr(c);
fm.WriteString("(" + "* multibranch Dijkstra"+"'"+"s loop: *"+")");
fm.rider.SetAttr(a);
NewLine(tabs, fm); fm.WriteString('LOOP IF '); pos := fm.Pos(); fm.WriteString(' THEN');
NewLine(tabs+1, fm);
NewLine(tabs, fm); fm.WriteString('ELSIF THEN');
NewLine(tabs+1, fm);
NewLine(tabs, fm); fm.WriteString('ELSE EXIT END END;');
END Dijkstra;
PROCEDURE Comment (translate: BOOLEAN; tabs: INTEGER; VAR fm: Formatter; OUT pos: INTEGER);
VAR l, e: String; a, c: M.Attributes;
BEGIN
a := fm.rider.attr;
c := M.NewStyle(a, { Fonts.italic });
c := M.NewColor(c, Ports.RGBColor(00H, 70H, 60H));
fm.rider.SetAttr(c);
fm.WriteString("(* *)");
fm.rider.SetAttr(a);
pos := fm.Pos() - 3;
END Comment;
PROCEDURE InitComplexes;
(* перечисляются все нетрив. синтаксические структуры;
для каждой предусмотрена отдельная процедура раскрытия (поле Do) *)
VAR c: Complex;
PROCEDURE Ins( s: ARRAY OF CHAR );
BEGIN complexes.Insert(c, s$, Vo.dontReplace);
END Ins;
BEGIN
complexes.Init;
NEW(c); c.Do := Case; Ins( 'CASE' );
NEW(c); c.Do := Comment; Ins( 'COMMENT' );
NEW(c); c.Do := Exit; Ins( 'EXIT' );
NEW(c); c.Do := If; Ins( 'IF' );
NEW(c); c.Do := Loop; Ins( 'LOOP' );
NEW(c); c.Do := Module; Ins( 'MODULE' );
NEW(c); c.Do := Procedure; Ins( 'PROCEDURE' );
NEW(c); c.Do := Record; Ins( 'RECORD' );
NEW(c); c.Do := Repeat; Ins( 'REPEAT' );
NEW(c); c.Do := Return; Ins( 'RETURN' );
NEW(c); c.Do := While; Ins( 'WHILE' );
NEW(c); c.Do := With; Ins( 'WITH' );
NEW(c); c.Do := Dijkstra; Ins( 'DIJKSTRA' );
NEW(c); c.Do := For; Ins( 'F'+'OR' );
(* NEW(c); c.Do := Forbidden; Ins( 'F'+'OR' );*)
(* для отучения некоторых хвататься за FOR, закомментить синюю строку и раскомментить красную, скомпилировать, перегрузить этот модуль *)
END InitComplexes;
PROCEDURE Find (IN s: String; OUT do: What; OUT translate: BOOLEAN);
VAR e: Vo.Entry; en: String;
BEGIN
en := s$;
Vo.ToEnglish(en);
e := complexes.Find( en$, TRUE );
IF e # NIL THEN
do := e(Complex).Do;
translate := s # en;
ELSE
do := NIL;
translate := FALSE;
END;
END Find;
PROCEDURE Copy (rd: M.Reader; beg, end: INTEGER; OUT s: ARRAY OF CHAR);
VAR i, length: INTEGER;
BEGIN
ASSERT(beg < end, 20);
length := end - beg;
rd.SetPos(beg);
i := 0; WHILE i < length DO rd.ReadChar(s[i]); INC(i) END;
s[i] := 0X;
END Copy;
PROCEDURE BackSelect (rd: M.Reader; VAR pos: INTEGER);
VAR ch: CHAR;
BEGIN
(* select the string of (*small*) characters and digits to left of insertion point *)
(* loop to find beginning *)
rd.SetPos(pos); rd.ReadPrevChar(ch);
WHILE Ch.IsIdentChar(ch) OR Ch.IsLetter(ch) OR (ch >= "0") & (ch <= "9") DO
DEC(pos); ASSERT(pos = rd.Pos(), 100); rd.ReadPrevChar(ch)
END;
END BackSelect;
PROCEDURE Indents (rd: M.Reader): INTEGER;
VAR pos, res: INTEGER; ch: CHAR;
BEGIN
pos := rd.Pos();
(* find start of line *)
ch := 0X;
WHILE ~((rd.Pos() = 0) OR (ch = 0DX) OR (ch = 0EX)) DO
rd.ReadPrevChar(ch)
END;
(* (r.Pos() = 0) OR (ch = 0DX) OR (ch = 0EX) *)
IF (ch = 0DX) OR (ch = 0EX) THEN rd.SetPos(rd.Pos() + 1) END;
(* count indents *)
res := 0;
REPEAT INC(res); rd.ReadChar(ch) UNTIL ch # 9X ;
DEC(res);
rd.SetPos(pos);
RETURN res
END Indents;
PROCEDURE Capitalize0 (expand: BOOLEAN);
VAR c: TextControllers.Controller;
fm: Formatter; a: M.Attributes;
back, beg, pos, end, tabs: INTEGER; done, translate: BOOLEAN;
rd: M.Reader;
s: String;
script: Stores.Operation;
Do: What;
BEGIN
c := TextControllers.Focus(); IF c = NIL THEN RETURN END;
IF c.HasSelection() THEN
c.GetSelection(beg, end); ASSERT(beg < end, 100);
ELSE
beg := c.CaretPos();
end := beg;
END;
ASSERT(beg <= end, 101);
rd := c.text.NewReader(rd); (* new reader at start of text *)
(* if no selection, select to left of insertion point *)
IF beg = end THEN BackSelect(rd, beg) END;
(* it is still possible that there is no selection *)
IF beg < end THEN
Copy(rd, beg, end, s); ASSERT(Strings.Valid(s), 100);
a := rd.attr; (* attributes from the last character in the segment beg, end *)
(* we can examine string and modify\expand it accordingly *)
Models.BeginScript (rd.Base(), "Expand", script); (* все действия до EndScript будут отменяться как целое при нажатии Ctrl+Z *)
rd.Base().Delete(beg, end);
fm.ConnectTo(rd.Base()); fm.SetPos(beg); fm.rider.SetAttr(a);
Ch.ToUnicode(s, s);
Ch.ToUpper(s, s);
IF ~expand THEN
fm.WriteString(s$); pos := fm.rider.Pos()
ELSE
rd.SetPos(beg);
tabs := Indents(rd);
ExpandHint(s, done);
IF ~done THEN GuessKeyword(s) END;
SimpleExpansion(s, done, back);
IF done THEN
fm.WriteString(s$); pos := fm.rider.Pos() - back;
ELSE
Find(s, Do, translate); (* по s ищем Do, translate;
Do # NIL <=> s есть начальное ключ. слово сложной конструкции;
translate <=> это начальное ключ. слово -- на нац языке *)
IF Do # NIL THEN
Do(translate, tabs, fm, pos)
ELSE
fm.WriteString(s$); pos := fm.rider.Pos()
END
END
END;
fm.ConnectTo(NIL);
c.SetCaret(pos);
Models.EndScript (rd.Base(), script);
END
END Capitalize0;
PROCEDURE Capitalize*;
(** guard: TextCmds.FocusGuard **)
BEGIN Capitalize0(FALSE)
END Capitalize;
PROCEDURE CapitalizeExpand*;
(** guard: TextCmds.FocusGuard **)
BEGIN Capitalize0(TRUE)
END CapitalizeExpand;
PROCEDURE Init;
BEGIN
keywords.Init;
AddKeywords('', 'keywords');
hints.Init;
AddHints( '', 'hints' );
simples.Init;
AddSimples( '', 'simples' );
InitComplexes;
END Init;
PROCEDURE SetLanguage* ( lan: ARRAY OF CHAR );
BEGIN
Init;
Vo.silent := TRUE;
Vo.SetLanguage( lan );
IF (lan # '') & (lan # 'en') THEN
AddKeywords( lan, 'vocab');
AddHints( lan, 'hints' );
AddSimples( lan, 'simples' );
END;
END SetLanguage;
BEGIN Init
END i21sysEdit.
"i21sysEdit.SetLanguage('')"
"i21sysEdit.SetLanguage('ru')"
левые части дополнительных hints/simples автоматически заносятся в список ключевых слов
"i21sysEdit.AddSimples('ua', 'robot')"
"i21sysVocabulary2.SetLanguage('')" (*никакого (кроме английского)*)
"i21sysEdit.AddHints('ru', 'hints')" "i21sys/Rsrc/ru/hints"
"i21sysVocabulary.SetLanguage('')" (*никакого (кроме английского)*)
"i21sysVocabulary.SetLanguage('ru')"
"i21sysVocabulary.SetLanguage('kabarda')"
"i21sysVocabulary.SetLanguage('ua')"
i21sysVocabulary.Log
"i21sysEdit.AddKeywords('', 'keywords')" "i21sys/Rsrc/keywords"
"i21sysEdit.AddKeywords('ru', 'keywords')" "i21sys/Rsrc/ru/keywords"
"i21sysEdit.AddKeywords('ru', 'vocab')" "i21sys/Rsrc/ru/vocab"
"i21sysEdit.AddKeywords('kabarda', 'vocab')"
"i21sysEdit.AddKeywords('ua', 'vocab')"
"i21sysEdit.AddHints('', 'hints')"
"i21sysEdit.AddHints('ru', 'hints')" "i21sys/Rsrc/ru/hints"
"i21sysEdit.AddHints('kabarda', 'hints')"
"i21sysEdit.AddHints('ua', 'hints')"
"i21sysEdit.AddSimples('', 'simples')"
"i21sysEdit.AddSimples('ru', 'simples')"
"i21sysEdit.AddSimples('kabarda', 'simples')"
"i21sysEdit.AddSimples('ua', 'simples')"
i21sysEdit.LogKeywords
i21sysEdit.LogHints
i21sysEdit.LogSimples
"i21sysVocabulary.SetLanguage('ru')"
"i21sysVocabulary.SetLanguage('')" | i21sys/Mod/Edit.odc |
MODULE i21sysFiles; (* info21 2010-04-07 *)
IMPORT Files, HostFiles;
VAR glopath: ARRAY 2000 OF CHAR;
PROCEDURE Copy* ( f: Files.File; to: Files.Locator; OUT new: Files.File; OUT res: INTEGER );
CONST buflen = 100000;
VAR rd: Files.Reader; wr: Files.Writer; buf: ARRAY buflen OF BYTE; rem, n: INTEGER;
BEGIN
ASSERT( f # NIL, 20 );
ASSERT( to # NIL, 21 );
rd := f.NewReader( NIL ); ASSERT( rd # NIL );
new := Files.dir.New( to, Files.dontAsk ); ASSERT( ( new # NIL ) & ( to.res = 0 ) );
wr := new.NewWriter( NIL ); ASSERT( wr # NIL );
rem := f.Length();
WHILE rem > 0 DO
n := MIN( rem, buflen );
rd.ReadBytes( buf, 0, n );
wr.WriteBytes( buf, 0, n );
DEC( rem, n );
END;
ASSERT( ( rd.Pos() = f.Length() ) & ( rd.Pos() = wr.Pos() ) );
res := 0;
ASSERT( res = 0, 126 );
END Copy;
(*
PROCEDURE Test; (* of Copy *)
VAR name: ARRAY 1000 OF CHAR; from, to: Files.Locator; f, new: Files.File; res: INTEGER;
BEGIN
from := Files.dir.This('u:\temp');
In.Open; In.String( name ); ASSERT( In.done );
f := Files.dir.Old( from, name$, Files.shared );
to := Files.dir.This( 'c:\temp' );
Copy( f, to, new, res );
new.Register( name$, '', Files.ask, res );
ASSERT( res = 0 );
END Test; (* i21sysFiles.Test "test.djv" "test.txt" "test.rar" *)
*)
PROCEDURE GetDiskLetter* ( loc: Files.Locator; OUT disk: CHAR );
VAR l, i, j: INTEGER; path: ARRAY 2000 OF CHAR;
BEGIN
ASSERT( loc # NIL, 20 );
disk := loc( HostFiles.Locator ).path[0]
END GetDiskLetter;
PROCEDURE GetFolderName* ( loc: Files.Locator; OUT name: ARRAY OF CHAR );
VAR l, i, j: INTEGER; path: ARRAY 2000 OF CHAR;
BEGIN
ASSERT( loc # NIL, 20 );
path := loc( HostFiles.Locator ).path$;
glopath := path$;
l := LEN( path$ );
i := l - 1;
WHILE ( i >= 0 ) & ~( path[ i ] = '\' ) DO
DEC( i )
END;
IF i > 0 THEN
INC( i ); j := 0;
WHILE i < l DO
name[ j ] := path[ i ];
INC( i ); INC( j )
END;
name[ j ] := 0X;
ELSE
ASSERT( i = -1 );
name := "\";
END;
END GetFolderName;
END i21sysFiles.
i21sys/Docu/ru/Files.odc | i21sys/Mod/Files.odc |
MODULE i21sysHello; (** для проекта Информатика-21 ФВТ 2009-10-05 *)
IMPORT StdLog;
PROCEDURE Do*;
VAR
BEGIN
StdLog.String('hello!'); StdLog.Ln;
END Do;
END i21sysHello.
i21sysHello.Do
| i21sys/Mod/Hello.odc |
MODULE i21sysIn;
(**
2012-09-21 Ф.В.Ткачев. Практика показала, что нужны альтернативы старой процедуре Open с более простой логикой принятия решения насчёт того, откуда брать поток ввода. Поэтому добавлены:
OpenSelection: открывает выделенный фрагмент (именно она теперь стоит в меню для Open Input);
OpenCommander: открывает текст после коммандера (точнее, после имени команды);
в самой Open теперь нет попытки открыть весь документ в переднем окне при отсутствии выделенного фрагмента (в программе это не важно, в интерактивной работе это только запутывает, притом что всегда можно предварительно нажать Ctrl+A).
2010-09-16 Модификация Real, указанная Е.Э.Темиргалеевым: теперь команда Real корректно вернет значение, если в потоке ввода константа типа LONGINT (например, 1234567890123456).
2010-09-17 Ф.В.Ткачев
для полноты поддержки парадигмы "текст как интерфейс" добавлены
процедура Restart ,
глобальный scanner для полного доступа к потоку ввода;
добавлена глобальная done, всегда равная Done.
Первая версия: август 2002, Ф.Т. *)
IMPORT TextControllers, TextMappers, TextModels, DevCommanders;
VAR
done-, Done-: BOOLEAN; (* Done оставлен на случай проблем у народа с совместимостью *)
scanner*: TextMappers.Scanner;
PROCEDURE OpenText* ( text: TextModels.Model; beg, end: INTEGER );
VAR t: TextModels.Model;
BEGIN
ASSERT( text # NIL, 20 );
ASSERT( (0 <= beg) & (beg <= end) & (end <= text.Length()), 21 );
t := TextModels.dir.New();
t.InsertCopy( 0, text, beg, end );
scanner.ConnectTo( t ); scanner.SetPos( 0 ); scanner.rider.Read;
done := TRUE;
Done := done
END OpenText;
PROCEDURE OpenFocus*; (** поток ввода весь передний текст **)
VAR c: TextControllers.Controller;
BEGIN
c := TextControllers.Focus();
IF c # NIL THEN
OpenText( c.text, 0, c.text.Length() )
ELSE
(* в фокусе нет текста *)
done := FALSE; Done := done
END;
ASSERT( Done = done, 60 )
END OpenFocus;
PROCEDURE OpenSelection*;
VAR c: TextControllers.Controller; beg, end: INTEGER;
BEGIN
c := TextControllers.Focus();
IF ( c # NIL ) & c.HasSelection() THEN
c.GetSelection( beg, end );
OpenText( c.text, beg, end )
ELSE
(* в фокусе нет текста *)
done := FALSE; Done := done
END;
ASSERT( Done = done, 60 )
END OpenSelection;
PROCEDURE OpenCommander*;
BEGIN
IF DevCommanders.par # NIL THEN (* внутри команды, вызванной из коммандера *)
OpenText( DevCommanders.par.text, DevCommanders.par.beg, DevCommanders.par.end )
ELSE
done := FALSE; Done := done
END;
ASSERT( Done = done, 60 )
END OpenCommander;
PROCEDURE Open*;
BEGIN
OpenSelection;
IF ~done THEN
OpenCommander
END;
ASSERT( Done = done, 60 )
END Open;
PROCEDURE Restart*; (** возвращаемся в начало потока ввода **)
BEGIN
done := ( scanner.rider # NIL ) & ( scanner.rider.Base() # NIL );
IF done THEN
scanner.SetPos( 0 ); scanner.rider.Read;
END;
Done := done
END Restart;
PROCEDURE Char* ( OUT ch: CHAR );
BEGIN
IF done THEN
IF scanner.rider.eot THEN
done := FALSE;
ELSE
ch := scanner.rider.char; scanner.rider.Read
END
END;
Done := done
END Char;
PROCEDURE Int* ( OUT i: INTEGER );
BEGIN
IF done THEN
scanner.Scan;
IF scanner.type = TextMappers.int THEN
i := scanner.int
ELSE
done := FALSE
END
END;
Done := done
END Int;
PROCEDURE LongInt* ( OUT l: LONGINT );
BEGIN
IF done THEN
scanner.Scan;
IF ( scanner.type = TextMappers.lint ) OR ( scanner.type = TextMappers.int ) THEN
l := scanner.lint
ELSE
done := FALSE
END
END;
Done := done
END LongInt;
PROCEDURE Real* ( OUT x: REAL );
BEGIN
IF done THEN
scanner.Scan;
IF scanner.type = TextMappers.real THEN
x := scanner.real (* в блэкбоксовском In эта инструкция дана подчеркнуто с ошибкой; в менее явном виде эта ошибка есть еще у Вирта-Райзера, откуда в качестве примера был взят модуль In; авторы Блэкбокса оставили ошибку сознательно, т.к. имели целью точно воспроизвести пример Вирта-Райзера; мы здесь не связаны таким условием :-) т.к. пытаемся довести In до ума в качестве удобного инструмента ввода данных *)
ELSIF scanner.type IN { TextMappers.int, TextMappers.lint } THEN (* в старом Обероне это было неактуально; исправление указано Е.Э.Темиргалеевым *)
x := scanner.lint
ELSE
done := FALSE
END
END;
Done := done
END Real;
PROCEDURE Name* ( OUT name: ARRAY OF CHAR );
BEGIN
IF done THEN
scanner.Scan;
TextMappers.ScanQualIdent( scanner, name, Done )
END;
Done := done
END Name;
PROCEDURE String* ( OUT str: ARRAY OF CHAR );
BEGIN
IF done THEN
scanner.Scan;
IF scanner.type = TextMappers.string THEN
str := scanner.string$
ELSE
done := FALSE
END
END;
Done := done
END String;
END i21sysIn.
| i21sys/Mod/In.odc |
MODULE i21sysInfo;
(* 2010-10-18 Е.Э.Темиргалеев -- выделено из i21sysCalls для корректной работы под wine+linux *)
IMPORT Dialog, WinApi, HostDialog;
CONST (* Dialog *)
windows32s* = 11;
windows95* = 12;
windowsNT3* = 13;
windowsNT4* = 14;
windows2000* = 15;
windows98* = 16;
windowsXP* = 17;
windowsVista* = 18;
macOS* = 21;
macOSX* = 22;
linux* = 30;
tru64* = 40;
CONST
wine* = 17.5;
VAR
platform*: REAL; (* REAL, .. ну Dialog.windows... INTEGER *)
PROCEDURE Init;
VAR h: WinApi.HMODULE; adr: WinApi.FARPROC; res: WinApi.BOOL;
BEGIN
(* 1.5-1.6 HostDialog Dialog.platform; *)
platform := Dialog.platform; ASSERT(platform # 0, 100);
(* http://habrahabr.ru/blogs/development/76131/ *)
h := WinApi.LoadLibrary("ntdll.dll");
IF h # WinApi.NULL THEN
adr := WinApi.GetProcAddress(h, "wine_get_version");
IF adr # NIL THEN platform := wine END;
res := WinApi.FreeLibrary(h)
END
END Init;
BEGIN
Init
END i21sysInfo.
| i21sys/Mod/Info.odc |
MODULE i21sysInПримеры; (* info21 2006-03-01; last modification 2010-04-01 *)
IMPORT In := i21sysIn, Log := StdLog;
PROCEDURE Do*;
VAR x: REAL; n: INTEGER; s: ARRAY 1000 OF CHAR;
BEGIN
In.OpenCommander; ASSERT( In.done ); Log.Ln;
In.Real( x ); ASSERT( In.done ); Log.Real( x );
In.Int( n ); ASSERT( In.done ); Log.Int( n );
In.String( s ); ASSERT( In.done ); Log.String( s );
Log.Ln
END Do;
PROCEDURE Do2* ( m: INTEGER );
VAR x: REAL; n: INTEGER; s: ARRAY 1000 OF CHAR;
BEGIN
Log.Ln;
Log.Int( m );
In.OpenCommander; ASSERT( In.done );
In.Real( x ); ASSERT( In.done ); Log.Real( x );
In.Int( n ); ASSERT( In.done ); Log.Int( n );
In.String( s ); ASSERT( In.done ); Log.String( s );
Log.Ln
END Do2;
PROCEDURE Do3*;
VAR x: REAL; n: INTEGER; s: ARRAY 1000 OF CHAR;
BEGIN
Log.Ln;
Log.String('input from selection'); Log.Ln;
In.OpenSelection; ASSERT( In.done );
In.Real( x ); ASSERT( In.done ); Log.Real( x );
In.Int( n ); ASSERT( In.done ); Log.Int( n );
In.String( s ); ASSERT( In.done ); Log.String( s );
Log.Ln
END Do3;
PROCEDURE DoRu*;
VAR s: ARRAY 1000 OF CHAR;
BEGIN
In.Open; ASSERT( In.done ); Log.Ln;
In.String( s ); ASSERT( In.done ); Log.String( s );
Log.Ln
END DoRu;
PROCEDURE Copy2; (* копируем два числа из уже открытого потока ввода в Рабочий журнал *)
VAR n: INTEGER;
BEGIN
ASSERT( In.done );
In.Int( n ); ASSERT( In.done ); Log.Int( n );
In.Int( n ); ASSERT( In.done ); Log.Int( n );
Log.Ln;
END Copy2;
PROCEDURE TestRestart*;
BEGIN
In.Restart; ASSERT( In.done );
Copy2;
In.Restart; ASSERT( In.done );
Copy2;
END TestRestart;
PROCEDURE TestRestart2*;
VAR n: INTEGER;
BEGIN
In.Restart; ASSERT( In.done );
Copy2;
In.OpenCommander; ASSERT( In.done );
Copy2;
In.Restart; ASSERT( In.done );
Copy2;
END TestRestart2;
PROCEDURE TestOpen*;
BEGIN
In.Open; ASSERT( In.done );
Copy2;
END TestOpen;
END i21sysInПримеры.
Общие замечания см. здесь, а полное описание возможностей модуля i21sysIn в документации.
Примеры использования средств модуля i21sysIn
Ввод данних из текста, следующего за коммандером:
простейший пример ввода данных:
i21sysInПримеры.Do 3.14 137 " цепочка литер"
пример ввода данных с одновременной передачей параметра:
"i21sysInПримеры.Do2(88)" 3.14 137 " цепочка литер"
два вызова подряд читают один и тот же поток данных:
"i21sysInПримеры.Do2(1);i21sysInПримеры.Do2(2)" 3.14 137 " цепочка литер"
Ввод данних из фрагмента, выделенного мышкой:,
Выделить мышкой следующие данные и кликнуть по коммандеру:
2.14 2345 " другая цепочка"
i21sysInПримеры.Do3
Можно поменять данные или значения параметров и снова покликать.
Примеры работы с потоком данных, определяемым отдельно
Выделить мышкой два числа 14 13 (эти числа могут находиться и в другом текстовом окне)
и нажать Shift+F1 (предполагается, что на эту горячую клавишу "посажена" команда i21sysIn.OpenSelection).
Затем кликнуть по этому коммандеру:
i21sysInПримеры.TestRestart 5 6
должно напечататься:
14 13
14 13
потому что процедура TestRestart игнорирует текст после коммандера, но зато использует уже открытый поток данных, где бы они ни находились (т.е. не вызывает i21sysIn.OpenCommander, а только i21sysIn.Restart).
Затем кликнуть по
i21sysInПримеры.TestRestart2 5 6
должно напечататься
14 13
5 6
5 6
Это эффект переопределения входного потока из-за вызова OpenCommander в процедуре TestRestart2, так что второй и третий проход чтения идут по данным, стоящим после коммандера.
Команда Open
Эта команда имеет чуть более сложную логику и удобна в задачах, где есть несколько входных потоков основной и вспомогательные (например, тестовые).
В этом случае после коммандера ставятся основной набор данных, а где-нибудь отдельно создаются вспомогательные.
При вызове с основными данными достаточно обеспечить, чтобы при клике по коммандеру не было выделенного фрагмента. Если же нужно вызвать команду с тестовыми данными, то достаточно выделить их мышкой перед кликом по тому же коммандеру.
Например, если кликнуть по следующему коммандеру, предварительно выделив мышкой числа 14 13,
i21sysInПримеры.TestOpen 5 6
то в Рабочем журнале будут напечатаны не числа 5 6, а 14 13.
Если же снять выделение (кликнув в любое место текста) и кликнуть по тому же коммандеру, то напечатаются 5 6.
| i21sys/Mod/InПримеры.odc |
MODULE i21sysKoi8r; (* info21 2010-04-07; 2011-12-13 *)
IMPORT Log := StdLog, Converters, Stores, Files, Views, Fonts, TextModels, TextMappers, TextViews, TextControllers;
VAR w: TextModels.Writer; r: TextModels.Reader; f: TextMappers.Formatter;
PROCEDURE CP1251* ( koi8r: CHAR ): CHAR;
VAR ch: CHAR;
BEGIN
CASE koi8r OF
|03FX: ch := 0B9X; (* номер *)
|0BFX: ch := 0A9X; (* copyright *)
|"Б": ch := "а"
|"В": ch := "б"
|"Ч": ch := "в"
|"З": ch := "г"
|"Д": ch := "д"
|"Е": ch := "е"
|0A3X: ch := "ё"
|"Ц": ch := "ж"
|"Ъ": ch := "з"
|"Й": ch := "и"
|"К": ch := "й"
|"Л": ch := "к"
|"М": ch := "л"
|"Н": ch := "м"
|"О": ch := "н"
|"П": ch := "о"
|"Р": ch := "п"
|"Т": ch := "р"
|"У": ch := "с"
|"Ф": ch := "т"
|"Х": ch := "у"
|"Ж": ch := "ф"
|"И": ch := "х"
|"Г": ch := "ц"
|"Ю": ch := "ч"
|"Ы": ch := "ш"
|"Э": ch := "щ"
|"Я": ch := "ъ"
|"Щ": ch := "ы"
|"Ш": ch := "ь"
|"Ь": ch := "э"
|"А": ch := "ю"
|"С": ch := "я"
|"б": ch := "А"
|"в": ch := "Б"
|"ч": ch := "В"
|"з": ch := "Г"
|"д": ch := "Д"
|"е": ch := "Е"
|0B3X: ch := "Ё"
|"ц": ch := "Ж"
|"ъ": ch := "З"
|"й": ch := "И"
|"к": ch := "Й"
|"л": ch := "К"
|"м": ch := "Л"
|"н": ch := "М"
|"о": ch := "Н"
|"п": ch := "О"
|"р": ch := "П"
|"т": ch := "Р"
|"у": ch := "С"
|"ф": ch := "Т"
|"х": ch := "У"
|"ж": ch := "Ф"
|"и": ch := "Х"
|"г": ch := "Ц"
|"ю": ch := "Ч"
|"ы": ch := "Ш"
|"э": ch := "Щ"
|"я": ch := "Ъ"
|"щ": ch := "Ы"
|"ш": ch := "Ь"
|"ь": ch := "Э"
|"а": ch := "Ю"
|"с": ch := "Я"
ELSE
ch := koi8r
END;
RETURN ch
END CP1251;
PROCEDURE TranslateFromKoi8r*; (** документ в фокусе в KOI8-R будет переведен в CP1251/Win-1251 результат в новом окне **)
VAR c: TextControllers.Controller; t, t1: TextModels.Model; v: TextViews.View;
koi8r: CHAR; f: Fonts.Typeface; a: TextModels.Attributes;
BEGIN
c := TextControllers.Focus();
t := c.text;
t1 := TextModels.CloneOf( t );
r := t.NewReader( r ); r.SetPos( 0 );
w := t1.NewWriter( w ); w.SetPos( 0 );
r.ReadChar( koi8r );
WHILE ~r.eot DO
w.WriteChar( CP1251( koi8r ) );
r.ReadChar( koi8r )
END;
(* set font *)
f := "Verdana";
a := TextModels.NewTypeface( TextModels.dir.attr, f );
t1.SetAttr( 0, t1.Length(), a );
v := TextViews.dir.New( t1 );
Views.OpenView( v )
END TranslateFromKoi8r;
PROCEDURE ImportKoi8rText* ( f: Files.File; OUT s: Stores.Store );
VAR rd: Stores.Reader; i, len: INTEGER; koi8r, ch: SHORTCHAR;
t: TextModels.Model; fm: TextMappers.Formatter;
BEGIN
len := f.Length();
rd.ConnectTo( f );
t := TextModels.dir.New(); fm.ConnectTo( t );
FOR i := 0 TO len - 1 DO
rd.ReadSChar( koi8r );
ch := SHORT( CP1251( koi8r ) );
IF ch = 0AX THEN
fm.WritePara
ELSIF ch = 0DX THEN
fm.WriteLn
ELSE
fm.WriteChar( ch )
END
END;
fm.ConnectTo( NIL );
s := TextViews.dir.New( t )
END ImportKoi8rText;
END i21sysKoi8r.
| i21sys/Mod/Koi8r.odc |
MODULE i21sysLatin1;
(** This module is part of the educational versions of BlackBox 1.5 provided by the project "Informatika-21".
Its purpose is to provide support for the standard character set in Component Pascal identifiers as specified in the Language Report. See i21sysCharacters and its documentation.
**)
(**
project = "Информатика-21 / Informatika-21"
contributors = "F.V.Tkachov"
changes = "
- 20111214, F.V.Tkachov, initial version
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
CONST
HostFontsCHARSET* = 0;
CONST uBase = 0; uRange = 100H;
VAR E, e, U, u: ARRAY 128 OF CHAR;
charSetName-: ARRAY 64 OF CHAR;
VAR
ascii: ARRAY 256 OF RECORD
isCap, isLetter, isFirstIdentChar, isIdentChar: BOOLEAN;
cap, low, unicode: CHAR;
END;
unicode: ARRAY uRange OF RECORD
isCap, isLetter: BOOLEAN;
cap, low, ascii: CHAR;
END;
PROCEDURE IsCap* (ch: CHAR): BOOLEAN;
VAR res: BOOLEAN; i: INTEGER;
BEGIN
IF ORD(ch) < 256 THEN
res := ascii[ORD(ch)].isCap
ELSE
i := ORD(ch) - uBase;
res := (0 <= i) & (i < uRange) & unicode[i].isCap;
END;
RETURN res
END IsCap;
PROCEDURE IsDigit* (ch: CHAR): BOOLEAN;
BEGIN
RETURN ("0" <= ch) & (ch <= "9")
END IsDigit;
PROCEDURE IsLetter* (ch: CHAR): BOOLEAN;
VAR res: BOOLEAN; i: INTEGER;
BEGIN
IF ORD(ch) < 256 THEN
res := ascii[ORD(ch)].isLetter
ELSE
i := ORD(ch) - uBase;
IF (0 <= i) & (i < uRange) THEN
res := unicode[i].isLetter
ELSE
res := FALSE
END
END;
RETURN res
END IsLetter;
PROCEDURE IsFirstIdentChar* (ch: CHAR): BOOLEAN;
BEGIN
RETURN (ORD(ch) < 256) & ascii[ORD(ch)].isFirstIdentChar
END IsFirstIdentChar;
PROCEDURE IsIdentChar* (ch: CHAR): BOOLEAN;
BEGIN
RETURN (ORD(ch) < 256) & ascii[ORD(ch)].isIdentChar
END IsIdentChar;
PROCEDURE Cap* (ch: CHAR): CHAR;
VAR res: CHAR; i: INTEGER;
BEGIN
IF ORD(ch) < 256 THEN
res := ascii[ORD(ch)].cap
ELSE
i := ORD(ch) - uBase;
IF (0 <= i) & (i < uRange) THEN
res := unicode[i].cap
ELSE
res := ch
END
END;
RETURN res
END Cap;
PROCEDURE Upper* (ch: CHAR): CHAR; (* as in Strings *)
BEGIN RETURN Cap(ch)
END Upper;
PROCEDURE Lower* (ch: CHAR): CHAR; (* is used in Kernel *)
VAR res: CHAR; i: INTEGER;
BEGIN
IF ORD(ch) < 256 THEN
res := ascii[ORD(ch)].low
ELSE
i := ORD(ch) - uBase;
IF (0 <= i) & (i < uRange) THEN
res := unicode[i].low
ELSE
res := ch
END
END;
RETURN res
END Lower;
PROCEDURE UnicodeOf* (ch: CHAR): CHAR; (* unicode chars unaffected *)
VAR res: CHAR;
BEGIN
IF ORD(ch) < 128 THEN
res := ch
ELSIF ORD(ch) < 256 THEN
res := ascii[ORD(ch)].unicode
ELSE
res := ch
END;
RETURN res
END UnicodeOf;
PROCEDURE ExtendedAsciiOf* (ch: CHAR): CHAR;
VAR res: CHAR; i: INTEGER;
BEGIN
IF ORD(ch) < 256 THEN
res := ch
ELSE
i := ORD(ch) - uBase;
IF ( 0 <= i ) & ( i < uRange ) THEN
res := unicode[i].ascii
ELSE
res := '?'
END
END;
RETURN res
END ExtendedAsciiOf;
PROCEDURE ToUpper* (IN in: ARRAY OF CHAR; OUT out: ARRAY OF CHAR);
VAR len, i: INTEGER;
BEGIN
len := LEN(in$); i := 0;
WHILE i < len DO out[i] := Cap(in[i]); INC(i) END;
out[i] := 0X
END ToUpper;
(*
PROCEDURE ToLower* (IN in: ARRAY OF CHAR; OUT out: ARRAY OF CHAR);
VAR len, i: INTEGER;
BEGIN
len := LEN(in$); i := 0;
WHILE i < len DO out[i] := Lower(in[i]); INC(i) END;
out[i] := 0X
END ToLower;
*)
PROCEDURE ToUnicode* (IN in: ARRAY OF CHAR; OUT out: ARRAY OF CHAR); (* used in (Host)Dialog *)
VAR len, i: INTEGER;
BEGIN
len := LEN(in$); i := 0;
WHILE i < len DO out[i] := UnicodeOf(in[i]); INC(i) END;
out[i] := 0X
END ToUnicode;
PROCEDURE ToExtendedAscii* (IN in: ARRAY OF CHAR; OUT out: ARRAY OF CHAR);
VAR len, i: INTEGER;
BEGIN
len := LEN(in$); i := 0;
WHILE i < len DO out[i] := ExtendedAsciiOf(in[i]); INC(i) END;
out[i] := 0X
END ToExtendedAscii;
PROCEDURE Set;
VAR i, icap, ilow, j: INTEGER;
BEGIN
ASSERT( (LEN(E$)=LEN(e$)) & (LEN(E$)=LEN(U$)) & (LEN(E$)=LEN(u$)), 20 );
FOR i := 0 TO LEN(E$)-1 DO
ASSERT( (128 <= ORD(E[i])) & (ORD(E[i]) < 256), 21 );
ASSERT( (128 <= ORD(e[i])) & (ORD(e[i]) < 256), 22 );
ASSERT( ORD(U[i]) >= 128, 23 ); (* not >=256 to allow for U=E, u=e, etc.*)
ASSERT( ORD(u[i]) >= 128, 24 );
END;
ASSERT( uBase >= 0, 25 );
FOR j := 0 TO 255 DO
ascii[j].cap := CHR(j); (* self *)
ascii[j].low := CHR(j); (* self *)
ascii[j].isCap := FALSE;
ascii[j].isLetter := FALSE;
ascii[j].isFirstIdentChar := FALSE;
ascii[j].isIdentChar := FALSE;
END;
j := ORD('_');
ascii[j].isFirstIdentChar := TRUE;
ascii[j].isIdentChar := TRUE;
FOR j := ORD("0") TO ORD("9") DO
ascii[j].isIdentChar := TRUE
END;
FOR icap := ORD("A") TO ORD("Z") DO ilow := icap+32;
ascii[icap].low := CHR(ilow);
ascii[ilow].cap := CHR(icap);
ascii[icap].isCap := TRUE;
ascii[icap].isLetter := TRUE;
ascii[ilow].isLetter := TRUE;
ascii[icap].isFirstIdentChar := TRUE;
ascii[ilow].isFirstIdentChar := TRUE;
ascii[icap].isIdentChar := TRUE;
ascii[ilow].isIdentChar := TRUE;
END;
FOR i := 0 TO 255 DO
ascii[i].unicode := CHR(i) (* self by default *)
END;
FOR i := 0 TO uRange-1 DO
unicode[i].ascii := '?';
unicode[i].cap := CHR(i + uBase); (* self by default *)
unicode[i].low := CHR(i + uBase); (* self by default *)
unicode[i].isCap := FALSE;
unicode[i].isLetter := TRUE;
END;
FOR i := 0 TO LEN(E$)-1 DO
ascii[ORD( E [i])].isLetter := TRUE;
ascii[ORD( e [i])].isLetter := TRUE;
ascii[ORD( E[i] )].isCap := TRUE;
ascii[ORD( E[i] )].low := e[i];
ascii[ORD( e[i] )].cap := E[i];
ascii[ORD(E [i])].unicode := U[i];
ascii[ORD(e [i])].unicode := u[i];
unicode[ORD(U [i]) - uBase].ascii := E[i];
unicode[ORD(u [i]) - uBase].ascii := e[i];
unicode[ORD(u [i]) - uBase].cap := U [i];
unicode[ORD(U [i]) - uBase].low := u [i];
unicode[ORD(U [i]) - uBase].isCap := TRUE;
unicode[ORD(U [i]) - uBase].isLetter := TRUE;
unicode[ORD(u [i]) - uBase].isLetter := TRUE;
END;
FOR i := 128 TO 255 DO
ascii[i].isFirstIdentChar := ascii[i].isLetter;
ascii[i].isIdentChar := ascii[i].isLetter;
END;
END Set;
PROCEDURE Init;
VAR i: INTEGER;
BEGIN
E := "АБВГДЕЖЗИЙКЛМНОПРСТУФХЦ"+"ШЩЪЫЬЭЮЯ";
e := "абвгдежзийклмнопрстуфхц"+"шщъыьэюя";
U := E;
u := e;
charSetName := "Latin-1";
Set;
END Init;
BEGIN
Init
END i21sysLatin1.
i21sysUnicodeTools.ExamineIn
| i21sys/Mod/Latin1.odc |
(* примеры создания списков подсистем, модулей и проч. *)
MODULE i21sysListings; (* F.V.Tkachov 2004; edited 2008-2-18 *)
IMPORT Log := StdLog, F := Files, TextModels, TextMappers, TextViews, StdLinks,
Ports, Views, Strings;
PROCEDURE Subsystems*;
VAR loc: F.Locator; li: F.LocInfo;
BEGIN
loc := F.dir.This('');
li := F.dir.LocList( loc );
Log.Ln;
(* Log.String('subsystems:'); Log.Ln; *)
WHILE li # NIL DO
Log.String( li.name ); Log.Ln;
li := li.next
END
END Subsystems;
PROCEDURE Modules* ( IN subsystem: ARRAY OF CHAR );
VAR loc: F.Locator; fi: F.FileInfo; li: F.LocInfo; name: ARRAY 100 OF CHAR;
pos: INTEGER;
BEGIN
ASSERT( subsystem # '', 20 );
loc := F.dir.This( '' );
li := F.dir.LocList( loc );
WHILE ( li # NIL ) & ( li.name$ = subsystem$ ) DO
li := li.next
END;
IF li = NIL THEN
Log.String( 'subsystem ' + subsystem + ' not found.' ); Log.Ln; RETURN
END;
loc := loc.This( subsystem );
li := F.dir.LocList( loc );
WHILE ( li # NIL ) & ( li.name$ = 'Mod' ) DO
li := li.next
END;
IF li = NIL THEN
Log.String( 'folder Mod not found in subsystem ' + subsystem ); Log.Ln; RETURN
END;
loc := loc.This( 'Mod' );
fi := F.dir.FileList( loc );
IF fi # NIL THEN
Log.Ln
END;
WHILE fi # NIL DO
name := subsystem + fi.name;
Strings.Find( name, '.odc', 0, pos );
IF pos >= 0 THEN
Strings.Replace( name, pos, 4, '' );
Log.String( name );
Log.Ln
END;
fi := fi.next
END;
END Modules;
PROCEDURE ModulesAsLinks* ( IN subsystem: ARRAY OF CHAR );
VAR loc: F.Locator; fi: F.FileInfo; li: F.LocInfo; name: ARRAY 100 OF CHAR;
t: TextModels.Model; fm: TextMappers.Formatter; pos, pos0, pos1: INTEGER;
link: StdLinks.Link;
blue, default: TextModels.Attributes;
v: TextViews.View;
BEGIN
ASSERT( subsystem # '', 20 );
loc := F.dir.This( '' );
li := F.dir.LocList( loc );
WHILE ( li # NIL ) & ( li.name$ = subsystem$ ) DO
li := li.next
END;
IF li = NIL THEN
Log.String( 'subsystem ' + subsystem + ' not found.' ); Log.Ln; RETURN
END;
loc := loc.This( subsystem );
li := F.dir.LocList( loc );
WHILE ( li # NIL ) & ( li.name$ = 'Mod' ) DO
li := li.next
END;
IF li = NIL THEN
Log.String( 'folder Mod not found in subsystem ' + subsystem ); Log.Ln; RETURN
END;
loc := loc.This( 'Mod' );
default := TextModels.dir.attr;
blue := TextModels.NewColor( default, Ports.blue );
fi := F.dir.FileList( loc );
t := Log.text;
fm.ConnectTo( t );
IF fi # NIL THEN
fm.WriteString("A mouse click on a name opens the document:");
fm.WriteLn
END;
WHILE fi # NIL DO
name := fi.name$;
Strings.Find( name, '.odc', 0, pos );
IF pos >= 0 THEN
Strings.Replace( name, pos, 4, '' );
name := subsystem + name;
link := StdLinks.dir.NewLink('StdCmds.OpenDoc(' + "'" + subsystem + '/Mod/' + fi.name + "'" + ')');
fm.WriteView( link );
pos0 := fm.Pos();
fm.WriteString( name );
pos1 := fm.Pos();
link := StdLinks.dir.NewLink('');
fm.WriteView( link );
t.SetAttr( pos0, pos1, blue );
fm.WriteLn;
END;
fi := fi.next
END;
END ModulesAsLinks;
PROCEDURE Files* ( IN folder: ARRAY OF CHAR );
VAR loc: F.Locator; fi: F.FileInfo; li: F.LocInfo;
BEGIN
ASSERT( folder # '', 20 );
loc := F.dir.This( folder ); ASSERT( loc.res = 0, 21 );
fi := F.dir.FileList( loc );
IF fi # NIL THEN
Log.Ln
END;
WHILE fi # NIL DO
Log.String( folder + '/' + fi.name ); Log.Ln;
fi := fi.next
END;
END Files;
END i21sysListings.
| i21sys/Mod/Listings.odc |
MODULE Program0;
IMPORT Log;
BEGIN
Log.String( 'Привет!' ); Log.Ln;
END Program0.
Простейшая программа турбопаскалевского типа.
Исходный текст программы должен стоять в начале документа.
После текста программы документ может содержать всё, что угодно.
Компилируется и выполняется такая программа нажатием Ctrl+F9 или, что то же самое, командой меню Dev, Compile and Reload (по-русски: Разработка, Компилировать и перегрузить).
Попробуйте нажать Ctrl+F9 и посмотрите в Log (Рабочий журнал).
Попробуйте изменить программу (изменить печатаемый текст, внести в программу ошибку и т.п.) и снова нажать Ctrl+F9.
Данный пример имеет целью показать наипростейшую программу в Блэкбоксе. Более реалистичная учебная программа будет иметь чуть более сложный вид и использовать более удобный вывод, а также ввод (см. Program1).
Об отличиях Компонентного Паскаля от старого см. краткую справку.
| i21sys/Mod/Program0.odc |
MODULE Program1;
IMPORT Log := StdLog, In := i21sysIn, Math;
VAR n, sum: INTEGER;
BEGIN
(* должен быть задан поток ввода *)
sum := 0;
In.Restart; (* встаём в начало входного потока *)
In.Int( n ); Log.Int( n ); sum := sum + n;
In.Int( n ); Log.Int( n ); sum := sum + n;
Log.Ln;
Log.String('сумма равна '); Log.Int( sum ); Log.Ln;
END Program1.
Простейшая реалистичная учебная программа турбопаскалевского типа.
Программа компилируется и выполняется нажатием Ctrl+F9.
Компилятор игнорирует текст после завершающей точки модуля в строке END Program1.
Компиляция без выполнения: Ctrl+K (K латинское).
Программа предполагает, что задан поток ввода, из которого она читает два целых числа.
Поток ввода это современная замена т.наз. вводу чисел с командной строки в устаревших системах программирования, несущих печать времен, когда пользователь был лишен возможности непосредственного взаимодействия с вычислительной системой.
Поток ввода нужно задать до вызова программы: нужно выделить мышкой пару чисел в любом месте текста (или даже в другом окне) например, любую из вот этих пар:
8 9 или 10 -13
и нажать Shift+F1 (через меню: Text, Open Input).
Возможность ввода данных в программу прямо из открытых документов это пример так называемого документо-ориентированного подхода к организации взаимодействия человек-компьютер, см. подробнее Тексткакинтерфейс.
См. также документ Вводданных(In) или стандартную документацию к модулю i21sysIn (дважды кликнуть по имени модули и вызвать команду меню Info, Документация).
| i21sys/Mod/Program1.odc |
MODULE i21sysScanner;
(**
project = "Информатика-21 / Informatika-21"
contributors = "F.V.Tkachov"
changes = "
- 20121106, F.V.Tkachov, simplified, all conversions to unicode removed
vocabularies abstracted to here
- 20100411, F.V.Tkachov, original version
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
(**
Сканер словариков типа используемых в i21sysEdit и при работе с нац. ключевыми словами (например i21sys/Rsrc/ru/vocab.odc и т.п.).
**)
IMPORT Log := StdLog, TextMappers, Files, Converters, Views, TextViews, DevCommanders;
TYPE
String* = ARRAY 256 OF CHAR;
CONST path0 = "i21sys/Rsrc/";
VAR
string-: String;
done-: BOOLEAN;
path: ARRAY 2000 OF CHAR;
name: Files.Name;
sc: TextMappers.Scanner; ok: BOOLEAN;
PROCEDURE Open* ( path: ARRAY OF CHAR; name: Files.Name ); (* path relative to path0 *)
VAR loc: Files.Locator; i: INTEGER; fullName: Files.Name;
conv: Converters.Converter; v: Views.View;
BEGIN
string := '';
done := FALSE;
loc := Files.dir.This( path0 ); ASSERT( loc.res = 0 );
loc := loc.This( path$ );
ok := loc.res = 0;
IF ~ok THEN RETURN END;
fullName := name + '.odc';
v := Views.Old( Views.dontAsk, loc, fullName, conv );
ok := ( v # NIL ) & ( v IS TextViews.View );
IF ~ok THEN RETURN END;
sc.ConnectTo( v( TextViews.View ).ThisModel() );
sc.SetOpts( { TextMappers.returnViews } ); (* используем вьюшку для отметки конца списка, поэтому хотим, чтобы sc ее не игнорировал, тогда мы тут засечем ее *)
done := TRUE;
path := path$;
name := name$;
END Open;
PROCEDURE SkipToNextLine; (* стоим после % *)
CONST
stop = {TextMappers.eot, TextMappers.view, TextMappers.line, TextMappers.para};
startOfLine = {TextMappers.line, TextMappers.para};
BEGIN
sc.SetOpts( sc.opts + { TextMappers.returnCtrlChars } ); (* сканер видит концы линий etc. *)
REPEAT sc.Scan
UNTIL ( sc.type IN stop );
done := ( sc.type IN startOfLine );
sc.SetOpts( sc.opts - { TextMappers.returnCtrlChars } ); (* сканер не видит концы линий etc. *)
END SkipToNextLine;
PROCEDURE Next*; (* после очередной литерной цепочки *)
BEGIN
string := '';
sc.Scan();
(* пропускаем комментарии, пока не прочтем очередную цепочку *)
WHILE ( sc.type # TextMappers.eot ) & ( sc.type # TextMappers.view )
& ( sc.type = TextMappers.char ) & ( sc.char = '%' ) DO
IF ( sc.type = TextMappers.char ) & ( sc.char = '%' ) THEN SkipToNextLine END;
IF done THEN sc.Scan() END;
END;
IF done & ( sc.type # TextMappers.eot ) & ( sc.type # TextMappers.view ) THEN
ASSERT( ( sc.type = TextMappers.string )
OR (( sc.type = TextMappers.char ) & ( sc.char # '%' )) );
string := sc.string$;
ELSE
done := FALSE
END;
END Next;
END i21sysScanner.
PROCEDURE Restart*;
BEGIN
string := '';
IF ok THEN
sc.SetPos( 0 ); done := TRUE
ELSE
done := FALSE
END;
END Restart;
| i21sys/Mod/Scanner.odc |
MODULE i21sysScannerTest; (* info21 2010-09-27 *)
IMPORT Log := StdLog, In := i21sysIn, Math, S := i21sysScanner;
PROCEDURE Do* ( folder, name: ARRAY OF CHAR );
BEGIN
S.Open( folder, name$ ); ASSERT( S.done );
IF S.done THEN S.Next END;
WHILE S.done DO
Log.String( S.string ); Log.Ln;
S.Next
END;
END Do;
PROCEDURE Do2* ( folder, name: ARRAY OF CHAR );
BEGIN
S.Open( folder, name$ );
IF S.done THEN S.Next END;
WHILE S.done DO
Log.String( S.string ); Log.Tab;
S.Next; ASSERT( S.done );
Log.String( S.string ); Log.Ln;
S.Next
END;
END Do2;
END i21sysScannerTest.
"i21sysScannerTest.Do('','keywords')"
"i21sysScannerTest.Do('ru','vocab')"
"i21sysScannerTest.Do2('ru','vocab')"
"i21sysScannerTest.Do2('ua','vocab')"
"i21sysScannerTest.Do2('Беларусь','vocab')"
| i21sys/Mod/ScannerTest.odc |
MODULE i21sysScript; (* Fyodor Tkachov 2009-10-21 *)
IMPORT Log := StdLog, Files, HostFiles, i21sysFiles, Stores, Dialog, i21sysCalls;
PROCEDURE CreateVbs*;
CONST
vbsname = '#i21sys:StartupBlackBox';
cannotCreate = '#i21sys:CannotCreateVbs';
type = 'vbs';
VAR loc, rsrc: Files.Locator; f, new: Files.File; rd: Stores.Reader; wr: Stores.Writer;
path: ARRAY 2000 OF CHAR; fi: Files.FileInfo; res: INTEGER; b: BYTE;
string: ARRAY 200 OF CHAR;
BEGIN
loc := Files.dir.This('');
path := loc( HostFiles.Locator ).path$;
loc := Files.dir.This( path ); (* to prevent BB from looking for files in the primary BlackBox directory *)
(* this is a nuisance of little help
fi := Files.dir.FileList( loc );
WHILE ( fi # NIL ) & ( fi.name # (vbsname + '.' + type) ) DO
fi := fi.next
END;
IF fi # NIL THEN
Dialog.GetOK( vbsname + ' already exists -- cannot continue', '','','', {Dialog.ok}, res );
HALT( 128 );
END;
*)
fi := Files.dir.FileList( loc );
WHILE ( fi # NIL ) & ( fi.name # 'BlackBox.exe' ) DO
fi := fi.next
END;
IF fi = NIL THEN
Dialog.GetOK( cannotCreate, '', '', '', {Dialog.ok}, res );
HALT( 128 );
END;
path := loc( HostFiles.Locator ).path$ + '\BlackBox.exe';
new := Files.dir.New( loc, Files.dontAsk );
wr.ConnectTo( new );
rsrc := loc.This( 'i21sys/Rsrc' );
f := Files.dir.Old( rsrc, '1', Files.shared );
rd.ConnectTo( f );
rd.ReadByte( b );
WHILE ~rd.rider.eof DO
wr.WriteByte( b );
rd.ReadByte( b );
END;
rd.ConnectTo( NIL );
wr.WriteSString( SHORT( path ) ); wr.SetPos( wr.Pos() - 1 );
f := Files.dir.Old( rsrc, '2', Files.shared );
rd.ConnectTo( f );
rd.ReadByte( b );
WHILE ~rd.rider.eof DO
wr.WriteByte( b );
rd.ReadByte( b );
END;
rd.ConnectTo( NIL );
wr.ConnectTo( NIL );
Dialog.MapString( vbsname, string );
new.Register( string$, 'vbs', Files.ask, res ); ASSERT( res = 0 );
END CreateVbs;
END i21sysScript.
i21sysScript.CreateVbs
| i21sys/Mod/Script.odc |
MODULE i21sysText;
IMPORT Log := StdLog, In := i21sysIn, Ports, Strings, TextControllers, M := TextModels;
PROCEDURE Offset0*;
(** guard: TextCmds.SelectionGuard **)
VAR c: TextControllers.Controller; t: M.Model; rd: M.Reader;
beg, end: INTEGER; a, new: M.Attributes; ch: CHAR;
BEGIN
c := TextControllers.Focus();
IF (c # NIL) & c.HasSelection() THEN
c.GetSelection(beg, end);
t := c.text;
rd := t.NewReader(rd);
rd.SetPos(end - 1);
rd.ReadChar(ch);
a := rd.attr;
new := M.NewOffset(a, 0);
t.SetAttr(beg, end, new);
c.SetSelection(beg, end);
END
END Offset0;
PROCEDURE Raise*;
(** guard: TextCmds.SelectionGuard **)
VAR c: TextControllers.Controller; t: M.Model; rd: M.Reader;
beg, end: INTEGER; a, new: M.Attributes; ch: CHAR;
BEGIN
c := TextControllers.Focus();
IF (c # NIL) & c.HasSelection() THEN
c.GetSelection(beg, end);
t := c.text; rd := t.NewReader(rd);
rd.SetPos(end - 1);
rd.ReadChar(ch);
a := rd.attr;
new := M.NewOffset(a, a.offset + Ports.point DIV 2);
t.SetAttr(beg, end, new);
c.SetSelection(beg, end)
END
END Raise;
PROCEDURE Lower*;
(** guard: TextCmds.SelectionGuard **)
VAR c: TextControllers.Controller; t: M.Model; rd: M.Reader;
beg, end: INTEGER; a, new: M.Attributes; ch: CHAR;
BEGIN
c := TextControllers.Focus();
IF (c # NIL) & c.HasSelection() THEN
c.GetSelection(beg, end);
t := c.text;
rd := t.NewReader(rd);
rd.SetPos(end - 1);
rd.ReadChar(ch);
a := rd.attr;
new := M.NewOffset(a, a.offset - Ports.point DIV 2);
t.SetAttr(beg, end, new);
c.SetSelection(beg, end);
END
END Lower;
END i21sysText. | i21sys/Mod/Text.odc |
MODULE i21sysUnicodeTools;
(** инструменты в помощь преобразованию [частей] документов в Юникод и обратно **)
(** "StdCmds.OpenToolDialog('i21sys/Rsrc/UnicodeTools','EASCII <> Юникод')" **)
IMPORT Log := StdLog, In := i21sysIn, i21sysCyrillic,
Stores, Models, Dialog, Strings, Views, TextModels, TextViews, TextControllers;
TYPE String = ARRAY 1000 OF CHAR;
PROCEDURE ExamineSelection*;
VAR ch: CHAR; s, p: ARRAY 100 OF CHAR;
BEGIN
In.OpenSelection;
In.Char(ch);
WHILE In.done DO
Strings.IntToStringForm( ORD(ch), Strings.hexadecimal, 6, Strings.digitspace, Strings.showBase, s );
IF ch < 80X THEN p := '(pure ASCII)'
ELSIF ch < 100X THEN p := '(Extended ASCII)'
ELSIF (400X <= ch) & (ch <= 527X) THEN p := '(Unicode Cyrillic)'
ELSE p := '(Unicode, non-Cyrillic)'
END;
Log.Char(ch); Log.Tab; Log.String(s); Log.Tab; Log.String(p); Log.Ln;
In.Char(ch);
END;
END ExamineSelection; (* i21sysUnicodeTools.ExamineSelection *)
PROCEDURE ToEASCII (t: TextModels.Model; beg, end: INTEGER); (* преобразуем текст *)
VAR rd: TextModels.Reader; wr: TextModels.Writer; ch: CHAR; pos: INTEGER;
script: Stores.Operation;
BEGIN
end := MIN(end, t.Length());
rd := t.NewReader(NIL);
rd.SetPos(beg);
wr := t.NewWriter(NIL);
Models.BeginScript (t, "Convert to EASCII", script); (* все действия до EndScript будут отменяться как целое при нажатии Ctrl+Z *)
rd.Read;
WHILE ~rd.eot & (rd.Pos() <= end) DO
IF rd.view = NIL THEN
ch := i21sysCyrillic.ExtendedAsciiOf( rd.char );
IF ch # rd.char THEN (* заменить литеру *)
pos := rd.Pos();
wr.SetPos( pos );
wr.WriteChar( ch );
t.Delete( pos-1, pos );
rd.SetPos( pos );
END;
END;
rd.Read;
END;
Models.EndScript (t, script);
END ToEASCII;
PROCEDURE ToUnicode (t: TextModels.Model; beg, end: INTEGER); (* преобразуем текст *)
VAR rd: TextModels.Reader; wr: TextModels.Writer; ch: CHAR; pos: INTEGER;
script: Stores.Operation;
BEGIN
end := MIN(end, t.Length());
rd := t.NewReader(NIL);
rd.SetPos(beg);
wr := t.NewWriter(NIL);
Models.BeginScript (t, "Convert to Unicode", script); (* все действия до EndScript будут отменяться как целое при нажатии Ctrl+Z *)
rd.Read;
WHILE ~rd.eot & (rd.Pos() <= end) DO
IF rd.view = NIL THEN
ch := i21sysCyrillic.UnicodeOf( rd.char );
IF ch # rd.char THEN (* заменить литеру *)
pos := rd.Pos();
wr.SetPos( pos );
wr.WriteChar( ch );
t.Delete( pos-1, pos );
rd.SetPos( pos );
END;
END;
rd.Read;
END;
Models.EndScript (t, script);
END ToUnicode;
PROCEDURE SelToEASCII*;
VAR c: TextControllers.Controller; t: TextModels.Model; v: Views.View; beg, end: INTEGER;
BEGIN
(* взять текст в фокусе *)
c := TextControllers.Focus();
IF c # NIL THEN
ASSERT(c.text # NIL); (* c.text = нужный текст *)
IF c.HasSelection() THEN
c.GetSelection(beg, end);
ToEASCII( c.text, beg, end );
c.SetSelection(beg, end);
ELSE Dialog.ShowMsg("#Dev:NoSelectionFound")
END;
ELSE Dialog.ShowMsg("#Dev:NoTextViewFound")
END;
END SelToEASCII;
PROCEDURE SelToUnicode*;
VAR c: TextControllers.Controller; t: TextModels.Model; v: Views.View; beg, end: INTEGER;
BEGIN
(* взять текст в фокусе *)
c := TextControllers.Focus();
IF c # NIL THEN
ASSERT(c.text # NIL); (* c.text = нужный текст *)
IF c.HasSelection() THEN
c.GetSelection(beg, end);
ToUnicode( c.text, beg, end );
c.SetSelection(beg, end);
ELSE Dialog.ShowMsg("#Dev:NoSelectionFound")
END;
ELSE Dialog.ShowMsg("#Dev:NoTextViewFound")
END;
END SelToUnicode;
PROCEDURE IsEASCII (rd: TextModels.Reader): BOOLEAN; (*element last read is EASCII char*)
VAR ch: CHAR; ord: INTEGER;
BEGIN
IF rd.view = NIL THEN ch := rd.char; ord := ORD(ch) END;
RETURN (rd.view = NIL) & (128 <= ord) & (ord < 256) & (ord # 0A0H (*non-break*))
END IsEASCII;
PROCEDURE IsEASCII2 (rd: TextModels.Reader): BOOLEAN; (*element last read is EASCII char*)
VAR ch: CHAR; ord: INTEGER;
BEGIN
IF rd.view = NIL THEN ch := rd.char; ord := ORD(ch) END;
RETURN (rd.view = NIL)
& ( (0 <= ord) & (ord < 256) & ~(("A"<=ch) & (ch <="Z") OR ("a"<=ch) & (ch <="z")))
END IsEASCII2;
PROCEDURE NextEASCII*;
(* Find next stretch of EASCII characters after current selection|cursor.
The stretch may include digits and special characters from the pure ASCII range -- but not Latin characters.
в том числе для поиска в английском тексте немецких букв с умляутом и т.п.
*)
VAR c: TextControllers.Controller; t: TextModels.Model; beg, end, pos: INTEGER;
rd: TextModels.Reader;
BEGIN
(* взять текст в фокусе *)
c := TextControllers.Focus();
IF c = NIL THEN
Dialog.ShowMsg("#Dev:NoTextViewFound")
ELSE
ASSERT(c.text # NIL); (* c.text = нужный текст *)
rd := c.text.NewReader(NIL);
IF c.HasSelection() THEN
c.GetSelection(beg, pos);
ELSE
pos := c.CaretPos();
END;
rd.SetPos(pos);
(* rd is set at the correct start of search *)
(* searching next EASCII char *)
rd.Read;
WHILE ~rd.eot & ~IsEASCII(rd) DO rd.Read END;
IF ~rd.eot THEN (* found *)
beg := rd.Pos() - 1; (* -1 because rd has jumped over EASCII char *)
(* теперь найти конец *)
(* searching for view or non-EASCII char *)
rd.Read;
WHILE ~rd.eot & IsEASCII2(rd) DO
rd.Read
END;
IF ~rd.eot THEN
end := rd.Pos() - 1
ELSE
end := c.text.Length()
END;
c.SetSelection(beg, end)
ELSE (* not found *)
c.SetCaret(c.text.Length());
Log.String("reached end of text"); Log.Ln;
END;
END;
END NextEASCII;
PROCEDURE IsUnicode (rd: TextModels.Reader): BOOLEAN; (*element last read is Unicode char*)
VAR ord: INTEGER;
BEGIN
ord := 0;
IF rd.view = NIL THEN ord := ORD(rd.char) END;
RETURN (rd.view = NIL) & (256 <= ord)
END IsUnicode;
PROCEDURE IsUnicode2 (rd: TextModels.Reader): BOOLEAN; (*element last read is Unicode char*)
VAR ch: CHAR; ord: INTEGER;
BEGIN
IF rd.view = NIL THEN ch := rd.char; ord := ORD(ch) END;
RETURN (rd.view = NIL)
& (
(256 <= ord)
OR
(0 <= ord) & (ord < 128) & ~(("A"<=ch) & (ch <="Z") OR ("a"<=ch) & (ch <="z"))
)
END IsUnicode2;
PROCEDURE NextUnicode*;
(* Find next stretch of Unicode characters after current selection|cursor.
The stretch may include digits and special characters from the pure ASCII range -- but not Latin characters.
в том числе для поиска в английском тексте немецких букв с умляутом и т.п.
*)
VAR c: TextControllers.Controller; t: TextModels.Model; beg, end, pos: INTEGER;
rd: TextModels.Reader;
BEGIN
(* взять текст в фокусе *)
c := TextControllers.Focus();
IF c = NIL THEN
Dialog.ShowMsg("#Dev:NoTextViewFound")
ELSE
ASSERT(c.text # NIL); (* c.text = нужный текст *)
rd := c.text.NewReader(NIL);
IF c.HasSelection() THEN
c.GetSelection(beg, pos);
ELSE
pos := c.CaretPos();
END;
rd.SetPos(pos);
(* rd is set at the correct start of search *)
(* searching next Unicode char *)
rd.Read;
WHILE ~rd.eot & ~IsUnicode(rd) DO rd.Read END;
IF ~rd.eot THEN (* found *)
beg := rd.Pos() - 1; (* -1 because rd has jumped over Unicode char *)
(* теперь найти конец *)
(* searching for view or non-Unicode char *)
rd.Read;
WHILE ~rd.eot & IsUnicode2(rd) DO
rd.Read
END;
IF ~rd.eot THEN
end := rd.Pos() - 1
ELSE
end := c.text.Length()
END;
c.SetSelection(beg, end)
ELSE (* not found *)
c.SetCaret(c.text.Length());
Log.String("reached end of text"); Log.Ln;
END;
END;
END NextUnicode;
END i21sysUnicodeTools.
Чтобы понять, что за буквы стоят в тексте (Юникод или Extended ASCII), выделить фрагмент и вызывать процедуру ExamineSelection.
В Рабочем журнале (Log) будет появляться информация по каждой литере.
i21sysUnicodeTools.ExamineIn
перенабито в ББ "об этой конфигурации Блэкбокса/di21_readme.odc"
из Total Commander простой Paste " \di21_readme.odc"
из Total Commander Paste Special, Unicode " \di21_readme.odc"
из Total Commander простой Paste Special, Plain Text "?? ???? ???????????? ?????????\di21_readme.odc"
i21sysUnicodeTools.NextEASCII
i21sysUnicodeTools.NextUnicode
i21sysUnicodeTools.SelToEASCII
i21sysUnicodeTools.SelToUnicode
выделение может содержать, наряду с EASCII, ещё цифры 00 и любые знаки препинания. | i21sys/Mod/UnicodeTools.odc |
MODULE i21sysVocabulary;
(** project = "Информатика-21 / Informatika-21"
contributors = "F.V.Tkachov"
changes = "
- 20121106, F.V.Tkachov, conversions to unicode minimized based on actual usage
- 20100411, F.V.Tkachov, original version
- YYYYMMDD, nn, ...
"
issues = "
- ...
"
**)
(**
Словарик для трансляции (ключевых) слов и средства трансляции для последующей компиляции и возвращением маркеров ошибок в исходный текст до трансляции.
Модуль выделен из i21sysCompiler, чтобы DevDebug с одной стороны, и i21sysCompiler+DevCompiler с другой, могли перезагружаться независимо;
DevDebug ссылается сюда.
**)
IMPORT Log := StdLog, Views,
M := TextModels, TextViews, TextControllers, Dialog,
Ch := i21sysCharacters, Sc := i21sysScanner;
CONST inc = 100; (* управление размером словариков *)
replace* = TRUE; dontReplace* = FALSE;
VAR
language-: ARRAY 100 OF CHAR;
module: ARRAY 100 OF CHAR; (* the word MODULE in the chosen language, in Unicode *)
import: ARRAY 100 OF CHAR; (* the word IMPORT in the chosen language, in Unicode *)
TYPE
Element = POINTER TO RECORD
next: Element;
pos0, pos1: INTEGER;
END;
VAR table: Element; (* NIL = трансляция тождественная *)
TYPE
String = Sc.String;
Entry* = POINTER TO ABSTRACT RECORD
key-: String; (* всегда приводится к заглавным в уникоде *)
END;
Vocabulary* = RECORD
len: INTEGER;
a: POINTER TO ARRAY OF Entry;
END;
Entry1 = POINTER TO RECORD ( Entry )
translation: String;
END;
VAR
naen, enna: Vocabulary;
VAR silent*: BOOLEAN; (* controls messages about replacement of vocab entries *)
(* Vocabulary *)
PROCEDURE ( v: Entry ) Log*, NEW, EMPTY;
PROCEDURE ( VAR v: Vocabulary ) Init*, NEW;
BEGIN NEW( v.a, inc ); v.len := 0;
END Init;
PROCEDURE ( VAR v: Vocabulary ) Log*, NEW;
VAR i: INTEGER;
BEGIN
FOR i := 0 TO v.len-1 DO
Log.String( v.a[i].key );
v.a[i].Log;
Log.Ln;
END;
END Log;
PROCEDURE AssertIsSorted ( VAR v: Vocabulary );
VAR i: INTEGER;
BEGIN
i := 1;
WHILE i < v.len DO ASSERT(v.a[i-1].key < v.a[i].key, 60); INC(i) END;
END AssertIsSorted;
PROCEDURE ( VAR v: Vocabulary ) FindIndex ( key: String ): INTEGER, NEW;
VAR i, L, R: INTEGER;
BEGIN
L := 0; R := v.len;
WHILE L < R DO
i := (L+R) DIV 2;
IF v.a[i].key < key THEN
L := i+1
ELSE (* key <= a[i].key *)
R := i
END;
END;
ASSERT(L = R, 100);
RETURN L;
END FindIndex;
PROCEDURE ( VAR v: Vocabulary ) Find* ( key: String; exact: BOOLEAN ): Entry, NEW;
VAR i: INTEGER; res: Entry;
BEGIN
Ch.ToUnicode( key, key );
i := v.FindIndex( key );
IF ( i < v.len ) & (~exact OR (v.a[ i ].key = key)) THEN
res := v.a[ i ]
ELSE
res := NIL
END;
RETURN res
END Find;
PROCEDURE EnsureLen ( VAR v: Vocabulary );
VAR new: POINTER TO ARRAY OF Entry; i: INTEGER;
BEGIN
(* обеспечить достаточно места для новой вставки: *)
IF v.len = LEN(v.a) (* забито под завязку *) THEN
NEW( new, LEN(v.a)+inc ); (* inc это константа для подобных целей всюду в этом модуле *)
i := 0;
WHILE i < LEN(v.a) DO new[i] := v.a[i]; INC(i) END;
v.a := new; new := NIL;
END;
ASSERT(v.len < LEN(v.a), 60);
END EnsureLen;
PROCEDURE ( VAR v: Vocabulary ) Insert* ( e: Entry; key: String; replace: BOOLEAN ), NEW;
VAR L, i: INTEGER; exists: BOOLEAN;
BEGIN
exists := FALSE;
Ch.ToUpper( key, key );
Ch.ToUnicode( key, key );
L := v.FindIndex( key );
IF (L < v.len) & (key # v.a[L].key) THEN
EnsureLen( v );
FOR i := v.len TO L+1 BY -1 DO
v.a[i] := v.a[i-1]
END;
e.key := key;
v.a[L] := e;
INC(v.len);
ELSIF L = v.len THEN
EnsureLen( v );
e.key := key;
v.a[L] := e;
INC(v.len);
ELSIF replace THEN
v.a[L] := e;
ELSIF ~silent THEN
Log.String('failed attempt to replace entry:' ); Log.Ln;
e.Log; Log.Ln;
END;
(* AssertIsSorted(v); *)
END Insert;
PROCEDURE ( v: Entry1 ) Log*;
BEGIN Log.Tab; Log.String( v.translation );
END Log;
PROCEDURE Show*;
BEGIN
Log.Ln;
Log.String( language ); Log.Ln;
Log.String( module ); Log.Ln;
Log.String( import ); Log.Ln;
Log.String( 'i21sysVocabulary: active vocabulary' ); Log.Ln;
naen.Log;
END Show;
PROCEDURE IsImport* ( s: ARRAY OF CHAR ): BOOLEAN;
VAR res: BOOLEAN;
BEGIN
res := s = 'IMPORT';
IF ~res THEN
Ch.ToUnicode( s, s );
res := s = import;
END;
RETURN res
END IsImport;
PROCEDURE IsModule* ( s: ARRAY OF CHAR ): BOOLEAN;
VAR res: BOOLEAN;
BEGIN
res := s = 'MODULE';
IF ~res THEN
Ch.ToUnicode( s, s );
res := s = module;
END;
RETURN res
END IsModule;
PROCEDURE ToNational* ( VAR s: Sc.String ); (* с английского на родной, нужна в сложных подстановках *)
VAR e: Entry;
BEGIN
e := enna.Find( s, TRUE );
IF e # NIL THEN
s := e(Entry1).translation$
END;
END ToNational;
PROCEDURE ToEnglish* ( VAR s: Sc.String ); (* с родного/в любой кодировке на английский *)
VAR e: Entry;
BEGIN
e := naen.Find( s, TRUE );
IF e # NIL THEN
s := e(Entry1).translation$
END;
END ToEnglish;
PROCEDURE WriteWord (wr: M.Writer; IN id: Sc.String);
VAR i: INTEGER;
BEGIN
i := 0; WHILE id[i] # 0X DO wr.WriteChar(id[i]); INC(i) END;
END WriteWord;
PROCEDURE ConvertText* (t0: M.Model; OUT t1: M.Model); (* преобразуем текст, одновременно запоминая таблицу соответствия позиций переведенных слов (идентификаторов, в которых разрешены уникодовские буквы наряду с тем, что допускает язык) *)
VAR
rd: M.Reader; wr: M.Writer; attr: M.Attributes; ch: CHAR;
id: Sc.String; (* буфер для очередного слова, найденного в оригинальном тексте *)
uid, en: Sc.String;
pos, i: INTEGER; new, e: Element;
BEGIN
(* ASSERT(language # '', 20 ); *)
rd := t0.NewReader(NIL);
t1 := M.dir.New(); wr := t1.NewWriter(NIL);
NEW(table); table.pos0 := -1; table.pos1 := -1; table.next := NIL; (* барьер *)
(*
К вопросу об эффективности систематических методов программирования вообще и построения сложных циклов методом Дейкстры в частности.
Вся группа циклов, играющая центральную роль в этом модуле, во главе со следующим шестиветочным циклом Дейкстры и вместе с соответствующими циклами в модуле i21sysCompiler, была написана за одну рабочую сессию (всего около 10 часов, включая либеральные перерывы на чай, ужин, чтение новостей и отслеживание текущих результатов матчей проходившего тогда теннисного турнира WTA) и сразу корректно заработала, не потребовав традиционной отладки.
Единственная ошибка (случай, когда документ кончается до точки, закрывающей модуль) была найдена просто на свежую голову (на следующее утро) верификацией программного текста, то есть, опять же, без отладки.
Разумеется, окончательный результат подвергся довольно обширному тестированию, но это важно подчеркнуть роль традиционной отладки как способа поиска и устранения ошибок была равна в точности нулю.
Ф.В.Ткачев (info21)
*)
(* готовимся войти в цикл: *)
pos := 0; (* позиция начала id в исходном тексте *)
i := 0; (* позиция внутри id *)
rd.Read; ch := rd.char;
(* цикл Дейкстры: *)
LOOP IF ~rd.eot & (attr # rd.attr) THEN
(* наткнулись на изменение атрибутов текста просто копируем *)
attr := rd.attr;
wr.SetAttr(attr);
ELSIF ~rd.eot & (rd.view # NIL) THEN
(* наткнулись на вьюшку, делаем дубликат (?) и копируем *)
wr.WriteView(Views.CopyOf(rd.view, Views.deep), rd.w, rd.h);
rd.Read;
ELSIF ~rd.eot & (i = 0) & (Ch.IsFirstIdentChar(rd.char) OR Ch.IsLetter(rd.char)) THEN
(* увидели начало слова *)
pos := rd.Pos() - 1; (* запомнили, где оно начинается в оригинале *)
id[i] := rd.char; INC(i); (* записали в буфер его первую литеру *)
rd.Read;
ELSIF ~rd.eot & (i > 0) & (Ch.IsIdentChar(rd.char) OR Ch.IsLetter(rd.char)) THEN
(* слово еще не закончилось *)
id[i] := rd.char; INC(i); (* записали в буфер его очередную литеру *)
rd.Read;
ELSIF i > 0 THEN (* завершили чтение слова *)
id[i] := 0X; (* оформили завершение соотв. цепочки литер *)
(* пытаемся заменить id по словарику: *)
Ch.ToUnicode(id, uid);
en := uid;
ToEnglish( en );
IF en # uid THEN
NEW(new);
new.pos0 := pos; (* позиция слова в оригинале *)
new.pos1 := wr.Pos(); (* позиция перевода, здесь начнется переведенное слово *)
new.next := table; table := new;
WriteWord(wr, en);
ELSE
WriteWord(wr, id);
END;
i := 0;
wr.WriteChar(rd.char);
rd.Read;
ELSIF ~rd.eot THEN
wr.WriteChar(rd.char);
rd.Read;
ELSE EXIT END END;
NEW(new);
new.pos0 := t0.Length();
new.pos1 := t1.Length();
new.next := table; table := new;
END ConvertText;
PROCEDURE OriginalPos* (pos: INTEGER): INTEGER;
VAR e: Element; pos0: INTEGER;
BEGIN
(* позицию определяем в обратном направлении т.е. относительно начала *следующего* попавшего в список слова; помним, что список у нас в обратном порядке: *)
e := table;
WHILE (e # NIL) & ~((pos <= e.pos1) & (pos > e.next.pos1)) DO
e := e.next
END;
IF e # NIL THEN
pos0 := e.pos0 - (e.pos1 - pos);
ELSE
pos0 := pos
END;
RETURN pos0
END OriginalPos;
PROCEDURE ConvertFocus*;
VAR c: TextControllers.Controller; t: M.Model; error: BOOLEAN; v: Views.View;
BEGIN
(* взять текст в фокусе *)
c := TextControllers.Focus();
IF c # NIL THEN
ASSERT(c.text # NIL); (* c.text = нужный текст *)
(* преобразовать c.text в t, заменяя ключевые слова, при этом создать таблицу table *)
ConvertText(c.text, t);
v := TextViews.dir.New(t);
Views.OpenView(v);
Views.SetDirty(v);
END;
END ConvertFocus;
PROCEDURE SetLanguage* ( lang: ARRAY OF CHAR );
VAR e, f: Entry1; res: INTEGER; out: ARRAY 100 OF CHAR; replaced: BOOLEAN;
BEGIN
naen.Init;
enna.Init;
language := 'en'; module := 'MODULE'; import := 'IMPORT';
IF ( lang # '' ) & ( lang # 'en') THEN
(* формат словарика описан в i21sys/Rsrc/ru/vocab.odc *)
Sc.Open(lang, 'vocab'); (* подсоединились к словарику, можно читать *)
language := lang$;
(* проходим по парам в словарике, записываем в два словаря: *)
Sc.Next; (* первый элемент пары *)
WHILE Sc.done DO
(* ASSERT( IsLatinCaps(i21sysScanner.s0), 30 ); *)
NEW( e );
e.translation := Sc.string$;
Sc.Next; ASSERT( Sc.done ); (* дочитали пару *)
silent := FALSE;
naen.Insert( e, Sc.string, dontReplace );
IF e.translation = 'MODULE' THEN module := e.key$
ELSIF e.translation = 'IMPORT' THEN import := e.key$
END;
NEW( f );
f.translation := e.key;
silent := TRUE;
enna.Insert( f, e.translation, dontReplace );
Sc.Next; (* первый элемент пары *)
END;
END;
Dialog.MapParamString('#i21sys:KeywordsLanguage', language, '', '', out);
Log.String(out); Log.Ln;
END SetLanguage;
BEGIN
silent := TRUE;
(* не через SetLanguage, чтобы не было лишнего сообщения *)
naen.Init;
enna.Init;
language := 'en'; module := 'MODULE'; import := 'IMPORT';
END i21sysVocabulary.
i21sysVocabulary.Show
"i21sysVocabulary.SetLanguage('ru')"
"i21sysVocabulary.SetLanguage('')"
| i21sys/Mod/Vocabulary.odc |
MODULE i21sysVocabularyTest;
IMPORT Log := StdLog,
S := i21sysScanner, V := i21sysVocabulary;
TYPE
Entry = POINTER TO RECORD ( V.Entry )
s: S.String;
END;
PROCEDURE ( e: Entry ) Log;
BEGIN Log.Tab; Log.String( e.s );
END Log;
PROCEDURE Do*;
VAR v: V.Vocabulary; e, f: Entry; f0: V.Entry;
BEGIN
v.Init;
S.Open('', 'keywords');
S.Next; ASSERT( S.done );
NEW( e );
v.Insert( e, S.string );
S.Next; ASSERT( S.done );
e.s := S.string;
S.Next; ASSERT( S.done );
NEW( e );
v.Insert( e, S.string );
S.Next; ASSERT( S.done );
e.s := S.string;
v.Log;
V.silent := FALSE;
NEW( e );
v.Insert( e, 'ABS' );
e.s := '00000';
v.Log;
f0 := v.Find('A', FALSE);
IF f0 # NIL THEN
f := f0(Entry)
END;
Log.String( 'non-exact search: ' + f.key ); Log.Ln;
f0 := v.Find('A', TRUE);
IF f0 # NIL THEN
f := f0(Entry);
Log.String( 'exact search: ' + f.key ); Log.Ln;
ELSE
Log.String( 'exact search failed' ); Log.Ln;
END;
v.Init;
Log.String('after Init: '); Log.Ln;
v.Log;
HALT( 7 );
END Do;
END i21sysVocabularyTest.Do | i21sys/Mod/VocabularyTest.odc |
MODULE i21sysWindows; (** **)
(** Для Информатики-21: обслуживание окон документов в Блэкбоксе. **)
(* 2009-10-09 Ф.В.Ткачев, полностью переделано. *)
(* 2009-03-17 Ф.В.Ткачев
-- все ссылки на Win API переведены на псевдо модуль WinApi
-- убраны IsOpen, Close, LogClose
-- уточнена процедура SetPos
-- экспортирована процедура ThisWindows
*)
(* 2008-02-16 Ф.В.Ткачев, переименования и мелкая редакция. *)
(** Finding, positioning, setting size of windows. **)
(** 2001-08-03 Modifications for BlackBox 1.4: winTitle for Log window now is "#Dev:Log" (formerly "Log") **)
IMPORT Log := StdLog, Views, Windows, HostWindows, WinApi, Ports, Stores;
CONST
minimized = 0; maximized = 1; (* Window states *)
TYPE
State* = RECORD (* позиция окна (с рамками и т.п.) на экране в пикселях *)
l, t, r, b: INTEGER;
state: SET
END;
PROCEDURE GetState* ( v: Views.View; OUT s: State );
VAR win: Windows.Window;
wh: WinApi.HANDLE; ret: WinApi.BOOL; wp: WinApi.WINDOWPLACEMENT; rect: WinApi.RECT;
BEGIN
win := Windows.dir.First();
WHILE ( win # NIL ) & ( win.doc.ThisView() # v ) DO
win := Windows.dir.Next( win );
END;
ASSERT( win # NIL );
wh := win( HostWindows.Window ).wnd;
ret := WinApi.GetWindowPlacement( wh, wp ); (* relative position in app window *)
s.l := wp.rcNormalPosition.left;
s.t := wp.rcNormalPosition.top;
s.r := wp.rcNormalPosition.right;
s.b := wp.rcNormalPosition.bottom;
s.state := {};
IF WinApi.IsIconic ( wh ) = 1 THEN INCL( s.state, minimized ) END;
IF WinApi.IsZoomed ( wh ) = 1 THEN INCL( s.state, maximized ) END;
END GetState;
PROCEDURE SetState* ( v: Views.View; s: State );
VAR win: Windows.Window;
wh: WinApi.HANDLE; ret: WinApi.BOOL; x, y, w, h: INTEGER;
BEGIN
win := Windows.dir.First();
WHILE ( win # NIL ) & ( win.doc.ThisView() # v ) DO
win := Windows.dir.Next( win );
END;
IF win # NIL THEN
wh := win( HostWindows.Window ).wnd;
x := s.l; w := s.r - s.l;
y := s.t; h := s.b - s.t;
ret := WinApi.MoveWindow( wh, x, y, w, h, 1 );
END;
END SetState;
PROCEDURE ExternalizeState* ( wr: Stores.Writer; s: State );
BEGIN
wr.WriteInt( s.l );
wr.WriteInt( s.t );
wr.WriteInt( s.r );
wr.WriteInt( s.b );
wr.WriteSet( s.state );
END ExternalizeState;
PROCEDURE InternalizeState* ( rd: Stores.Reader; OUT s: State );
BEGIN
rd.ReadInt( s.l );
rd.ReadInt( s.t );
rd.ReadInt( s.r );
rd.ReadInt( s.b );
rd.ReadSet( s.state );
END InternalizeState;
(** все экспортированные процедуры работают с передним окном **)
PROCEDURE SetSize* ( w, h: INTEGER (*пиксели; внутр. размеры*) );
VAR win: Windows.Window;
BEGIN
win := Windows.dir.First();
IF win # NIL THEN win.SetSize( w, h ) END
END SetSize; (*"i21sysWindows.SetSize(300,200)" *)
PROCEDURE WinSetPos ( win: Windows.Window; x, y: INTEGER );
VAR w, h: INTEGER;
wh: WinApi.HANDLE; wp: WinApi.WINDOWPLACEMENT; rect: WinApi.RECT; ret: WinApi.BOOL;
BEGIN
wh := win( HostWindows.Window ).wnd;
ret := WinApi.GetWindowRect( wh, rect ); (* rect := window's bounds, in pixels *)
(* абсолютный внешний размер в пикселях: *)
w := rect.right - rect.left ; h := rect.bottom - rect.top ;
ret := WinApi.MoveWindow( wh, x, y, w, h, 1 ); (* позиция в реально видимой части экрана *)
END WinSetPos;
PROCEDURE SetPos* ( x, y: INTEGER ); (* позиция в реально видимой части экрана *)
VAR win: Windows.Window;
BEGIN
win := Windows.dir.First();
IF win # NIL THEN WinSetPos( win, x, y ) END;
END SetPos; (*"i21sysWindows.SetPos(0,0)" *)
PROCEDURE AlignTopLeft*; (* вызывается из меню; передвигает переднее окно *)
VAR win: Windows.Window;
BEGIN
win := Windows.dir.First();
IF win # NIL THEN WinSetPos( win, 0, 0 ) END;
END AlignTopLeft; (*i21sysWindows.AlignTopLeft *)
PROCEDURE WinAlignTopRight ( win: Windows.Window );
VAR r, b: INTEGER; x, y, w, h: INTEGER;
wh: WinApi.HANDLE; wp: WinApi.WINDOWPLACEMENT; rect: WinApi.RECT; ret: WinApi.BOOL;
BEGIN
wh := win( HostWindows.Window ).wnd;
ret := WinApi.GetWindowPlacement( wh, wp ); (* relative position in app window *)
rect := wp.rcNormalPosition;
w := rect.right - rect.left ; h := rect.bottom - rect.top ;
x := HostWindows.mainW - w; y := 0;
ret := WinApi.MoveWindow( wh, x, y, w, h, 1 );
END WinAlignTopRight;
PROCEDURE AlignTopRight*; (* вызывается из меню; передвигает переднее окно *)
VAR win: Windows.Window;
BEGIN
win := Windows.dir.First();
IF win # NIL THEN WinAlignTopRight( win ) END;
END AlignTopRight; (* i21sysWindows.AlignTopRight *)
PROCEDURE ThisWindow* ( winTitle: Views.Title ): Windows.Window;
VAR win: Windows.Window; t: Views.Title;
BEGIN
t := '';
win := Windows.dir.First();
LOOP (* схема линейного поиска *)
IF win = NIL THEN EXIT END;
win.GetTitle( t );
IF t = winTitle THEN EXIT END;
win := Windows.dir.Next( win )
END;
ASSERT( ( win = NIL ) OR ( t = winTitle ), 60 );
RETURN win
END ThisWindow;
END i21sysWindows.
PROCEDURE AlignTopRightWin ( win: Windows.Window ); (* старая версия *)
VAR l, t, r, b: INTEGER; x, y, w, h: INTEGER;
wh: WinApi.HANDLE; wp: WinApi.WINDOWPLACEMENT; rect: WinApi.RECT; ret: WinApi.BOOL;
BEGIN
wh := win( HostWindows.Window ).wnd;
(* внутренние границы окна Блэкбокса: *);
HostWindows.GetMainBorder( l, t, r, b );
ret := WinApi.GetWindowPlacement( wh, wp ); (* relative position in app window *)
rect := wp.rcNormalPosition;
w := rect.right - rect.left ; h := rect.bottom - rect.top ;
x := r - w; y := t;
ret := WinApi.MoveWindow( wh, x, y, w, h, 1 );
END AlignTopRightWin;
PROCEDURE SetPos* ( winTitle: Views.Title; x, y: INTEGER (*pixels*) );
VAR win: Windows.Window;
BEGIN
win := ThisWindow( winTitle );
IF win # NIL THEN SetPosWin( win, x, y ) END;
END SetPos;
PROCEDURE SetSize* ( winTitle: Views.Title; w, h: INTEGER (*пиксели; внутр. размеры*) );
VAR win: Windows.Window;
BEGIN
win := ThisWindow( winTitle );
IF win # NIL THEN win.SetSize( w, h ) END
END SetSize;
PROCEDURE LogTopLeft*;
BEGIN SetPos( "#Dev:Log", 0, 0 );
END LogTopLeft; (*i21sysWindows.LogTopLeft*)
PROCEDURE LogTopRight*;
BEGIN
AlignTopRight( '#Dev:Log' );
END LogTopRight; (*i21sysWindows.LogTopRight*)
(*"i21sysWindows.LogTopLeft;i21sysWindows.LogTopRight" --проверка, что размер не меняется*)
(*
PROCEDURE CorrectMinimized; (* это делает HostMenus.ArrangeIcons *)
(* решается ОС-ная проблема: при разворачивании на (или из) два экрана размер внутреннего поля Блэкбокса меняется -- положения минимизированных окон становятся некорректными. Поправление: каждое минимизированное окно сначала восстанавливается, потом снова минимизируется. *)
VAR win: Windows.Window; wh: WinApi.HANDLE; ret: INTEGER;
aw: POINTER TO ARRAY OF Windows.Window; n: INTEGER;
BEGIN
n := 0;
win := Windows.dir.First();
WHILE win # NIL DO INC( n ); win := Windows.dir.Next( win ) END;
NEW( aw, n );
n := 0;
win := Windows.dir.First();
WHILE win # NIL DO aw[ n ] := win; INC( n ); win := Windows.dir.Next( win ) END;
FOR n := 0 TO LEN( aw ) - 1 DO (* while как выше >> бесконечный цикл *)
wh := aw[ n ]( HostWindows.Window ).wnd;
IF WinApi.IsIconic( wh ) = 1 THEN
ret := WinApi.ShowWindow( wh, 1 ); (* восстановить окно *)
ret := WinApi.ShowWindow( wh, 6 ); (* снова минимизировать окно *)
END;
END;
END CorrectMinimized; (* i21sysWindowsTests.CorrectMinimized *)
CorrectMinimized *)
| i21sys/Mod/Windows.odc |
% Словарик подсказок.
% F5 пытается угадать ключевое слово по первым буквам.
% Однако может быть несколько ключевых слов, начинающихся одинаково.
%
% Например, одинаковая первая буква есть у пяти слов: IF, IN, INC, INCL и INTEGER.
% Из них у четырех одинаковые первые две, а у двух первые две.
% Однако из них намного чаще встречается слово INTEGER, поэтому хотелось бы гарантировать, чтобы именно INTEGER "угадывалось" по первой букве i клавишей F5.
% Для этого и служит список подсказок:
%
% Первой идет комбинация начальных букв.
% Затем то слово, которое хотелось бы "угадать" именно по этим начальным буквам.
% В комментарии после % указано, с каким ключевым словом может быть путаница.
%
% Не требуется, чтобы список был упорядочен по алфавиту.
% В обоих позициях могуть быть любые литерные цепочки в кавычках см. пример в конце.
%
% О синтаксических правилах записи словариков см. русскую документацию к модулю i21sysAuxScanner.
% 2012-04-27 info21
A ARRAY
AS ASSERT % ASH
B BOOLEAN % BITS
C CHAR % CHR
CH CHAR
D DIV % DIJKSTRA
DI DIV % DIJKSTRA
EN ENTIER % END
END END % чтобы исключить раскрытие в ENDASH
EX EXTENSIBLE % EXIT
F FALSE % FOR
I INTEGER % IN
IN IN % иначе in может раскрыться в INTEGER
INC INC % INCL
M MODULE % MOD
P PROCEDURE % POINTER
R REAL % RECORD, REPEAT
RE REAL
T TRUE % TO
W WHILE % WITH
INFO "Информатика-21" % пример цепочки литер
INFO21 "Информатика-21" % пример цепочки литер
"21" "Информатика-21" % пример цепочки литер
| i21sys/Rsrc/hints.odc |
% Список английских ключевых слов для угадывания по первым буквам в алгоритмах модуля i21sysEdit (раскрытие синтаксических конструкций с помощью F5).
% Алфавитный порядок не важен.
%
% О синтаксических правилах записи словариков см. русскую документацию к модулю i21sysScanner.
% 2012-04-27 info21; последние правки 2012-11-06
ABS
ABSTRACT
ANYPTR
ANYREC
ARRAY
ASSERT
BEGIN
BITS
BOOLEAN
BYTE
CASE
CHAR
CLOSE
CONST
DIV
ELSE
ELSIF
EMPTY
END
ENTIER
EXIT
EXTENSIBLE
FALSE
FINALIZE
FOR
HALT
IMPORT
IN
INC
INTEGER
IS
LEN
LIMITED
LONG
LONGINT
LOOP
MAX
MIN
MOD
MODULE
NEW
ODD
OR
ORD
OUT
POINTER
PROCEDURE
REAL
RECORD
REPEAT
RETURN
SET
SHORT
SHORTCHAR
SHORTINT
SHORTREAL
SIZE
THEN
TRUE
TYPE
UNTIL
VAR
WHILE
WITH
DIJKSTRA % не принадлежит языку Компонентный Паскаль, но включить можно
"BlackBox Component Builder" % на самом деле сюда много чего можно навключать
| i21sys/Rsrc/keywords.odc |
% Словарик подстановки простых синтаксических конструкций.
% Позиция, где курсор должен стоять после раскрытия, указывается литерой |. Если ее нет, то в конце.
% Сама эта литера при подстановке удаляется.
% Подробней о синтаксических правилах записи словариков
% см. русскую документацию к модулю i21sysScanner.
%
% Нужно помнить, что прежде чем слово будет сопоставляться со словами в левой колонке,
% с ним произойдет следующее:
% сначала будет сделана попытка угадать полное слово по подсказкам (hints);
% если подсказки не нашлось, то будет сделана попытка заменить его
% на первое подходящее слово в keywords, начало которого совпадает с раскрываемым словом.
% Этим объясняется, почему здесь можно включить подстановки вида H126 или Q1:
% они проходят сквозь два описанных шага "угадывания" без изменений.
%
% Если слово не раскрывается по одной из вышеперечисленных простых подстановок,
% то для него делается попытка сложной замены с помощью процедур, зашитых в Edit.
%
% Алфавитный порядок соблюдать не обязательно.
% 2012-02-10 info21
ABS 'ABS( | );'
ARRAY 'ARRAY OF '
ASH 'ASH( | );'
ASSERT 'ASSERT( | );'
DEC 'DEC( | );'
ELSIF 'ELSIF | THEN'
EMDASH ''
ENDASH ''
ENTIER 'ENTIER( | );'
EXCL 'EXCL( |, );'
H126 'HALT( 126 );' % еще не реализовано
H128 'HALT( 128 );' % молчаливая остановка (без окошка Трапа)
HALT 'HALT( | );'
INC 'INC( | );'
INCL 'INCL( |, );'
LEN 'LEN( | );'
LONG 'LONG( | );'
MAX 'MAX( | );'
MIN 'MIN( | );'
NA 'NEW, ABSTRACT'
NEW 'NEW( | );'
ODD 'ODD( | );'
ORD 'ORD( | );'
POINTER 'POINTER TO '
Q '|' % одинарные английские кавычки
Q1 '|' % одинарные английские кавычки
Q2 '|' % двойные английские кавычки
QUOTE '|' % двойные английские кавычки
SHORT 'SHORT( | );'
SIZE 'SIZE( | );'
VAR 'VAR '
| i21sys/Rsrc/simples.odc |
STRINGS
CharacterSet CP identifier characters: ^0
UnableToRestoreDocument Не удалось восстановить документ ^0
IndentChecksOn Проверки отступов включены
IndentChecksOff Проверки отступов отключены
IndentMenuOn Включить проверки отступов
IndentMenuOff Отключить проверки отступов
KeywordsLanguage Словарик редактора: ^0
i21sysKoi8r.ImportKoi8rText Текст (кодировка KOI8-R)
StartupBlackBox пускач Блэкбокса
CannotCreateVbs Чтобы сделать пускач, нужно запустить BlackBox.exe в основной папке
CannotSave Нужно сохранить документы!
CannotClose Нужно сохранить документы!
CannotExit Нужно сохранить документы!
SilentModeOn cистемные звуковые сигналы отключены
| i21sys/Rsrc/Strings.odc |
i21sys/Rsrc/UnicodeTools.odc |
|
Создание простых диалогов
Нигде в примерах (кроме ***) не предполагается знание типов RECORD.
Простыекомандныекнопки.
Полевводадляцепочкилитер.
Полевводадляцелого.
Диалогсобновляемымрезультатом.
Уведомитель (обновление результата "на лету", без нажатия кнопок).
Флажки,связанныеслогическими(BOOLEAN)переменными.
*** Тоже,нообновлениевсехполейодниммахом.
Флажки,связанныесSET.
Переключатель.
Список.
Списоксвыбором.
Комбинированныйсписок.
________________________________________________
Первоначальная версия: 2003-10-23 при активном участии А.И.Попкова.
Версия 2010-10-01: Ф.В.Ткачев.
Исправления диалоговых форм 2011-02-13: Ф.В.Ткачев, список ошибок: Александр Шостак.
| i21диал/Создание простых диалогов.odc |
(* То же, что и в предыдущем примере i21диалТекст, но в поле ввода предназначено для ввода целого числа. *)
MODULE i21диалВводЦелого;
IMPORT StdLog;
VAR целое*: INTEGER;
PROCEDURE Напечатать*;
BEGIN
(* напечатать в Рабочий журнал, чтобы видеть, что хранится в переменной целое *)
StdLog.Int( целое );
StdLog.Ln
END Напечатать;
BEGIN целое := 9876 (* начальное значение, устанавливаемое при свежей загрузке модуля *)
END i21диалВводЦелого.
Создаем диалог (Диалоги, Новая форма...),
сохраняем в i21диал/Rsrc/ВводЦелого.odc.
Мышкой увеличить кнопку, правый клик, Свойства..
"StdCmds.OpenAuxDialog('i21диал/Rsrc/ВводЦелого','Поле ввода целого')"
Заметим, что в поле для ввода целого Блэкбокс не дает напечатать ничего, кроме цифр! (Блэкбокс умный...)
Открыть форму для модификации:
"StdCmds.OpenDoc('i21диал/Rsrc/ВводЦелого')"
| i21диал/Mod/ВводЦелого.odc |
(* Ввод целого числа через текстовое поле [Field]. В этом примере будем вычислять и обновлять значение в новом поле диалога. *)
MODULE i21диалВводЦелого2;
IMPORT StdLog, Math, Dialog;
VAR
целое*: INTEGER;
результат-: REAL; (* ограниченный экспорт -- значение переменной нельзя менять извне модуля: будет показано в диалоге серым цветом. *)
PROCEDURE ПечататьЦелое*;
BEGIN
StdLog.Int( целое );
StdLog.Ln
END ПечататьЦелое;
PROCEDURE ВычКвадрКорень*;
VAR
BEGIN
(* вычисляем и заносим значение в глобальную переменную: *)
результат := Math.Sqrt( целое ); (* здесь могло бы быть очень сложное вычисление *)
(* Теперь нужно обновить диалог, в котором показывается переменная результат: *)
Dialog.UpdateReal( результат ) (* Update = обновить. *)
(* Без этого будет по-прежнему показываться старое значение корня. *)
(* На самом деле одна и та же переменная может показываться
в нескольких разных диалогах одновременно,
и по данному вызову умный Блэкбокс обновит все диалоги,
где показывается эта переменная. *)
END ВычКвадрКорень;
BEGIN
(* начальные значения сразу после свежей загрузки модуля: *)
целое := 144;
ВычКвадрКорень (* вызываем, чтобы правильно заполнить переменную результат *)
END i21диалВводЦелого2.
"StdCmds.OpenAuxDialog('i21диал/Rsrc/ВводЦелого2','Ввод целого 2')"
Открыть форму для модификации:
"StdCmds.OpenDoc('i21диал/Rsrc/ВводЦелого2')"
Упражнение. Изменить названия кнопок в диалоговой форме.
Упражнение. Добавить в модуль процедуру, а в диалог соответствующую кнопку, для печати в рабочий журнал значения переменной результат.
Замечание.
В модуле Dialog есть отдельные процедуры для переменых основных типов (BOOLEAN, INTEGER, LONGINT, REAL). Вот их сигнатуры:
PROCEDURE UpdateBool (VAR b: BOOLEAN);
PROCEDURE UpdateInt (VAR i: INTEGER);
PROCEDURE UpdateLInt (VAR l: LONGINT);
PROCEDURE UpdateReal (VAR r: REAL);
Можно делать обновление сразу для группы переменных разных типов, но для этого надо знать, что такое RECORD.
Упражнение. Изменить диалог так, чтобы одновременно с корнем вычислялось наибольшее целое число, квадрат которого не превосходит значения переменной целое.
| i21диал/Mod/ВводЦелого2.odc |
(* Выбор [SelectionBox]. В диалоге можно выбрать одновременно несколько вариантов из списка (Ctrl+щелк или Shift+щелк). *)
MODULE i21диалВыбор;
IMPORT StdLog, Dialog;
CONST прог = 0; матем = 1; муз = 2; худож = 3; англ = 4;
VAR доп_занятия*: Dialog.Selection;
PROCEDURE Показать*;
VAR i: INTEGER; есть: BOOLEAN;
BEGIN
StdLog.String('дополнительные занятия:'); StdLog.Ln;
есть := FALSE;
FOR i := 0 TO доп_занятия.len - 1 DO
IF доп_занятия.In( i ) THEN
есть := TRUE;
StdLog.Tab;
CASE i OF
|0: StdLog.String('программирование')
|1: StdLog.String('математика')
|2: StdLog.String('музыкальная школа')
END;
StdLog.Ln
END
END;
IF ~есть THEN
StdLog.Tab; StdLog.String('не посещает'); StdLog.Ln
END
END Показать;
BEGIN
доп_занятия.SetLen( 3 );
доп_занятия.SetItem( 0, 'программирование' );
доп_занятия.SetItem( 1, 'математика' );
доп_занятия.SetItem( 2, 'музыкальная школа' );
END i21диалВыбор.
Создание диалога:
Дважды щелкнуть по имени модуля, Диалог, Новый диалог... , OK.
Ctrl+S.
"StdCmds.OpenAuxDialog('i21диал/Rsrc/Выбор','Список с выбором')"
Открыть форму для модификации:
"StdCmds.OpenDoc('i21диал/Rsrc/Выбор')"
Если названия (цепочки литер) для элементов списка переопределяются динамически (перевычисляются в программе) в зависимости от каких-то условий, задаваемых в диалоге,
то нужно вызвать Dialog.UpdateList( ... ), чтобы новые названия стали доступны в текущем диалоге.
Упражнение. Добавить "гуру" (3).
Замечание. В получившемся диалоге можно отметить любое число строк (Ctrl+клик)
| i21диал/Mod/Выбор.odc |
(* Кнопки [Command Button]. Модуль с двумя экспротированными процедурами без параметров (у кнопок нет параметров).
В диалоге каждой процедуре соответствует кнопка. *)
MODULE i21диалКнопки;
IMPORT StdLog;
PROCEDURE Команда*;
VAR
BEGIN
(* просто сделать что-нибудь *)
StdLog.String('первый пример диалоговой кнопки'); StdLog.Ln
END Команда;
PROCEDURE ЕщеКоманда*;
VAR
BEGIN
(* сделать еще что-нибудь *)
StdLog.String('ну и напечатаем еще что-нибудь'); StdLog.Ln
END ЕщеКоманда;
END i21диалКнопки.
Что две команды работают, можно убедиться здесь:
i21диалКнопки.Команда
i21диалКнопки.ЕщеКоманда
Чтобы спроектировать диалог, нужно создать его "форму" особый вид документа, который, как и текстовые документы, может храниться в файле и редактироваться, но состоит не из литер, а из объектов, изображающих кнопки, поля ввода данных и т.п.
В соответствии с этой "формой" Блэкбокс будет изображать на экране диалог, когда программа его вызовет.
Есть два способа сделать форму для диалога:
Первый способ: сначала придумать, написать и скомпилировать модуль, потом автоматически построить диалог:
1) Диалоги, Новая форма;
2) в открывшемся диалоге в поле "Связать с:" скопировать имя модуля (дважды щелкнуть где-нибудь по имени модуля, Ctrl+C, щелкнуть мышкой внутрь поля "Связать с:", Ctrl+V, OK).
3) Появится форма нового диалога с двумя кнопками. Сохранить: нажать Ctrl+C (система сама откроет диалог в правильной папке и предложит разумное имя; это все можно изменить как обычно в ОС Windows), OK.
Следует обратить внимание на команду меню Разметка, Пересчитать размер (меню Разметка появляется в верхней линейке меню, когда в фокусе находится какой-нибудь редактируемый форма диалога).
Эту команду удобно применять после того, как элемент диалога подвинут за край поля: команда увеличивает размер диалога так, чтобы все элементы помещались целиком.
Второй способ: начать с пустого диалога и "собрать" его, добавляя элементы (кнопки и т.п.). В этом случае нужно вручную вставлять кнопки и т.п. и связывать их с экспортированными процедурами. Здесь не рассматриваем, а только заметим, что в одном диалоге разные элементы (кнопки, поля ввода и т.п.) могут быть связаны с разными модулями по усмотрению программиста.
Итак, по первому способу сделали диалог и сохранили его в i21диал/Rsrc/Кнопки.odc
Чтобы вызвать его, нужно выполнить команду:
"StdCmds.OpenAuxDialog('i21диал/Rsrc/Кнопки','любой заголовок для диалога')"
Расширение (тип) файла указывать не обязательно: .odc подразумевается.
Открыть форму диалога для модификаций (если спасли его так, не меняя ни имени, ни места, предложенного системой при сохранении новой формы):
"StdCmds.OpenDoc('i21диал/Rsrc/Кнопки')"
Задача. Сделать диалог с одной кнопкой, чтобы нажатие кнопки вызывало печать в Рабочий журнал очередного простого числа.
Подсказка: информацию о последнем напечатанном числе сохранять в скрытой глобальной переменной модуля.
Внимание! Если сделать диалог с парой кнопок, а потом добавить в модуль еще одну процедуру-команду и попытаться заново сделать диалог с тремя кнопками, то нужно не забыть предварительно выгрузить из памяти старый скомпилированный модуль, если он там.
Как проверить, какием модули в памяти: Инфо, Загруженные модули.
Как выгрузить модуль: дважды щелкнуть по имени модуля и выполнить Разработка, Выгрузить модули из списка). | i21диал/Mod/Кнопки.odc |
(* Комбинированный список [ComboBox]. Можно выбрать один из предусмотренных вариантов или задать свой: например, напечатать Екатеринбург. *)
MODULE i21диалКомбиСписок;
IMPORT StdLog, Dialog;
VAR город*: Dialog.Combo;
PROCEDURE Показать*;
BEGIN
StdLog.String( город.item ); StdLog.Ln;
END Показать;
BEGIN
город.SetLen( 4 );
город.SetItem( 0, 'Стрежевой' );
город.SetItem( 1, 'Нижневартовск' );
город.SetItem( 2, 'Томск' );
город.SetItem( 3, 'Москва' );
(* номера пропускать нельзя должны идти подряд, начиная с нуля.*)
END i21диалКомбиСписок.
Создание диалога: как обычно.
"StdCmds.OpenAuxDialog('i21диал/Rsrc/КомбиСписок','Комбинир. список')"
Открыть форму для модификации:
"StdCmds.OpenDoc('i21диал/Rsrc/КомбиСписок')"
Если названия (цепочки литер) для элементов списка переопределяются динамически (перевычисляются в программе) в зависимости от каких-то условий, задаваемых в диалоге,
то нужно вызвать Dialog.UpdateList( ... ), чтобы новые названия стали доступны в текущем диалоге.
| i21диал/Mod/КомбиСписок.odc |
(* Переключатель [Radio Button]. *)
MODULE i21диалПереключатель;
IMPORT StdLog, Dialog;
CONST нач = 0; опытн = 1; эксп = 2;
VAR уровень*: INTEGER;
PROCEDURE Показать*;
BEGIN
CASE уровень OF
|нач:
StdLog.String('начинающий программист'); StdLog.Ln
|опытн:
StdLog.String('опытный программист'); StdLog.Ln
|эксп:
StdLog.String('эксперт высшего класса'); StdLog.Ln
END;
END Показать;
BEGIN
END i21диалПереключатель.
Диалог создается как обычно.
Во вновь созданной диалоге:
Стереть элементы "уровень" и соотв. текстовое поле,
выполнить команду меню Диалоги, Вставить переключатель [Radio button],
расположить как надо,
правый клик, Свойства.
Заполнить поля:
Связан с: i21диалПереключатель.уровень
Ярлык: начинающий
Уровень: 0
OK
Повторить дважды для опытного и эксперта.
"StdCmds.OpenAuxDialog('i21диал/Rsrc/Переключатель','Переключатель')"
Открыть форму для модификации:
"StdCmds.OpenDoc('i21диал/Rsrc/Переключатель')"
Упражнение. Добавить "гуру" (3).
| i21диал/Mod/Переключатель.odc |
(* Список [ListBox]. *)
MODULE i21диалСписок;
IMPORT StdLog, Dialog;
CONST нач = 0; опытн = 1; эксп = 2;
VAR уровень*: Dialog.List;
PROCEDURE Показать*;
BEGIN
StdLog.String('численное значение уровня: '); StdLog.Int( уровень.index ); StdLog.Ln;
StdLog.String('словесное описание: ');
CASE уровень.index OF
|0: StdLog.String('начинающий')
|1: StdLog.String('опытный')
|2: StdLog.String('эксперт')
END;
StdLog.Ln;
END Показать;
BEGIN
уровень.SetLen( 3 );
уровень.SetItem( 0, 'начинающий' );
уровень.SetItem( 1, 'опытный' );
уровень.SetItem( 2, 'эксперт' );
(* номера пропускать нельзя должны идти подряд, начиная с нуля.*)
END i21диалСписок.
Создание диалога:
Дважды щелкнуть по имени модуля, Диалоги, Новая форма..., OK.
Ctrl+S.
"StdCmds.OpenAuxDialog('i21диал/Rsrc/Список','Список')"
Открыть форму для модификации:
"StdCmds.OpenDoc('i21диал/Rsrc/Список')"
Если названия (цепочки литер) для элементов списка переопределяются динамически (перевычисляются в программе) в зависимости от каких-то условий, задаваемых в диалоге,
то нужно вызвать Dialog.UpdateList( ... ), чтобы новые названия стали видны в текущем диалоге.
Упражнение. Добавить в диалог "гуру" (3).
| i21диал/Mod/Список.odc |
(* Ввод строки литер через текстовое поле ввода [Field]. *)
MODULE i21диалТекст;
IMPORT StdLog;
VAR текст*: ARRAY 20 OF CHAR;
(* переменная должна быть экспортирована, т.к. нужно менять ее значение извне модуля. *)
PROCEDURE ПоказатьТекст*;
BEGIN
(* напечатать в Рабочий журнал, чтобы видеть, что хранится в переменной текст *)
StdLog.String( текст );
StdLog.Ln
END ПоказатьТекст;
BEGIN
текст := "в начале..." (* начальное значение сразу после свежей загрузки модуля *)
END i21диалТекст.
Создаем диалог (Диалоги, Новая форма...),
сохраняем в i21диал/Rsrc/Текст.odc.
Предварительно можно подвигать и увеличить кнопки, чтобы было видно название целиком. Для этого щелкнуть мышкой по кнопке и потянуть за черные квадратики, чтобы увеличить кнопку, или потянуть за середину, чтобы передвинуть кнопку в новое место.
Чтобы поменять текст на кнопке, нужно сделать
правый клик по этой кнопке;
вызвать команду меню Свойства...;
в поле Ярлык: изменить текст по желанию.
Не забыть сохранить изменения в файле.
"StdCmds.OpenAuxDialog('i21диал/Rsrc/Текст','Текст')"
Открыть форму для модификации:
"StdCmds.OpenDoc('i21диал/Rsrc/Текст')" | i21диал/Mod/Текст.odc |
(* Уведомитель [Notifier]. Позволяет обновлять результат "на лету", без нажатия спец. кнопки, т.е. диалог вообще без кнопок. *)
MODULE i21диалУведомитель; (* notifier = тот, кто уведомляет другие поля, "уведомитель" *)
IMPORT StdLog, Dialog, Math;
VAR аргумент*, корень-: REAL;
PROCEDURE Уведомитель* (op, from, to: INTEGER); (* В простых ситуациях параметры не используются, но стоять должны именно так, как показано, иначе Блэкбокс заругается при создании диалога. *)
BEGIN
корень := Math.Sqrt( аргумент );
Dialog.UpdateReal( корень )
END Уведомитель;
BEGIN аргумент := 0
END i21диалУведомитель.
Создаем диалог (Диалоги, Новая форма...) и т.д.
Правый щелк по полю ввода аргумента (белый прямоугольник), Свойства...
в поле набить (или скопировать) i21диалУведомитель.Уведомитель,
OK,
сохраняем в i21диал/Rsrc/Уведомитель.odc,
закрываем,
спасаем и закрываем форму диалога.
Вызываем диалог:
"StdCmds.OpenAuxDialog('i21диал/Rsrc/Уведомитель','Уведомитель')"
Если все сделано правильно, то значение корня будет обновляться на лету сразу при любом изменении поля "аргумент".
(Если нужные вычисления сложные и долгие, то, естественно, придется ждать.)
Открыть форму для модификации:
"StdCmds.OpenDoc('i21диал/Rsrc/Уведомитель')"
| i21диал/Mod/Уведомитель.odc |
(* Флажки [CheckBox], связанные с логическими (булевскими) переменными. *)
MODULE i21диалФлажки;
IMPORT StdLog, Math, Dialog;
VAR
a*, b*, and-, or-, xor-, implies-: BOOLEAN;
PROCEDURE Вычислить*;
VAR
BEGIN
and := a & b; Dialog.UpdateBool( and );
or := a OR b; Dialog.UpdateBool( or );
xor := ~a & b OR a & ~b; Dialog.UpdateBool( implies );
implies := ~a OR b; Dialog.UpdateBool( implies );
END Вычислить;
BEGIN
END i21диалФлажки.
"StdCmds.OpenAuxDialog('i21диал/Rsrc/Флажки','Логические операции')"
Открыть форму для модификации:
"StdCmds.OpenDoc('i21диал/Rsrc/Флажки')"
Внимание! Обратить внимание на размер получающихся элементов диалога (размер соотв. рамки виден после щелчка мышкой): нужно их уменьшить так, чтобы после передвижения они не перекрывались.
Упражнение. Разобраться с порядком вычислений в правой части присваивания для xor (вспомнить приоритеты операций; ср. приоритеты и визуальный размер соотв. знака операции).
Упражнение. Добавить в диалог операцию отрицания.
Упражнение. Исключить кнопку из диалога так, чтобы результаты операций обновлялись "на лету".
| i21диал/Mod/Флажки.odc |
(* Флажки [Check box]. То же, что и пример i21диалФлажки, но обновление всех полей одним махом. *)
MODULE i21диалФлажки1;
IMPORT StdLog, Math, Dialog;
VAR
a*, b*: BOOLEAN;
рез*: RECORD
and-, or-, implies-: BOOLEAN
END;
PROCEDURE Вычислить*;
VAR
BEGIN
рез.and := a & b;
рез.or := a OR b;
рез.implies := ~a OR b;
Dialog.Update( рез ) (* не зависит от того, сколько и каких полей у записи рез *)
END Вычислить;
BEGIN Вычислить
END i21диалФлажки1.
Обратить внимание на рамочку, которая появится вокруг полей для результатов.
Это самостоятельный диалоговый элемент, кликнув по нему и нажав Ctrl+Enter можно поменять текст вверху (содержимое поля "Ярлык:").
"StdCmds.OpenAuxDialog('i21диал/Rsrc/Флажки1','Логические операции')"
Открыть форму для модификации:
"StdCmds.OpenDoc('i21диал/Rsrc/Флажки1')"
Упражнение. Добавить в диалог операцию xor (вычисляется как в предыдущем примере).
Упражнение. Изменить программу так, чтобы переменные a, b были внутри RECORD.
| i21диал/Mod/Флажки1.odc |
(* Флажки [Check box], связанные с SET.
Данный диалог может быть частью диалога ввода данных для базы данных школьников. *)
MODULE i21диалФлажки2;
IMPORT StdLog, Dialog;
CONST прог = 0; матем = 1; англ = 2; худож = 3; муз = 4;
VAR доп_занятия*: SET;
PROCEDURE Напечатать*;
VAR i: INTEGER;
BEGIN
IF доп_занятия # {} THEN
StdLog.String('дополнительные занятия:'); StdLog.Ln;
FOR i := 0 TO 4 DO
IF i IN доп_занятия THEN
CASE i OF
прог:
StdLog.Tab; StdLog.String('программирование'); StdLog.Ln
|матем:
StdLog.Tab; StdLog.String('математика'); StdLog.Ln
|англ:
StdLog.Tab; StdLog.String('английский язык'); StdLog.Ln
|худож:
StdLog.Tab; StdLog.String('художественная школа'); StdLog.Ln
|муз:
StdLog.Tab; StdLog.String('музыкальная школа'); StdLog.Ln
END
END
END
ELSE
StdLog.String('дополнительных занятий не посещает'); StdLog.Ln;
END
END Напечатать;
BEGIN
END i21диалФлажки2.
Создание диалога:
Диалоги, Новая форма... , в текстовом поле напечатать i21диалФлажки2, OK.
Сдвигая кнопку вправо вниз и выполняя Разметка, Пересчитать размер, увеличить размер поля до нужного.
Для каждого вида доп. занятий сделать:
Диалоги, Вставить флажок,
оттащить в нужное место,
если нужно, воспользоваться командой Разметка, Пересчитать размер.
Правый клик, Свойства (или левый клик, затем нажать Alt+Enter)
заполнить поля:
Связан с: i21диалФлажки2._,
Ярлык: соотв. текст,
Уровень: указать соотв. целое значение.
OK.
Растянуть, чтобы был виден текст.
После того, как это проделано для каждого вида занятий, сохранить форму в файл и закрыть.
"StdCmds.OpenAuxDialog('i21диал/Rsrc/Флажки2','SET')"
Открыть форму для модификации:
"StdCmds.OpenDoc('i21диал/Rsrc/Флажки2')"
| i21диал/Mod/Флажки2.odc |
i21диал/Rsrc/ВводЦелого.odc |
|
i21диал/Rsrc/ВводЦелого2.odc |
|
i21диал/Rsrc/Выбор.odc |
|
i21диал/Rsrc/Кнопки.odc |
|
i21диал/Rsrc/КомбиСписок.odc |
|
i21диал/Rsrc/Переключатель.odc |
|
i21диал/Rsrc/Список.odc |
|
i21диал/Rsrc/Текст.odc |
|
i21диал/Rsrc/Уведомитель.odc |
|
i21диал/Rsrc/Флажки.odc |
|
i21диал/Rsrc/Флажки1.odc |
|
i21диал/Rsrc/Флажки2.odc |
|
Примеры решений задач ЕГЭ
Демо-вариант 2010
С4 англ. русс.
| i21егэ/Примеры решений задач ЕГЭ.odc |
MODULE i21егэDemo2010C4en;
(* не проверено по УСЛОВИЮ; русский вариант; см. инструкции в конце документа *)
IMPORT Log := StdLog, In := i21sysIn, Math;
VAR
минЦена, сколько: ARRAY 3 OF INTEGER;
осталось, i, марка, цена: INTEGER;
x: ARRAY 21 OF CHAR;
BEGIN
FOR i := 0 TO 2 DO
минЦена[ i ] := 3001; сколько[ i ] := 0
END;
In.Open;
In.Int( осталось );
WHILE осталось > 0 DO
In.String( x ); In.String( x ); (* пропускаем пару цепочек в данных *)
In.Int( марка );
IF марка = 92 THEN марка := 0
ELSIF марка = 95 THEN марка := 1
ELSE марка := 2
END;
In.Int( цена ); ASSERT( (цена >= 1000) & (цена <= 3000) );
IF цена < минЦена[ марка ] THEN
минЦена[ марка ] := цена;
сколько[ марка ] := 1
ELSIF цена = минЦена[ марка ] THEN
сколько[ марка ] := сколько[ марка ] + 1
END;
осталось := осталось - 1;
END;
Log.Int( сколько[0] );
Log.Int( сколько[1] );
Log.Int( сколько[2] );
Log.Ln;
END i21егэDemo2010C4en.
Выделить мышкой входные данные и нажать Ctrrl+F9
2
aaa bbb 92 2000
ccc dddd 95 2001
---------
Справкапоучебномувводу-выводу
| i21егэ/Mod/Demo2010C4en.odc |
МОДУЛЬ i21егэDemo2010C4ru;
(* не проверено по УСЛОВИЮ; англ. вариант; см. инструкции в конце документа *)
(* см. также Использованиенеанглийскихключевыхслов *)
ПОДКЛЮЧИТЬ Вывод := i21eduВывод, Ввод := i21eduВвод;
ПЕРЕМЕННЫЕ осталось, i, марка, цена: ЦЕЛЫЕ;
минЦена, сколько: МАССИВ 3 ИЗ ЦЕЛЫХ; x: МАССИВ 21 ИЗ ЛИТЕР;
НАЧАЛО
ДЛЯ i := 0 ДО 2 ДЕЛАТЬ
минЦена[ i ] := 3001; сколько[ i ] := 0
КОНЕЦ;
Ввод.Открыть;
Ввод.Цел( осталось );
ПОКА осталось > 0 ДЕЛАТЬ
Ввод.Цепочка( x ); Ввод.Цепочка( x ); (* пропускаем пару цепочек в данных *)
Ввод.Цел( марка );
ЕСЛИ марка = 92 ТО марка := 0
АЕСЛИ марка = 95 ТО марка := 1
ИНАЧЕ марка := 2
КОНЕЦ;
Ввод.Цел( цена ); УБЕДИТЬСЯ( (цена >= 1000) & (цена <= 3000) );
ЕСЛИ цена < минЦена[ марка ] ТО
минЦена[ марка ] := цена;
сколько[ марка ] := 1
АЕСЛИ цена = минЦена[ марка ] ТО
сколько[ марка ] := сколько[ марка ] + 1
КОНЕЦ;
осталось := осталось - 1
КОНЕЦ;
Вывод.Цел( сколько[0] );
Вывод.Цел( сколько[1] );
Вывод.Цел( сколько[2] );
Вывод.НовСтрока;
КОНЕЦ i21егэDemo2010C4ru.
Выделить мышкой данные и нажать Ctrrl+F9:
2
aaa bbb 92 2000
ccc dddd 95 2001
---------------
Справкапоучебномувводу-выводу
| i21егэ/Mod/Demo2010C4ru.odc |
(* то же, что и i21егэDemo2010C4, но без отступов и без пустых строк *)
MODULE i21егэDemo2010C4плохо;
IMPORT Log := StdLog, In := i21sysIn, Math;
VAR минЦена, сколько: ARRAY 3 OF INTEGER;
n, i, марка, цена: INTEGER;
x: ARRAY 21 OF CHAR;
BEGIN
FOR i := 0 TO 2 DO минЦена[ i ] := 3001; сколько[ i ] := 0 END;
In.Open;
In.Int( n );
FOR i := 1 TO n DO In.String( x ); In.String( x );
In.Int( марка );
IF марка = 92 THEN марка := 0
ELSIF марка = 95 THEN марка := 1
ELSE марка := 2
END;
In.Int( цена ); ASSERT( (цена >= 1000) & (цена <= 3000) );
IF цена < минЦена[ марка ] THEN
минЦена[ марка ] := цена;
сколько[ марка ] := 1
ELSIF цена = минЦена[ марка ] THEN
сколько[ марка ] := сколько[ марка ] + 1
END
END;
Log.Int( сколько[0] );
Log.Int( сколько[1] );
Log.Int( сколько[2] );
Log.Ln;
END i21егэDemo2010C4плохо.
Выделить мышкой входные данные и нажать Ctrrl+F9
2
aaa bbb 92 2000
ccc dddd 95 2001
| i21егэ/Mod/Demo2010C4плохо.odc |
i21примерыТетрис
DEFINITION i21примерыТетрис;
IMPORT Views, Stores, Models, Ports;
PROCEDURE НоваяИгра;
END i21примерыТетрис.
Управление игрой:
Esc начать/остановить игру.
Стрелка влево/вправо (или цифры 4/6) сдвинуть фигурку влево/вправо.
Стрелка вниз/пробел сбросить фигурку.
Стрелка вверх/5 повернуть фигурку.
i21примерыТетрис.НоваяИгра кликнуть по коммандеру, чтобы начать игру.
| i21прим/Docu/ru/Тетрис.odc |
0. Пошаговая разработка программ: Обзор
Упоминаемые ниже документы можно использовать в качестве введения в программирование на Компонентном Паскале в системе Блэкбокс для тех, кто уже умеет программировать на старом Паскале и знаком с общими принципами работы в системе MS Windows например, для учителей информатики.
Ниже даются ссылки на несколько подробных примеров разработки простых программ методом пошагового уточнения (еще говорят о пошаговой детализации, по английски step-wise refinement; термин введен Н.Виртом в классической статье Program development by step-wise refinement в 1971 г.).
Предполагается, что идеи алгоритмов в общем известны. Речь идет лишь об их реализации на языке Компонентный Паскаль в системе Блэкбокс. В частности, в первом примере подробно объясняются технические детали работы в Блэкбоксе.
Описание разработки для каждого примера дается в отдельном файле (список приведен ниже). Открыть их можно кликом мышки по голубым подчеркнутым гиперссылкам. В данном случае файлы открываются в режиме чтения, т.е. они будут защищены от случайных изменений.
Рекомендуется изучать примеры, начиная с первого, т.к. он самый подробный. Лучше всего изучать примеры, повторяя описанные там действия в новом документе (Ctrl+N; см. пояснения в первом примере).
1.Сортировкавставками
2.Пузырьковаясортировка
3.Простыечисла
4.Уплотнениесимвольногомассива
Полезная информация о программировании в системе Блэкбокс содержится в документе Полезныесведения.
Общие замечания
По необходимости последовательные варианты модуля помещаются прямо в тексте описания, хотя в реальной разработке модифицируется один и тот же документ.
Не оговаривается необходимость периодического сохранения файла (достаточно нажимать Strl+S; хотя сам Блэкбокс в высшей степени надежен, сбой операционной системы может быть вызван другими программами).
Полезно сохранять промежуточные варианты программы с другими именами (например, добавляя последовательные номера в конце имени файла). Для этого имеется удобная команда меню Файлы --> Сохранить копию как ... (Files --> Save Copy As ...).
В каждой очередной версии модуля вновь добавленные или измененные куски текста показаны зеленым цветом.
| i21прим/Docu.Пошаговая разработка/0. Пошаговая разработка.odc |
1. Пошаговая разработка: Сортировка вставками
Задача. Разработать процедуру сортировки массива целых чисел в порядке неубывания методом вставок
Решение
Построение программы происходит в несколько шагов, каждому из которых посвящена отдельная часть документа:
ЧастьЏА Постановка задачи. Проектирование интерфейса
ЧастьЏБ Разработка тела процедуры. Сведение задачи к более простой подзадаче
ЧастьЏВ Реализация процедуры Вставить
ЧастьЏГ Демонстрация работы
ЧастьЏД Замена рекурсии на цикл
Часть А. Постановка задачи. Проектирование интерфейсов
Поскольку о задаче сказано в самом общем виде, необходимо принять ряд решений проектного характера.
Во-первых, сделаем процедуру частью отдельного модуля, который назовем Вставки. Модуль сделаем частью подсистемы i21прим.
Соответственно полное имя модуля будет i21примВставки.
(Напомним, что в Компонентном Паскале большие и малые буквы различаются причем те и другие можно использовать в идентификаторах.)
Опроцедурахимодулях
ОподсистемахБлэкбокса
Обидентификаторах
Уже можно написать первый вариант модуля. Для этого откроем новый чистый документ (с клавиатуры Ctrl+N или через меню Файл --> Новый) и напечатаем там одну букву:
m
Зеленый цвет используется только в данном описании для пометки новых фрагментов программного текста. При выполнении описываемых действий не нужно раскрашивать в зеленый цвет свой документ.
ОбиспользованиицветавпрограммахБлэкбокса
Напечатав букву m, сразу нажмем клавишу F5. Получится следующий текст:
MODULE ;
IMPORT Log := StdLog, In := i21sysIn, Math;
END.
Слова вроде MODULE, состоящие только из больших букв, относятся к числу ключевых слов языка Компонентный Паскаль. Ключевые слова пишутся только большими буквами и их нельзя использовать в качестве идентификаторов. (Их полный список дан в Сообщении о языке.)
Вторая строка, начинающаяся после отступа словом IMPORT, содержит через запятую имена модулей, которые будут использоваться в программе. В зависимости от настроек вставляться могут разные списки модулей. Здесь показан некий часто встречающися вариант. Для двух из трех модулей введены сокращенные имена (Log вместо StdLog и In вместо i21sysIn); эти сокращенные имена должны использоваться всюду в тексте модуля. Log помогает печатать данные в рабочий журнал (см. об истории названия слова Log), а In вводить данные. Math содержит простые математические функции (синусы, логарифмы и т.п.).
На самом деле наша текущая задача настолько простая, что ни один из этих модулей не понадобится, и эту строку можно было бы стереть, но мы не будем этого делать.
Курсор будет мигать в первой строке непосредственно перед точкой с запятой в точности там, где нужно теперь напечатать имя модуля; так и поступим.
Получится следующий текст:
MODULE i21примВставки;
IMPORT Log := StdLog, In := i21sysIn, Math;
END.
Теперь скопируем имя модуля в позицию перед точкой через пробелы от слова END.
Удобная последовательность действий такова:
дважды кликнем мышкой по только что напечатанному имени модуля,
нажмем Ctrl+C,
нажмем Ctrl+K (см. ниже об этой важной горячей клавише),
нажмём клавишу пробела (по клавише пробела удобнее всего "стучать" большим пальцем любой руки; полезно выработать у себя такую привычку),
нажмем Ctrl+V,
снова нажмем Ctrl+K.
Получится текст:
MODULE i21примВставки;
IMPORT Log := StdLog, In := i21sysIn, Math;
END i21примВставки.
Мы выделили имя модуля жирным шрифтом (двойной клик по имени, потом нажать Ctrl+B). Компилятор игнорирует жирный шрифт, курсив, цвета и т.п. всё это можно использовать для облегчения визуальной ориентации в программном тексте.
То, что у нас получилось уже полноценный модуль, который можно компилировать (хотя выполнять там пока нечего).
Нужно стремиться к тому, чтобы после каждого шага уточнения получался модуль, который компилируется без ошибок.
Это позволяет задействовать возможности компилятора, чтобы обнаружить ошибки как можно раньше:
Чем позже обнаруживается ошибка,
тем труднее ее искать и исправлять.
Скомпилируем модуль (Ctrl+K; напомним, что здесь K латинское, и что переключать клавиатуру с русской на латинскую для выполнения команд Ctrl не нужно).
Окомпиляции
Сохраним модуль (Ctrl+S или Файл --> Сохранить) в папке i21прим\Mod\ с именем Простые (стандартный суффикс .odc система добавит автоматически).
В дальнейшем мы не будем повторять, что полезно периодически сохранять файл (достаточно нажимать Ctrl+S).
Еще полезно сохранять промежуточные варианты программы с другими именами (например, добавляя последовательные номера в конце имени файла). Для этого имеется удобная команда меню Файлы --> Сохранить копию как ... (Files --> Save Copy As ...).
Теперь выберем имя для процедуры, которую требуется построить.
Чтобы отразить смысл процедуры в ее имени, назовем ее, скажем, Сорт.
Создадим остов процедуры. Для этого:
кликнем мышкой в пустом пространстве после точки с запятой в строчке IMPORT, курсор должен встать после точки с запятой;
нажмем клавишу ввода дважды добавятся две новые строки, причем в начале каждой новой строки автоматически вставляется столько же символов табуляции, сколько их было в начале предыдущей (в нашем случае один; чтобы на них посмотреть, нажать Ctrl+H; нажать Ctrl+H еще раз, чтобы спрятать); наберем латинскую букву p, после чего текст будет выглядеть след. образом, с курсором сразу после procedure:
MODULE i21примВставки;
IMPORT Log := StdLog, In := i21sysIn, Math;
p
END i21примВставки.
Нажатие клавиши-помощницы F5 превратит этот текст в следующий:
MODULE i21примВставки;
IMPORT Log := StdLog, In := i21sysIn, Math;
PROCEDURE ();
VAR
BEGIN
END;
END i21примВставки.
При этом курсор будет стоять точно там, где требуется напечатать имя процедуры. Сделаем это, обращая внимание на большие и маленькие буквы:
MODULE i21примВставки;
IMPORT Log := StdLog, In := i21sysIn, Math;
PROCEDURE Сорт ();
VAR
BEGIN
END;
END i21примВставки.
Сразу скомпилируем модуль (Ctrl+K). Компилятор поставит после END в конце процедуры черный квадратик, что говорит об ошибке в этой точке программы.
В левой части статусной полоски внизу окна Блэкбокса появится сообщение "ожидается идентификатор" (identifier expected).
Действительно, по правилам Компонентного Паскаля имя процедуры должно быть повторено после соответствующего END (это изменение по сравнению со старым Паскалем упрощает разработку сложных программ со многими END и многими процедурами).
Скопируем имя процедуры в позицию непосредственно перед символом ";" в конце процедуры так же, как в случае с модулем (двойной клик по имени, копируем в буфер обмена посредством Ctrl+C, компилируем посредством Ctrl+K, бьем большим пальцем по клавише пробела, вставляем имя посредством Ctrl+V).
Получим следующий модуль, который должен компилироваться без ошибок:
MODULE i21примВставки;
IMPORT Log := StdLog, In := i21sysIn, Math;
PROCEDURE Сорт ();
VAR
BEGIN
END Сорт;
END i21примВставки.
Теперь нужно зафиксировать сигнатуру процедуры, т.е. решить вопросы о количестве, порядке и типах параметров.
Разумеется, сортируемый массив следует считать одномерным, хоть это и не оговорено в условии задачи, ведь в противном случае не ясно, что понимать под сортировкой.
Здесь следует понять следующее:
(1) разрешается ли нашей процедуре менять содержимое исходного массива;
(2) следует ли возвращать отсортированный результат в новом массиве.
Поскольку всё это в условии задачи не оговорено, а алгоритм сортировки вставками может быть выполнен непосредственно в исходном массиве, то примем простейший вариант: определим у процедуры один параметр, являющийся массивом с исходными данными, и в том же самом массиве вернем результат.
Это значит, что массив должен передаваться "по ссылке", причем из трех возможных в этом случае атрибутов (IN, OUT, VAR) следует выбрать VAR (в случае IN запрещено менять элементы массива, а атрибут OUT можно применять, только если процедура не использует старых значений элементов массива, а просто заполняет его новыми).
Далее, каков тип элементов массива? Ведь в Компонентном Паскале есть 4 целых типа (INTEGER, SHORTINT, LONGINT, BYTE). Поскольку в условии задачи ничего на этот счет на сказано, выберем наиболее универсальный и простой в работе тип INTEGER (что соответствует 4 байтам или 32 битам или диапазону от примерно плюс два миллиарда до примерно минус два миллиарда).
Наконец, размер массива в условии задачи также не указан. Но процедуры вроде сортировки имеют универсальный характер, и применимы к массивам любого размера. Поэтому оставим наш единственный массив-параметр открытым, т.е. не будем указывать в описании его размер. Длину такого массива в процедуре всегда можно получить, обратившись к предопределенной процедуре-функции LEN, указав массив в качесте ее аргумента.
Имя параметру-массиву дадим произвольно, например, пусть это будет a (латинское).
Внимание! Латинское a и русское а для компилятора два разных символа, хотя на вид во многих шрифтах они не отличаются.
Мы предпочли латинскую букву, чтобы не переключать клавиатуру ради одной буквы при наборе программного текста.
Опишем массив между скобками в заголовке процедуры:
MODULE i21примВставки;
IMPORT Log := StdLog, In := i21sysIn, Math;
PROCEDURE Сорт ( VAR a: ARRAY OF INTEGER );
VAR
BEGIN
END Сорт;
END i21примВставки.
Если не допущено опечаток, то модуль должен компилироваться без ошибок.
О пробелах вокруг списка параметров: такие пробелы заметно улучшают читабельность, а это важно: глаз должен по возможности без усилий "разбирать" структуру программы. Особенно это важно при небольшом размере шрифта обычно хочется побольше видеть на экране. Насколько отсутствие таких пробелов затрудняет зрительное восприятие, легко почуствовать, читая тексты исходников Блэкбокса [например, дважды кликнуть по StdLog и нажать Ctrl+0, найти там длинные строки без единого пробела].
Последний пункт касается экспорта проектируемой процедуры. По смыслу подобных задач процедуру следует сделать доступной для использования в любых других модулях, а в Компонентном Паскале процедура по умолчанию невидима за пределами того модуля, где она определена. Чтобы сделать ее доступной извне данного модуля, следует пометить ее символом экспорта звездочкой:
MODULE i21примВставки;
IMPORT Log := StdLog, In := i21sysIn, Math;
PROCEDURE Сорт* ( VAR a: ARRAY OF INTEGER );
VAR
BEGIN
END Сорт;
END i21примВставки.
Имя процедуры мы выделили жирным шрифтом (двойной клик, Ctrl+B), чтобы легче было ориентироваться в тексте модуля. Компилятор такие украшения текста игнорирует.
Первая успешная компиляция после проставления звездочки должна сопровождаться сообщением в рабочем журнале "Сорт is new in symbol file".
Не вдаваясь в смысл сообщения, скажем лишь, что компилятор всегда пишет подобные сообщения в случае изменений интерфейса модуля (изменение имен и сигнатур экспортируемых объектов, их добавление и удаление, отмена экспорта и т.п.). Это очень важно в профессиональной работе, так как проектирование интерфейсов модулей одна из ключевых задач в создании программного обеспечения.
На этом заканчивается перевод постановки задачи на язык программирования.
Вообще-то грамотный профессионал в этом месте еще до разработки тела процедуры напишет отдельную процедуру, проверяющую, является ли заданный массив отсортированным. Не углубляясь в разработку такой процедуры, дадим ссылку на простейшийЏвариант. Демонстрационные примеры, которые используют только внешний интерфейс разработанной процедуры (т.е. не знают ничего о том, как она устроена), обсуждаются ниже.
Часть Б. Разработка тела процедуры. Сведение задачи к более простой подзадаче
Алгоритм заключается в том, чтобы продвигаться по массиву (скажем, по возрастанию индекса элементов) и вставлять очередной элемент в предшествующий ему сегмент массива так, чтобы сегмент оставался упорядоченным.
Фраза "продвигаться по массиву" подразумевает, что у нас должен быть индекс, показывающий, в каком месте массива мы находимся в данный момент.
Назовем его j; т.к. это целое число, объявим его как INTEGER (напечатать i, потом нажать F5):
MODULE i21примВставки;
IMPORT Log := StdLog, In := i21sysIn, Math;
PROCEDURE Сорт* ( VAR a: ARRAY OF INTEGER );
VAR j: INTEGER;
BEGIN
END Сорт;
END i21примВставки.
Сразу скомпилируем модуль, чтобы убедиться, что не допущено опечаток.
Теперь алгоритм можно описать так: на очередном шаге мы берем элемент a[j] и, считая, что сегмент массива a[0] .. a[j-1] уже отсортирован, добиваемся того, чтобы стал отсортирован сегмент a[0] .. a[j].
Пока мы не обсуждаем, как именно мы добъемся, чтобы стал отсортирован сегмент a[0] .. a[j] однако ясно, что эта задача проще, чем задача полной сортировки ведь сегмент a[0] .. a[j-1] уже отсортирован.
В этом месте очень важно четко понять следующее: после того как мы разберемся с элементом a[j] и перейдем к обработке следующего элемента, увеличив j на единицу, ситуация будет выглядеть точно так же, как и перед обработкой предыдущего элемента: снова обрабатываться будет элемент a[j], а сегмент слева от него будет уже отсортирован и т.д.
Говоря профессиональным языком: утверждение, что сегмент a[0] .. a[j-1] отсортирован, является инвариантом цикла. Оно справедливо в начале каждого шага цикла. Именно это гарантирует в дальнейшем правильность цикла.
Поскольку мы хотим пройтись по всему массиву элемент за элементом, то можно использовать цикл FOR с управляющей переменной j (кликнем в пустую строку примерно под VAR (курсор должен встать вровень с буквой V слова VAR), напечатаем for, нажмем F5, нажмем j):
MODULE i21примВставки;
IMPORT Log := StdLog, In := i21sysIn, Math;
PROCEDURE Сорт* ( VAR a: ARRAY OF INTEGER );
VAR j: INTEGER;
BEGIN
FOR j := TO DO
END;
END Сорт;
END i21примВставки.
Какими должны быть начальное и конечное значения для j?
Начальный элемент массива в Компонентном Паскале всегда имеет нулевой индекс.
Так как сегмент из единственного элемента всегда сам по себе отсортирован, то можно начинать сразу с j, равного 1. Действительно: сегмент слева от a[1] состоит из единственного элемента a[0] и поэтому автоматически отсортирован, так что первый шаг цикла будет начинаться корректно.
Последний элемент цикла в Компонентном Паскале всегда имеет индекс, равный LEN(a) - 1, где LEN стандартная процедура-функция, её значение равно количеству элементов массива; т.к. нумерация начинается с нуля, то индекс последнего элемента на единицу меньше, чем значение LEN.
На последнем шаге цикла мы должны разобраться с последним элементом массива. В итоге получаем следующий цикл:
MODULE i21примВставки;
IMPORT Log := StdLog, In := i21sysIn, Math;
PROCEDURE Сорт* ( VAR a: ARRAY OF INTEGER );
VAR j: INTEGER;
BEGIN
FOR j := 1 TO LEN(a) - 1 DO
END;
END Сорт;
END i21примВставки.
Помним, что на каждом шаге цикла нужно вставить a[j] в правильное место упорядоченного сегмента a[0] .. a[j-1], т.е. так, чтобы сегмент a[0] .. a[j] стал упорядоченным. Это гарантирует, что на каждом шаге цикла будет воспроизводиться одна и та же ситуация (будет выполнен инвариант цикла), и по завершении цикла мы получим нужный результат.
Компилируем и исправляем опечатки.
Теперь надо заполнить тело цикла. Для этого поступим самым надежным способом: выделим шаг цикла в отдельную процедуру, не зависящую от процедуры Сорт. Назовем новую процедуру Вставить. Пока не будем думать о ее параметрах, а только сделаем необходимую оформительскую работу.
В пустой строке в теле цикла напечатаем вызов процедуры, оставив место для параметров:
MODULE i21примВставки;
IMPORT Log := StdLog, In := i21sysIn, Math;
PROCEDURE Сорт* ( VAR a: ARRAY OF INTEGER );
VAR j: INTEGER;
BEGIN
FOR j := 1 TO LEN(a) - 1 DO
Вставить( )
END;
END Сорт;
END i21примВставки.
Как и в старом Паскале, после вызова процедуры Вставить (после закрывающей скобки) точка с запятой отсутствует. Но в отличие от старого Паскаля, в Компонентном Паскале точку с запятой в этом месте разрешено ставить, если хочется. Подробнее об этом см. здесь.
Сразу скомпилируем. Компилятор поставит черный квадратик после слова Вставить, в рабочем журнале появится сообщение "найдена одна ошибка", а слева внизу окна Блэкбокса появится сообщение "необъявленный идентификатор". В самом деле, процедуру Вставить мы еще не описали, и компилятор не знает, что это такое.
Определение новой процедуры проще всего поставить перед процедурой Сорт.
Опорядкеопределенияпроцедур
Поставим курсор непосредственно перед первой буквой слова PROCEDURE, нажмем ввод дважды, нажмем дважды стрелочку вверх, напечатаем латинскую p, нажмем F5, напечатаем имя процедуры Вставить, скопируем его в конец процедуры (не забыв про пробел после END). Получим:
MODULE i21примВставки;
IMPORT Log := StdLog, In := i21sysIn, Math;
PROCEDURE Вставить ( );
VAR
BEGIN
END Вставить;
PROCEDURE Сорт* ( VAR a: ARRAY OF INTEGER );
VAR j: INTEGER;
BEGIN
FOR j := 1 TO LEN(a) - 1 DO
Вставить( )
END;
END Сорт;
END i21примВставки.
Эта версия модуля компилируется без ошибок.
Заметим, что новая процедура не экспортируется в этом нет нужды, т.к. это чисто вспомогательная процедура (мы даже могли бы упрятать ее внутрь процедуры Сорт).
Теперь подумаем о параметрах новой процедуры. Объявления двух процедур полностью независимы (их тексты никак не пересекаются), поэтому ни одна из них не может знать, что происходит внутри другой. Поэтому, чтобы процедура Вставить могла что-то сделать с массивом a, его следует передать ей в качестве фактического параметра. Рассуждая как при разработке сигнатуры процедуры Сорт, приходим к выводу, что у процедуры Вставить должен быть такой же параметр для передачи массива, как и у процедуры Сорт. Достаточно просто скопировать объявление параметра из заголовка процедуры Сорт в заголовок процедуры Вставить:
MODULE i21примВставки;
IMPORT Log := StdLog, In := i21sysIn, Math;
PROCEDURE Вставить ( VAR a: ARRAY OF INTEGER );
VAR
BEGIN
END Вставить;
PROCEDURE Сорт* ( VAR a: ARRAY OF INTEGER );
VAR j: INTEGER;
BEGIN
FOR j := 1 TO LEN(a) - 1 DO
Вставить( )
END;
END Сорт;
END i21примВставки.
Разумеется, имена параметров в двух процедурах совершенно независимы мы могли бы дать параметру в процедуре Вставить другое имя, например, b.
Попробуем скомпилировать модуль появится черный квадратик уже внутри скобок в теле цикла, а сообщение слева внизу экрана будет "фактических параметров меньше, чем формальных". В самом деле, раз параметр задан в описании процедуры Вставить, то при вызове на его место нужно что-то поставить. Ясно, что в нашем случае нужно поставить идентификатор массива a, поскольку именно с ним должна поработать процедура Вставить:
MODULE i21примВставки;
IMPORT Log := StdLog, In := i21sysIn, Math;
PROCEDURE Вставить ( VAR a: ARRAY OF INTEGER );
VAR
BEGIN
END Вставить;
PROCEDURE Сорт* ( VAR a: ARRAY OF INTEGER );
VAR j: INTEGER;
BEGIN
FOR j := 1 TO LEN(a) - 1 DO
Вставить( a )
END;
END Сорт;
END i21примВставки.
Теперь все компилируется без ошибок.
Но процедура Вставить должна не просто поработать с массивом a она должна поработать с его j-м элементом. Передать ей эту информацию можно, поставив в качестве второго фактического параметра значение переменной j.
Но тогда второй параметр должен быть правильно описан в заголовке процедуры Вставить. Этот параметр должен, во-первых, иметь тип INTEGER (т.к. именно этот тип имеет переменная j, значение которой мы хотим передавать).
Во-вторых, переменная j, объявленная внутри Сорт, должна быть защищена в том смысле, что процедура Вставить не должна иметь возможности изменить ее. Поэтому параметр должен передаваться по значению, т.е. быть описан без атрибута VAR. Напечатаем все это, дав параметру другое имя во избежание путаницы:
MODULE i21примВставки;
IMPORT Log := StdLog, In := i21sysIn, Math;
PROCEDURE Вставить ( VAR a: ARRAY OF INTEGER; i: INTEGER );
VAR
BEGIN
END Вставить;
PROCEDURE Сорт* ( VAR a: ARRAY OF INTEGER );
VAR j: INTEGER;
BEGIN
FOR j := 1 TO LEN(a) - 1 DO
Вставить( a, j )
END;
END Сорт;
END i21примВставки.
Компилируем модуль ошибок быть не должно.
Подчеркнем, что процедура Сорт полностью закончена. Задача теперь свелась к написанию тела процедуры Вставить.
Часть В. Реализация процедуры Вставить
Процедура Вставить предполагает, что уже отсортирован сегмент массива слева от a[j] т.е. сегмент a[0] .. a[j-1]. Задача процедуры Вставить вставить значение элемента a[j] в этот сегмент так, чтобы сегмент a[0] .. a[j] тоже оказался отсортирован.
Введем обозначения для значений массива на момент начала выполнения процедуры Вставить:
пусть a'[k] значение, которое содержалось в k-м элементе массива;
а значение, которое содержалось в элементе a[j], пусть будет X.
Значения элементов сегмента a[0] .. a[j-1] расположены в порядке неубывания:
a'[0] <= a'[1] <= ... <= a'[j-1] ? X
0 1 ... j-1 j
В нижней строке показаны соответствующие значения индексов. В частности, значение X хранится в ячейке a[j]. Вопросительный знак показывает, что мы не знаем, в каком отношении находятся a'[j-1] и X.
Теперь представим себе, что должно получиться после завершения процедуры значение X должно найти свое правильное место среди упорядоченной цепочки a'[0] .. a'[j-1], т.е. должно получиться такое расположение значений:
a'[0] <= .. <= a'[n] <= X < ... a'[j-1]
0 n n+1 j
Другими словами, все элементы, которые были <= X, останутся на своих местах,
а остальные (большие X) сдвинутся вправо на одну позицию.
Мы, конечно, заранее не знаем, каково n.
Картинки такого рода, несмотря на всю их полезность, обладают одним большим недостатком: можно легко забыть об особых случаях, для изображения которых требуются отдельные картинки даже если такие случаи охватываются чисто логическими рассуждениями. В данной ситуации это особые случаи n=j и n=-1 (все элементы слева от a[j] не больше, или наборот, все больше, чем X). О таких особых случаях всегда нужно помнить и проверять их отдельно даже если чисто логически рассуждение построено так, что оно охватывает эти случаи.
Так и построим алгоритм. Начинаем в состоянии, когда значения расположены так, как уже было описано:
a'[0] <= a'[1] <= ... <= a'[j-1] ? X
0 1 ... j-1 j
Затем сравним значение X (а фактически значение из ячейки a[j]) c a[j-1].
Если окажется, что X меньше, то поменяем местами значения ячеек a[j-1] и a[j]. Получим следующее расположение значений:
a'[0] <= a'[1] <= ... <= a'[j-2] ? X <= a'[j-1]
0 1 ... j-2 j-1 j
и после этого получается точно такая же задача, как и та, с которой мы начали, но с j-1 вместо j.
В противном случае (т.е. если X оказалось не меньше, чем a[j-1]) имеем следующую ситуацию:
a'[0] <= a'[1] <= ... <= a'[j-1] <= X
0 1 ... j-1 j
так что ничего больше делать не надо, т.к. сегмент a[0] .. a[j] уже правильно отсортирован.
Эти рассуждения можно немедленно реализовать следующим образом (кликнуть в пустую строку между BEGIN и END в процедуре Вставить примерно под VAR, напечатать if, нажать F5, и т.д.):
MODULE i21примВставки;
IMPORT Log := StdLog, In := i21sysIn, Math;
PROCEDURE Вставить ( VAR a: ARRAY OF INTEGER; i: INTEGER );
VAR
BEGIN
IF a[i] < a[i-1] THEN
(* переставить значения a[i] и a[i-1] *)
Вставить( a, i-1 )
ELSE
(* делать нечего *)
END;
END Вставить;
PROCEDURE Сорт* ( VAR a: ARRAY OF INTEGER );
VAR j: INTEGER;
BEGIN
FOR j := 1 TO LEN(a) - 1 DO
Вставить( a, j )
END;
END Сорт;
END i21примВставки.
Обдумаем то, что мы написали.
1) Заметим, что в процедуре Вставить за словом VAR никаких объявлений нет но это разрешено, ведь модуль компилируется успешно. Можно было бы эту строку и стереть, но раздел объявлений нам еще понадобится оставим его пока как есть.
2) Вместо комментария после THEN нужно будет написать соответствующие команды. Пока отложим это.
3) Мы написали вызов процедуры вставить внутри нее самой другими словами, процедура Вставить получилась рекурсивной. В этом ничего страшного нет и в Компонентном Паскале все процедуры могут вызывать себя и друг друга. Но важно обеспечить, чтобы рекурсия не оказалась бесконечной. Заметим себе этот пункт он здесь самый важный.
4) Пустую ветвь ELSE условного оператора можно удалить.
Сначала сделаем самое легкое удалим пустую ветвь ELSE: отметим мышкой текст от начала ELSE до начала END и нажмем клавишу Delete. Должно получиться следующее:
MODULE i21примВставки;
IMPORT Log := StdLog, In := i21sysIn, Math;
PROCEDURE Вставить ( VAR a: ARRAY OF INTEGER; i: INTEGER );
VAR
BEGIN
IF a[i] < a[i-1] THEN
(* переставить значения a[i] и a[i-1] *)
Вставить( a, i-1 )
END;
END Вставить;
PROCEDURE Сорт* ( VAR a: ARRAY OF INTEGER );
VAR j: INTEGER;
BEGIN
FOR j := 1 TO LEN(a) - 1 DO
Вставить( a, j )
END;
END Сорт;
END i21примВставки.
Разобраться с замечанием 2) тоже легко. Перестановка значений двух переменных реализуется обычным образом с помощью вспомогательной переменной. Выберем для нее имя например, t и объявим ее в (пока пустом) разделе объявлений процедуры Вставить. Тип t должен быть таким же, как и у переменных, значения которых мы переставляем, т.е. INTEGER. После этого команды, выполняющие перестановку, пишутся легко, и процедура Вставить получается такой:
PROCEDURE Вставить ( VAR a: ARRAY OF INTEGER; i: INTEGER );
VAR t: INTEGER;
BEGIN
IF a[i] < a[i-1] THEN
t := a[i]; a[i] := a[i-1]; a[i-1] := t;
Вставить( a, i-1 )
END;
END Вставить;
Теперь обратимся к самому важному замечанию 3): корректное окончание цепочки рекурсивных вызовов:
Вставить( a, j ) --> Вставить( a, j-1 ) --> Вставить( a, j-2 ) --> ...
--> Вставить( a, 1 ) --> Вставить( a, 0 ) --> Вставить( a, -1 ) --> ...
Процедура в том виде, как она написана, будет пытаться выполнить всю эту бесконечную цепочку. Но применение метода пристального разглядывания показывает, что уже при значении второго параметра, равном нулю (i = 0), в теле процедуры Вставить будет сделана попытка обратиться к элементу массива с индексом i - 1 = -1, а таких элементов не существует. Обдумаем эту ситуацию, для этого вспомним, что должна делать процедура Вставить.
Мы условились, что процедура Вставить должна оставлять после себя отсортированный сегмент, последним элементом которого является a[i]. Но при i=0 этот сегмент состоит из единственного элемента a[0], а такой сегмент автоматически отсортирован, так что процедура в этом случае просто ничего делать не должна. Чтобы обеспечить это, "охватим" все выполняемое тело процедуры Вставить условным оператором IF i = 0 THEN ... и т.д.
Последовательность действий такова:
поставить курсор непосредственно перед IF;
нажать клавишу ввода;
стрелку вверх;
набрать if;
нажать F5;
набрать i > 0;
выделить целиком 4 строки второго оператора IF (например, поставить курсор в любое место строки IF a[i] ..., нажать клавишу Home, с нажатой клавишей Shift четырежды нажать стрелку вниз и отпустить Shift);
нажать F12 все четыре строки должны сдвинуться на один отступ вправо (в начале строк автоматически вставляются символы табуляции; заметим, что клавиша F11 действует в противоположном направлении но нажимать ее сейчас не надо);
нажать Ctrl+X (вырезать 4 строки в буфер обмена);
нажать один раз стрелку вверх;
с нажатой клавишей Shift трижды нажать стрелку вверх и отпустить Shift;
нажать Ctrl+V.
Результат должен быть таким:
PROCEDURE Вставить ( VAR a: ARRAY OF INTEGER; i: INTEGER );
VAR t: INTEGER;
BEGIN
IF i > 0 THEN
IF a[i] < a[i-1] THEN
t := a[i]; a[i] := a[i-1]; a[i-1] := t;
Вставить( a, i-1 )
END;
END;
END Вставить;
Благодаря правилу сокращенного вычисления логических выражений, два таких вложенных оператора IF (оба без ELSE) можно преобразовать в один:
IF (i > 0) & (a[i] < a[i-1]) THEN
t := a[i]; a[i] := a[i-1]; a[i-1] := t;
Вставить( a, i-1 )
END;
В самом деле, по правилу сокращенного вычисления, если результат вычисления i > 0 оказался FALSE, то результатом операции & (логическое И) будет FALSE независимо от значения второго операнда, и в таком случае этот второй операнд выражение (a[i] < a[i-1]) не вычисляется.
Окончательный результат:
MODULE i21примВставки;
IMPORT Log := StdLog, In := i21sysIn, Math;
PROCEDURE Вставить ( VAR a: ARRAY OF INTEGER; i: INTEGER );
VAR t: INTEGER;
BEGIN
IF (i > 0) & (a[i] < a[i-1]) THEN
t := a[i]; a[i] := a[i-1]; a[i-1] := t;
Вставить( a, i-1 )
END;
END Вставить;
PROCEDURE Сорт* ( VAR a: ARRAY OF INTEGER );
VAR j: INTEGER;
BEGIN
FOR j := 1 TO LEN(a) - 1 DO
Вставить( a, j )
END;
END Сорт;
END i21примВставки.
Разработка процедуры сортировки вставками закончена!
Часть Г. Демонстрация работы
Две программы, демонстрирующие работу построенного алгоритма сортировки, даны в отдельных модулях (открываются в режиме редактирования):
Демо1 Демо2
Первоначальные варианты можно открыть здесь (в режиме просмотра):
Демо1 Демо2
Часть Д. Замена рекурсии на цикл
Посмотрим внимательно на процедуру Вставить:
PROCEDURE Вставить ( VAR a: ARRAY OF INTEGER; i: INTEGER );
VAR t: INTEGER;
BEGIN
IF (i > 0) & (a[i] < a[i-1]) THEN
t := a[i]; a[i] := a[i-1]; a[i-1] := t;
Вставить( a, i-1 )
END;
END Вставить;
Заметим, что рекурсивный вызов процедуры Вставить стоит в самом конце, после него нет никаких исполняемых операторов. При этом все "актуальные экземпляры" процедуры Вставить работают с одним и тем же массивом. Таким образом, можно было бы просто изменить значение i на i-1 и выполнить процедуру снова. Но это эквивалентно тому, что мы выполняем цикл WHILE:
PROCEDURE Вставить ( VAR a: ARRAY OF INTEGER; i: INTEGER );
VAR t: INTEGER;
BEGIN
WHILE (i > 0) & (a[i] < a[i-1]) DO
t := a[i]; a[i] := a[i-1]; a[i-1] := t;
i := i-1
END;
END Вставить;
Нужно только обратить внимание на поведение параметра i. Так как он у нас объявлен как параметр, передаваемый "по значению", то это означает, что переменная i является фактически внутренней переменной процедуры Вставить в общем такой же, как и переменная t. Но значение переменной t при входе в процедуру не определено (по правилам языка), а значение i при первом вызове из процедуры Сорт равно значению выражения, которое было подставлено на его место в момент вызова процедуры (это было значение переменной j).
Другими словами, поведение параметра можно условно описать так:
PROCEDURE Вставить ( VAR a: ARRAY OF INTEGER; <значение j> );
VAR t: INTEGER; i: INTEGER;
BEGIN
i := <значение j>;
WHILE (i > 0) & (a[i] < a[i-1]) DO
t := a[i]; a[i] := a[i-1]; a[i-1] := t;
i := i-1
END;
END Вставить;
Легко убедиться, что цикл работает и завершается правильно в вырожденных случаях, упомянутых ранее когда все элементы слева от a[i] больше него, или, наоборот, меньше или равны.
В итоге модуль получается таким:
MODULE i21примВставки;
IMPORT Log := StdLog, In := i21sysIn, Math;
PROCEDURE Вставить ( VAR a: ARRAY OF INTEGER; i: INTEGER );
VAR t: INTEGER;
BEGIN
WHILE (i > 0) & (a[i] < a[i-1]) DO
t := a[i]; a[i] := a[i-1]; a[i-1] := t;
i := i-1
END;
END Вставить;
PROCEDURE Сорт* ( VAR a: ARRAY OF INTEGER );
VAR j: INTEGER;
BEGIN
FOR j := 1 TO LEN(a) - 1 DO
Вставить( a, j )
END;
END Сорт;
END i21примВставки.
Модуль компилируется без ошибок.
Чтобы продемонстрировать и проверить его работу, можно воспользоваться теми же процедурами, что были уже написаны (см. выше разделГ).
Внимание! Так как процедура сортировки и проверяющие программы реализованы в разных модулях, могут возникнуть проблемы (вызывается старая версия сортировки, когда уже написана и успешно скомпилирована новая). О том, что делать в таких случаях, см. здесь. | i21прим/Docu.Пошаговая разработка/1. Вставки.odc |
2. Пошаговая разработка: Пузырьковая сортировка
Задача. Разработать процедуру для сортировки массива целых цисел методом пузырька
Решение
ЧастьЏА Постановка задачи. Проектирование интерфейса
ЧастьЏБ Разработка тела процедуры. Сведение задачи к более простой подзадаче
ЧастьЏВ Реализация вспомогательной процедуры
ЧастьЏГ Демонстрация работы
Часть А. Постановка задачи. Проектирование интерфейсов
Эта часть выполняется так же, как и в первомпримере. Единственное отличие файлу дадим другое имя Пузырек, так что имя модуля будет i21примПузырек. Заготовка модуля и процедуры будет иметь след. вид (мы здесь не показываем строчку IMPORT она здесь не нужна):
MODULE i21примПузырек;
PROCEDURE Сорт* ( VAR a: ARRAY OF INTEGER );
VAR
BEGIN
END Сорт;
END i21примПузырек.
Часть Б. Разработка тела процедуры. Сведение задачи к более простой подзадаче
Вспомним идею пузырьковой сортировки: алгоритм состоит из нескольких шагов, причем на каждом шаге максимальное значение "всплывает" в крайнюю правую позицию; достигается это путем обменов значений между соседними элементами массива.
Пока забудем про то, как обеспечивается "всплытие" максимального значения, и постараемся "ухватить" общую структуру алгоритма.
Представим себе массив a:
a[0] a[1] ... a[len-1]
где len число элементов массива. Его всегда можно узнать с помощью стандартной функции LEN: len := LEN(a).
На первом шаге максимальное значение "всплывает" в позицию len-1.
На следующем шаге максимальное значение из оставшихся "всплывает" в позицию len-2. Кто такие "оставшиеся"? Это элементы a[0]a[1]..a[len-2].
На следующем шаге максимальное значение из оставшихся "всплывает" в позицию len-3. Кто такие "оставшиеся"? Это элементы a[0]a[1]..a[len-3].
И так далее.
Видим, что получается цикл, на каждом шаге которого делается по существу одно и то же: максимальное значение из некоторого сегмента a[0]..a[j] перемещается в крайнюю правую позицию сегмента т.е. в позицию j. Вот это число j и возьмем в качестве управляющей переменной цикла.
Первый шаг соответствует j = len-1. На каждом очередном шаге j уменьшается на единицу. Другими словами, получается следующий цикл:
FOR j := LEN(a) - 1 TO ? BY -1 DO
(* переместить макс. значение из сегмента a[0] .. a[j] на место a[j] *)
END;
Каким должно быть последнее значение? Рассмотрим крайнее значение: j=0. Но тогда сегмент состоит из единственного элемента, и он сам и есть максимальный, и притом стоит на своем месте в позиции a[j]. Так что шаг j=0 не нужен. Следующим кандидатом будет j=1. В этом случае речь идет о сегменте a[0]a[1], и шаг цикла имеет смысл.
Итак, вместо знака вопроса в цикле нужно поставить единицу.
Модуль приобретает следующий вид:
MODULE i21примПузырек;
PROCEDURE Сорт* ( VAR a: ARRAY OF INTEGER );
VAR j: INTEGER;
BEGIN
FOR j := LEN(a) - 1 TO 1 BY -1 DO
(* переместить макс. значение из сегмента a[0] .. a[j] на место a[j] *)
END;
END Сорт;
END i21примПузырек.
Как и в первом примере, поступим немного громоздким, но самым надежным способом: оформим шаг цикла в виде независимой процедуры (см. подробнее в первомпримере). Назовем ее МаксВправо, передавать ей будем массив а (по ссылке, т.е. как VAR-параметр), а сообщать о том, с каким сегментом нужно работать, будем с помощью второго параметра. Получится следующий модуль:
MODULE i21примПузырек;
PROCEDURE МаксВправо ( VAR a: ARRAY OF INTEGER; i: INTEGER );
VAR
BEGIN
END МаксВправо;
PROCEDURE Сорт* ( VAR a: ARRAY OF INTEGER );
VAR j: INTEGER;
BEGIN
FOR j := LEN(a) - 1 TO 1 BY -1 DO
МаксВправо( a, j )
END;
END Сорт;
END i21примПузырек.
Компилируем модуль ошибок быть не должно.
Процедура Сорт полностью закончена. Задача свелась к написанию тела процедуры МаксВправо.
Часть В. Реализация процедуры МаксВправо
Итак, сосредоточимся на процедуре МаксВправо. Нам нужно переставить самый большой из элементов a[0] .. a[i] в самую правую позицию.
Например, напишем цикл, в котором сначала сравниваются элементы a[0] и a[1], и если нужно, то их значения обмениваются так, чтобы большее оказалось в a[1]. Другими словами, сортируется пара элементов a[0] и a[1]. Затем аналогично сортируются a[1] и a[2] и т.д. Последней парой будет a[i-1], a[i].
Запишем это в виде такого цикла:
PROCEDURE МаксВправо ( VAR a: INTEGER; i: INTEGER );
VAR j: INTEGER;
BEGIN
FOR j := 0 TO i - 1 DO
(* сортировать пару a[j], a[j+1] *)
END;
END МаксВправо;
Нетрудно понять, что после проверки пары a[j], a[j+1] в позиции a[j+1] окажется самое большое значение из всех a[0], a[1], ... a[j+1]. А когда дойдем до j = i-1, то самое большое значение окажется в позиции a[i], что и требуется. Таким образом, задача полностью свелась к заданию шага цикла.
Опять выделим шаг цикла в виде отдельной процедуры уже третьей в нашем модуле (да пусть хоть сотой лишь бы все было правильно). Назовем ее СортироватьПару. Пусть она принимает в качестве фактических параметров a[j] и a[j+1], так чтобы цикл приобрел вид
FOR j := 0 TO i - 1 DO
СортироватьПару( a[j], a[j+1] )
END;
Понятно, что у новой процедуры должно быть два параметра. Как их надо описать?
Во-первых, тип обоих параметров должен совпадать с типом элементов массива a INTEGER чтобы можно было подставить на их места a[j] и a[j+1].
Во-вторых, по смыслу процедуры, значения элементов массива, которые передаются ей в качестве параметров, могут меняться в результате ее работы. Поэтому оба параметра нужно передать "по ссылке", т.е. снабдить атрибутом VAR.
Итак, модуль с новой процедурой может иметь такой вид:
MODULE i21примПузырек;
PROCEDURE СортироватьПару ( VAR лев, прав: INTEGER );
VAR
BEGIN
(* сортировать пару лев, прав *)
END СортироватьПару;
PROCEDURE МаксВправо ( VAR a: ARRAY OF INTEGER; i: INTEGER );
VAR j: INTEGER;
BEGIN
FOR j := 0 TO i - 1 DO
СортироватьПару( a[j], a[j+1] )
END;
END МаксВправо;
PROCEDURE Сорт* ( VAR a: ARRAY OF INTEGER );
VAR j: INTEGER;
BEGIN
FOR j := LEN(a) - 1 TO 1 BY -1 DO
МаксВправо( a, j )
END;
END Сорт;
END i21примПузырек.
Итак, процедура СортироватьПару должна, если нужно, переставлять значения параметров левый и правый так, чтобы после ее выполнения было выполнено условие лев <= прав. Очевидно, именно такое сравнение и должно быть выполнено в самом ее начале:
IF лев <= прав THEN
(* делать нечего *)
ELSE
(* обменять значения переменных лев и прав *)
END;
Обмен значений реализуется обычным способом с помощью вспомогательной переменной того же типа, что и обмениваемые значения, т.е. INTEGER.
Окончательно получается следующий модуль:
MODULE i21примПузырек;
PROCEDURE СортироватьПару ( VAR лев, прав: INTEGER );
VAR t: INTEGER;
BEGIN
IF лев <= прав THEN
(* делать нечего *)
ELSE
t := лев; лев := прав; прав := t
END;
END СортироватьПару;
PROCEDURE МаксВправо ( VAR a: ARRAY OF INTEGER; i: INTEGER );
VAR j: INTEGER;
BEGIN
FOR j := 0 TO i - 1 DO
СортироватьПару( a[j], a[j+1] )
END;
END МаксВправо;
PROCEDURE Сорт* ( VAR a: ARRAY OF INTEGER );
VAR j: INTEGER;
BEGIN
FOR j := LEN(a) - 1 TO 1 BY -1 DO
МаксВправо( a, j )
END;
END Сорт;
END i21примПузырек.
Часть Г. Демонстрация работы
Для демонстрации работы построенного алгоритма сортировки можно использовать те же модули, что и для сортировки вставками (открываются в режиме редактирования):
Демо1 Демо2
Поскольку сигнатуры обеих процедур сортировки одинаковы, достаточно в этих проверочных модулях заменить имена импторируемых модулей с процедурами сортироваки i21примВставки на i21примПузырек и затем перекомпилировать. См. замечания в конце файлов после текстов проверочных модулей.
Первоначальные варианты проверочных модулей можно открыть по этим ссылкам (в режиме просмотра):
Демо1 Демо2
| i21прим/Docu.Пошаговая разработка/2. Пузырек.odc |
3. Пошаговая разработка: Определение простоты числа
Задача. Разработать процедуру для определения простоты заданного целого большего единицы
Решение
ЧастьА Постановка задачи. Проектирование интерфейса
ЧастьБ Разработка тела процедуры. Сведение задачи к более простой подзадаче
ЧастьВ Перевод текстовых фрагментов на Компонентный Паскаль
ЧастьГ Выход из процедуры
ЧастьД Демонстрация работы
ЧастьЕ Упрощение кода
ЧастьЖ Оптимизация: сокращение количества шагов цикла
Парадокс Почему порочна преждевременная оптимизация
Часть А. Постановка задачи. Проектирование интерфейсов
Эта часть выполняется во многом так же, как и в первомпримере. Отличия в следующем. Во-первых, модулю дадим другое имя. Например, пусть полное имя будет i21примПростые, и тогда имя файла будет Простые.
Во-вторых, сигнатура процедуры будет иной. Процедура должна отвечать на некий вопрос относительно задаваемого целого числа. Самый естественный способ передавать в процедуру это число с помощью параметра типа INTEGER (как наиболее универсального из целых базовых типов Компонентного Паскаля). Так как процедура должна давать ответ типа да/нет, причем только один, то пусть она будет процедурой-функцией, а тип возвращаемого значения BOOLEAN.
Другие варианты. Целое число можно было бы передавать через целую переменную, определенную на уровне модуля и доступную извне модуля для записи, т.е. отмеченную символом полного экспорта *.
Результат можно было бы передавать с помощью аналогичной глобальной переменной, причем эту переменную имело бы смысл сделать видимой извне только для чтения, т.е. отметить символом частичного экспорта -.
Наконец, в некоторых ситуациях могло бы оказаться предпочтительным, чтобы результат был целым например, равным 0 или 1 в случае, соответственно, отрицательного или положительного ответа на вопрос о простоте числа.
Однако все эти варианты полезны лишь в каких-то особых ситуациях, не предусмотренных в условии задачи. Поэтому будем придерживаться наиболее универсального варианта.
Итак, заготовка модуля и процедуры будет такой (строка IMPORT пока опущена):
MODULE i21примПростые;
PROCEDURE Простое* ( n: INTEGER ): BOOLEAN;
VAR
BEGIN
END Простое;
END i21примПростые.
Звездочка экспорта в заголовке процедуры поставлена, чтобы можно было ею пользоваться из любых других программ, в том числе из других модулей.
Имя экспортированной процедуры выделено жирным шрифторм (Ctrl+B или выполнить команду меню Шрифт --> Жирный), потому что информация об экспорте очень важна.
Немедленно скомпилируем модуль (Ctrl+K).
Получим сообщение об ошибке черный квадратик сразу после ключевого слова BEGIN, а внизу экрана слева сообщение "функция без RETURN".
В самом деле, если определена процедура-функция, то в ее теле должен обязательно быть хотя бы один оператор возврата RETURN.
Вставим оператор RETURN последним оператором в пока еще пустом теле процедуры (поставим курсор в пустую строку кликнуть примерно под словом VAR, нажмем клавишу ввода (Enter), напечатаем слово return и нажмем F5).
Модуль примет след. вид:
MODULE i21примПростые;
PROCEDURE Простое* ( n: INTEGER ): BOOLEAN;
VAR
BEGIN
RETURN
END Простое;
END i21примПростые.
RETURN автоматически выделилось жирным шрифтом (это сработала процедура, вызванная нажатием F5), т.к. это полезно делать для выявления структуры программы. Компилятору это не важно.
Пустая строка перед RETURN напоминает о том, что там должны быть операторы, реализующие содержательную часть алгоритма.
Скомпилируем модуль (Ctrl+K). Возникнет сообщение об ошибке черный квадратик сразу после слова RETURN, а внизу экрана слева текст "тип результата выражения отличается от типа результата процедуры".
Действительно: раз процедура была объявлена как процедура-функция, возвращающая значение какого-то типа (в данном случае BOOLEAN), то по правилам Компонентного Паскаля после любого оператора RETURN в теле процедуры должно стоять выражение того же самого типа (BOOLEAN).
Какое выражение поставить?
У нас пока нет конкретного алгоритма вычисления ответа, поэтому пока поставим "затычку" простейшее выражение булевского типа, состоящее из одной константы FALSE (в месте курсора печатаем false и нажимаем F5).
Чтобы не забыть в дальнейшем про эту затычку, покрасим ее в красный цвет (двойной клик по FALSE, Шрифт > Красный).
Проверка входных данных. Наконец, в задаче есть еще одно условие: оговаривается, что проверяемые числа больше единицы. А как должна вести себя процедура, если на вход поступает число, не удовлетворяющее этому условию?
В этом случае, вообще говоря, возможны следующие варианты:
а) аварийная остановка;
б) возврат предопределенного значения;
в) сообщение пользователю (в рабочем журнале или в статусной строке или в виде диалогового сообщения);
г) присваивание специального значения некоторой глобальной переменной.
Чтобы сделать выбор особенно это касается вариантов б)-г) нужно больше знать о том контексте, в котором будет работать программа. Без дополнительной информации выберем вариант а), который является, во-первых, простейшим для реализации, во-вторых, наиболее жестким, т.е. в максимальной степени ограничивающий распространение ошибки (если считать ошибкой нарушение условия о том, что проверяемое число больше единицы).
Реализация варианта а) сводится к вызову стандартной процедуры ASSERT( n>1) ("убедиться, что n>1") в качестве первого исполняемого оператора в теле разрабатываемой процедуры. Тогда невыполнение условия n>1 вызовет аварийную остановку программы.
В итоге получаем получаем следующую заготовку модуля:
MODULE i21примПростые;
PROCEDURE Простое* ( n: INTEGER ): BOOLEAN;
VAR
BEGIN
ASSERT( n>1 );
RETURN FALSE
END Простое;
END i21примПростые.
Теперь модуль должен компилироваться без ошибок.
Часть Б. Разработка тела процедуры
Отталкиваемся от определения простоты: число n является простым, если оно не делится ни на что, кроме 1 и себя.
В случах, когда нужно вычислять логические значения, полезно бывает "вывернуть" условие задачи, т.е. найти его отрицание. В нашем случае это будет выглядеть так: число n не является простым, если у него есть хотя бы один делитель m, отличный от него самого и от 1. Поэтому если нам удастся найти такой делитель m, то n не может быть простым.
Таким образом, задача сводится к поиску какого-нибудь делителя для n в сегменте от 2 до n-1. Если поиск окажется удачным число не является простым. Если неудачным число n простое.
Как найти делитель в сегменте от 2 до n-1?
Как вообще искать объект с заданными свойствами в некотором множестве объектов? Простейшая и универсальная стратегия перебор.
Поэтому будем перебирать все числа из сегмента от 2 до n-1, пока не найдем делитель для n.
Стандартные средства перебора циклы. Их есть несколько видов. В нашем случае мы должны прекратить перебор, как только объект с заданными свойствами будет обнаружен, а стандартное средство подобного перебора цикл-пока. Такой цикл можно записать так:
WHILE (кандидат находится в допустимом диапазоне) & ~(кандидат обладает нужным свойством) DO
переход к очередному кандидату
END;
Чтобы напечатать это, нужно сначала напечатать while, нажать F5, на месте курсора напечатать первую пару круглых скобок, напечатать их содержимое, потом после скобок пробел, &, пробел, ~, вторую пару скобок, и потом содержимое скобок. Затем текст в теле цикла.
Заметим, что в языках программирования скобки ходят парами: для каждой открывающей должна быть и закрывающая. Поэтому полезно выработать привычку ставить скобки парами сразу открывающую вместе с закрывающей ДО того, как заполняется содержимое скобок. Это предотвратит целый класс синтаксических ошибок и сэкономит время при разработке программ.
Такое же правило применимо и в других случаях при написании комментариев, индексов массивов (пары квадратных скобок), "скобок" типа RECORD END и т.д. Впрочем, случаи вроде RECORD END обычно автоматически обрабатываются правильно при использовании клавиши F5 в нашей конфигурации Блэкбокса.
Если перевести ключевые слова на русский язык, то получится следующее:
ПОКА (кандидат находится в допустимом диапазоне) И неверно, что (кандидат обладает нужным свойством) ДЕЛАТЬ
переход к очередному кандидату
КОНЕЦ;
То, что стоит между WHILE и DO (ПОКА и ДЕЛАТЬ) логическое выражение. При этом фраза "неверно, что" это в точности операция логического отрицания, которая в Компонентном Паскале обозначается символом ~. А связка И является логической операцией, обозначаемой в Компонентном Паскале символом &.
Напомним, что в Компонентном Паскале вычисление второго операнда логической операции & (И), как и ИЛИ (OR), не выполняется, если значение операции может быть определено по первому операнду.
Именно поэтому при поиске вроде нашего сначала всегда ставится проверка того, входит ли очередной проверяемый кандидат в допустимый диапазон, т.к. если это не так, вторая проверка вообще может не иметь смысла и даже приводить к аварийной остановке.
Смысловое замечание. Пара логических условий, соединенных так, как это сделано в приведенном цикле, типична для задач поиска. При этом смысл задачи отражает второе условие в скобках после пары логических операций & ~. Первое условие имеет более технический характер и нужно для правильного выхода из цикла.
Поскольку каждый кандидат проверяется совершенно независимо от остальных, мы можем перебирать объекты-кандидаты в произвольном порядке и при этом использовать одну и ту же переменную для их хранения: так и назовем ее, "кандидат". Нужно объявить ее в разделе объявлений, т.е. после ключевого слова VAR. Сделав это, получим след. процедуру:
PROCEDURE Простое* ( n: INTEGER ): BOOLEAN;
VAR кандидат: INTEGER;
BEGIN
ASSERT( n>1 );
кандидат := начальное значение;
WHILE (кандидат находится в допустимом диапазоне) & ~(кандидат делит n) DO
переход к очередному кандидату
END;
RETURN FALSE
END Простое;
Конструкция WHILE ... DO оказалась слишком длинной и не поместилась на одной строке. Это особой роли не играет, но мешает схватывать конструкцию при чтении. Поэтому сформатируем строку следующим образом (кликнуть непосредственно перед &, нажать ввод, потом дважды Tab):
PROCEDURE Простое* ( n: INTEGER ): BOOLEAN;
VAR кандидат: INTEGER;
BEGIN
ASSERT( n>1 );
кандидат := начальное значение;
WHILE (кандидат находится в допустимом диапазоне)
& ~(кандидат делит n) DO
переход к очередному кандидату
END;
RETURN FALSE
END Простое;
Компилировать модуль здесь бессмысленно, т.к. имеются четыре чисто текстовых фрагмента. Их надо сначала перевести на Компонентный Паскаль. Это сделать несложно, причем эти фрагменты достаточно просты и уже не потребуют введения вспомогательных процедур.
Часть В. Перевод текстовых фрагментов на Компонентный Паскаль
Начнем с простейшего: "кандидат находится в допустимом диапазоне".
Допустимый диапазон от 2 до n-1 включительно.
То есть кандидат должен быть больше либо равен 2 и меньше либо равен n-1.
Перевод этого условия на Компонентный Паскаль не представляет трудностей:
(кандидат >= 2) & (кандидат <= n - 1)
Как теперь перевести фразу "кандидат делит n"?
Мы должны начать с двух переменных кандидат и n и проделать некоторое вычисление, в результате которого должно получиться логическое значение, равное TRUE, если кандидат делит n, и FALSE в противном случае.
Какие вычисления вообще можно проделать в Компонентном Паскале с двумя целыми числами?
Есть пять арифметических операций (+, -, *, DIV, MOD) все они дают в результате целое число (точнее, результат будет иметь тип INTEGER, если операнды имеют тип INTEGER).
Есть также шесть операций сравнения (=, #, >, <, >=, <=) они дают результат типа BOOLEAN.
Можно применить и операцию вещественного деления / она даст результат типа REAL.
Применяя метод пристального разглядывания, найдем, что к делимости двух целых чисел самое непосредственное отношение имеет операция MOD: выражение (n MOD кандидат) дает остаток от деления n на кандидата, и если этот остаток равен нулю, то кандидат делит n.
Таким образом, искомое выражение представляет собой выражение
(n MOD кандидат) = 0
в котором сначала вычисляется выражение в скобках, а потом получившееся число сравнивается с нулем.
Если получается TRUE, то кандидат делит n, что и требуется.
Процедура принимает следующий вид:
PROCEDURE Простое* ( n: INTEGER ): BOOLEAN;
VAR кандидат: INTEGER;
BEGIN
ASSERT( n > 1 );
кандидат := начальное значение;
WHILE ( (кандидат >= 2) & (кандидат <= n - 1) )
& ~( (n MOD кандидат) = 0 ) DO
переход к очередному кандидату
END;
RETURN FALSE
END Простое;
Осталось два текстовых фрагмента, описывающих стратегию перебора кандидатов.
Мы намеренно зазрабатываем программу так, что выбор стратегии перебора совершенно не зависим от структуры проверок в цикле.
Это позволяет лучше выявить в структуре программы общие моменты, не зависящие от специфики задачи.
Итак, мы должны перебрать кандидаты так, чтобы не пропустить ни одного потенциального делителя.
Поскольку кандидаты заполняют сегмент от 2 до n - 1, то естественно начать с наименьшего значения, т.е. двойки, а в качестве очередного кандидата брать число, на единицу большее.
То есть сделаем такие замены:
начальное значение > 2,
переход к очередному кандидату > кандидат := кандидат + 1
Замечание. Точку с запятой после этого оператора ставить можно, но не обязательно; в старом Паскале ее там ставить было нельзя. См. об этом здесь.
Важно теперь понять, всегда ли будет обеспечен выход из цикла. Поскольку значения, которые принимает кандидат, на каждом шаге меняются в одну сторону растут, то рано или поздно кандидат обязательно выйдет из допустимого диапазона, то есть первое условие в охране цикла гарантирует его завершение. Разумеется, выход из цикла может произойти и раньше по второму условию охраны. Смысл всего этого мы обсудим дальше. Пока важно убедиться, что выход из цикла обеспечен.
В итоге модуль примет следующий вид:
MODULE i21примПростые;
PROCEDURE Простое* ( n: INTEGER ): BOOLEAN;
VAR кандидат: INTEGER;
BEGIN
ASSERT( n>1 );
кандидат := 2;
WHILE ( (кандидат >= 2) & (кандидат <= n - 1) )
& ~( (n MOD кандидат) = 0 ) DO
кандидат := кандидат + 1
END;
RETURN FALSE
END Простое;
END i21примПростые.
Теперь его можно скомпилировать и устранить опечатки.
Часть Г. Выход из процедуры
Но пока наша процедура, хотя и компилируется без ошибок, всегда возвращает значение FALSE, независимо от результата поиска делителя в цикле. Нужно это поправить.
Рассмотрим подробнее, в каком состоянии завершается цикл.
Очевидно, цикл WHILE завершается, когда не выполнено условие в охране цикла. То есть после завершения цикла выполнено отрицание охраны.
Запишем и упростим соответствующиее логическое выражение (записывать его будем, выявляя структуру операций):
~(
( (кандидат >= 2) & (кандидат <= n - 1) )
& ~( (n MOD кандидат) = 0 )
)
Используем закон де Моргана для самого внешнего отрицания (законы де Моргана остаются справедливы для "компьютерных" вариантов логических операций):
~( (кандидат >= 2) & (кандидат <= n - 1) )
OR ( (n MOD кандидат) = 0 )
Получившийся результат можно переформулировать словами так:
либо неверно, что (кандидат находится в допустимом диапазоне),
либо в противном случае он является делителем для n.
Первый случай означает, что делителей не найдено, т.е. число n простое.
Второй случай означает, что в допустимом диапазоне найден делитель, т.е. число n не является простым.
Таким образом, ответ на вопрос, является ли n простым, оказывается в точности равен ответу на вопрос, неверно ли, что (кандидат находится в допустимом диапазоне) после выхода из цикла.
То есть в качестве возвращаемого значения после оператора RETURN вместо FALSE мы можем прямо подставить выражение
неверно, что (кандидат находится в допустимом диапазоне)
или на языке Компонентный Паскаль:
~( (кандидат >= 2) & (кандидат <= n-1) )
Во избежание опечаток выражение следует просто аккуратно скопировать из цикла с помощью Ctrl+C, Ctrl+V):
Выражение можно упростить, избавившись от отрицания с помощью закона де Моргана, но это не обязательно и вдобавок чревато ошибками; см. об этом далее разделД.
Окончательно модуль выглядит так:
MODULE i21примПростые;
PROCEDURE Простое* ( n: INTEGER ): BOOLEAN;
VAR кандидат: INTEGER;
BEGIN
ASSERT( n>1 );
кандидат := 2;
WHILE ( (кандидат >= 2) & (кандидат <= n - 1) )
& ~( (n MOD кандидат) = 0 ) DO
кандидат := кандидат + 1
END;
RETURN ~( (кандидат >= 2) & (кандидат <= n - 1) )
END Простое;
END i21примПростые.
Д. Демонстрация работы
Для демонстрации работы процедуры напишем отдельный модуль (в виде отдельного документа) с тестирующей процедурой, которая просто печатает все простые числа из заданного интервала в рабочий журнал:
MODULE i21примПростыеПечать;
IMPORT StdLog, i21примПростые;
PROCEDURE Выполнить* ( n, m: INTEGER );
VAR i: INTEGER;
BEGIN
StdLog.Ln;
StdLog.String("все простые числа в интервале от");
StdLog.Int( n );
StdLog.String(" до");
StdLog.Int( m );
StdLog.String(":");
StdLog.Ln;
FOR i := n TO m DO
IF i21примПростые.Простое( i ) THEN
StdLog.Int( i )
END
END;
StdLog.Ln
END Выполнить;
END i21примПростыеПечать.
"i21примПростыеПечать.Выполнить(2, 50)"
Чтобы выполнить процедуру, достаточно кликнуть по коммандеру. Меняя значения чисел, можно менять диапазон печатаемых простых чисел.
Е. Упрощение кода
Внимание! Давно известно, что бОльшая часть программистских проблем связана с преждевременными попытками сделать программу быстрее и вообще "эффективнее" за счет возни с мелкими трюками в тексте программы.
Интересно, что бОльшая часть таких попыток к заметному эффекту не приводит а нередко эффект получается вообще обратный. На самом деле определить, где реально программа проводит большую часть времени, нелегко без конкретных измерений (т.наз. профилирование; см. соотв. команды в меню Программирование).
Поэтому следует всемерно сопротивляться такого рода манипуляциям с кодом, стремясь прежде всего к "дубовой надежности" и "очевидной правильности" уже работающей программы и именно это должны поощрять преподаватели.
Можно даже сказать, что на ранних этапах обучения всякого рода хитроумие в программах не следует поощрять, возможно, даже наказывать, требуя прежде всего правильности рассуждений при построении программы.
И только убедившись в правильности своих рассуждений и получив правильную и работающую программу, приступить к ее исследованию на предмет оптимизации даже если оптимизация кажется простой: большинство ошибок в программах "глупые".
Однако явные упрощения если таковые находятся могут быть и полезны, если они упрощают код без нарушения его "очевидной правильности".
Что можно упростить в этой программе?
Прежде всего это логические выражения. Они довольно сложны.
Метод пристального разглядывания показывает, что условие кандидат >=2 всегда выполнено, т.к. мы начинаем со значения 2 и только увеличиваем значение кандидата.
Поэтому упростим оба логических выражения, заменив обсуждаемое условие на TRUE и отбросив его по правилу TRUE & X = X.
Это "хорошее" упрощение, т.к. приводит просто к отбрасыванию целого сравнения без ощутимого затемнения смысла программы.
Заголовок цикла станет таким:
WHILE (кандидат <= n - 1) & ~( (n MOD кандидат) = 0 ) DO
А оператор RETURN станет таким:
RETURN ~(кандидат <= n - 1)
Можно упростить выражение в RETURN, избавившись от отрицания, но это разрушит очевидное равенство выражения в скобках первому операнду охраны цикла.
Можно также упростить второе сравнение в охране цикла его смысл останется ясен:
~( (n MOD кандидат) = 0 ) заменится на ( (n MOD кандидат) # 0 )
В итоге получаем:
MODULE i21примПростые;
PROCEDURE Простое* ( n: INTEGER ): BOOLEAN;
VAR кандидат: INTEGER;
BEGIN
ASSERT( n>1 );
кандидат := 2;
WHILE (кандидат <= n - 1) & ~( (n MOD кандидат) = 0 ) DO
кандидат := кандидат + 1
END;
RETURN ~(кандидат <= n - 1)
END Простое;
END i21примПростые.
Ж. Оптимизация: сокращение количества шагов цикла
В данной процедуре возможна одна оптимизация, которая достаточно проста и практически не меняет структуру кода. Эта оптимизация связана не с мелкой оптимизацией кода, а с существом задачи (именно такие оптимизации наиболее полезны).
Замечание. Нахождение таких оптимизаций не относится собственно к программированию и выходит за пределы возможностей "чистых" программистов-профессионалов. Оно может произойти лишь в голове специалиста, четко понимающего как предметную область (в данном случае элементарную арифметику), так и методы построения алгоритмов. На обучение именно таких специалистов в первую очередь и нацелен проект Информатика-21.
В самом деле, пристальное разглядывание процедуры говорит о том, что все вычисления используют лишь "быстрые" операции, и важнейшая возможность существенно ускорить цикл состоит в том, чтобы как-то сократить количество повторений цикла.
Далее, пристальное разглядывание цикла показывает, что фактически цикл находит наименьший делитель для n. Но наименьший делитель не может превосходить квадратный корень из n. Другими словами, проверять кандидаты, превосходящие корень из n, нет нужды. Это сокращает количество шагов цикла и время выполнения процедуры на множитель, равный корню из n.
Для n = 1000000 имеем ускорение в 1000 раз. Овчинка выделки стоит.
Разумеется, вычисление такой стандартной функции, как квадратный корень в Блэкбоксе есть. Изучение библиотеки Блэкбокса показывает, что там есть модуль Math, содержащий процедуры вычисления элементарных функций, в том числе процедура Sqrt, вычисляющая квадратный корень.
Список процедур, предоставляемых модулем Math (точнее, список их сигнатур), можно получить, дважды кликнув мышкой по имени модуля (например, в предыдущей строчке) и нажав Ctrl+D (или командой меню Инфо > Клиентский интерфейс).
Имена функций в основном самоочевидны. Обнаруживаем, что нужная сигнатура имеет вид
PROCEDURE Sqrt (x: REAL): REAL;
Чтобы использовать эту функцию в нашем модуле, следует импортировать модуль Math. это достигается добавлением строки
IMPORT Math;
сразу после заголовка модуля. После этого нужное нам значение в теле процедуры Простое будет даваться выражением Math.Sqrt(n).
Следует разобраться с типами значений.
Сигнатура процедуры Sqrt показывает, что она принимает аргумент типа REAL.
Но у нас n имеет тип INTEGER. Компонентный Паскаль разрешает подставлять значения INTEGER там, где требуется REAL, при этом будет автоматически произведено надлежащее преобразование типа. (Естественное преобразование INTEGER в REAL не приводит к потере информации и поэтому разрешено как автоматическое. Напомним, что тип REAL в Компонентном Паскале соответствует арифметике с плавающей точкой двойной точности в других языках.)
Значение функции Math.Sqrt тоже имеет тип REAL.
Предположим, что мы сохранили его в переменной корень (типа REAL) до выполнения цикла. Тогда следует всюду изменить верхнюю границу допустимого диапазона для переменной кандидат, заменив:
MODULE i21примПростые;
IMPORT Math;
PROCEDURE Простое* ( n: INTEGER ): BOOLEAN;
VAR кандидат: INTEGER; корень: REAL;
BEGIN
ASSERT( n>1 );
кандидат := 2;
корень := Math.Sqrt( n );
WHILE (кандидат <= корень) & ~( (n MOD кандидат) = 0 ) DO
кандидат := кандидат + 1
END;
RETURN ~(кандидат <= корень)
END Простое;
END i21примПростые.
Программа компилируется без ошибок и работает, похоже, правильно.
Парадокс. Почему порочна преждевременная априорная оптимизация
Описанную оптимизацию часто кодируют чуть более "грамотно". При этом исходят из следующих умозрительных соображений о поведении программы.
Что происходит при сравнении кандидат <= корень, где левый операнд имеет тип INTEGER, а правый REAL?
Правила Компонентного Паскаля построены так, чтобы исключить неконтролируемую потерю информации. Это возможно, только если в таком сравнении операнд типа INTEGER преобразуется к типу REAL.
Именно это и имеет место причем на каждом шаге цикла. Кроме того, на машинном уровне операция сравнения обычно подразумевает вычитание операндов и сравнение результата с нулем. И обычно выполнение отдельно операции вычитания для значений INTEGER быстрее, чем для значений REAL.
Таким образом, имеет смысл избавиться от всех значений типа REAL в цикле.
Cоображения кажутся "очевидно правильными" и тем не менее результат может оказаться прямо противоположным. Чтобы исследовать вопрос, выполним эту оптимизацию. Это делается так (соответствующий вариант процедуры Простое назовем Простое2).
Объявим переменную корень как INTEGER, а в правой части присваивания поставим целую часть от вещественного значения:
корень := SHORT( ENTIER( Math.Sqrt( n ) );
Пояснения. Сначала вычисление Math.Sqrt( n ) дает значение REAL. Применение определенной в языке функции ENTIER выбирает целую часть вещественного результата и возвращает ее как значение типа LONGINT. Но т.к. n имело тип INTEGER, то и целая часть его квадратного корня попадет в диапазон типа INTEGER, поэтому получившееся значение типа LONGINT можно "сократить" до типа INTEGER с помощью функции SHORT.
Никаких других изменений в тексте процедуры не требуется.
Нужно только проверить правильность замены вещественного числа на его целую часть в дальнейших неравенствах. Целая часть может быть меньше, чем исходное вещественное значение, и поэтому сравнение <= могло бы нарушиться. Но в левой части сравнения всегда стоит целое значение, так что худшее, что может случиться, это фактическое строгое неравенство превратится в равенство. Но результат нестрого неравенства от этого не пострадает. (Пример: 2 <= 2.236, где правая часть соответствует квадратному корню из 5.)
Для этой вспомогательной задачки создадим новый модуль, включим в него новый вариант процедуры и добавим две тестирующие процедуры, каждая из которых вызывает свой вариант процедуры Простое миллион раз (нужно не забыть импортировать уже написанный модуль):
MODULE i21примПростыеОпт;
IMPORT Math, i21примПростые;
PROCEDURE Простое2* ( n: INTEGER ): BOOLEAN;
VAR кандидат: INTEGER; корень: INTEGER;
BEGIN
ASSERT( n>1 );
кандидат := 2;
корень := SHORT( ENTIER( Math.Sqrt( n ) ) );
WHILE (кандидат <= корень) & ~( (n MOD кандидат) = 0 ) DO
кандидат := кандидат + 1
END;
RETURN ~(кандидат <= корень)
END Простое2;
PROCEDURE Test*;
CONST миллион = 1000000;
VAR res: BOOLEAN; n: INTEGER;
BEGIN
FOR n := миллион TO 2*миллион DO
res := i21примПростые.Простое( n )
END;
END Test;
PROCEDURE Test2*;
CONST миллион = 1000000;
VAR res: BOOLEAN; n: INTEGER;
BEGIN
FOR n := миллион TO 2*миллион DO
res := Простое2( n )
END;
END Test2;
END i21примПростыеОпт.
Воспользуемся возможностью Блэкбокса выполнять программы с замером времени.
Напишем прямо в данном тексте полное имя тестирующей процедуры для "медленного" варианта с переменной корень, объявленной как REAL:
i21примПростыеОпт.Test
Отметив мышкой полное имя, выполним команду меню
Программирование > Выполнить с замером времени.
Через некоторое время (около 5 сек. на Pentium III/866) в рабочем журнале появится время выполнения вызванной процедуры в тысячных долях секунды. Повторим это действие несколько раз времена будут слегка меняться, но оставаться в некотором узком диапазоне (в нашем случае 4843-4860 миллисек.)
Теперь точно так же измерим второй, предположительно более быстрый, вариант процедуры, в котором из цикла исключена арифметика вещественных чисел:
i21примПростыеОпт.Test2
В нашем случае получается диапазон 5031-5047 миллисек. Другими словами:
"Быстрая" версия оказалась определенно медленней!
Хотя разница невелика всего 4% но ее знак противоположен ожиданиям.
Для наблюденного эффекта можно придумать объяснение (паралеллизм работы блоков процессора, ответственных за вычисления с целыми и вещественными числами) но главное, что наш эксперимент иллюстрирует давно известный факт:
Заранее правильно предсказать эффект "мелкой" оптимизации нелегко,
а величина его скорее всего ничтожна,
так что затрачиваемые усилия окупятся
лишь в исключительных случаях.
В подавляющем же большинстве случаев
прямым и немедленным результатом умозрительной "оптимизации"
будет усложнение и затемнение кода.
Это с самого начала затруднит разработку,
лишая программиста главного ресурса времени
для серьезного анализа уже работающей программы.
| i21прим/Docu.Пошаговая разработка/3. Простые.odc |
Subsets and Splits