В этом разделе описываются встроенные функции HomeLisp, предназначенные для управления средой разработки и диалогом с пользователем. Все эти функции, за исключением пары TRACE/UNTRACE, отсутствуют в реализации Лаврова и Силагадзе.

Некоторые из функций, рассматриваемых в этом разделе, недоступны при работе WEB-компоненты или при работе с библиотекой HomeLispLib.exe (этот факт отмечается в детальном описании таких функций). Те функции, которые реализованы только в ядре 11 или 13 помечены значками (11) и (13) соответственно.

Функция ASK предназначена для организации примитивного диалога с пользователем (во время выполнения программы на Лиспе). Функция ожидает единственный аргумент - атом. Выводится диалоговое окно (INPUT BOX), в область приглашения которого попадет значение атома-аргумента. Пользователь вводит ответ в область ввода и нажимает кнопку "Принять". Ответ пользователя превращается в атом с индикатором STRING и этот атом возвращается в качестве результата функции.

Так, если ввести: (ask "Введите что-нибудь"), то будет выведено диалоговое окно:

Если далее пользователь введет в область ввода текст или S-выражение, то функция вернет ввод пользователя в виде атома с индикатором STRING. Если пользватель нажмет кнопку "Cancel" ("Отказ"), то результатом будет пустая строка.

Разработчик обращает внимание на то, что если требуется ввести S-выражение, то результат вызова ASK следует передать на вход функции INPUT, описываемой ниже. Функция недоступна при работе WEB-компоненты.

Функция ASSERT (реализованная только в 13-й редакции ядра HomeLisp),предназначена для работы в диалоговом отладчике среды разработки. Эта функция недоступна в WEB-компоненте. При работе с библиотекой HomeLispLib.exe или в составе EXE-файла функция игнорируется (сразу же возвращает Nil).

Функция принимает S-выражение. Если при вызове функции активен диалоговый отладчик, то заданное S-выражение вычисляется в текущем контексте. Если результат оказывается отличным от Nil, выполнение приостанавливается, и пользователь получает возможность увидеть значение переменных, задать/сменить точки останова и т.д.

Если же при вызове функции отладчик неактивен, то функция ASSERT сразу же возвращает Nil. Рассмотрим пример:

(defun f (x &aux i n) (for i 20 40 ((setq n (fact i)) (assert (>= n x))) ) ) ==> f (f 100000000000000000000000000) ==> 40

Здесь в теле функции последовательно вычисляется значение факториалы целых от 20 до 40. Если вызвать эту функцию из IDE, то цикл выполнится до конца (как это видно из приведенной врезки). Если же выполнить эту функцию в автоматическом режиме под отладчиком, то пользователь увидит:


Нетрудно убедиться, что выражение, заданное в ASSERT станет истиным, когда i > 25, что и подтверждается информацией, отображенной в окне "Лексический контекст".

Функция ASSOLIST строит снимок ассоциативного списка (на момент вызова функции). При вызове может быть указан один необязательный аргумент (типа STRING). В снимок включаются все переменные из ассоциативного списка, в именах которых содержится (в любой позиции) значение аргумента. Если аргумент опущен - строится снимок всего ассоциативного списка.

При работе в Web-компоненте снимок представляет собой отдельный html-файл, сылка на который сохраняется в течение сеанса пользователя. Так, если выполнить в Web-компоненте следующий код:

(setq a 111) (defun f (x) (prog nil (assolist) (* x x)))

то снимок ассоциативного списка будет иметь вид:

Здесь хорошо видно, что переменная a (созданная на верхнем уровне вызовом SETQ) является глобальной переменной, тогда как переменная x является параметром функции и при выходе из функции будет уничтожена.

В составе библиотеки HomeLispLib.Exe снимок ассоциативного списка в виде таблички направляется в область вывода (аналогично выходным данным функции PRINT). Так, в составе скриптового движка Conlisp, снимок ассоциативного списка отображается так:

