In the previous exercise, you started with the following line:

(defun c:rec ()

You may recall from Chapter 26 that the defun function lets you create commands. The name that follows the defun function is the name of the command as you enter it through the keyboard. The c: tells AutoLISP to make this program act like a command. If the c: was omitted, you'd have to enter (rec) to view the program. The set of empty parentheses is for an argument list, which I'll discuss later.

In the next line, the variable Pt1 is assigned a value for a point you enter using your cursor. Getpoint is the AutoLISP function that pauses the AutoLISP program and allows you to pick a point using your cursor or to enter a coordinate. Once a point is entered, Getpoint returns the coordinate of that point as a list.

Immediately following Getpoint is a line that reads as follows:

"Pick first corner point:"

Getpoint allows you to add a prompt in the form of text. You may recall that when you first used Getpoint, it caused the prompt to go blank. Instead of a blank, you can use text as an argument to the Getpoint function to display a prompt describing what action to take.

The third line is similar to the second. It uses Getpoint to get the location of another point and then assigns that point to the variable Pt3:

(setq Pt3 (getpoint "Pick opposite corner:" ))

Once AutoLISP has the two corners, it has all the information it needs to find the other two corners of the rectangle.

Figure 27.3. The rec program draws a rectangle by getting two corner points of the rectangle from you and then recombining coordinates from those two points to find the other two points of the rectangle.

The next thing AutoLISP must do is take apart Pt1 and Pt3 to extract their X and Y coordinates and then reassemble those coordinates to get the other corner coordinates. AutoLISP must take the X coordinate from Pt3 and the Y coordinate from Pt1 to get the coordinate for the lower-right corner of the rectangle (see Figure 27.3). To do this, you use two new functions: Nth and List.

nth extracts a single element from a list. Because coordinates are lists, nth can be used to extract an X, Y, or Z component from a coordinate list. In the fourth line of the program, you see this:

(nth 0 Pt3)

Here the zero immediately following the Nth function tells Nth to take element number 0 from the coordinate stored as Pt3. Nth starts counting from 0 rather than 1, so the first element of Pt3 is considered item number 0. This is the X component of the coordinate stored as Pt3.

To see how Nth works, try the following:

Immediately following the first Nth expression is another Nth expression similar to the previous one:

(nth 1 Pt1)

Here, Nth extracts element number 1, the second element, from the coordinate stored as Pt1. This is the Y component of the coordinate stored as Pt1. If you like, try the previous exercise again, but this time, enter (nth 1 point1) and see what value you get.

AutoLISP has extracted the x component from Pt3 and the y component of Pt1. They must now be joined together into a new list. This is where the List function comes in. The List expression looks like this:

(list (nth 0 pt3) (nth 1 pt1))

You know that the first Nth expression extracts an X component and that the second extracts a Y component, so the expression can be simplified to look like this:

(list X Y)

Here X is the value derived from the first Nth expression, and Y is the value derived from the second Nth expression. The List function recombines its arguments into another list, in this case another coordinate list.

Finally, the outermost function of the expression uses Setq to create a new variable called Pt2, which is the new coordinate list derived from the List function. The following is a schematic version of the fourth line of the rec program, so you can see what is going on more clearly:

(setq pt2 (list X Y))

Pt2 is a coordinate list derived from combining the x component from Pt3 and the y component from Pt1.

Try the following exercise to see how List works:

The fifth line is similar to the fourth. It creates a new coordinate list using the X value from Pt1 and the Y value from Pt2:

(setq Pt4 (list (nth 0 Pt1) (nth 1 Pt3)))

The last line tells AutoCAD to draw a polyline through the four points to create a box:

(command "Pline" Pt1 Pt2 Pt3 Pt4 "c")

The Command function issues the Pline command and then inputs the variables Pt1 through Pt4. Finally, it enters c to close the polyline. Note that in this expression, keystroke entries, such as "Pline" and "C", are enclosed in quotes.

In your rec program, you prompted the user to pick some points by using the Getpoint function. Several other functions allow you to pause for input and tell the user what to do. Nearly all these functions begin with the Get prefix.

Table 27.2 shows a list of these Get functions. They accept single values or, in the case of points, a list of two values.

In Getstring, string values are case sensitive. This means that if you enter a lowercase letter in response to Getstring, it's saved as a lowercase letter; uppercase letters are saved as uppercase letters. You can enter numbers in response to the Getstring function, but they're saved as strings and can't be used in mathematical operations. Also, AutoLISP automatically adds quotes to string values it returns, so you don't have to enter any.

* This function requires a base point value as a first argument. This base point defines the first corner of the window. A window appears, allowing you to select the opposite corner.

Just as with Getpoint, all these Get functions allow you to create a prompt by following the function with the prompt enclosed by quotation marks, as in the following expression:

(getpoint "Pick the next point:" )

This expression displays the prompt Pick the next point: while AutoCAD waits for your input.

The functions Getangle, Getorient, Getdist, Getcorner, and Getpoint let you specify a point from which the angle, distance, or point is to be measured, as in the following expression:

(getangle Pt1 "Pick the next point:" )

Here, Pt1 is a previously defined point variable. A rubber-banding line appears from the coordinate defined by Pt1 (see Figure 27.4).

Once you pick a point, the angle defined by Pt1 and the point you pick are returned in radians. You can also enter a relative coordinate through the keyboard in the unit system currently being used in your drawing. Getangle and Getdist prompt you for two points if a point variable isn't provided. Getcorner always requires a point argument and generates a window rather than a rubber-banding line (see Figure 27.5).

Figure 27.4. Using Getcorner

Figure 27.5. Using Getangle

You can also use the ss1 variable in an AutoLISP expression. For example, the r90 macro in the next exercise lets you select several objects to be rotated 90°:

The defun function tells AutoLISP this is to be a command called r90. A list follows the name of the macro—it's called an argument list. We'll look at argument lists a bit later in this chapter.

Following the argument list is the (setq ss1 (ssget)) expression you used in the previous exercise. This is where the new macro stops and asks you to select a set of objects to later be applied to the Rotate command.

The next expression uses the Command function. Command lets you include standard AutoCAD command-line input in an AutoLISP program. In this case, the input starts by issuing the Rotate command. It then applies the selection set stored by ss1 to the Rotate command's object-selection prompt. Next, the two "" marks indicate an

Command: Rotate

Select objects:!ss1

Select objects:

Specify base point: (pause for input)
Specify rotation angle or [Copy/Reference] <0>: 90

In this macro, the Ssget function adds flexibility by allowing the user to select as many objects as desired. (You could use the Pause function in place of the variable ss1, but with Pause, you can't anticipate whether the user will use a window, pick points, or select a previous selection set.)

Selection sets are memory hogs in AutoLISP. If you create too many of them, you'll end up draining AutoLISP's memory reserves. To limit the memory used by selection sets, you can turn them into local variables. Local variables are variables that exist only while the program is executing its instructions. Once the program is finished, local variables are discarded.

The vehicle for making variables local is the argument list. Let's look again at the set of empty parentheses that immediately follow the program name in the rec macro:

(defun c:rec () . . .)

If you include a list of variables between those parentheses, those variables become local. In the new r90 macro you just looked at, the ss1 selection-set variable is a local variable:

(defun c:r90 (/ ss1). . .)

The argument list starts with a forward slash and then a space followed by the list of variables. Once the r90 macro is done with its work, any memory assigned to ss1 can be recovered.

Sometimes, you'll want a variable to be accessible at all times by all AutoLISP programs. Such variables are known as global variables. You can use global variables to store information in the current editing session. You could even store a few selection sets as global variables. To control memory consumption, however, use global variables sparingly.

These functions are useful for manipulating geometric data. (And don't forget the Get functions listed earlier, in Table 27.2.)

These functions allow you to manipulate strings. Although you can't supply strings for the text input of the text command, you can use the Command function with string variables to enter text, as in the following:

(Setq note "Hello World")
 (command "text" (getpoint) "2.0" "0" note)

In this example, note is first assigned a string value. Then, the Command function is used to issue the Text command and place the text in the drawing. Notice the (getpoint) function, which is included to obtain a point location.

Two other string functions, Substr and Strcat, let you manipulate text.