Search Top Index
HELP POP-11 Robert Duncan, May 1995 An introduction to the Poplog Pop-11 subsystem. CONTENTS - (Use <ENTER> g to access required sections) 1 The Pop-11 Language 2 Running Pop-11 3 Writing a Program 4 Initialisation and Libraries 5 Command Line Arguments 6 Additional Information ----------------------------------------------------------------------- 1 The Pop-11 Language ----------------------------------------------------------------------- Pop-11 is the core language of the Poplog system. Most of Poplog itself is written in Pop-11, including all the subsystem compilers, the editor and the X interface. For this reason alone, it is worthwhile for all Poplog users -- whatever their primary language -- to have some familiarity with Pop-11, since there are inevitably some features of Poplog which can most easily (or perhaps only) be accessed through Pop-11 by means of mixed-language calls. Pop-11 has evolved from a long line of Pop languages, developed primarily for applications in Artificial Intelligence. Unsurprisingly, then, it shares many features with modern Lisp languages, features which emphasise the importance of symbolic programming, data abstraction, convenience of use and language extensibility. But, as with Lisp, the usefulness of Pop-11 extends far beyond the traditional AI domain: those same features which make the language suitable for tackling the complex problems posed by AI also make it a powerful tool for solving hard problems in all kinds of application areas. The use of Pop-11 within Poplog serves as an immediate example of its general applicability. Characteristic features common to the Pop-11/Lisp style include: # built-in support for a varied range of datatypes. Types built in to Poplog Pop-11 include: strings, words (symbols), booleans, a rich set of numeric types, aggregates (lists, vectors and arrays), generic mappings (properties) and various system types including I/O devices and ``lightweight'' processes # the ability to add new, user-defined types with the same status as those built-in # first-class procedures with a choice of lexical or dynamic scoping of variables # a dynamic (run-time) type system # automatic storage management (garbage collection) # an interactive programming environment # an extensive collection of library procedures # extensible syntax But the Pop tradition has always rejected Lisp-style syntax in favour of a more conventional, structured style. By way of example, here is the definition of a Pop-11 procedure which computes the value of a polynomial of arbitrary degree, given a list of coefficients and a value x: define polynomial(x, coefficients) -> y; lvars c, y = 0; for c in coefficients do y * x + c -> y; endfor; enddefine; ;;; print the value of 11x^3 + 4x^2 - 5 for x = 7 polynomial(7, [11 4 0 -5]) => Most newcomers to the language find this core syntax straightforward both to read and write and can move on quickly to developing significant programs, concentrating on semantic issues without being distracted by syntactic details. Experienced programmers can build upon the core syntax, using its extensibility to define new forms tailored to their own problem domains. This extensibility also allows Pop-11 to develop incrementally over time as experimental features become accepted and integrated into the mainstream language. A second aspect of Pop-11 which distinguishes it from Lisp is its explicitly stack-based evaluation semantics. This makes Pop-11 programming a distinctly novel experience for many users, and can provide some elegant programming solutions. Here, for example, is a simple procedure which selects interesting items from a list: define select(list, interesting) -> selected; lvars selected = [% lvars item; for item in list do if interesting(item) then item endif; endfor; %]; enddefine; If we define as ``interesting'' numbers which are integral, then the statement select([6 13 5 27.42 31 9.45 31.24], isintegral) => will display the list [6 13 5 31] It is the implicit use of the stack in select which allows the evaluating list brackets ([%%]) to collect an arbitrary number of results. As an aside, this example also demonstrates the regular treatment of procedure values in Pop-11 -- as in Scheme and other functional languages -- exemplified here by the binding of the formal parameter interesting to the built-in procedure isintegral. Use of the stack is often transparent, and it's possible to write Pop-11 in a very clean, functional style. Some users, however, choose to use the stack aggressively, adopting a style not unlike that of Forth. This is merely an example of how the richness of Pop-11's syntax and semantics can support a variety of programming paradigms which in other contexts might appear to be in conflict. Its extensibility means it can be continually adapting to new modes and styles of programming, most recently -- in line with current trends -- towards an object-oriented style. The Pop-11 language is regrettably less well-known than it ought to be. Anyone wishing to begin experimenting with the language should start by reading TEACH * PRIMER which gives an overview of many of the language features. ----------------------------------------------------------------------- 2 Running Pop-11 ----------------------------------------------------------------------- From the operating system prompt, the pop11 command will take you into the interactive top-level; your terminal screen should look something like the following: Sussex Poplog (Version 15.03 Thu Jun 20 16:20:20 BST 1996) Copyright (c) 1982-1996 University of Sussex. All rights reserved. Setpop : The Setpop message is printed whenever the Pop-11 compiler is started: here for the first time and subsequently after an error or interrupt. The colon (:) is the Pop-11 prompt, and indicates that the compiler is ready for input: you can type any Pop-11 expression or command here, such as those copied from above. A good starting point is to use the immediate-mode command: : im which will start an interactive session within an editor window. This works just like the top-level interaction, but you can use editor commands to edit and re-enter input and format output for easier reading, or to save a record of the interaction to a file. Other useful commands to try are: : help topic Displays documentation on the given topic : load file Compiles a file : ved file Edits a file : bye Terminates the interaction: at top-level, this will exit from the pop11 command You can use all these commands from inside the editor too, by using the <ENTER> key to take you to the editor command line. X users should start pop11 with the %x command-line argument: in a standard system this will pop up a ``control panel'' window from which you can invoke common Poplog functions. Browse through the Help menu to find information about using the control panel and the editor or choose the Interaction option from the File menu to start an interactive window. ----------------------------------------------------------------------- 3 Writing a Program ----------------------------------------------------------------------- Use the ved command to open a program file or choose Open from the control panel File menu. By convention, Pop-11 program files have an extension of '.p'. If you conform to this, Poplog will recognise your program files and assign to them the correct compiler. A program can contain a mixture of definitions and execute-level evaluations: you could copy exactly the program fragments shown above, for example. You can compile a program from within the editor by using the <ENTER> l1 command, where l1 means ``load one file''. This compiles directly from the current editor buffer, so you don't need to save the file first. Any output or errors will be sent to an editor output window. To compile a named file, use the load command, either at the interactive prompt or from the editor command-line. Alternatively, use the Compile option from the control panel File menu. The Pop-11 compiler is incremental. This means that regardless of which files you compile or how you compile them, all the definitions they contain -- unless you have explicitly chosen to restrict their scope -- are added to a global environment shared by all other program files and interactive windows. So you can break a program across multiple files as convenient and test out individual procedures interactively. Modifying and recompiling a file updates the environment to reflect any new or changed definitions, allowing you to switch quickly between writing and testing code, and to build up a complete program in incremental steps. As your files get larger, you can use editor commands to compile just part of a file, omitting those sections that aren't yet completed or which have been compiled once and not since modified: TEACH * LMR and TEACH * LCP tell you how to do this. This leads to a highly productive method of working. ----------------------------------------------------------------------- 4 Initialisation and Libraries ----------------------------------------------------------------------- When starting in interactive mode, pop11 will compile an initialisation file called "init.p" if it exists in your poplib directory. By default, this directory is assumed to be your home (login) directory. You can choose a different location by setting poplib as an environment variable (logical name) before starting pop11; this is most conveniently done in your ".login", ".profile" or "login.com" file. The "init.p" file is a standard Pop-11 program file, so can contain any code you like for customising your working environment. Clearly, the more you put in here the longer it takes to compile, increasing the time it takes to get to the interactive prompt. As you develop a collection of frequently-used procedures to which you want ready access, rather than define them all in your "init.p" file, you should consider making them into libraries which you can load explicitly as needed. This is easy to do. First, create a library directory. The pathname ~/pop11/lib will do as an example; VMS users might prefer to write this as sys$login:[.pop11.lib] but Poplog will convert automatically from the Unix form to maximise portability. Define your procedures in one or more '.p' files in this directory, e.g. ~/pop11/lib/useful.p and add the line '~/pop11/lib/' :: popuseslist -> popuseslist; into your "init.p" file. This adds the library directory to the library search path; to load the useful procedures, you need only type lib useful; More sophisticated effects are possible with the uses syntax and autoloadable identifiers: see REF * LIBRARY for details. The %noinit command-line option prevents compilation of the "init.p" file. This is useful for quick startup, or when your init file contains some kind of error. ----------------------------------------------------------------------- 5 Command Line Arguments ----------------------------------------------------------------------- To summarise the command-line syntax discussed in this file: the general form of the pop11 command is pop11 [%args] [vedcommand] [file] All arguments are optional. The %args control system startup behaviour: %x %x ( X Toolkit options ) Initiates a connection with the X server by calling *sysxsetup. You can supply standard X Toolkit options by placing them in parentheses after the %x. %noinit Suppresses compilation of the "init.p" file and any init files used by Ved or other subsystems. A vedcommand argument causes Poplog to go straight into the editor, and can be any of the following: ved im help ref teach Used in conjunction with a vedcommand argument, a trailing file name is given as argument to that command. Otherwise, if there is no Ved command, the file is compiled as a Pop-11 program file; in this case, your "init.p" file is not compiled, regardless of whether %noinit was specified. Instead of a file, you can give an argument :expression in which case the expression is evaluated by the Pop-11 compiler. Examples: pop11 %x im Starts up Pop-11 with an X connection, displaying the user- interface control panel and an immediate-mode XVed window pop11 ref library Starts up Pop-11 with a Ved window displaying REF * LIBRARY pop11 ":popversion=>" Prints the Pop-11 version string Full details of the command line are given in REF * SYSTEM. ----------------------------------------------------------------------- 6 Additional Information ----------------------------------------------------------------------- On the Pop-11 language: TEACH * PRIMER An introduction to Pop-11 with many examples REF * ITEMISE * POPSYNTAX * SYNTAX Itemisation and syntax rules REF * ARRAYS * DATA * LISTS * NUMBERS * PROCEDURE * PROCESS REF * PROPS * RECORDS * STRINGS * VECTORS * WORDS Built-in types HELP * EQUAL Equality and pattern matching REF * OBJECTCLASS Object-oriented extensions REF * CHARIO * SYSIO * PRINT Input and output REF * ASYNC * DEFSTRUCT * EXCEPTION * EXTERNAL * IDENT * KEYS REF * POPCOMPILE * PROGLIST * SECTIONS * TIMES * STACK * SYSUTIL Advanced features On Poplog in general: REF * SYSTEM Startup and exit, saved images, storage management, etc. REF * SUBSYSTEM * LIBRARY Subsystems and libraries HELP * POPVARS Variables controlling system behaviour HELP * POPREFS Other literature relevant to the Poplog languages --- C.all/help/pop11 --- Copyright University of Sussex 1996. All rights reserved.