Хотя при работе в IDE пользователю доступна кнопка просмотра ассоциативного списка, можно пользоваться и функцией ASSOLIST (это оправдано, поскольку можно вызвать ASSOLIST из функции и увидеть значения параметров. Вот как это выглядит:

(setq a 222) ==> 222 (defun f (x y) (prog nil (assolist) (return (* x y)))) ==> f (f 5 6) +-----------------+---------+-----------+ | Имя переменной | Тип | Значение | +-----------------+---------+-----------+ |a |Глобал. |222 | |x |Параметр |5 | |y |Параметр |6 | +-----------------+---------+-----------+ ==> 30

Эта функция не имеет аргументов. Ее выполнение заключается в очистке области вывода. Этого же эффекта можно добиться, нажав соответствующую кнопку или выполнив пункт контекстного меню "Очистить область вывода". Функция недоступна при работе WEB-компоненты, а также библиотеки HomeLispLib.exe.

Функция DEBUG (реализованная только в 13-й редакции ядра HomeLisp), доступна только при работе в IDE. Функция активизирует интерактивный отладчик (описанию отладчика посвящен отдельный документ).

Функция DEBUG принадлежит к типу FSUBR и принимает один необязательный аргумент - отлаживаемое S-выражение. Если аргумент не задан, то выражение можно задать уже в отладчике (в окне "Стартовое S-выражение").

Функция DUMP* (отсутствующая у Лаврова и Силагадзе) позволяет пользователю проследить весь процесс вычисления S-выражения на весьма детальном уровне. Использование странного, на первый взгляд, окончания имени функции (*) имеет на самом деле вескую причину. В Лиспе принято, что функция, имя которой оканчивается буквой p, является предикатом (функцией, возвращающей логическое значение). Поскольку описываемая функция предикатом не является, использование слова DUMP для ее именования нарушило бы традицию Лиспа.

Функция DUMP* может иметь единственный параметр строкового типа. Он интерпретируется как имя выходного файла (может присутствовать буква диска и слэши). Если параметр не содержит буквы диска и слэшей, то он интерпретируется как имя файла в текущей директории. Если присутствует расширение, то оно заменяется на ".dmp". Если функция DUMP* вызвана без параметров, то отображается окно диалога и пользователь может выбрать выходной файл. После того, как выходной файл выбран, его имя отображается в шестой (самой правой) панели статус-бара главного окна. Теперь при вводе любого S-выражения результаты всех промежуточных вычислений будут выведены в выбранный файл; файл каждый раз переоткрывается в режиме "APPEND".

Включить дампирование можно и нажатием кнопки (выбором пункта меню). В этом случае появится окно диалога и пользователь может выбрать файл. При нажатии кнопки "Отказ" режим не включается. Результаты дампа можно просмотреть, не выходя из среды разработки. Для этого служит соответствующая кнопка и пункт меню.

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

Рассмотрим пример. Пусть значение переменной x равно 1, значение переменной y равно 2, и значение переменной z равно 3.Ниже приводится ход вычисления выражения (+ x y z).

.EVAL вход:  (PLUS x y z)
..CAR вход: A= (PLUS x y z)
..CAR выход: Рез= PLUS
..CDR вход: A= (PLUS x y z)
..CDR выход: Рез= (x y z)
..APPLY вход: A1= PLUS A2= (x y z)
...EVFUN вход: A1= PLUS A2= (x y z)
...
... Ассоциативный список:
...
...  3  ->  (z . 3)
...  2  ->  (y . 2)
...  1  ->  (x . 1)
...
....LIST вход: A= (x y z)
.....CAR вход: A= (x y z)
.....CAR выход: Рез= x
.....EVAL вход:  x
......EVATOM вход:  x
......EVATOM выход:  1
.....EVAL выход:  1
.....CDR вход: A= (x y z)
.....CDR выход: Рез= (y z)
.....CAR вход: A= (y z)
.....CAR выход: Рез= y
.....EVAL вход:  y
......EVATOM вход:  y
......EVATOM выход:  2
.....EVAL выход:  2
.....CDR вход: A= (y z)
.....CDR выход: Рез= (z)
.....CAR вход: A= (z)
.....CAR выход: Рез= z
.....EVAL вход:  z
......EVATOM вход:  z
......EVATOM выход:  3
.....EVAL выход:  3
.....CDR вход: A= (z)
.....CDR выход: Рез= NIL
....LIST выход: Рез= (1 2 3)
....PLUS вход: A= (1 2 3)
.....CAR вход: A= (1 2 3)
.....CAR выход: Рез= 1
....PLUS пром. рез=1
.....CDR вход: A= (1 2 3)
.....CDR выход: Рез= (2 3)
.....CAR вход: A= (2 3)
.....CAR выход: Рез= 2
....PLUS пром. рез=3
.....CDR вход: A= (2 3)
.....CDR выход: Рез= (3)
.....CAR вход: A= (3)
.....CAR выход: Рез= 3
....PLUS пром. рез=6
.....CDR вход: A= (3)
.....CDR выход: Рез= NIL
....PLUS выход: Рез= 6
...EVFUN выход:  6
..APPLY выход:  6
.EVAL выход:  6

Функция ECHO управляет режимом дублироания введенного S-выражение в область вывода. Включается режим вызовом функции (ECHO T), а выключается вызовом (ECHO NIL). Когда режим эха включен, введенное пользователем S-выражение дублируется в области вывода; результат вычисления выводится ниже после комбинации "==>". Если режим эха выключен, то в области вывода печатется только результат вычисления. Состояние режима эха (Вкл/Выкл) выводится в шестой (самой правой) панели статус-бара. Режимом эха можно управлять и с помощью меню или тулбара - имеется пункт меню и командная кнопка. Однократное нажатие на кнопку меняет статус эха на противоположный. Функция недоступна при работе WEB-компоненты, а также при работе в составе EXE-файла и при вызове из библиотеки HomeLispLib.Exe.

Функция EXIT завершает сеанс работы. Программа HomeLispIde.Exe завершается. Функция может иметь аргумент (обязательно типа STRING). Если аргумент задан, текст строки выдается в диалоговом окне в качестве "прощального сообщения" - (EXIT "Прощай!..") Для завершения сеанса пользователь может также нажать кнопку "Выход" или щелкнуть по соответствующему пункту главного меню. Функция недоступна при работе WEB-компоненты.

Функция INPUT ожидает единственный аргумент-атом строкового типа. Функция рассматривает значение атома (строку символов) как S-выражение и переводит его во внутреннюю Лисп-форму. Полученное S-выражение функция INPUT возвращает в качестве результата. Вот как это выглядит:

(input "(+ 3 4)")

==>  (PLUS 3 4)

(eval (input "(+ 3 4)"))

==>  7

(input "(a . b)")

==>  (a . b)

(input "nil")

==>  NIL

(input "(a b c)")

==>  (a b c)

(eval (input "(a b c)"))

Атом "a" не имеет значения (не связан).
==>  ERRSTATE

(input '(a b c))

INPUT: параметр - не атом
==>  ERRSTATE

(input 'a)

INPUT: параметр должен иметь тип STRING
==>  ERRSTATE

(input ")(")

Нарушен баланс скобок или неверна скобочная структура
==>  NIL

Функция OBJLIST принимает единственный необязательный аргумент (типа STRING) и строит снимок списка объектов (атомов), в именах которых в любой позиции встречается значение аргумента. Если аргумент опущен, то строится снимок всех объектов. Следует отметить, что если очередной объект есть строка, то проверка осуществляется с учетом регистра. Для прочих атомов проверка выполняется без учета регистра.

При работе в Web-компоненте снимок списка объектов формируется в отдельном html-файле (который сохраняется до конца сеанса пользователя). Вид списка объекта приводится ниже:

При работе со скриптовым движком Conlisp.exe список имеет вид:

Здесь создано графическое окно ww, а затем запрошен список объектов, в именах которых содержится комбинация ww. Видно, что таких атомов оказалось всего два: окно и строка "ww" (из вызова (objlist "ww"). Пусть читатель обратит внимание на то, что у строки установлен только стандартный флаг STRING, тогда как у атома ww наряду со стандартным флагом WINDOW, имеется список нестандартных свойств (характеристики окна).

Совершенно аналогично выглядит результат вызова функции OBJLIST в среде IDE:

(grwCreate 'ww 200 200 "Графическое окно" _WHITE) ==> ww (objlist "ww") +-----------------------------------------+-----------------+-----------------+ | Имя атома | Станд. флаги | Доп. флаги | +-----------------------------------------+-----------------+-----------------+ |"ww" |STRING; | | |ww |WINDOW; |(width 200 height| | | | 200 title "Графи| | | |ческое окно" back| | | |color &HFFFFFF WI| | | |NHANDLE 1) | +-----------------------------------------+-----------------+-----------------+ ==> T

Функция OUTPUT ожидает единственный аргумент произвольного типа (атом или список) и выводит его значение в виде строки. Функция OUTPUT позволяет сохранить внешнюю (печатную) форму S-выражения в виде строки. Функция OUTPUT предназначена в основном для использования в диалоговых программах. Следует отметить, что в отличие от функций PRINT/PRINTS, Функция OUTPUT возвращает строку и дополнительно ничего не выводит в область вывода (при использовании в IDE). Ниже приводятся примеры вызовов OUTPUT:

(output (cdr '(1 2 3)))

==> "(2 3)"

(input (output (cdr '(1 2 3))))

==> (2 3)

Функция PHIDE не имеет аргументов. Вызов этой функции скрывает прогресс-бар, отображенный ранее функцией PSHOW.

Функция PSHOW имеет два аргумента. Первый аргумент должен быть числом в интервале [0 - 100]. Второй аргумент (необязательный) должен быть строкой разумной длины. Вызов функции PSHOW вызывает отображение на экране прогресс-бара. При этом первый параметр задает процент выполнения процесса, ход которого показывает прогресс-бар. Второй параметр задает текст, который отображается над прогресс-баром. Если второй параметр опущен, то в области текста отображается значение первого параметра. Прогресс-бар, отображенный вызовом (pshow 43 "Немного подождите...") выглядит так:

Скрыть прогресс-бар можно вызовом функции PHIDE.

Функция RDS предназначена для чтения S-выражений из файла. Вызвать функцию RDS можно двумя способами: без аргументов и с единственным аргументом (значение которого должно быть строкового типа).

В первом случае будет вызвано стандартное окно диалога выбора файла (с расширением .lsp). Если пользователь выбирает файл и нажимает кнопку "Принять", то из файла считываются и загружаются все S-выражения. S-выражения в файле могут быть записаны в свободном формате. При этом содержимое строки после пары символов "//" или ";;" считается комментарием и игнорируется.

Во втором случае проверяется, существует ли файл с именем, заданным значения аргумента. Имя может содержать букву диска. Если имя не содержит обратных слешей и буквы диска, файл будет искаться в текущей директории. При этом, если расширение файла задано отличным от .lsp, оно принудительно Заменяется на .lsp.

В случае успешной загрузки всех S-выражений из файла, в область вывода выводится сообщение об успешной загрузке файла, в противном случае выводится сообщение об ошибке. Функция RDS неявно вызывается при запуске HomeLisp с параметром имя автозагружаемой библиотеки. При работе WEB-компоненты функция позволяет загрузить данные только из рабочей директории авторизованного пользователя. Аргумент в этом случае является обязательным и не может содержать путь (диск и директорию).

Функция READ введена в HomeLisp для совместимости с существующими версиями Лиспа. Функция не требует параметров и обеспечивает чтение S-выражения, вводимого пользователем во время выполнения программы. Результатом функции является S-выражение, введенное пользователем. Функция READ имеет два отличия от описанной выше функции ASK:

  Функция READ возвращает не строку, а S-выражение (т.е. не требует последующего вызова функции INPUT);
  Функция READ не выводит диалогового окна, а ожидает ввода пользователя в области ввода (зависящей от режима выполнения).

При выполнении программы в IDE вызов функции READ выполнение программы прерывается, цвет области ввода становится белым, а вся область ввода окружается красной рамкой. Пользователь должен ввести S-выражение в область ввода и нажать ENTER. Функция не вернет управление до тех пор, пока пользователь не введет корректное S-выражение (со сбалансированными скобками). После возврата из функции READ цвет области ввода восстановится, а красная рамка исчезнет.

При выполнении программы в среде Conlisp.exe вызов READ устанавливает курсор в начало строки, следующей за текущей. Пользователь должен ввести S-выражение и нажать ENTER.

Если вызов функции READ встретился в коде, выполняющемся в среде Wlisp.exe, то функция возвращает Nil. Функция READ недоступна в WEB-компоненте и в составе EXE-файлов.

Псевдофункция READIMAGE (реализованная только в 13-й редакции ядра HomeLisp) обеспечивает восстановление состояния Лисп-машины из образа, созданного вызовом функции WRITEIMAGE. Слово "псевдо" в названии фигурирует не случайно: READIMAGE не является частью ядра HomeLisp. Если при работе IDE ввести в область ввода команду (READIMAGE), то откроется окно диалога Открыть и пользователь может выбрать файл-образ (*.hli). Если же ввести (READIMAGE "имя.hli"), то будет выполнена попытка восстановления состояния из заданного файла.

В обоих случаях состояние Лисп машины после восстановления не имеет ничего общего с состоянием машины до выполнения (READIMAGE), поэтому совершенно бессмысленно использовать вызов (READIMAGE) в программном коде (такая попытка вызовет ошибку Отсутствует функция READIMAGE.

Вместо того, чтобы вводить команду (READIMAGE), можно просто нажать кнопку "Загрузить" и в выпадающем списке типов файлов выбрать "Файлы образов *.hli".

Пользователю будет предложено подтвердить восстановление состояния. При подтверждении состояние восстанавливается. При этом все объекты Лиспа, созданные до восстановления, замещаются номыми.

Псевдофункция RESTART (реализованная только в 13-й редакции ядра HomeLisp) переводит Лисп-машину в состояние, которое она имела при старте сразу после загрузки функций стандартной библиотеки. Команду (RESTART) можно ввести только при работе с IDE. Честно говоря, разработчик сейчас сомневается, стоило ли открывать доступ к служебной функции RESTART, ведь достаточно просто достичь эффекта рестарта можно просто перезапустив IDE...

Функция SAY предназначена выдачи сообщения пользователю во время выполнения программы на Лиспе. Функция ожидает единственный параметр-атом. Этот атом может иметь тип FIXED, FLOAT, STRING или BITS. Выводится стандартный message-box в область текста которого попадает значение аргумента. Так, если введено выражение (SAY &H112233), то пользователь увидит следующее:

Функция SAY всегда возвращает T. Функция недоступна при работе в составе WEB-компоненты.

Функция STAT не требует аргументов. Эта функция включает режим статистики. При включенном режиме статистики после завершения вычисления входного выражения выдается количество обращений ко всем функциям системы. Включение режима статистики позволяет оценивать и анализировать сложность вычисления вводимых выражений. Статус режима статистики выводится в шестой (самой правой) панели статус-бара главного окна программы (Стат=Вкл/Выкл; по умолчанию режим выключен). Для включения режима статистики можно также использовать соответствующую кнопку панели инструментов или пункт главного меню. При успешном завершении функции STAT, она возвращает результат T.

Вот как выглядит результат применения режима статистики. Рассчитаем значение числа 20! двумя способами - с использованием рекурсивной процедуры fact_rec и с использованием итерационной процедуры fact_iter:

(defun fact_rec (x) (cond ((eq x 1) 1) (t (* x (fact_rec (- x 1))))))

==> fact_rec

(STAT)

==> T

(fact_rec 20)

==>  2432902008176640000

*** Статистика обращений ***
DIFFERENCE ...............  19
TIMES ....................  19
EQ .......................  20
FACT_REC .................  20
COND .....................  20


(defun fact_iter (x) (prog (r)
                       (setq r 1) 
                   L   (cond ((eq x 1) (return r)))
                       (setq r (* r x))
                       (setq x (- x 1))
                       (go l)
                     )
)

==> fact_iter

*** Статистика обращений ***
DEFUN ....................  1

(fact_iter 20)

==> 2432902008176640000

(fact_iter 20)

==> 2432902008176640000

*** Статистика обращений ***
FACT_ITER ................  1
PROG .....................  1
RETURN ...................  1
DIFFERENCE ...............  19
GO .......................  19
TIMES ....................  19
COND .....................  20
EQ .......................  20
SETQ .....................  39

Функция TRACE принимает один аргумент - имя функции типа EXPR, FEXPR или MACRO. Если функция, заданная аргументом TRACE, существует, то в качестве результата вычисления возвращается значение аргумента. В противном случае возвращается NIL. Вызов функции TRACE устанавливает у функции, заданной значением аргумента, флаг трассировки. Если теперь вызвать эту функцию, то перед печатью результата вычисления будет выведен протокол трассировки, включающий входную информацию каждого вызова трассируемой функции и результат вычислений. Рассмотрим, например, протокол трассировки рекурсивной функции вычисления факториала:

(defun fact_rec (x) (cond ((eq x 1) 1) (t (* x (fact_rec (- x 1))))))

==> fact_rec

(trace fact_rec)

==> fact_rec

(fact_rec 7)

Вход в функцию fact_rec Аргументы:  (7)
  Вход в функцию fact_rec Аргументы:  (6)
    Вход в функцию fact_rec Аргументы:  (5)
      Вход в функцию fact_rec Аргументы:  (4)
        Вход в функцию fact_rec Аргументы:  (3)
          Вход в функцию fact_rec Аргументы:  (2)
            Вход в функцию fact_rec Аргументы:  (1)
            Возврат из функции fact_rec Результат:  1
          Возврат из функции fact_rec Результат:  2
        Возврат из функции fact_rec Результат:  6
      Возврат из функции fact_rec Результат:  24
    Возврат из функции fact_rec Результат:  120
  Возврат из функции fact_rec Результат:  720
Возврат из функции fact_rec Результат:  5040

==> 5040

Функция UNDUMP* (звездочка в конце имени введена из-за нежелания нарушать традицию Лиспа - все, что оканчивается на p - предикат) выключает режим дампирования. Вместо явного вызова функции UNDUMP* можно нажать соответствующую кнопку панели инструментов или выбрать соответствующий пункт главного меню. Функция UNDUMP* всегда возвращает NIL

Функция UNSTAT выключает режим статистики. Функция всегда возвращает NIL. Вместо явного вызова функции UNSTAT можно нажать соответствующую кнопку панели инструментов или выбрать соответствующий пункт главного меню.

Функция UNTRACE выключает режим трассировки для фукнции, имя которой есть значение единственного аргумента UNTRACE. Функция возвращает имя функции, у которой выключается трассировка. Если функция, заданная аргументом UNTRACE, отсутствует, возвращается NIL.

Функция VARLIST (реализованная только в 13-м ядре) отображает список активных в момент вызова переменных вместе с их типами. Функция принимает один необязательный параметр строкового типа. Если параметр задан, то в список переменых попадают только переменные, в имени которых присутствует заданная строка. Рассмотрим пример:

(setq *g* 100) ==> 100 Создана глобальная переменная *g* (defvar *d* -100) ==> *d* (defun f (x y) (varlist) (list x y)) ==> f (f 222 333) +-------------------+---------+-----------+ | Имя переменной | Тип | Значение | +-------------------+---------+-----------+ |y |Лексич. |333 | |x |Лексич. |222 | |*d* |Динамич. |-100 | |*g* |Глобальн.|100 | +-------------------+---------+-----------+ ==> (222 333) (varlist) +-------------------+---------+-----------+ | Имя переменной | Тип | Значение | +-------------------+---------+-----------+ |*d* |Динамич. |-100 | |*g* |Глобальн.|100 | +-------------------+---------+-----------+ ==> T

Здесь создана глобальная переменная *g*, динамическая переменная *d*, после чего вызвана функция f, в теле которой содержится вызов VARLIST. Хорошо видно, что в точке вызова VARLIST активны четыре переменные - глобальная, динамическая и две лексические (параметры функции). Вызов функции VARLIST на верхнем уровне показывает, естественно, только две переменные - *g* и *d*.

Разумеется, увидеть переменные *g* и *d* можно при работе в IDE, нажав кнопку "Просмотр переменных", но лексические переменные можно увидеть только в отладчике.

Функция WRITEIMAGE (реализованная только в 13-м ядре) сохраняет полный образ состояния Лисп-машины в двоичный файл на диске. В образ попадают все созданные объекты (включая графические окна с содержимым, диалоги, BLOB-ы, hash-таблицы). Функция принимает один необязательный параметр - имя файла-образа. Если параметр не задан, открывается стандартный диалог "Сохранить как". Если пользователь нажмет кнопку отказа, сохранение не выполняется. В качестве расширения файла-образа устанавливается .hli (HomeLisp Image).

Файл-образ, полученный в результате работы функции WRITEIMAGE, пригоден для последующей загрузки псевдо-функцией READIMAGE.

Важнейшее отличие функции WRITEIMAGE от функции WRS (описанной ниже) состоит в том, что функция WRS не способна сохранять циклические структуры. Это не представляется удивительным, поскольку функция WRS в сущности просто "печатает" все S-выражения в текстовый файл (а циклическая структура не может быть распечатана).

Функция WRS обеспечивает выгрузку определяющих выражений всех функций, переменных и констант во внешний текстовый файл. Функция WRS имеет необязательный аргумент типа STRING, представляющий собой имя файла для выгрузки. Выгрузка осуществляется в файл с расширением lsp. Если задано другое расширение, то оно заменится на lsp. Если задано короткое имя файла, то он образуется в текущей директории.

Если аргумент Функции WRS опущен, то выводится стандартное диалоговое операционной системы "Cохранить как". В этом случае пользователь может отказаться от выгрузки, нажав кнопку "Отмена" или выполнить выгрузку, выбрав директорию и файл, и нажав кнопку "Сохранить".

Полученный в результате работы функции WRS текстовый файл пригоден для загрузки данных посредством функции RDS.

При работе WEB-компоненты функция позволяет сохранить данные только в рабочую директорию авторизованного пользователя. Аргумент в этом случае является обязательным и не может содержать путь (диск и директорию).