@Make(Manual) @Define(PE,FaceCode U) @Begin(TitlePage) @Begin(TitleBox) @MajorHeading[GLISP User's Manual] @BlankSpace(2) @Center( Gordon S. Novak Jr. Computer Science Department Stanford University Stanford, California 94305) @BlankSpace(3) @BlankSpace(2) @Center[@B @Value(Date)] @End(TitleBox) @Begin(ResearchCredit) This research was supported in part by NSF grant SED-7912803 in the Joint National Science Foundation - National Institute of Education Program of Research on Cognitive Processes and the Structure of Knowledge in Science and Mathematics, and in part by the Defense Advanced Research Projects Agency under contract MDA-903-80-c-007. @End(ResearchCredit) @End(TitlePage) @Chapter(Introduction) @Section(Overview of GLISP) GLISP is a LISP-based language which provides high-level language features not found in ordinary LISP. The GLISP language is implemented by means of a compiler which accepts GLISP as input and produces ordinary LISP as output; this output can be further compiled to machine code by the LISP compiler. GLISP is available for several LISP dialects, including Interlisp, Maclisp, UCI Lisp, ELISP, Franz Lisp, and Portable Standard Lisp. The goal of GLISP is to allow structured objects to be referenced in a convenient, succinct language, and to allow the structures of objects to be changed without changing the code which references the objects. GLISP provides both PASCAL-like and English-like syntaxes; much of the power and brevity of GLISP derive from the compiler features necessary to support the relatively informal, English-like language constructs. The following example function illustrates how GLISP permits definite reference to structured objects. @Begin(ProgramExample) (HourlySalaries (GLAMBDA ( (a DEPARTMENT) ) (for each EMPLOYEE who is HOURLY (PRIN1 NAME) (SPACES 3) (PRINT SALARY) ) )) @End(ProgramExample) The features provided by GLISP include the following: @Begin(Enumerate) GLISP maintains knowledge of the "context" of the computation as the program is executed. Features of objects which are in context may be referenced directly; the compiler will determine how to reference the objects given the current context, and will add the newly referenced objects to the context. In the above example, the function's argument, an object whose class is DEPARTMENT, establishes an initial context relative to which EMPLOYEEs can be found. In the context of an EMPLOYEE, NAME and SALARY can be found. GLISP supports flexible object definition and reference with a powerful abstract datatype facility. Object classes are easily declared to the system. An object declaration includes a definition of the storage structure of the object and declarations of properties of the object; these may be declared in such a way that they compile open, resulting in efficient object code. GLISP supports object-centered programming, in which processes are invoked by means of "messages" sent to objects. Object structures may be LISP structures (for which code is automatically compiled) or Units in the user's favorite representation language (for which the user can supply compilation functions). Loop constructs, such as @ (FOR EACH WITH DO ...)@ , are compiled into loops of the appropriate form. Compilation of infix expressions is provided for the arithmetic operators and for additional operators which facilitate list manipulation. Operators are interpreted appropriately for Lisp datatypes as well as for numbers; operator overloading for user-defined objects is provided using the message facility. The GLISP compiler infers the types of objects when possible, and uses this knowledge to generate efficient object code. By performing @I[ compilation relative to a knowledge base ], GLISP is able to perform certain computations (e.g., inheritance of an attached procedure from a parent class of an object in a knowledge base) at compile time rather than at runtime, resulting in much faster execution. By separating object definitions from the code which references objects, GLISP permits radical changes to object structures with no changes to code. @End(Enumerate) @Section(Implementation) GLISP is implemented by means of a compiler, which produces a normal Lisp EXPR from the GLISP code; the GLISP code is saved on the function's property list, and the compiled definition replaces the GLISP definition. Use of GLISP entails the cost of a single compilation, but otherwise is about as efficient as normal LISP. The LISP code produced by GLISP can be further compiled to machine code by the LISP compiler. GLISP functions are indicated by the use of GLAMBDA instead of LAMBDA in the function definition. When the Lisp interpreter sees the GLAMBDA, it calls the GLISP compiler to incrementally compile the GLISP function. The compiled version replaces the GLISP version (which is saved on the function name's property list), and is used thereafter. This automatic compilation feature is currently implemented in Interlisp and in Franz Lisp. In other dialects, it is necessary for the user to explicitly invoke compilation of GLISP functions by calling the compiler function @PE[GLCC] for each one. To use GLISP, it is first necessary to load the compiler file into Lisp. Users' files containing structure descriptions and GLISP code are then loaded. Compilation of a GLISP function is requested by: @Tabset(1.7 inch) @Begin(Format) @PE[(GLCC 'FN)]@\Compile @PE[FN]. @PE[(GLCP 'FN)]@\Compile @PE[FN] and prettyprint the result. @PE[(GLP 'FN)]@\Print the compiled version of @PE[FN]. @End(Format) In Interlisp, all the GLISP functions (beginning with GLAMBDA) in a file can be compiled by invoking @PE[(GLCOMPCOMS@ COMS)], where @PE[COMS] is the list of file package commands for the file. Properties of compiled functions are stored on the property list of the function name: @Begin(Format) @PE[GLORIGINALEXPR]@\Original (GLISP) version of the function.@FOOT[The original definition is saved as EXPR in Interlisp.] @PE[GLCOMPILED]@\GLISP-compiled version of the function. @PE[GLRESULTTYPE]@\Type of the result of the function. @PE[GLARGUMENTTYPES]@\Types of the arguments of the function. @End(format) Properties of GLISP functions can be examined with the function @PE[(GLED ')], which calls the Lisp editor on the property list of @PE[]. @PE[(GLEDF ')] calls the Lisp editor on the original (GLISP) definition of @PE[]. @Section(Error Messages) GLISP provides detailed error messages when compilation errors are detected; many careless errors such as misspellings will be caught by the compiler. When the source program contains errors, the compiled code generates runtime errors upon execution of the erroneous expressions. @Section(Interactive Features of GLISP) Several features of GLISP are available interactively, as well as in compiled functions: @Enumerate{ The @PE[A] function, which creates structured objects from a readable property/value list, is available as an interactive function. Messages to objects can be executed interactively. A display editor/inspector, GEV, is available for use with bitmap graphics terminals.@Foot[GEV is currently implemented only for Xerox Lisp machines.] GEV interprets objects according to their GLISP structure descriptions; it allows the user to inspect objects, edit them, interactively construct programs which operate on them, display computed properties, send messages to objects, and "push down" to inspect data values.} @Chapter(Object Descriptions) @Section(Declaration of Object Descriptions) An @I(Object Description) in GLISP is a description of the structure of an object in terms of named substructures, together with definitions of ways of referencing the object. The latter may include @I( properties ) (i.e., data whose values are not stored, but are computed from the values of stored data), adjectival predicates, and @I(messages) which the object can receive; the messages can be used to implement operator overloading and other compilation features. Object Descriptions are obtained by GLISP in several ways: @Begin(Enumerate) The descriptions of basic datatypes (e.g., INTEGER) are automatically known to the compiler. Structure descriptions (but not full object descriptions) may be used directly as @I(types) in function definitions. The user may declare object descriptions to the system using the function GLISPOBJECTS; the names of the object types may then be used as @I[ types ] in function definitions and definitions of other structures. Object descriptions may be included as part of a knowledge representation language, and are then furnished to GLISP by the interface package written for that representation language. @End(Enumerate) LISP data structures are declared using the function GLISPOBJECTS@Foot{ Once declared, object descriptions may be included in INTERLISP program files by including in the COMS a statement of the form: @PE[(GLISPOBJECTS@ @ ...@ )]}, which takes one or more object descriptions as arguments (assuming the descriptions to be quoted). Since GLISP compilation is performed relative to the knowledge base of object descriptions, the object descriptions must be declared prior to GLISP compilation of functions using those descriptions. The format of each description is as follows: @Begin(ProgramExample) (