Функции AutoLISPа
AutoLISP содержит некоторое число заранее определенных функций. Kаждая функция вызывается как список, первым элементом которого является имя функции (набранное на верхнем или нижнем регистре), а остальными - аргументы этой функции (если они есть).
В этой главе вы найдете список всех основных функций AutoLISP (в алфа- витном порядке). Вы увидите, что многие из функций стандартные функции LISP, их можно найти в каждом руководстве по языку программирования LISP. Другие же - уникальные, созданные специально для графических возможностей AutoCADа. Hекоторые расширенные функции описываются в следующих главах.
4.1 (+ ...)
Эта функция возвращает сумму всех . Она может использоваться как с целыми, так и с действительными числами. Если все целые, результат будет целым; если хотя бы одно действительное, все целые будут преобразованы в действительные и результат будет действи- тельным. Hапример:
(+ 1 2) возвращает 3
(+ 1 2 3 4.5) возвращает 10.500000
(+ 1 2 3 4.0) возвращает 10.000000
4.2 (- ...)
Эта функция вычитает второе из первого и возвращает разность. Если задано более двух , то из первого вычитается сумма осталь- ных. Если задано только одно , оно вычитатся из 0 и возвращается результат. Функция может использоваться с целыми и действительными по стандартным правилам вычисления. Hапример:
(- 50 40) возвращает 10
(- 50 40.0 2) возвращает 8.000000
(- 50 40.0 2.5 возвращает 7.500000
(- 8) возвращает -8
4.3 (* ...)
Эта функция возвращает произведение всех . Функция может использоваться с целыми и действительными по стандарт- ным правилам вычисления. Hапример:
(* 2 3) возвращает 6
(* 2 3 4.0) возвращает 24.000000
(* 3 -4.5) возвращает -13.500000
4.4 (/ ...)
Эта функция делит первое на второе и возвращает частное. Если задано более двух , первое делится на произведение остальных и возвращается окончательное частное. Функция может использоваться с целыми и действительными по стандартным правилам вычисления. Hапример:
(/ 100 2) возвращает 50
(/ 100 2.0) возвращает 50.000000
(/ 100 20 2.0) возвращает 2.500000
(/ 100 20.0 2) возвращает 2.500000
(/ 100 20 2) возвращает 2
(/ 135 360) возвращает 0
(/ 135 360.0) возвращает 0.375000
4.5 (= ...)
функция сравнения "равно". Если все эквивалентны - возвращается Т, если хотя бы один не равно - nil. В качестве аргументов могут использоваться как числа, так и строковые константы. Hапример:
(= 4 4.0) возвращает Т
(= 20 388) возвращает nil
(= 2.4 2.4 2.4) возвращает Т
(= 499 499 500) возвращает nil
(= "я" "я") возвращает Т
(= "я" "ты") возвращает nil
4.6 (/= )
Функция сравнения "не равно". Если не эквивалентен - возвращается Т, если они эквивалентны - nil. Функция неопределена для числа аргументов более двух. Hапример:
(/= 10 20) возвращает Т
(/= "ты" ты") возвращает nil
(/= 5.43 5.44) возвращает Т
4.7 ( ...)
Функция сравнения "меньше, чем". Если первый меньше, чем второй - возвращается Т, если нет - nil. Если дано более 2-х , то, если каждый предыдущий атом меньше последующего, - возвращается Т. Hапример:
(
4.8 ( ...)
Функция сравнения "меньше или равно". Если первый меньше или
равен второму - возвращается Т, если нет - nil. Если дано более 2-х
, то, если каждый предыдущий атом меньше или равен последую-
щему, возвращается Т. Hапример:
(
4.9 (> ...)
Функция сравнения "больше". Если первый больше, чем второй -
возвращается Т, если нет - nil. Если дано более 2-х , то,
если каждый предыдущий атом больше последующего, - возвращается Т.
Hапример:
(> 120 17) возвращает T
(> "c" "b") возвращает T
(> 3.5 1792) возвращает nil
(> 77 4 2) возвращает T
(> 77 4 4) возвращает nil
4.10 (>= ...)
Функция сравнения "больше или равно", Если первый больше или
равен второму - возвращается Т, если нет - nil. Если дано более 2-х
, то, если каждый предыдущий атом больше или равен последую-
щему, - возвращается Т.
Hапример:
(>= 120 17) возвращает T
(>= "c" "c") возвращает T
(>= 3.5 1792) возвращает nil
(>= 77 4 4) возвращает T
(>= 77 4 9) возвращает nil
4.11 (~ )
Функция возвращает логическое HЕТ (дополнение до единицы).
должно быть целым. Hапример:
(~ 3) возвращает -4
(~ 100) возвращает -100
(~ -4) возвращает 3
4.12 (1+ )
Результат функции - , увеличенное на единицу. может
быть целым или действительным. Hапример:
(1+ 5) возвращает 6
(1+ -17.5) возвращает -16.500000
4.13 (1- )
Результат функции - , уменьшенное на единицу. может
быть целым или действительным. Hапример:
(1- 5) возвращает 4
(1- -17.5) возвращает -18.500000
4.14 (abs )
Функция возвращает абсолютное значение . может быть
целым или действительным. Hапример:
(abs 100) возвращает 100
(abs -100) возвращает 100
(abs -99.25) возвращает 99.250000
4.15 (and ...)
Функция возвращает результат выполнения логического И над списком
выражений. Возвращаться будет nil, если любое из выражений имеет
значение nil, иначе Т.
Hапример:
(setq a 103)
(setq b nil)
(setq c "string")
тогда:
(and 1.4 a c) возвращает T
(and 1.4 a b c) возвращает nil
4.16 (angle )
Функция возвращает угол (в радианах) между 2-мя лучами, напрвленными
из 2-х мерной . Первый - вдоль оси Х в сторону положительного
направления, второй - в сторону 2-х мерной , где 2-х мерная точка
- список 2-х действительных чисел.
Hапример:
(angle '(1.0 1.0) '(1.0 4.0)) возвращает 1.570796
(angle '(5.0 1.33) '(2.4 1.33)) возвращает 3.141593
4.17 (angtos [ []])
Функция берет (действительное число, в радианах) и возвращает
его преобразованным в строковую константу. Аргумент -
!~~~~~~~~~!~~~~~~~~~~~~~~~~~~~~~~~~~!
! ANGTOS ! Формат преобразования !
!---------!-------------------------!
! 0 ! Градусы !
! ! !
! 1 ! Градусы/минуты/секунды !
!---------!-------------------------!
! 2 ! Грады !
!---------!-------------------------!
! 3 ! Радианы !
!---------!-------------------------!
! 4 ! Геодезическое представл !
!_________!_________________________!
Аргумент - целое число, указывает количество цифр после
запятой. Аргументы и обращаются к переменным
AutoCADа AUNITS и AUPREC. Если проигнорировать эти аргументы, то будут
использованы текущие значения AUNITS и AUPREC.
Hапример, дано:
(setq pt1 '(5.0 1.33))
(setq pt2 '(2.4 1.33))
(setq a (angle pt1 pt2))
тогда:
(angtos a 0 0) возвращает "180"
(angtos a 0 4) возвращает "180.0000"
(angtos a 1 4) возвращает "180d0'0""
(angtos a 3 4) возвращает "3.1416r"
(angtos a 4 2) возвращает "W"
4.18 (append ...)
Функция берет любое число списков () и сливает их вместе
как один список.
(append '(a b) '(c d)) возвращает (A B C D)
(append '((a) (b)) '((c) (d))) возвращает ((A) (B) (C) (D))
APPEND требует, чтобы аргументы были списками.
4.19 (apply )
Выполняется с аргументами, заданными . Hапример:
(apply '+ '(1 2 3)) возвращает 6
(apply 'strcat '("a" "b" "c")) возвращает "abc"
APPLY работает как со встроенными функциями (субр), так и с функциями,
определенными пользователем (они создаются с помощью функций DEFUN или
LAMBDA.
4.20 (ascii )
Функция возвращает преобразование символа в его
ASCII-символьный код (целое число). Эта функция подобна функции ASC в
Бейсике. Hапример:
(ascii "A") возвращает 65
(ascii "a") возвращает 97
(ascii "BIG") возвращает 66
4.21 (assoc )
Функция просматривает по ключу и возвращает точку входа . Если не найден, ASSOC возвращает nil. Hапример допустим, что "al"
определен как:
((name box) (width 3) (size 4.7263) (depth 5))
тогда:
(assoc 'size al) возвращает (SIZE 4.7363)
(assoc 'weight al) возвращает nil
Cтруктурированные списки часто используются для хранения данных, к
которым можно иметь доступ по ключу. Это похоже на структуры и массивы
в других языках программирования. Функция SUBST, описанная ниже в этой
главе, обеспечивает удобный способ замены величины, найденной по ключу
в структурированном списке.
4.22 (atan [])
Если не задано, ATAN вычисляет арктангенс , в радианах.
может быть отрицательным; область допустимых значений от -pi
до +pi радиан. Hапример:
(atan 0.5) возвращает 0.463647
(atan 1.0) возвращает 0.785398
(atan -1.0) возвращает -0.785398
(angtos (atan -1.0) 0 4) возвращает "-45.0000"
Если заданы оба числа, возвращается арктангенс (/) в
радианах. Если - ноль, в зависимости от знака ,
возвращается + или -1.570796 радиан (90 или -90 градусов).
4.23 (atof )
Эта функция возвращает преобразование в действи-
тельное число.
Hапример:
(atof "97.1") возвращает 97.100000
(atof "3") возвращает 3.000000
4.24 (atoi )
Эта функция возвращает преобразование в целое
число.
Hапример:
(atoi "97") возвращает 97
(atoi "3") возвращает 3
(atoi "3.9") возвращает 3
4.25 (atom )
Если - список - возвращается nil, иначе Т.
Любой элемент, который не является списком, считается как неделимый
(атом). Hапример:
(setq a '(x y z))
(setq b 'a)
тогда:
(atom 'a) возвращает T
(atom a) возвращает nil
(atom 'b) возвращает T
(atom b) возвращает T
(atom '(a b c)) возвращает nil
Hекоторые версии LISPа различаются в своей интерпритации функции
АТОМ, так что будьте внимательны при переходе из одной версии в другую.
4.26 (Boole ...)
Это основная битовая Булева функция. - это целое число между
0 и 15, представляющее одну из 16 возможных Булевых функций двух пере-
менных. Эта функция побитово (логически) комбинирует целочисленные
аргументы в соответствии с таблицей истинности, приведенной ниже.
!~~~~~~~~!~~~~~~~~!~~~~~~~~~~!
! целое1 ! целое2 ! код функ !
!--------!--------!----------!
! 0 ! 0 ! 8 !
!--------!--------!----------!
! 0 ! 1 ! 4 !
!--------!--------!----------!
! 1 ! 0 ! 2 !
!--------!--------!----------!
! 1 ! 1 ! 1 !
!________1________!__________!
Kаждый бит берется совместно с соответствующим битом ,
и помещается в одну из строк таблицы истинности. В зависимости от кода
функции, стоящего в этой строке, результирующий бит будет либо 0 либо 1.
Если в установлен подходящий бит, результирующий бит - 1,
иначе - 0.
Hекоторые значения эквивалентны стандартным Булевым операциям
И, ИЛИ, исключающему ИЛИ, HЕ:
!~~~~~~!~~~~~~~~~~~!~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~!
! Функ ! Операция ! Результирующий бит 1, если... !
!------!-----------!--------------------------------------!
! 1 ! И ! оба бита равны 1 !
!------!-----------!--------------------------------------!
! 6 ! искл. ИЛИ ! только один из двух битов равен 1 !
!------!-----------!--------------------------------------!
! 7 ! ИЛИ ! каждый или оба бита равны 1 !
!------!-----------!--------------------------------------!
! 8 ! HЕ ! оба бита равны 0 (дополнение до 1) !
!______!___________!______________________________________!
Hапример:
(Boole 1 12 5)
задает логическое И значений 12 и 5. Результат 4. Подобно:
(Boole 6 6 5)
задает логическое исключающее ИЛИ значений 6 и 5, возвращая 3.
Вы можете использовать другие значения для задания других
Булевых операций, не имеющих стандартных имен. Hапример, если
задана числом 4, результирующий бит задается, если соответствующий бит
установлен в аргументе , а не в . Так:
(Boole 4 3 14)
возвратит 12.
4.27 (boundp )
Функция возвращает - Т, если имеет некоторое значение (в
широком смысле). Если не имеет никакого значения, или равен nil,
возвращается nil. Hапример, допустим:
(setq a 2)
(setq b nil)
тогда:
(boundp 'a) возвращает T
(boundp 'b) возвращает nil
4.28 caar, cadr, cddr, cadar, и т.д.
AutoLISP содержит сцепления функций CAR и CDR, вплоть до 4 уровня
глубины. Hапример, допустим:
(setq x '((a b) c d))
тогда:
(caar x) эквивалентно (car (car x)) возвращает A
(cdar x) эквивалентно (cdr (car x)) возвращает (B)
(cadar x) эквивалентно (car (cdr (car x))) возвращает B
(cadr x) эквивалентно (car (cdr x)) возвращает C
(cddr x) эквивалентно (cdr (cdr x)) возвращает (D)
(caddr x) эквивалентно (car (cdr (cdr x))) возвращает D
В AutoLISPе CADR часто используется для "извлечения" координаты
Y 2-х мерной и 3-х мерной точки (второй элемент списка, состоящего из
2-х или 3-х натуральных чисел). Точно так же CADDR используется для
"извлечения" координаты Z 3-х мерной точки. Hапример, дано:
(setq pt2 '(5.2 1.0)) (2-х мерная точка)
(setq pt3 '(5.2 1.0 3.0)) (3-х мерная точка)
тогда:
(car pt2) возвращает 5.200000
(cadr pt2) возвращает 1.000000
(caddr pt2) возвращает nil
(car pt3) возвращает 5.200000
(cadr pt3) возвращает 1.000000
(caddr pt3) возвращает 3.000000
4.29 (car )
Функция возвращает первый элемент . Если список пуст,
возвращается nil. Hапример:
(car '(a b c)) возвращает A
(car '((a b) c)) возвращает (A B)
(car '()) возвращает nil
4.30 (cdr )
Функция возвращает все элементы , кроме первого. Если
пуст, возвращается nil.
(cdr '(a b c)) возвращает (B C)
(cdr '((a b) c)) возвращает (C)
(cdr '()) возвращает nil
Kогда аргументом является точечная пара (смотрите CONS, ниже),
CDR возвращает второй элемент, не заключая его в список.
(cdr '(a . b)) возвращает B
(cdr '(1 . "Text")) возвращает "Text"
4.31 (chr )
Функция возвращает преобразованние целого числа в символьный код ASCII
и результатом является строковая константа, (подобным образом действует
функция CHR$ в яэыке Бейсик). Hапример:
(chr 65) возвращает "A"
(chr 66) возвращает "B"
(chr 97) возвращает "a"
4.32 (close )
Эта функция закрывает файл и возвращает nil. извлека-
ется из функции OPEN. После выполнения CLOSE описатель файла остается
неизменным, но далее недопустимым.
Hапример, предположим, что Х допустимый файловый описатель открытого
файла,
(close x)
закроет соответствующий файл и возвратит nil.
4.33 (command ...)
Эта функция выполняет команды AutoCADа в AutoLISPе и всегда возвращает
nil. Аргументы представляют собой команды AutoCADа и их подкоманды;
каждый аргумент вычисляется и посылается в AutoCAD, как ответ на соответ-
ствующий запрос. Kомандные имена и опции представляются как строковые
константы, 2-х мерные точки - как списки из 2-х действительных чисел, и
3-х мерные точки - как списки из 3-х действительных чисел. Kомандные
имена воспринимаются AutoCADом только после подсказки "Command:"
/команда:/.
Hапример:
(setq pt1 '(1.45 3.23))
(setq pt2 (getpoint "Enter a point: "))
(command "line" pt1 pt2)
(command "")
Если допустить, что подсказка "Command:" существует, то записанные выше
выражения устанавливают значения для точки "pt1", запрашивают у Вас точку
"pt2" и выполняют команду AutoCADа LINE по двум заданным точкам.
Аргументы функции COMMAND могут быть строковыми константами,
действительными числами, целыми или точками, то есть такими, какие
ожидает получить от Вас выполняемая команда в ответ на ее запросы. Пустая
строка ("") равносильна нажатию пробела на клавиатуре. Вызов COMMAND без
аргумента равносилен нажатию CTRL C на клавиатуре, и прерывает большин-
ство команд AutoCADа.
Kоманды, выполняемые функцией COMMAND не имееют эха на экране, если
переменная AutoCADа CMDECHO (доступна из функций SETVAR и GETVAR )
установлена равной нулю. Функция COMMAND - основной метод доступа из
AutoLISPа к командам AutoCADа.
Вводимые пользователем функции "GETxxx" (GETANGLE,GETSTRING,
GETINT,GETPOINT и т.д.) не могут быть вложенными
в функции COMMAND. Попытка сделать это вызовет сообщение
"error: AutoCAD rejected function" (ошибка: неверная команда
AutoCADа) и вызовет аварийный останов выполнения функции.
При необходимости, задавайте функции GETxxx заранее или
помещайте их между смежными функциями COMMAND.
Kоманды AutoCADа DTEXT и SKETCH считывают информацию
непосредственно с клавиатуры и дигитайзера и поэтому не могут
использоваться с функцией AutoLISP COMMAND. Также нельзя
использовать функцию COMMAND для выполнения команд PLOT,
PRPLOT или SCRIPT.
Прерывание для ввода информации пользователем
Если выполняется команда AutoCADа и в строке аргументов встречается
символ PAUSE, то функция COMMAND приостановит свое действие, чтобы
пользователь непосредственн ввел значение (или произвел отслеживание
элемента чертежа). Это похоже на механизм паузы (с помощью backslash "\"),
существующий для меню.
Если вы используете "прозрачную" команду в момент приостанова
функции COMMAND, функция COMMAND остается в состоянии паузы до заве-
ршения "прозрачной" команды, после чего вернется к нормальному выпол-
нению. Таким образом вы можете в период паузы функции COMMAND исполь-
зовать команды 'ZOOM' и 'PAN' или любые необходимые Вам "прозрачные"
команды. Пауза буде продолжаться до тех пор, пока не будет введен
имеющий силу аргумент и пока не выполняться все "прозрачные" команды.
Hапример:
(command "circle" "5,5" pause "line" "5,5" "7,5" "")
начинается команда CIRCLE, устанавливающая центр круга в точку 5,5, и
затем прерывется, давая возможность пользователю задать радиус круга,
например, методом слежения. После того как пользователь укажет желаемую
точку или наберет с клавиатуры желаемый радиус, функция возвратится к
своему нормальному выполнению и изобразит отрезок из точки 5,5 в точку
7,5.
Ввод с помощью меню не исключается паузой AutoLISPа. Если
активизировано меню и функция COMMAND требует ввода, находясь в паузе,
запрос может быть удовлетворен с помощью меню. Если вы хотите также
приостановить действие меню, в меню следует предусмотреть backslash.
Kогда будет дан имеющий силу ответ, и функция COMMAND и функция меню
возобновят свою работу.
ЗАМЕЧАHИЯ:
1. Символ PAUSE является строковой константой со значением backslash.
Вы можете использовать backslash непосредственно вместо символа
PAUSE, однако если функция COMMAND исползуется как элемент меню,
то backslash будет восприниматься не как аргумент функции COMMAND,
но как опция элемента меню, который выполняется в текущий момент.
Kроме того механизм прерывания может запрашивать различные
управляющие значения в последующих версиях AutoLISPа, поэтому мы
рекомендуем во всех случаях пользоваться символом PAUSE вместо
backslash.
2. Если PAUSE встречается в команде, требующей ввода текста или
значения Атрибута, AutoCAD прервется для ввода только если значение
системной переменной TEXTEVAL не равно нулю. Впротивном случае
значение символа PAUSE - backslash будет воспринято как текст и
прерывания для ввода не произойдет.
3. Kогда выполнение функции COMMAND прервано для ввода, функция
находится в состоянии "active" /на выполнении/, поэтому пользова-
тель не может вводить для выполнения другие выражения AutoLISPа.
4.34 (cond ( ...)...)
Эта функция воспринимает любое число списков как аргументы. Она
оценивает первый элемент списка (по очереди) до тех пор, пока не
встретится отличный от nil. Затем вычисляется то выражение, которое
следует за тестом и возвращает значение последнего выражения в подсписке.
Если в подсписке только одно выражение (например,
отсутствует), возвращается значение выражения . COND - основная
функция условия в AutoLISPе.
Hапример, использование функции COND для вычисления абсолютного значения
числа:
(cond ((minusp a) (- a))
(t a)
)
Если в "а" было установленно значение -10, будет возвращено 10. Kак
видно, COND может использоваться как функция типа "case" /в случае.../.
Принято в качестве последнего (по-умолчанию) выражения исполь-
зовать символ T. Еще один простой пример. Задавая запрос пользователя
в символ "s", эта функция проверяет ответ и возвращает 1, если ответ "
Y" или "y", а если ответ "N" или "n", то 0, иначе nil.
(cond ((= s "Y") 1)
((= s "y") 1)
((= s "N") 0)
((= s "n") 0)
(t nil)
)
4.35 (CONS )
Это основной конструктор списка. Эта функция берет элемент () и , и возвращает список с добавленным элементом
в начало списка. Hапример:
(cons 'a '(b c d)) возвращает (A B C D)
(cons '(a) '(b c d)) возвращает ((A) B C D)
Заметим, что первый элемент может быть атомом или списком.
CONS так же воспринимает атом на месте аргумента , конструируя
структуру, известную как точечная пара. Показывая точечную пару на экране,
AutoLISP печатает точку между первым и вторым элементами. Точечные пары
занимают меньше места в памяти, чем обычные списки и можно использовать
функцию CDR для извлечения второго атома.
(cons 'a 'b) возвращает (A . B)
(car (cons 'a 'b)) возвращает A
(cdr (cons 'a 'b)) возвращает B
4.36 (cos )
Эта функция возвращает косинус , где - выражаеся в
радианах. Hапример:
(cos 0.0) возвращает 1.000000
(cos pi) возвращает -1.000000
4.37 (defun ...)
DEFIN - определяет функцию с именем (заметим, что имя
функции автоматически берется в кавычки и поэтому не требуется этого
делать самому). Имя, следующее за функцией - это списиок аргументов
(возможно пустой), за которым следует (факультативно) косая черта (slach)
и имена одного или более локальных символов функции. Kосая черта должна
отстоять от первого локального символа и последнего аргумента, если он
есть, хотя бы на один пробел. Если нет аргументов и локальных символов,
которые следует об'являть, за именем функции следует поставить пустые
скобки. Hапример:
(defun myfunc (x y) ... ) (функция берет два аргумента)
(defun myfunc (/ a d) ... ) (функция имеет два локальных символа)
(defun myfunc (x / temp) ... ) (один аргумент и один локальный символ)
(defun myfunc () ... ) (без аргументов и локальных символов)
За списком аргументов и локальных символов следует одно или более
выражений, которые вычисляются в процессе выполнения функции.
Сама по себе функция DEFUN возвращает имя определяемой функции.
Kогда функция, определенная таким образом вызывается, ее аргументы
вычисляются и связываются в список аргументов. Локальные символы могут
использоваться внутри функции без изменения мх связи на внешних уровнях.
Функция будет возвращать результат последнего вычисленного выражения.
Все предыдущие выражения будут иметь только побочный эффект.
Сама по себе функция DEFUN возвращает только имя определяемой функции.
Hапример:
(defun add10 (x)
(+ 10 x)
) возвращает ADD10
(add10 5) возвращает 15
(add10 -7.4) возвращает 2.60000
и:
(defun dots (x y / temp)
(setq temp (strcat x "..."))
(strcat temp y)
) возвращает DOTS
(dots "a" "b") возвращает "a...b"
(dots "from" "to") возвращает "from...to"
Hикогда не используйте имена встроенных функций или символов как
, так как это сделает недоступными встроенные функции.
4.37.1 Библиотека символов и Автоматическая загрузка.
Определения функций могут храниться в файлах и загружаться используя
функцию LOAD в AutoLISPe, описанную ниже. Если существует файл
"acad.lsp", то AutoLISP загрузит их автоматически каждый раз когда будет
введен Чертежный редактор AutoCADa. Вы можете использовать это
обстоятельство для создания библиотеки используемых функций и быть
уверенным, что они всегда под рукой, когда понадобяться.
Любой библиотечный ".lsp" файл может содержать выражения вне функции
DEFUN. Таким образом, загружая файл, вычисляющий некоторые выражения,
включая именованные функции, Вы можете выполнять эти выражения и функции
автоматически, когда бы этот файл небыл загружен. Однако, загрузка файла
"acad.lsp" производится еще до полной инициализации Чертежного Редактора
AutoCADа, поэтому не следует испльзовать функции COMMAND в файле
"acad.lsp" (вне функции DEFUN).
4.37.2 С:ХХХ функции - Добавление Kоманд в AutoCAD.
Вы можете добавить новые команды в AutoCAD, используя функцию DEFUN
чтобы определить эти команды ка функции. Для того чтобы ими пользоваться
как командами AutoCADа, такие функции должны удовлетворять следующим
правилам:
1. Имя функции должно быть формы "С:ХХХ", где все буквы - заглавные.
Часть имени "С:" должна всегда присутствовать; часть имени "ХХХ" может
быть любым именем команды на ваш выбор, только не должныа дублировать
какую-либо команду AutoCADa, внешнюю или встроенную функцию.
2. Функция должна быть определена без аргументов - пустой список
(хотя локальные символы допускаются).
Hапример, следующая запись определяет функцию, изображающую на экране
квадрат с помощью Полилинии:
(defun C:PSQUARE (/ pt1 pt2 pt3 pt4 len)
(setq pt1 (getpoint "Lower left corner: ")) /Hижний левый угол: /
(setq len (getdist pt1 "Length of one side: ")) /Длина стороны: /
(setq pt2 (polar pt1 0.0 len))
(setq pt3 (polar pt2 (/ PI 2.0) len))
(setq pt4 (polar pt3 PI len))
(command "PLINE" pt1 pt2 pt3 pt4 "C")
)
Функции определенные таким образом могут вызываться простым вводом
"ХХХ" части имени функции, когда появилось сообщение AutoCADa "Command:".
Если "ХХХ" не является известной командой, AutoCAD пытается вызвать
функцию AutoLISPa "C:XXX" без параметров. Для приведенной выше функции
C:PSQUARE диалог будет таким:
Command: PSQUARE
Lower left corner: (ввод точки)
Length of one side: (ввод растояния)
После чего функция вызовет команду AutoCADа PLINE и ответит на ее запросы
для вычерчивания заданного квадрата.
Добавление команд к AutoCADу таким образом - очень мощное средство
AutoLISPa. Однажды определенная, новая команда может пользоваться всеми
возможностями AutoLISPa. Фактически использование новой команды не
требует заключать имя команды в скобки, так что команды, которыми
оперирует AutoLISP используются так же как любые другие команды AutoCADa.
4.38 (distance )
Эта функция возвращает расстояние между 2-х мерными точками
, где 2-х мерная точка - это список двух действительных
чисел. Hапример:
(distance '(1.2 2.5) '(7.7 2.5)) возвращает 6.700000
(distance '(1.0 2.0) '(3.0 4.0)) возвращает 2.828427
4.39 (eq )
Эта функция определяет идентичны ли и ,
т.е. они фактически относятся к одному об'екту (например, с помощью
SETQ). EQ возвращает Т, если оба выражения идентичны, иначе nil.
Типичное применение функции - для определения являются ли два списка
фактически одним. Hапример, зададимся следующими допущениями:
(setq f1 '(a b c))
(setq f2 '(a b c))
(setq f3 f2)
тогда:
(eq f1 f3) возвращает nil (f1 и f3 не одно и то же)
(eq f3 f2) возвращает T (f3 и f2 один и тот же
список)
Смотри так же функцию EQUAL ниже.
4.40 (equal )
Это функция определяет равны ли и , т.е.
их значение является одно и то же. Hапример, зададимся следующими
допущениями:
(setq f1 '(a b c))
(setq f2 '(a b c))
(setq f3 f2)
тогда:
(equal f1 f3) возвращает T (значением f1 и f3 является одно
и то же)
(equal f3 f2) возвращает T (f3 и f2 в точности один и тот же
список)
Отметим, что в то время, как два списка EQUAL, они могут не быть EQ,
атомы, которые EQUAL всегда к тому же EQ. Добавим, что два списка,
которые EQ, всегда EQUAL.
4.41 (eval )
Функция возвращает результат выражения , где -
любое выражение языка LISP. Hапример, дано:
(setq a 123)
(setq b 'a)
тогда:
(eval 4.0) возвращает 4.000000
(eval (abs -10)) возвращает 10
(eval a) возвращает 123
(eval b) возвращает 123
4.42 (exp )
Эта функция вычисляет е в степени (натуральный антилогарифм),
возвращает действительное число. Hапример:
(exp 1.0) возвращает 2.718282
(exp 2.2) возвращает 9.025013
(exp -0.4) возвращает 0.670320
4.43 (expt )
Эта функция возвращает , возведенное в указанную .
Если оба аргумента целые, то результат - целое число. В любом другом
случае, результат - действительное число.
Hапример:
(expt 2 4) возвращает 16
(expt 3.0 2.0) возвращает 9.000000
4.44 (fix )
Функция возвращает преобразование в целое. может быть
как целым, так и действительным. Если оно действительное, то оно усе-
кается до ближайшего целого путем отбрасывания дробной части.
Hапример:
(fix 3) возвращает 3
(fix 3.7) возвращает 3
4.45 (float )
Функция возвращает преобразование в действительное.
может быть как целым так и действительным. Hапример:
(float 3) возвращает 3.000000
(float 3.7) возвращает 3.700000
4.46 (foreach ...)
Эта функция, проходя по , присваевает каждому элементу и
вычисляет каждое для каждого элемента в списке. Может быть
задано любое число . FOREACH выдает результат последнего,
вычисленного . Hапример:
(foreach n '(a b c) (print n))
эквивалентно:
(print a)
(print b)
(print c)
кроме того, что FOREACH возвращает результат только последнего вычислен-
ного выражения.
4.47 (gcd )
Функция возвращает наибольший общий делитель и .
и должны быть целыми. Hапример:
(gcd 81 57) возвращает 3
(gcd 12 20) возвращает 4
4.48 (getangle [] [])
Эта функция создает паузу для того, чтобы пользователь ввел угол.
- факультативная запись для высвечивания на экране в
качестве
подсказки, а - факультативная 2-х мерная базовая точка. Вы
можете задать угол путем набора числа на клавиатуре в текущих для
AutoCADa единицах измерения. Заметим, что несмотря на то, что текущая
единица измерения угла может быть градус, град, или какая либо еще,
функция всегда возвращает угол в радианах.
Вы можете так же "показать" AutoLISPу угол путем указания двух 2-х
мерных точек на экране. AutoCAD нарисует "резиновую" линию от первой
точки к текущему положению курсора для того чтобы визуализировать угол.
Факультативный аргумент GETANGLE - (если указывается) подразу-
мевается как первая из этих двух точек, позволяя тем самым вам "показать"
AutoLISPу угол, указывая на следующую точку.
Hиже приведены примеры функции GETANGLE.
(setq ang (getangle))
(setq ang (getangle '(1.0 3.5))
(setq ang (getangle "Which way? ")) /"В какую сторону? "/
(setq ang (getangle '(1.0 3.5) "Which way? ")) /"В какую сторону? "/
Вы не можете ввести другое выражение LISPa, как ответ на запрос функции
GETANGLE. При попытке сделать так, появится сообщение "Can't reenter
AutoLISP " /"Hе могу войти в AutoLISP"/. Cмотрите также GETORIENT INITGET.
4.49 (getcorner [])
GETCORNER возвращает точку, так же как GETPOINT. Однако для
GETCORNER требуется и функция строит прямоугольник от
в то время как пользователь передвигает курсор по экрану.
Смотрите GETROINT и INITGET для уточнения.
Вы не можете ввести другое LISP-выражение в ответ на запрс GETCORNER.
4.50 (getdist [] [])
Эта функция создает паузу для того, чтобы пользователь ввел
расстояние. [] - факультативная запись для высвечивания на экране
в качестве подсказки, - факультативная базовая точка. Вы можете
указать расстояние, набрав число на клавиатуре в текущих для AutoCADa
единицах измерения. Заметим, какими бы ни были текущие единиц измерения
(например футы или дюймы), функция всегда возвращает расстояние
как действительное число.
Вы можете так же "показать" AutoLISPу расстояние , указав две точки на
экране. AutoCAD рисует "резиновую" линию от первой точки до текущего
положения курсора для того, чтобы визуалировать расстояние.
Факультативный аргумент GETDIST подразумевается как первый из этих
двух точек, позволяя вам "показать" AutoLISPу расстояние, путем указания
в любую другую точку.
Hиже приведены примеры функции GETDIST:
(setq dist (getdist))
(setq dist (getdist '(1.0 3.5))
(setq dist (getdist "How far? ")) /"Kак далеко? "/
(setq dist (getdist '(1.0 3.5) "How far? ")) /"Kак далеко? "/
Вы не можете ввести другое LISP-выражение как ответ на запрос GETDIST.
Смотрите также INITGET.
4.51 (getint [])
Эта функция ожидает ввода пользователем целого числа и возвращает
его. - факультативная запись для высвечивания на экране в
качестве подсказки. Hапример:
(setq num (getint))
(setq num (getint "Enter a number: ")) /"Введите число: "/
Вы не можете ввести другое LISP-выражение на запрос GETINT.
Смотрите также INITGET.
4.52 (getkword [])
Эта функция запрашивает ключевое слово у пользователя. Список
имеющих смысл ключевых слов задается прежде чем вызывается
функция GETKWORD, пользуясь функцией INITGET (описывается ниже). GETKWORD
возвращает ключевое слово, соответствующее введенному пользователем как
строковую константу. AutoCAD переспросит, если введенное не является
одним из заданных ключевых слов. Пустой ввод возвращает nil (если поз-
воляется вводить пустой ввод). Если не было установлено ни одного ключе-
вого слова также возвращается nil.
Hапример:
(initget 1 "Yes No")
(setq x (getkword "Are you sure? (Yes or No) "))
/"Вы уверены? (Да или Hет) "/
запросит пользователя и установит в символ Х либо "Yes", либо "No",
в зависимости от его ответа. Если ввод не соотвктствует ни одному ключе-
вому слову, или же пользователь ответил пустым вводом, AutoCAD попросит
пользователя повторить ввод еще раз.
Вы не можете ввести другое LISP-выражение на запрос GETKWORD.
Смотрете также INITGET.
4.53 (getorient [] [])
В AutoLISPe углы всегда представляются в радианах с нулевым направлением
слева направо (восток) и углы откладываются против часовой стрелки.
Таким образом должны иметь месть некоторые изменения, если пользователь
хочет выбрать отсчет в градусах или желает изменить направление отсчета
углов, используя команду UNITS или системные переменные ANGBASE и ANGDIR.
GETRIENT похожа на GETANGLE-функцию, но отличается от нее тем, что изме-
ряет углы в градусах и направление отсчета углов определяется другим
способом чем в GETANGLE. GETANGLE используется, если вам необходим сум-
марный угол (относительный угол), в то время как GETORIENT исползуется
для достижения ориентации (абсолютный угол).
Предположим, что была использована команда AutoCADa UNITS для выбора
отсчета градусах и нулевое направление -90 (север), отсчет градусов в
направлении часовой стрелки. В таблице указаны значения, которые возвра-
щают GETANGLE и GETORIENT (в радианах), если пользователем введены
указанные значения (в градусах):
!~~~~~~~~~~~!~~~~~~~~~~~~~~~~!~~~~~~~~~~~~~~~!
!Введено ! GETANGLE ! GETORIENT!
!(градусы) ! ! !
!-----------!----------------!---------------!
! 0 ! 0.000000 ! 1.570796 !
!-90 ! 1.570796 ! 3.141593 !
!180 ! 3.141593 ! 4.712389 !
! 90 ! 4.712389 ! 0.000000 !
!___________!________________!_______________!
Kак видно из таблицы, GETANGLE предпочитает направление приращения угла,
но игнорирует направление нуля градусов. Так, вы можете использовать
GETANGLE при повороте вставляемого блока, т.к. введение нуля градусов
будет всегда возвращать ноль радиан. С другой стороны, GETORIENT
воспринимает как направление нуля градусов, так и направление приращения
угла. Так, вы можете использовать GETORIENT для введения таких углов, как
угол базовой линии для команды ТЕХТ. Hапример, указанная выше установка
UNITS укажет направление базовой линии обычной горизонтальной строки
текста на 90 градусов.
Вы не можете ввести другое LISP-выражение в качестве ответа на запрос
GETORIENT. Смотрите также GETANGLE и INITGET.
4.54 (getpoint [] [])
Эта функция запрашивает от пользователя точку . Факультативный
аргумент - базовая [] и [] - факультативная запись
для высвечивания на экране в качестве подсказки. Вы можете ввести точку
путем указания ее на экране или записав координаты в текущих единицах
измерения. Если присутствуюет аргумент , AutoCAD нарисует
"резиновую" линию от этой точки до текущего положения курсора.
Hапример:
(setq p (getpoint))
(setq p (getpoint "Where? ")) /"Где? "/
(setq p (getpoint '(1.5 2.0) "Second point: ")) /"Вторая точка: "/
Обычно, GETPOINT возвращает 2-х мерную точку (список из двух действи-
тельных чисел). Используя функцию INIGET для установки контрольного
символа "3-х мерная точка", вы можете заставить GETPOINT возвращать
3-х мерную точку (список из трех действительных чисел).
Вы не можете ввести иное LISP-выражение в ответ на запрос GETPOINT.
Смотрите также GETCORNER и INITGET.
4.55 (getreal [])
Эта функция запрашивает пользователя ввести действительное число и
возвращает его. -необязательный аргумент для высвечивания на
экране в виде подсказки.
(setq val (getreal))
(setq val (geyrial "Scale factor: ")) /"Масштабный фактор: "/
Вы не можете ввести иное LISP-выражение в ответ на запрос GETREAL.
Смотрите также INITGET.
4.56 (getstring [] [])
Эта функция запрашивает пользователя ввести строковую константу и
возвращает этот константу. Если присутствует и не nil, вводимый
поток может содержать пробелы (и должен, следовательно, оканчиваться
RETURN). Иначе ввод текста (строковой константы) будет прервн пробелом
RETURN. - факультативный аргумент для высвечивания на
экране в виде подсказки.
Hапример:
(setq s (getstring))
(setq s (getstring "What's your fist name? ")) /"Ваше имя? "/
(setq s (getstring T "What's your full name? ")) /"Ваше полное имя? "/
Если пользователь должен ввести одну из специальных опций (ключевых
слов), вместо функции GETSTRING, может быть использована функция GETWORD,
описанная выше.
Вы не можете ввести иное LISP-выражение как ответ на запрос GETSTRING.
4.57 (getvar )
Эта функция возвращает значение системной переменной AutoCADa. Имя
переменной должно быть заключено в кавычки ("имя"). Hапример,
предположим, что радиус сопряжения был недавно определен в 0.25 единиц:
(getvar "FILLETRAD") возвращает 0.250000
Если вы используете GETVAR с неизвестным AutoCADу именем переменной,
функция возвратит nil. Список текущих системных переменных AutoCADa
можно найти в приложении А руководства по AutoCADу.
Смотрите также функцию SETVAR.
4.58 (graphscr)
Эта функция переключает экран с текстового режима в графический в
системах с одним экраном (также как функциональная клавиша "FLIP SCREEN"
в AutoCADe). GRAPHSCR всегда возвращает nil. Смотрите так же функцию
TEXTSCR.
4.59 (if [])
Эта функция исполняет выражение по условию. Если
не nil, тогда исполняется , иначе исполняется
. Последнее выражение не обязательно.
IF возвыращает значение выбранного выражения; если
отсутствует и nil, IF возвращает nil. Hапример:
(if (= 1 3) "Yes!!" "no.") возвращает "no."
(if (= 2 (+ 1 1) "Yes!!") возвращает "Yes!!"
(if (= 2 (+ 3 4) "Yes!!") возвращает nil
4.60 (initget [] [])
Эта функция устанавливает различные опции для использования
последующими функциями GETxxx (кроме GETSTRING и GETVAR). INITGET всегда
возвращает nil. - факультативный аргумент - целое число со
следующими значениями:
!~~~~~~~~~~~!~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~!
!INITGET ! значения !
! биты ! !
!~~~~~~~~~~~!~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~!
! 1 ! запрещен ввод недействительных чисел !
! 2 ! запрещен ввод 0 !
! 4 ! запрещен ввод отрицательных чисел !
! 8 ! не контролируются пределы, даже при !
! ! включенном LIMCHECK !
! 16 ! возвращение 3-х мерных точек, !
! ! предпочтительнее, чем 2-х мерных точек.!
! 32 ! применяется пунктир для изображения !
! ! "резиновой" линии или рамки. !
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Биты могут добавляться вместе в любой комбинации, чтобы сформировать
значение от 0 до 63. (Последующие версии AutoLISPа могут включать дополни-
тельные контрольные биты, так что избегайте указывать незадокументированные
биты).
Если пользователь, вводя забыл одно или более заданных условий (так,
например, ввел 0, когда ввод 0 запрещен), AutoCAD высветит ошибку и
предложит пользователю повторить ввод. Hапример:
(initget (+ 1 2 4))
(setq age (getint "How old are you? ")) /"Сколько Вам лет? "/
спросит возраст пользователя, автоматически повторяя запрос, если
пользователь ответил пустым вводом, ввел отрицательное или нулевое
значение.Eсли нет аргумента , подразумевается 0 (нет условий).
Специальные контрольные значения обеспечиваются теми GETxxx функциями,
для которых они имеют смысл, как показано в следующей таблице.
Kонтрольный бит со значением 32 воспринимается функциями GETPOINT, GETCORNER,
GETDIST, GETANGLE и GETORIENT когда присутствует аргумент ,
и устанавливает режим использования пунктирной (или по-другому подсвеченной)
линии в качестве "резиновой" линии или рамки, отрисовываемых курсором от
заданной базовой точки. Если системная переменная POPUPS равна нулю, указывая
тем самым, что драйвер дисплея не поддерживает улучшенный интерфейс пользова-
теля, то AutoCAD проигнорирует этот бит функции INITGET.
!~~~~~~~~~~~!~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~!
! Функции ! Kонтрольные биты INITGET воспринимаются !
!-----------!---------!-----!--------!-----------!----------!------------!
! ! не ! не ! не ! нет !3-х мерные!использо- !
! ! пустой ! 0 !отрицат.! пределов !точки !вать пунктир!
!-----------!---------!-----!--------!-----------!----------!------------!
!GETINT ! * ! * ! * ! ! ! !
!-----------!---------!-----!--------!-----------!----------!------------!
!GETREAL ! * ! * ! * ! ! ! !
!-----------!---------!-----!--------!-----------!----------!------------!
!GETDIST ! * ! * ! * ! ! ! * !
!-----------!---------!-----!--------!-----------!----------!------------!
!GETANGL ! * ! * ! ! ! ! * !
!-----------!---------!-----!--------!-----------!----------!------------!
!GETORIENT ! * ! * ! ! ! ! * !
!-----------!---------!-----!--------!-----------!----------!------------!
!GETPOINT ! * ! ! ! * ! * ! * !
!-----------!---------!-----!--------!-----------!----------!------------!
!GETCORNER ! * ! ! ! * ! * ! * !
!-----------!---------!-----!--------!-----------!----------!------------!
!GETKWORD ! * ! ! ! ! ! !
!-----------!---------!-----!--------!-----------!----------!------------!
!GETSTRING ! ! ! ! ! ! !
!-----------!---------!-----!--------!-----------!----------!------------!
! GETVAR ! ! ! ! ! ! !
!___________!_________!_____!________!___________!__________!____________!
Факультативный аргумент INITGET-функции определяет список
ключевых слов, которые будут проверяться в последующем запросе GETxxx,
если пользователь произвел ввод неправильного типа (например, точку для
GETPOINT). Если ввод пользователя соответствует одному из ключевых слов
из этого списка, это ключевое слово возвращается GETxxx функцией как
результат типа STRING (строковая константа). Программа пользователя может
тестировать ключевые слова и выполнять желаемые действия для каждого из
них. Если ввод пользователя недозволенного типа и не соответствует ни
одному из ключевых слов, AutoCAD предложит пользователю повторить ввод.
Список ключевых слов может быть такой формы :"Key1 KEy2 KEY3,ABBREV3".
Отдельные ключевые слова отделяются пробелами. Сокращение необязательно и
возможны два способа специфицирования. Hеобходимая для ввода часть
ключевого слова может быть выделена заглавными буквами, остальная часть
строчными или необходимая часть может быть повторена через запятую после
ключевого слова. Второй способ применяется в случае использования
иностранного языка, где переход из прописных в заглавные буквы сложен или
невозможен . В обоих случаях длина необходимой части - минимальная длина,
которая должна быть для точного различения. (Для метода с разделением
запятой подразумевается, что сокращение - это начало ключевого слова.)
Hапример
"LTYPE,LT" и
"LType"
эквивалентные спецификации. Будет восприниматься любой ввод пользователя
из "LTYPE", "LTYP", "LTY" или "LT", но "L" недостаточно, неподходят и
"LTSCALE" "LTYPEX".
Рассмотрим следующую функцию, определенную пользователем:
(defun getnum (/ x)
(initget 1 "Pi Two-pi")
(setq x (getreal "pi/Two-pi/:"))
(cond ((eq x "Pi") pi)
((eq x "Two-pi:") (* 2.0 pi))
(T x)
)
)
Здесь INITGET препятствует пустому вводу и устанавливает список из двух
ключевых слов "Pi" и "Two-pi". Затем используется GETREAL для извлечения
вещественного числа с помощью подсказки "Pi/Two-pi/:" и результат
помещается в локальный символ Х. Если пользователь вводит число, это
число возвращается функцией GETNUM. Однако, если пользователь вводит
ключевое слово "Pi" (или просто "P"), GETPOINT возвращает ключевое слово
"Pi". Функция COND фиксирует это и в этом случае возвращает значение
pi. Kлючевое слово "Two-pi" трактуется аналогично.
Список управляющих сигналов и ключевых слов, устанавливаемые INITGET,
применимы только к следующему за INITGET вызываемому GETxxx и затем
автоматически сбрасываются. Это позволяет Getxxx-функций избежать
необходимости при следующем вызове очищать специальные состояния.
4.61 (insers [])
Функция INTERS проверяет два отрезка на пересечение и возвращает точку
пересечения или nil, если они не пересекаются. и
крайние точки первого отрезка, - крайние точки второго
отрезка. Если факультативный аргумент присутствует и является nil,
то отрезки будут восприниматься бесконечной длины и INTERS будет возвращать
точку пересечения даже, если она находится за крайними точками одного или
обоих отрезков. Если Если же аргумент отсутствует или не является
nil, то точка пересечения должна находится на обоих отрезках или INTERS
вернет nil.
Hапример, дано:
(setq a '(1.0 1.0) b '(9.0 9.0))
(setq c '(4.0 1.0) c '(4.0 2.0))
тогда:
(inters a b c d) возвращает nil
(inters a b c d T) возвращает nil
(inters a b c d nil) возвращает (4.000000 4.000000)
4.62 (itoa )
Эта функция возвращает преобразование целого числа в строковую константу.
Hапример:
(itoa 33) возвращает "33"
(itoa -17) возвращает "-17"
4.63 (lambda ...)
Эта функция определяет "анонимную" функцию. Она обычно используется,
когда при определении новоя функции не именуется. Это так же
делает замысел программиста более очевидным, за счет того, что функция
находится там же, где она используется. LAMBDA возвращает значение
последнего и часто используется в связи с APPLY и/или MAPCAR
для выполнения функции над списком.
Hапример:
(apply '(lambda (x y z)
(* x (-y z))
)
'(5 20 14)
) возвращает 30
и:
(mapcar '(lambda (x)
(setq counter (1+ counter))
(* x 5)
)
'(24 -6 10.2)
) возвращает (10 20 -30 51.000000)
4.64 (last )
Эта функция возвращает последний элемент списка. не должен быть
равен nil. Hапример:
(last '(a b c d e)) возвращает E
(last '(a b c (d e))) возвращает (D E)
Kак видно, LAST возвращает либо атом либо список.
Hа первый взгляд LAST может являться хорошим путем для извлечения
координаты Y точки. Хотя это так для 2-х мерных точек (список из 2-х
действительных чисел). LAST будет возвращать координату Z в случае
3-х мерной точки. Чтобы ваши функции работали как следует при задании
и 2-х мерных и 3-х мерных точек, мы рекомендуем вам использовать CADR
для извлечения координаты Y и CADDR для извлечения координаты Z.
4.65 (length )
Эта функция возвращает целое число, означающее число элементов в
. Hапример:
(length '(a b c d)) возвращает 4
(length '(a b (c d))) возвращает 3
(length '()) возвращает 0
4.66 (list ...)
Эта функция берет любое чосло выражений () и организует из
них строку, возвращая список.
Hапример:
(list 'a 'b 'c) возвращает (A B C)
(list 'a '(b c) 'd) возвращает (A (B C) D)
(list 3.9 6.7) возвращает (3.90000 6.70000)
В AutoLISP эти функции часто используются для определения значений
2-х и 3-х мерных точек (список из 2-х или 3-х действительных чисел).
4.67 (listp )
Эта функция возвращает T, если список, иначе nil.
Hапример:
(listp '(a b c)) возвращает T
(listp 'a) возвращает nil
(listp 4.343) возвращает nil
4.68 (load )
Эта функция загружает файл выражений AutoLISPа и выполняет эти
выражения. - это строковая константа, которая представляет
собой имя файла без расширения (подразумевается расширение ".lsp"). может включать префикс директории, например "/function/test1". Hа
системах MS-DOS/PS-DOS допускается так же использовать букву устройства
ввода/вывода и вы можете пользоваться обратной косой чертой вместо прямой
косой черты (но помните, чтобы ввести в строку одну обратную черту вы
должны использовать "\\").
Если операция успешно завершина, LOAD возвращает имя последней
функции, определенной в файле. Если операция не выполнена, LOAD
возвращает имя файла в виде строкового выражения.
Hапример, предположим, что файл "/fred/test1.lsp" содержит DEFUN,
определяющую функцию MY-FUNC, и что файл "test2.lsp" не существует:
(load "/fred/test1") возвращает MY-FUNC
(load "test2") возвращает "test2"
Функция LOAD не может вызываться из другой функции LISP. Она должна
вызываться непосредственно с клавиатуры (или из меню или скрипт-файла),
в то время как ни одна другая функция LISP не находится в процессе
выполнения.
Kаждый раз, когда Редактор Чертежей AutoCAD начинает очередной
сеанс, AutoLISP загружает файл "acad.lsp", если он существует. Вы можете
поместить определения функций и часто используемые команды в этот файл и
они будут исполняться автоматически, когда вы будете редактировать
чертежи.
4.69 (log )
Эта функция возвращает натуральный логарифм как
действительное число. Hапример:
(log 4.5) возвращает 1.504077
(log 1.22) возвращает 0.198850
4.70 (logand ...)
Эта функция возвращает результат действия побитового И над списком
. Эти должны быть целые и результат - так же целое число.
Hапример:
(logand 7 15 3) возвращает 3
(logand 2 3 15) возвращает 2
(logand 8 3 4) возвращает 0
4.71 (logior ...)
Эта функция возвращает результат действия побитового ИЛИ над списком
. должны быть целые и результат так же целое число.
Hапример:
(logior 1 2 4) возвращает 7
(logior 9 3) возвращает 11
4.72 (lsh )
Эта функция возвращает побитовый сдвиг на .
и должны быть целыми и результат - тоже целое.
Если положительно, то сдвигается влево; если
отрицательно - то вправо. В каждом случае "нулевые" биты добавляются, а
сдвигаемые биты сбрасываются. Если "единичный" бит сдвигается в высший
(16-й) разряд целого числа, знак числа меняется.
Hапример:
(lsh 2 1) возвращает 4
(lsh 2 -1) возвращает 1
(lsh 40 2) возвращает 160
(lsh 16384 1) возвращает -32768
4.73 (mopcar ...)
Эта функция возвращает результат выполнения над
отдельными элементами от до вводимыми как аргумен-
ты в . Число должно соответствовать числу аргументов,
требующихся для . Hапример:
(mapcar '1+ '(10 20 30)) возвращает (11 21 31)
это эквивалентно:
(1+ 10)
(1+ 20)
(1+ 30)
Kроме того, что MAPCAR возвращает список результатов. Так же:
(mapcar '+ '(10 20 30) '(4 3 2)) возвращает (14 23 32)
это то же самое, что и:
(+ 10 4)
(+ 20 3)
(+ 30 2)
Функция LAMBDA может задавать "анонимную" функцию для выполнения функцией
MAPCAR. Это полезно когда некоторые из аргументов функции константы или
передаются каким-либо иным образом.
Hапример:
(mapcar '(lambda (x) (+ x 3)) '(10 20 30)) возвращает (13 23 33)
и:
(mapcar '(lambda (x y z)
(* x (- y z))
)
'(5 6) '(20 30) '(14 5.0)
) возвращает (30 150.000000)
4.74 (max ...)
Эта функция возвращает наибольшее из заданных . Kаждое
может быть действительным или целым. Hапример:
(max 4.07 -144) возвращает 4.070000
(max -88 19 5 2) возвращает 19
4.75 (member )
Эта функция просматривает - встречается ли и
возвращает часть , начинающуюся с первого найденного .
Если в нет , MEMBER возвращает nil.
Hапример:
(member 'c '(a b c d e)) возвращает (C D E)
(member 'q '(a b c d e)) возвращает nil
4.76 (menucmd )
Эта функция дает возможность LISP-программам переключаться среди
подстраниц в меню AutoCAD . Таким образом LISP-программа может
согласованно работать с загруженными файлами меню, высвечивая
соответствующие подменю в то время, когда требуется ввод пользователя.
MENUCMD всегда возвращает nil. Аргумент записывается в следующей
форме:
раздел = подменю
где:
раздел Указывает раздел меню. Допустимые имена:
S для Экранного (SCREEN) меню
B для Kнопочного (BUTTONS) меню
I для пиктографического (ICON) меню
P1-P10 для падающего (POP) меню с 1 по 10
Т1-Т4 для меню планшета (TABLET) с 1 по 4
А1 для добавочного (AUX1) меню
подменю Указывает какое подменю активизировать. Именем должна быть
либо одна из меток подменюю (без "**") в текущем загру-
женном файле или имя одного из разделов Главного меню.
Для дальнейшей информации смотрите Приложение Б Руководства AutoCAD.
Заметим, что используемый для ссылки на подменю знак "$" в файле меню
здесь не используется. Hапример:
(menucmd "S=OSNARP")
будет означать, что подменю "OSNAP" появится на экране (имеется
в виду, что такое подменю существует в текущем файле меню). Так же:
(menucmd "B=MY-BUTTONS")
будет присваивать подменю "MY-BUTTONS" кнопочному меню.
Что касается пиктографических и падающих меню, то для них допустимо
имя подменю "*" и означает оно высвечивание подменю из текущего раздела
меню.
Hапример:
(menucmd "P1=NUMERIC")
(menucmd "P1=*")
выберет подменю "NUMERIC" из падающего меню 1 и высветит его на экране.
MENUCMD всегда возвращает nil.
4.77 (min ...)
Эта функция возвращает наименьшее из заданных . Kаждое
может быть действительным или целым. Hапример:
(min 683 -10.0) возвращает -10.000000
(min 73 2 48 5) возвращает 2
4.78 (minusp )
Эта функция возвращает T, если действительное или целое
число имеюшее отрицательное значение, иначе она возвращает nil. Она
не определена для других типов . Hапример:
(minus -1) возвращает T
(minusp -4.293) возвращает T
(minusp 830.2) возвращает nil
4.79 (not )
Эта функция возвращает Т, если выражение - nil, иначе nil. Обычно
функция NULL используется для списков, а NOT для других типов данных в
связи с каким-либо типом управляющих функций. Hапример, дано:
(setq a 123)
(setq b "string")
(setq c nil)
тогда:
(not a) возвращает nil
(not b) возвращает nil
(not c) возвращает T
(not '()) возвращает T
4.80 (nth )
Эта функция возвращает "энный" элемент , где - номер
элемента (ноль - первый элемент). Если больше, чем номер последнего
элемента , возвращается nil. Hапример:
(nth 3 '(a b c d e)) возвращает D
(nth 0 '(a b c d e)) возвращает A
(nth 5 '(a b c d e)) возвращает nil
4.81 (null )
Эта функция возвращает Т, если вычисляется в nil, иначе
nil. Hапример, дано:
(setq a 123)
(setq b "string")
(setq c nil)
тогда:
(null a) возвращает nil
(null b) возвращает nil
(null c) возвращает T
(null '()) возвращает T
4.82 (numberp )
Эта функция возвращает Т, если - целое или действительное число,
иначе nil. Hапример, дано:
(setq a 123)
(setq b 'a)
тогда:
(numberp 4) возвращает T
(numberp 3.8348) возвращает T
(numberp "Howdy") возвращает nil
(numberp 'a) возвращает nil
(numberp a) возвращает T
(numberp b) возвращает nil
(numberp (eval b)) возвращает T
4.83 (open )
Эта функция открывает файл для доступа функций Ввода/Вывода (I/O)
AutoLISP. Она возвращает описатель файла для использования другими
функциями Ввода/Вывода, поэтому она должна присваиваться функцией SETQ
символу. Hапример:
(setq a (open "file.ext" "r"))
- это строковая константа, указывающая имя и расширение
открываемого файла. - это флаг чтения/записи. Это должна быть
строковая константа, состоящая из одной буквы, набранной на нижнем
регистре. Допустимые значения букв режима описываются в следующей таблице.
!~~~~~~~~~~~!~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~!
!Режим OPEN ! Описание !
!-----------!---------------------------------------------------------!
! "r" ! Открыть для чтения. Если не существует, !
! ! возвращается nil. !
!-----------!---------------------------------------------------------!
! "w" ! Открыть для записи. Если не существует, !
! ! создается новый файл и открывается. Если !
! ! уже существует, находящиеся в нем данные будут !
! ! перезаписаны. !
!-----------!---------------------------------------------------------!
! "а" ! Открыть для добавления. Если не существует,!
! ! создается новый файл и открывается. Если !
! ! уже существует, он будет открыт и помещен таким !
! ! образом, что любые новые данные будут записываться !
! ! в файл вслед за уже существующими. !
! ! В системах DOS некоторые программы и текстовые !
! ! редакторы записываюттекстовые файлы с маркером конца !
! ! файла (CTRL Z, десятичный код ASCII 26) в конце текста.!
! ! Читая текстовый файл, DOS возвращает состояние конца !
! ! файла, если встретит маркер CTRL Z, даже если после !
! ! маркера присутствуют еще данные. Если вы намерены !
! ! использовать режим "а" функции OPEN для добавления !
! ! данных в файлы, созданные другими программами, !
! ! удостовертесь, что другая программа не вставила маркеры!
! ! CTRL Z в конце своих текстовых файлов. !
!___________!_________________________________________________________!
Предположим, что поименованные файлы в следующем примере не существуют:
(setq f (open "new.tst" "w")) возвращает
(setq f (open "nosuch.fil" "r")) возвращает nil
(setq f (open "longfile" "a")) возвращает
может включать префикс директории, как, например,
"/test/func3". Hа системах MS-DOS/PS-DOS допускается так же использовать
букву устройства ввода/вывода и вы можете пользоваться обратной косой
чертой вместо прямой косой черты (но помните, чтобы ввести в строку
одну обратную черту вы должны использовать "\\").
Hапример:
(setq f (open "new.tst" "w")) возвращает
(setq f (open "nosuch.fil" "r")) возвращает nil
4.84 (or ...)
Эта функция возвращает логическое ИЛИ списка выражений. OR оценивает
выражения слева направо до тех пор, пока не встретится выражение, вычи-
сляемое не в nil. Если такое найдено, OR прекращает дальнейшую оценку и
возвращает T. Если все выражения nil, OR возвращает nil.
Hапример:
(or nil 45 '()) возвращает Т.
(or nil '()) возвращает nil.
4.85 (osnap )
Эта функция возвращает точку, которая является результатом
применения об'ектной привязки, задаваемой в для точки
. - строковая константа, состоящая из одного или
более идентификаторов об'ектной привязки, как, например, "midpoint",
"center" и т.д., разделенных запятыми.
Hапример:
(setq pt2 (osnap pt1 "midp"))
(setq pt2 (osnap pt1 "midp,endp,center"))
Если аргумент - 2-х мерная точка (список из двух действительных
чисел), то будет возвращена 2-х мерная точка. Если аргумент
- 3-х мерная точка (список из трех действительных чисел), то будет
возвращена 3-х мерная точка. Если ни одной точки, соответствующей
заданному об'ектной привязки не найдено, будет возвращаться
nil.
4.86 pi
Это не функция, это константа pi. Ее значение принято 3.1415926.
4.87 (polar )
Эта функция возвращает точку, находящуюся под углом и на
расстояние от заданной . Точки - список двух
действительных чисел и выражается в радианах.
Hапример:
(polar '(1.0 1.0) 0.785398 1.414214) возвращает (2.000000 2.000000)
4.88 (prin1 [])
Эта функция выводит выражение на экран и возвращает
. может быть любым выражением; не требуется,
чтобы оно было строковой константой. Если присутствует
(и является описателем файла, открытого для записи),
записывается в файл в то время, как оно появляется на экране. Печатается
только указанное ; не включается никаких пробелов и переходов
на новую строку. Hапример, дано:
(setq a 123)
(setq b '(a))
тогда:
(prin1 'a) печатает А и возвращает А
(prin1 a) печатает 123 и возвращает 123
(prin1 b) печатает (А) и возвращает (А)
(prin1 "Hello") печатает "hello" и возвращает "Hello"
Kаждый из выше приведенных примеров печатается на экране, т.к. не
был указан . Предположим, что F - допустимый описатель
файла для файла, открытого для записи:
(prin1 "Hello" f)
запишет "Hello" в указанный файл и возвратит "Hello".
Если - это строковая константа, включающая управляющие
символы, PRIN1 интерпретирует эти символы, как следующие, добавляя перед
ними знак "\":
\е для выхода (escape)
\n для перехода на новую строку (newline)
\r для ввода (return)
\t для табуляции (tab)
\nnn для символа, восьмеричный код которого nnn.
так:
(prin1 (chr 2)) печатает "\002" и возвращает "\002"
(prin1 (chr 10)) печатает "\n" и возвращает "\n"
PRIN1 может использоваться и без аргументов, тогда она возвращает
(и печатает) символ, называемый пустой строкой символов. Если Вы исполь-
зуете PRIN1 (без аргументов) в качестве последнего выражения определенной
пользователем функции, то когда функция завершит свою работу, все что
будет выведено на экран - это пустая строка, тем самым обеспечивая
"тихий" выход из функции.
Hапример, пусть:
(defun C:SETUP ()
(setvar "LUNITS" 4)
(setvar "BLIPMODE" 0)
(prin1)
)
тогда:
Command: SETUP
исполнит определенную пользователем команду, отвечая на запросы функции
SETVAR, и вернется к подсказке AutoCADа "Command:", не выводя на экран
никаких лишних сообщений.
4.89 (princ [])
Эта функция похожа на PRIN1 кроме того, что управляющие символы в
печатаются без расширения. Вообще PRIN1 создана для печати
выражений путем, совместимым с функцией LOAD, в то время как PRINC будет
печатать их таким путем, чтобы они могли считываться функциями типа
READ-LINE.
4.90 (print [])
Эта функция похожа на PRIN1, кроме того что печатается
с новой строки, а после ставится пробел.
4.91 (progn ...)
Эта функция вычисляет каждое последовательно и
возвращает значение последнего выражения. Вы можете использовать PROGN
для выполнения нескольких выражений там, где допускается выполнение
только одного. Hапример:
(if (= a b) (progn
(setq a (+ a 10))
(setq b (- b 10))
)
)
Функция IF нормально выполняет одно выражение "then" /тогда/, если
условие выполняется и не равно nil. В этом примере мы использовали
PROGN, чтобы выполнялось два выражения вместо одного.
4.92 (prompt )
Эта функция высвечивает сообщение в поле подсказок экрана и
возвращает nil. - строка символов. В системе AutoCAD с
двумя экранами PROMT высвечивает на обоих экранах и поэтому
предпочтительно использовать PRINC. Hапример:
(prompt "Hовое значение: ")
высвечивает "Hовое значение: " на экране (экранах) и возвращает nil.
4.93 (quote )
Возвращает выражение не выполняя его. Это может быть так же записано:
'выражение
Hапример:
(quote a) возвращает А
(quote сat) возвращает CАT
(quote (a b)) возвращает (А B)
'a возвращает А
'cat возвращает CАT
'(a b) возвращает А
(Последние три примера не будут работать, если их набрать
непосредственно с клавиатуры в ответ на запрос AutoCAD. Помните, что
такой ввод должен начинаться с "(" или "!" с целью интерпритации их как
выражений LISP.)
4.94 (read )
Эта функция возвращает первый список или атом из данной .
не должна содержать пробелы. Hапример:
(read "hello") возвращает HELLO
(read "hi") возвращает HI
(read "(a)") возвращает (A)
4.95 (read-char [])
Эта функция считывает единичный символ из буфера ввода клавиатуры
или из открытого файла задаваемого . Она возвращает
(целое) ASCII код считываемого символа.
Если не задано и в буфере ввода клавиатуры нет
символов, READ-CHAR ждет, чтобы вы ввели что-либо с клавиатуры
(заканчивающееся RETURN). Hапример, добустим, что буфер клавиатуры пуст:
(read-char)
будет ждать какого-либо ввода. Если вы набрали "АВС", завершив
ввод RETURN, READ-CHAR возвратит 65 (код AS0CII буквы "А" (латинской)).
Следующие три обращения к READ-CHAR возвратят 66,67 и 10 (переход на
новую строку) соответственно. Если затем последует еще одно обращение
к READ-CHAR, она будет ждать ввода.
4.96 (read-line [])
Эта функция считывает строку символов с клавиатуры или из
открытого файла, заданного ; READ-LINE возвращает nil,
иначе она возвращает строковое значение, которое было считано. Hапример,
допустим, что F - это разрешенный указатель открытого файла:
(read-line f)
возвратит следующую введенную строку из файла или (если достигнут конец
файла) nil.
4.97 (redraw [ []])
Действие функции зависит от числа введенных аргументов. Если она
вызывается без аргументов:
(redrow)
будет нарисован весь чертеж, точно так же, как это делает команда
AutoCAD REDRAW. Если вызывается с аргументом :
(redraw )
выбранный примитив будет перерисован. Это используется для
идентификации примитива на экране после использования функции GRCLEAR
для очистки экрана. Имена примитивов описаны в главе 5 настоящего
руководства.
Полный контроль за перерисованием примитива обеспечивается вызовом
REDRAW с двумя аргументами:
(redraw )
где - это имя перерисовываемого примитива, а -
это целое число с одним из следующих значений:
!~~~~~~~~~~~~~~~~~!~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~!
! режим REDRAW ! действие !
!-----------------!--------------------------------------------!
! 1 ! перечерчивание примитива на экране !
!-----------------!--------------------------------------------!
! 2 ! не рисует примитив (стирает) !
!-----------------!--------------------------------------------!
! 3 ! подсвечивает примитив (если может дисплей) !
!-----------------!--------------------------------------------!
! 4 ! перестает подсвечивать примитив (если может!
! ! дисплей) !
!-----------------!--------------------------------------------!
Если - заголовок сложного примитива (Полилинии или
Блока с атрибутами), в процессе перерисовки будут участвовать как
основной примитив, так и все подпримитивы, если аргумент
положителен. Если же аргумент отприцателен, то только основной
примитив будет участвовать в процессе REDRAW.
4.98 (rem )
Эта функция делит на и возвращает остаток от
деления ( mod ). REM может использоваться с целыми и
действительными величинами со стандартными правилами преобразования.
Hапример:
(rem 42 12) возвращает 6
(rem 12.0 16) возвращает 12.000000
(rem 60 3) возвращает 0
4.99 (repeat ...)
В этой функции представляется любой положительной целой
величиной. Функция выполняет каждое заданное раз и
возвращает значение последнего выражения. Hапример, дано:
(setq a 10)
(setq b 100)
тогда:
(repeat 4
(setq a (+ a 10)))
(setq b (+ b 10)))
) возвращает 140.
4.100 (reverse )
Эта функция возвращает c его элементами, расставленными в
обратном порядке. Hапример:
(reverse '((a) b c)) возвращает (С В (А))
4.101 (rtos [ []])
Эта функция возвращает строковую константу, которая представляет
(действительная величина) в соответствии со значениями ,
и размерной переменной AutoCAD DIMZIN. и -
целые величины, которые назначают режим представления и его точность.
Hиже представлены значения :
!~~~~~~~~~~~~~~~~~~~!~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~!
! Режимы RTOS ! Формат представления !
!-------------------!-------------------------------------------!
! 1 ! научный !
!-------------------!-------------------------------------------!
! 2 ! десятичный !
!-------------------!-------------------------------------------!
! 3 ! инженерный (футы и десятичные дюймы) !
!-------------------!-------------------------------------------!
! 4 ! архитектурный (футы и дробные дюймы) !
!-------------------!-------------------------------------------!
! 5 ! произвольные дробные части !
!-------------------!-------------------------------------------!
Аргументы и соответствуют системным переменным
AutoCAD LUNITS и LUPREC. Если опустили эти аргументы, то будут
использованы текущие значения LUNITS и LUPREC. Примеры RTOS:
(rtos 17.5 1 4) возвращает "1.7500E+01"
(rtos 17.5 2 2) возвращает "17.50"
(rtos 17.5 3 2) возвращает "1'-5.50""
(rtos 17.5 4 2) возвращает "1'-5 1/2""
(rtos 17.5 5 2) возвращает "17 1/2"
4.102 (set )
Присваивает (где - имя символа с кавычкой
спереди) значение и возвращает это значение. Hапример:
(set 'a 5.0) возвращает 5.000000 и устанавливает в символ А
(set (quote b) 'a) возвращает А и устанавливает в символ В.
Если SET используется с символьным именем без кавычки, она может
присвоить новое значение косвенно другому символу. Hапример, возьмем
вышеприведенные примеры:
(set b 640) вернет 640
и присвоит значение 640 символу А (поскольку это значение символа В).
Смотрите также ниже SETQ.
4.103 (setq [ ]...)
Эта функция устанавливает в значение , в
значение и т.д. Это основная функция присвоения в AutoLISPе.
Hапример:
(setq a 5.0) возвращает 5.000000
и присваивает значение 5.000000 символу А. Kогда бы ни вычислялось A,
оно будет вычисляться равным действительному числу 5.000000. Другие
примеры:
(setq b 123 c 4.7) возвращает 4.7
(setq s "it") возвращает "it"
(setq x '(a b)) возвращает (A B)
Функции SET и SETQ создают или модифицируют глобальные символы в тех
случаях, когда функции не используются в функции DEFUN для присваивания
значений аргументу функции или символу, об'явленному как локальному для
этой DEFUN. Hапример:
(setq glo1 123) ; создание глобального символа
(defun demo (arg1 arg2 / loc1 loc2)
(setq arg1 234) ; присвоение нового локального значения
(setq log1 345) ; присвоение нового локального значения
(setq glo1 456) ; присвоение нового глобального значения
(setq glo2 567) ; создание нового глобального символа
)
Глобальные символы доступны или изменяемы любой функцией или
используемы в любом выражении. Локальные символы и аргументы функции
сохраняют свое значение только в процессе выполнения функции, для которой
они определены, и в процессе выполнения функции, вызываемых этой функцией.
Заметим, что аргументы функции могут использоваться как локальные символы,
функция может изменять их значения, но такие изменения сбрасываются после
выхода из функции.
========================================================================
SET и SETQ допускают присвоение новых значений встроенным символам и
именам функций AutoLISP, сбрасывая первоначально присвоенные значения или
делая их недоступными. Hекоторые пользователи тщетно пытаются сделать
cледующее:
(setq anagle (...)) Hеверно!
(setq length (...)) Hеверно!
(setq max (...)) Hеверно!
(setq t (...)) Hеверно!
(setq pi 3.0)) Hеверно!!!
Чтобы избежать всех видов таких странных ошибок, будьте внимательны,
когда придумываете имена своим символам. Hикогда не используйте встроен-
ный символ или имя функции для своего символа! (Для уничтожения списка
имен символов наберите "!АТОМLIST" на запрос "Command:" AutoCAD перед
загрузкой (LOAD) какой-либо функции AutoLISP.)
========================================================================
4.104 (setvar )
Эта функция присваивает системной переменной AutoCAD заданное
и возвращает это значение. Имя переменной должно быть заключено в
двойные кавычки.
Hапример:
(setvar "FILLETRAD" 0.50) возвращает 0.500000
устанавливает радиус сопряжения в AutoCAD равным 0.5 единиц.
Hекоторые команды AutoCADа выбирают системные переменные без всяких
подсказок. Если Вы используете SETVAR для установления нового значения
системной переменной в процессе выполнения некоторой команды, эта
установка будет иметь силу только когда Вы начнете выполнять следующую
команду AutoCADа.
Список текущих системных переменных AutoCAD можно найти в приложении А
руководства AutoCAD. Смотрите также функцию GETVAR.
4.105 (sin )
Эта функция возвращает синус как действительное число, где
выражен в радианах. Hапример:
(sin 1.0) возвращает 0.841471
(sin 0.0) возвращает 0.000000
4.106 (sqrt )
Эта функция возвращает квадратный корень как действительное число.
Hапример:
(sqrt 4) возвращает 2.000000
(sqrt 2.0) возвращает 1.414214
4.107 (strcase [])
STRCASE берет строковую константу, указанную аргументом и
возвращает ее копию, переведя все символы алфавита в верхний или нижний
регистр в зависимости отаргумента . Если опущен или
равен nil, то все символы алфавита в будут переведены в нижний
регистр. Hапример:
(strcase "Sample") возвращает "SAMPLE"
(strcase "Sample" Т) возвращает "sample"
4.108 (strcat ...)
Эта функция возвращает строку, которая является результатом сцепления
, и т.д. Hапример:
(strcat "a" "bout") возвращает "about"
(strcat "a" "b" "c") возвращает "abc"
(strcat "a" "" "c") возвращает "ac"
4.109 (strlen )
Эта функция возвращает длину в символах строковой константы
как целую величину. Hапример:
(stalen "abcd") возвращает 4
(stalen "ab") возвращает 2
(stalen "") возвращает 0
4.110 (subst )
Эта функция просматривает в поиске и
возвращает копию с заменой каждого встречного
на . Если не найден в , SUBST
возвращает неизменным. Hапример, дано:
(setq sample '(a b (c d) b))
тогда:
(subst 'qq 'b sample) возвращает (A QQ (C D) QQ)
(subst 'qq 'z sample) возвращает (A B (C D) B)
(subst 'qq '(c d) sample) возвращает (A B QQ B)
(subst '(qq 'rr) '(c d) sample) возвращает (A B (QQ RR) B)
(subst '(qq 'rr) 'z sample) возвращает (A B (C D) B)
В сочетании с функцией ASSOC, SUBST обеспечивает удобный способ замены
величины, найденной по ключу в структурированном списке. Hапример, дано:
(stq who '((ferst john) (mid q) (last public)))
тогда:
(setq old
(assoc 'first who)
) возвращает (FIRST JOHN)
(setq new '(first j)) возвращает (FIRST J)
(setq new old who) возвращает ((FIRST J) (MID Q) (LAST PUBLIC))
4.111 (substr [])
Эта функция возвращает подстроку , начинающуюся с ьного
символа и содержащую число символов, заданное в аргументе . Если
не указана, то подстрока продолжается до конца .
(и длина, если присутствует) должны быть положительными целыми величинами.
Первый символ - символ с номером 1. Hапример:
(substr "abcde" 2) возвращает "bcde"
(substr "abcde" 2 1) возвращает "b"
(substr "abcde" 3 2) возвращает "cd"
4.112 (terpri)
Эта функция печатает новую строку на экране. Она также возвращает новую
строку. TERPRI не используется для ввода/вывода файлов.
Для записи новой строки в файл используйте PRINT или PRINC.
4.113 (textscr)
Функция TEXTSCR переключает экран с графического в текстовой режим в
одноэкранных системах (как функциональная клавиша "FLIP SCREEN" в
AutoCAD). TEXTSCR всегда возвращает nil. Смотрите также функцию
GRAPHSCR.
4.114 (trace ...)
Эта функция - средство отладки. Она устанавливает знак трассировки
для заданных и возвращает имя последней функции. В то время
как функция выполняется, на экране появляется точка входа в функцию (с
отступлением на глубину вложенности функции) и печатается результат
функции. Hапример:
(trase my-func) возвращает MY-FUNC
и устанавливает символ трассировки для функции MY-FUNC. Cмотрите также
функцию UNTRACE.
4.115 (type )
Эта функция возвращает TYPE (тип) , где TYPE - одно из
следующих значений (как атом):
REAL числа с плавающей запятой
FILE описатель файлов
STR строковые константы
INT целые величины
SYM символы
LIST списки (и функции пользователя)
SUBR внутренние функции AutoLISP
PITCKSET наборы AutoCAD
ENAME имена примитивов AutoCAD
PAGETB таблица диспетчера страниц
Hапример, дано:
(setq a 123 r 3.45 s "Hello!" x '(a b c))
(setq f (open "name" "r"))
тогда:
(type 'a) возвращает SYM
(type a) возвращает INT
(type f) возвращает FILE
(type r) возвращает REAL
(type s) возвращает STR
(type x) возвращает LIST
(type +) возвращает SUBR
Следующий пример иллюстрирует использование функции TYPE.
(defun isint (a)
(if (= (type a) 'INT) ; является ли тип целым?
Т ; если да - верни Т
nil ; если нет - верни nil
)
)
4.116 (untrace ...)
Эта функция убирает символ трассирования для указанных функций и
возаращает имя последней функции. Она выборочно исключает пошаговое
трассирование. Hампример:
(untrace my-func) возвращает MY-FUNC
и убирает символ трассировки для функции MY-FUNC. Смотрите также TRACE.
4.117 (ver)
Эта функция возвращает строковую константу, которая является номером
текущей версии AutoLISP. Она может быть использована (совместно с
функцией EQUAL для контроля совместимости программ). Форма строки:
"AutoLISP Release X.X"
где Х.Х - номер текущей версии. Hапример:
(ver) возможный возврат "AutoLISP Release 9.0"
4.118 (while ...)
Эта функция вычисляет и, если оно не является nil,
вычисляет другие выражения, затем снова проверяет . Это
продолжается до тех пор, пока не nil. Затем WHILE
возвращает самое позднее значение последнего . Hапример, дано:
(setq a 1)
тогда:
(while ( 4.119 (write-char [])
Эта функция записывает один символ на экран или в открытый файл,
заданный . ) - это код ASII символа, и является
значением возвращаемым функцией. Hапример:
(write-char 67) возвращает 67
и записывает латинскую букву С на экране. Предположим, что F - описатель
открытого файла:
(write-char 67 f) возвращает 67
и записывает латинскую букву С в этот файл.
4.120 ((write-line [])
Эта функция записываект строковую константу на экране или в
открытый файл, заданный . Она возвращает ,
взятую в кавычки, и опускает кавычки когда записывается в файл. Hапример,
предположим, что F это допустимый описатель открытого файла:
(write-line "Test" f) записывает Test и возвращает "Test".
4.121 (zerop )
Эта функция возвращает T, если действительное или целое
число, равное нулю, иначе возвращает nil. Она не определенадля других
типов . Hапример:
(zerop 0) возвращает Т
(zerop 0.0) возвращает Т
(zerop 0.0001) возвращает nil
4.122 (*error* )
Это, определяемая пользователем функция, трактующая ошибки. Если она
не nil, она выполняется как функция всякий раз, когда присутствует
проверка ошибок AutoLISP. Она выдает один аргумент - строку, состоящую
из описания ошибки.
Hапример:
(defun *error* (msg)
(princ "error:")
(princ msg)
(terpri)
)
Эта функция будет делать тоже самое, что и стандартная функция
трактовки ошибок AutoLISP - печать "error:" и описание.
[ Назад ]
[ Оглавление ]
[ Далее ]
Оставить комментарий
Комментарии
Функция возвращает логическое HЕТ (дополнение до единицы). <Число> должно быть целым. Hапример:
(~ 3) возвращает -4
(~ 100) возвращает -100
(~ -4) возвращает 3
Здесь ошибка не -100 а -101