Inside Macintosh: Interapplication Communication /

Chapter 7 - Introduction to Scripting

Manipulating and Executing Scripts

Your application can use scripting component routines to manipulate and execute scripts written in any scripting language based on the OSA. This section describes how scripting components use script data and summarizes some of the tasks your application can perform by calling the standard scripting component routines.

Your application can manipulate and execute scripts regardless of whether it is scriptable or recordable. However, if your application is scriptable, you can easily make it capable of manipulating and executing scripts that control its own behavior. For example, the forms application shown in Figure 7-4 on page 7-10 uses standard scripting component routines to execute a script whenever the cursor is in the appropriate field and the user presses Enter or Tab. Applications can also use scripting component routines to allow users to edit, recompile, save, and load such scripts in order to adapt them to their own purposes.

Before using any scripting component routines, your application must open a connection with at least one scripting component. After opening a connection with a component, your application receives a component instance that it can use as the first parameter for any scripting component routine. You can use the Component Manager to establish a connection with the generic scripting component or to establish an explicit connection with any other scripting component. Your application can open connections with different scripting components under different circumstances and, if necessary, simultaneously.

To manipulate or execute scripts written in any scripting language based on the OSA, your application can open a connection with the generic scripting component. The generic scripting component in turn attempts to open connections dynamically with the appropriate scripting component for a given script. If your application opens a connection with the generic scripting component, it can load and execute scripts created by any scripting component that is registered with the Component Manager on the current computer. The generic scripting component also provides routines that allow you to determine which scripting component created a particular script and to perform other useful tasks when you are using multiple scripting components.

To manipulate and execute scripts written in a single scripting language only, your application can open an explicit connection with the scripting component for that language. In this case your application can load and execute only those scripts that were created by that component; however, your application can also take advantage of additional routines and other special capabilities provided by the component.

After your application has established a connection with the appropriate scripting component for an existing script, it can use the standard scripting component routines to execute scripts. A script that has not yet been compiled consists of source data, or statements in a scripting language. Before executing source data, your application must use scripting component routines to compile it so that the scripting component can keep track of it in memory and execute it.

Scripting components can refer to at least three kinds of script data in memory:

• A compiled script consists of compiled code that an application can decompile into source data or execute using the standard scripting component routines.
• A script value consists of an integer, a string, a Boolean value, constants, PICT data, or any other fixed data returned or used by a scripting component in the course of executing a script.
• A script context maintains context information for the execution of other scripts. A script context can also contain executable statements in a scripting language. Like a compiled script, a script context can be decompiled as source data.

  For example, a script context can contain user-defined handlers for specific Apple events. In AppleScript, a script context that contains such handlers or other executable statements is called a script object. Handlers in a script object resemble HyperTalk message handlers. They consist of AppleScript statements and have no corresponding entry in Apple event dispatch tables.

Scripting components keep track of script data in memory by means of script IDs of type OSAID.

TYPE OSAID = LongInt;

A scripting component assigns a script ID to a compiled script or script context whenever the component creates or loads the corresponding script data. The scripting component routines that compile, load, and execute scripts all return script IDs, and you must pass valid script IDs to many of the other routines that manipulate scripts.

Applications most commonly use scripting component routines to

• compile source data and execute the resulting compiled script, so that a user can create a new script and execute it immediately from within the application
• get a handle to script data in a form that can be saved, and load and execute the script data again when necessary
• allow users to modify a script, then recompile and save the script
• redirect Apple events to script contexts

The remainder of this section provides an overview of the scripting component routines you can use to perform these tasks.

Your application can also use scripting component routines to

• get information about scripts
• get information about scripting components
• coerce script values to descriptor records and vice versa
• set a resume dispatch function and alternative send, create, and active functions for use by a scripting component
• control the recording process directly, turning recording off and on and saving the recorded script for use by your application

The chapter "Scripting Components" in this book provides detailed information about using all the standard scripting component routines as well as additional routines provided by the AppleScript component and the generic scripting component.

---

Subtopics

Compiling, Saving, Modifying, and Executing Scripts

Using a Script Context to Handle an Apple Event