An_Introduction_to_AutoLISP资源-CSDN文库

需积分: 6 72 浏览量 2017-04-23 16:04:01 上传评论收藏 982KB PDF 举报

### AutoLISP简介 #### 课程概述《AutoLISP入门》是一门旨在介绍AutoLISP编程语言的基础课程。该课程共分为八节课，最初是以月刊的形式在《CADalyst》杂志上发布。读者可以选择注册该课程，以便获得印刷版的课程大纲、学习指南、额外的AutoLISP示例、参考资料以及实际作业的答案。完成中级和最终的邮件项目后，学员将获得结业证书及4.0继续教育学分（CEUs）。 #### 联系信息欲了解更多信息，请联系： - Steve Bialek - 工程专业发展部 - 威斯康星大学麦迪逊分校 - 北湖街432号 - 麦迪逊，威斯康星州53706 - 电话：(608)262-1735 #### 第一课：AutoLISP简介本课主要介绍了AutoLISP作为一种函数和其他数据类型的集合，并解释了如何在AutoCAD绘图会话期间执行AutoLISP表达式和程序的各种方法。通过两个简单的AutoLISP函数，学员可以开始编写程序来绘制基本的几何形状。课程还引入了局部变量和全局变量的概念，并以一些家庭作业问题结束，以测试学员对文本的理解。 #### AutoLISP是什么？ AutoLISP是一种编程语言，它允许用户根据自己的独特需求定制AutoCAD。它是LISP（列表处理器）编程语言的一个子集，LISP广泛应用于人工智能和专家系统领域。为了使AutoLISP能够直接与AutoCAD交互，许多函数被添加到了LISP程序中，同时一些AutoCAD命令也被保留为AutoLISP函数。 AutoLISP是一种“解释型”语言而非“编译型”语言，这意味着程序中的每一行都会在读入计算机时被翻译并评估。这与编译型语言不同，在编译型语言中，整个程序会被预先翻译成机器码，然后再进行执行步骤。 #### AutoLISP中的程序语句在AutoLISP中，程序语句通常以括号表示，括号内的第一个元素是函数名，后面的元素是函数参数。例如，下面是一个简单的AutoLISP程序示例： ```lisp (defun c:draw-circle (radius) (command "circle" "0,0" radius "") ) ``` 这个程序定义了一个名为`c:draw-circle`的函数，它接受一个参数`radius`。当调用这个函数时，它会在AutoCAD中以坐标(0,0)为中心绘制一个半径为`radius`的圆。 #### 数据类型 AutoLISP支持多种数据类型，包括数字、字符串、列表等。这些数据类型对于构建复杂的程序至关重要。例如，数字用于数学计算，而字符串则用于处理文本数据。 #### 函数与执行在AutoLISP中，函数是主要的构建块。每个函数都由一个名称和一系列参数组成。函数可以通过多种方式执行，如直接调用、通过AutoCAD命令行或者通过其他函数的嵌套调用来执行。 #### 局部变量与全局变量 - **局部变量**：在函数内部声明的变量，只在该函数的作用域内有效。 - **全局变量**：在整个程序范围内都有效的变量，可以在任何地方访问。例如，下面的代码展示了局部变量和全局变量的使用： ```lisp (defvar *gvar* 10) ; 定义全局变量*gvar* (defun c:set-global-var (val) (setq *gvar* val) ; 修改全局变量 ) (defun c:set-local-var () (local var1) ; 定义局部变量var1 (setq var1 5) ; 设置局部变量值 ) ``` #### 家庭作业问题 - 如何创建一个简单的AutoLISP函数来绘制一个矩形？ - 解释一下AutoLISP中的`setq`和`set`函数的区别。 - 写出一个AutoLISP程序，该程序接收两个参数：圆心坐标和半径，并绘制一个圆。通过本课程的学习，学员不仅能够掌握AutoLISP的基本语法，还能学会如何利用AutoLISP来增强AutoCAD的功能，从而提高工作效率和精确度。

资源推荐

资源详情

资源评论

An Introduction to AutoLISP

An Introduction to AutoLISP

Lesson One in the CADalyst

University of Wisconsin Introduction to AutoLISP Programming course covers AutoLISP data types and

program execution

by

Anthony Hotchkiss, Ph.D, P.Eng.

About this course.

Introduction to AutoLISP Programming is an eight-lesson independent study course, originally published in monthly

installments in CADalyst magazine. Readers may optionally register for the course in order to receive a copy of the

printed course outline, a study guide containing additional AutoLISP examples, reference materials, and solutions to the

practical assignments. On successfully completing an intermediate and a final mail-in project, students will receive

certificates of completion and 4.0 CEU's (continuing education units).

For further information, contact:

Steve Bialek

Engineering Professional Development

University of Wisconsin-Madison

432 North Lake Street

Madison, Wisconsin 53706

(608) 262-1735

LESSON ONE - AN INTRODUCTION TO AUTOLISP

This months lesson introduces you to AutoLISP as a set of functions and other data types, and explains a variety of

ways in which AutoLISP expressions and programs may be executed, or 'run' during your AutoCAD drawing session.

You will see that with just two AutoLISP functions, you can begin creating programs to draw some basic geometric

shapes. The concepts of local and global variables are introduced, and the lesson ends with some homework questions

to test your understanding of the text.

WHAT IS AUTOLISP?

AutoLISP is a programming language that allows you to customize AutoCAD to meet your own unique requirements. It

is a subset of the LISP (List Processor) programming language, which is used in applications of artificial intelligence

and expert systems. Many functions have been added to the LISP program in order to interface AutoLISP directly to

AutoCAD, and you will see that some AutoCAD commands have been retained as AutoLISP functions.

AutoLISP is an 'interpreted' language rather than a 'compiled' language, which means each program statement is

translated and evaluated as the program is read into the computer. This differs from a compiled language for which a

complete translation into machine code is made prior to a program 'execution' step.

Program statements in AutoLISP are sets of functions and other data that are used with the function contained within

parentheses. An example of such a function and its other data is:

(command "line" pt1 pt2 pt3 pt4 "close")

Here, the function is 'command', which precedes the familiar AutoCAD 'line' command and its sub-command 'close'.

The content of the parentheses is a self-contained statement which causes a line to be drawn between the four points pt1

through pt4, and back to pt1. You must have already defined the meaning of the four points so that AutoCAD can use

them to draw the lines.

AUTOLISP DATA TYPES

Functions such as 'command', are termed 'built-in' or 'internal' functions. They are also known as subroutines, or simply

'subrs'. The subroutine terminology will be more familiar to those of you who have programmed in other languages

such as FORTRAN. The 'other data' that appear with the function are called the 'arguments' of the function.

Page 1 of 64

An Introduction to AutoLISP

Some AutoLISP functions (subrs) require that arguments be supplied in a particular order, and others may include

optional arguments, or no arguments at all. The complete set of functions is listed in the AutoLISP Programmer's

Reference, published by Autodesk, Inc., and supplied to purchasers of AutoCAD.

The data types that AutoLISP recognizes are:

Functions (subroutines, subrs)

Examples are +, -, *, \, command, princ, setq

(note that the arithmetic operators are treated as functions by AutoLISP)

Arguments of the functions

Examples are variables (also known as symbols)

constants (real (decimal) or integer)

character strings

file names (descriptors)

AutoCAD entity names

AutoCAD selection sets

external functions (supplied by the AutoCAD Development System)

AutoLISP data is supplied in the form of lists, where the items of the list can themselves be lists. For instance, in our

example of the command function

(command "line" pt1 pt2 pt3 pt4 "close")

the seven items contained in the parentheses form a list. Four of these items are the variables (symbols) pt1 through pt4

representing AutoCAD points. Now, since the points contain x, y and z coordinates, they are also lists. The other two

arguments, "line" and "close" are examples of character strings.

AutoLISP Atoms

A single item of a list, which is not itself a list, is called an 'atom' in AutoLISP terminology. According to this

definition, atoms are the fundamental indivisible particles of AutoLISP. Atoms are individual elements such as

symbols, numbers and subrs, and a complete set of the atoms can be displayed on your screens by entering !atomlist at

the AutoCAD command prompt. We will discuss the atomlist more fully later in this series.

EXECUTING AUTOLISP

AutoLISP input can be entered by typing in expressions in an AutoCAD session (at the command prompt), by reading

in the expressions from an ASCII file, or by reading from a string variable which may represent a complete program.

Execution by typing in an AutoLISP expression

Try typing in the following at the AutoCAD command prompt:

(command "line" "2,3" "4,5" " 6,3" "close")

Don't forget to include the parentheses, or AutoCAD won't recognize that this is an AutoLISP expression! Your

AutoCAD screen should now display a triangle. In this case, the variables used for points have been replaced by

character strings enclosed by double quotation marks. Now erase the triangle and re-type the expression with "c"

replacing the "close" element. The result is the same, because the command function allows regular AutoCAD

commands and subcommands to be entered.

Execution by reading an expression from an ASCII file

Now, shell out of AutoCAD and create an ASCII file (this can be done with EDLIN or the DOS 5 EDIT text editor)

named PROG1.LSP that contains only the above AutoLISP expression. To execute your first AutoLISP program, erase

the previous triangle, then use the following LOAD function at the command prompt:

Command: (load "prog1")

again, don't forget the parentheses and the double quotes, and you should see the triangle as before. Note here that the

program executes and draws the triangle immediately on being loaded, and this is generally true for AutoLISP programs

that contain only subrs (built-in functions).

Page 2 of 64

An Introduction to AutoLISP

AutoLISP execution from a file containing defined functions

In addition to subrs, it is also possible to define your own functions for AutoLISP. Such functions are called defined

functions to distinguish them from the built-in functions. If a program contains a defined function, when the program is

loaded, the name of the defined function must also be entered in parentheses so that it can be executed.

Try this by changing your prog1.lsp file to read the following:

(defun test1 ()

(command "line" "6,3" "8,5" "10,3" "c")

)

Don't forget to include all the parentheses. The AutoLISP subr to define functions is (defun .....), and in this case the

name of the defined function is test1. Now, if the AutoLISP file is named prog1.lsp, the following sequence is

followed:

Command: (load "prog1")

TEST1

Command: (test1)

Here, the word TEST1 appears immediately when the program is loaded by the first statement, but the program is not

executed until you enter '(test1)', the name of the defined function. We will see more of the defun function later, and the

significance of the empty pair of parentheses will be made clear in the section on 'global and local variables'.

AutoLISP execution with 'C:'

If the AutoLISP defined function name begins with C:, then after loading the program, the defined function becomes a

regular AutoCAD command that can be executed like other AutoCAD commands at the command prompt by entering

its name without parentheses. Try editing the prog1.lsp file to read:

(defun C:TEST1 ()

(command "line" "6,3" "8,5" "10,3" "c")

)

then use the following sequence of commands:

Command: (load "prog1")

C:TEST1

Command: test1

The name C:TEST1 is automatically written by AutoCAD when the program is loaded. At this point, the new command

'test1' may be entered at any time. An AutoLISP program containing one or more 'defun' defined functions only needs

to be loaded once in any drawing session.

AutoLISP execution from menu macros

AutoLISP expressions can be contained in menu macros to be executed when the menu label is selected. If you examine

the AutoCAD release 11 menu file ACAD.MNU, you will notice that it contains many AutoLISP programs and

expressions.

I use a personal menu file that I can select from a modified form of the standard ACAD.MNU. A menu item of the form

[aux-menu]^C^Cmenu;aux; is placed at a convenient position (I use the 'File' POP menu) in the standard menu, then I

place a similar command in my 'AUX.MNU' file to allow easy return to the standard menu. My preference is to leave

the standard menu alone, except for this small change so that the regular AutoCAD menus are always available on

demand, and any new material is then placed into the aux.mnu menu.

Here is a sample of my new POP2 menu which you can use for a basic AutoLISP development environment:

***POP2

[Set-ups]

|

|

[Lisp program development]^C^C$p2=p22 $p2=*

|

|

**p22

Page 3 of 64

An Introduction to AutoLISP

[Set-ups]

[Edit-LSP]^C^Cshell ed C:/acad11/lisp/test.lsp;graphscr

[Test-LSP]^C^C(load "/acad11/lisp/test");(test);

[Print test.lsp]^C^C(load "/acad11/lisp/printest");(printest);

[~--]

|

In the above, when the POP2 menu 'Set-ups' is selected, one of the choices is 'Lisp program development', and this

displays a new page that includes items to edit a file named test.lsp in the subdirectory lisp which is contained in the

AutoCAD directory, acad11. The call to the editor in this case is ed, because that is the name of the editor I use. You

may substitute edlin or edit or the name of your favorite text editor (provided that it produces ASCII output) in place of

this.

This menu macro only edits the file called test.lsp, which is the name I give to the current LISP program that I am

developing. To edit any other file, most text editors allow you to choose the filename after the editor has been entered,

so you could simply leave out the filename until the editor is running. Edlin requires a filename to be supplied on

execution, so simply give the shell command and issue the edlin command from the operating system.

The use of separate directories for lisp programs is a good management procedure that I recommend. After the lisp file

has been created or edited, it can be immediately tested by the Test-LSP macro, which loads and executes test.lsp

assuming a defined function named 'test' has been created.

The 'Print test.lsp' option calls a LISP program that prints the test.lsp file. The AutoLISP program to do this has been

adapted from the Autodesk Inc. 'Fprint.lsp' program, which is freely available to you for modification (with the

appropriate acknowledgements to Autodesk). We will examine this program in detail later in the course. In the

meantime, you may use your text editor or the DOS print command to print your program.

GLOBAL AND LOCAL VARIABLES

The default mode of AutoLISP is to define all variables to be 'global', which means that the variables are generally

available not only when the program containing them is executed, but also after the execution is completed. This means

that other programs you write will have access to variables that were defined by previous programs. It is possible to see

the values of global variables by typing their names preceded by ! at the command prompt. For instance, if pt1 is a

variable that represents a point whose coordinates are 2.5,3.0,0.0, then typing !pt1 will display the three coordinate

values.

Global variables appear in the ATOMLIST, and take up memory in the computer. For these reasons, and because you

will probably not want variables such as PT1 to take values left over by previous programs, it is wise not to have global

variables hanging around at the end of execution.

In order to avoid global variables, you may declare the program variables to be 'local' to a particular defined function by

adding their names, preceded by a slash mark and a space (/ ) in the parentheses which are supplied for that purpose in

the defun statement, thus:

(defun test2 (/ pt1 pt2 pt3 pt4)...........)

will make all of the point variables local. Note here that other variables may be defined as arguments of the defun

function, appearing before the slash mark, for instance,

(defun test3 (a b / pt1 pt2 pt3 pt4).............)

means that the two arguments a and b must be supplied to the defined function test3 before it can be executed, and

instead of executing with (test3) as before, you must supply values, such as (test3 2.2 3.0) so that the variables a and b

can take any value you wish, in this case, 2.2 and 3.0 respectively. We will see examples of programs using global and

local variables in the next lesson in this series.

Home work questions:

1. Why are the closing parentheses in the last 2 defined function examples on the same line as the opening

parentheses, instead of on a separate line as in our previous defined function examples?

2. Are the arguments a and b in the last defined function example local or global variables?

Page 4 of 64

剩余52页未读，继续阅读

内容反馈

nathae

粉丝: 0
资源: 2

最新资源

资源上传下载、课程学习等过程中有任何疑问或建议，欢迎提出宝贵意见哦~我们会及时处理！点击此处反馈

feedback-tip