From fa080de7afc95aa1c19a6e6fc0e0708ced2eadc4 Mon Sep 17 00:00:00 2001
From: Joseph Hunkeler <jhunkeler@gmail.com>
Date: Wed, 8 Jul 2015 20:46:52 -0400
Subject: Initial commit

---
 doc/cluser.tex | 5354 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 5354 insertions(+)
 create mode 100644 doc/cluser.tex

(limited to 'doc/cluser.tex')

diff --git a/doc/cluser.tex b/doc/cluser.tex
new file mode 100644
index 00000000..cfb028f8
--- /dev/null
+++ b/doc/cluser.tex
@@ -0,0 +1,5354 @@
+%\pagelayout{normal,twoside}
+%\textheight 8in \textwidth 6in\topmargin 0.0in
+%\documentstyle{article,11pt}
+
+\documentstyle[11pt,twoside]{article}
+
+\setlength{\textheight}{8in}
+\setlength{\textwidth}{6in}
+\setlength{\topmargin}{0in}
+\oddsidemargin 0pt
+\evensidemargin 0pt
+\hyphenation{pre-sents}
+\parskip 4pt
+
+\begin{document}
+
+\font \smcaps=amcsc10
+\font \bldcn=ambc12
+\font \eighttt=amtt8
+
+\newcommand{\filename}[1]{{\tenrm#1}}
+\newcommand{\key}[1]{\fbox{\eighttt#1}}
+\newcommand{\emphasize}[1]{{\sl#1\/}}
+\newcommand{\irafname}[1]{{\bf#1}}
+\newcommand{\taskname}[1]{{\sl#1\/}}
+\newcommand{\reference}[1]{{\it#1\/}}
+\newcommand{\comptype}[1]{{\tt#1}}
+\newcommand{\usertype}[1]{{\bldcn#1}}
+\newcommand{\upa}{{\tt \char94}}
+\newcommand{\lbox}{{\tt \char91}}
+\newcommand{\rbox}{{\tt \char93}}
+\newcommand{\bsl}{{\tt \char92}}
+\newcommand{\pipe}{{\tt |\ }}
+\newcommand{\pluseq}{$+\!=$}
+\newcommand{\minuseq}{$-\!=$}
+\newcommand{\timeseq}{$*\!=$}
+\newcommand{\diveq}{$/\!=$}
+\newcommand{\concateq}{$//\!=$}
+\newcommand{\ppind}{\hspace*{17pt}}
+
+\begin{titlepage} \vspace*{1.0in}
+
+\begin{center} \huge
+DRAFT\\ \vspace*{0.5in} \large \bf
+
+A User's Introduction to the IRAF Command Language \\ \medskip
+Version 2.3 \\
+
+\bigskip
+
+\smcaps Peter MB Shames\\
+\tenrm Space Telescope Science Institute\\
+\medskip
+\smcaps Doug Tody\\
+\tenrm National Optical Astronomy Observatories\\
+\vskip 1cm
+
+Revised  -- \today\\ \vskip 1cm
+
+\bldcn ABSTRACT\\ \medskip
+\end{center} \large
+
+\begin{quotation} \noindent
+This tutorial introduction to the IRAF Command Language
+presents an overview of the use and features of the language.
+The discussion is aimed toward the first-time
+user and describes the execution of tasks from the Command
+Language.  The focus is the Command Language itself;
+the many packages and tasks that compose the IRAF system and the 
+SDAS packages from STScI are described elsewhere.  The emphasis is
+on using the Command Language to run existing programs, although
+sections are included that describe the addition of new tasks
+of one's own making. A quick guide to language features and facilities
+and to the suite of reduction and analysis packages currently available
+is provided in the Appendices.
+\end{quotation}
+\end{titlepage}
+
+\pagestyle{empty}
+\newpage
+\thispagestyle{empty}
+
+\begin{center} \vspace*{1in}
+\large About the Authors
+\end{center}
+\vskip 1cm
+\rm
+
+\noindent
+Peter Shames is Chief of the Systems Branch at STScI, and along with Jim Rose
+and Ethan Schreier, was one of the key persons responsible for the selection
+of IRAF as the command language and operating environment for the STScI
+Science Data Analysis System (SDAS) in December of 1983.  Since that time,
+Peter has supervised the VMS/IRAF development effort at STScI, overseeing the
+implementation of the VMS/IRAF kernel, the initial port of IRAF to VMS,
+and the development of version 2.0 of the IRAF command language.
+Peter wrote the original CL User's Guide (version 2.0).
+
+\vskip 0.5cm
+\noindent
+Doug Tody is the originator and designer of the IRAF system (including the CL)
+and has been Chief Programmer of the IRAF project since the inception of the
+project at KPNO (now NOAO) in the fall of 1981.  As Chief Programmer, Doug has
+written virtually all of the IRAF system software with the exception of the
+VMS/IRAF kernel and the original CL 1.0 (which was written by Elwood Downey).
+Since 1983 Doug has been head of the IRAF group at NOAO, overseeing the
+development of the NOAO science applications software while continuing work
+on the IRAF systems software, and coordinating the effort with STScI.
+
+\newpage
+\thispagestyle{empty}
+
+\begin{center} \vspace*{1in}
+\large Acknowledgements
+\end{center}
+\vskip 1cm
+\rm
+
+\noindent
+The authors wish to acknowledge the efforts of the many people who have 
+contributed so much time, energy, thought and support to the development 
+of the IRAF system.  Foremost among these are the members of the IRAF
+development group at NOAO (Lindsey Davis, Suzanne Hammond, George Jacoby,
+Dyer Lytle, Steve Rooke, Frank Valdes, and Elwood Downey, with help from
+Ed Anderson, Jeannette Barnes, and Richard Wolff) and members of the VMS/IRAF
+group at STScI (Tom McGlynn, Jim Rose, Fred Romelfanger, Cliff Stoll,
+and Jay Travisano).  The sharp editorial eye and sharper pencil of
+Chris Biemesderfer have made major contributions to the clarity and style
+of this document.
+
+\vskip 0.3cm
+\noindent
+The continuing patience and understanding of members of the scientific
+staff at both institutions has been essential to the progress that has
+so far been achieved.  A major software project such as IRAF cannot
+be attempted without the cooperation of many individuals, since the
+resources required must inevitably place a drain on other activities.
+In particular, the support and encouragement of Harvey Butcher,
+Garth Illingworth, Buddy Powell, Steve Ridgway and Ethan Schreier has
+been invaluable.  Mention should also be made of Don Wells, who started
+in motion in the latter part of the last decade the process which eventually
+led to the creation of the IRAF system.
+
+\begin{flushright}
+Peter Shames \\
+Doug Tody 
+\end{flushright}
+
+\clearpage 
+\pagestyle{myheadings}
+\markboth{CL User's Guide (DRAFT)\hspace*{2.1in}}
+	 {\hspace*{2.1in}CL User's Guide (DRAFT)}
+\pagenumbering{roman}
+
+\tableofcontents
+
+\thispagestyle{empty}
+\newpage
+
+\pagestyle{myheadings}
+\markboth{CL User's Guide (DRAFT)\hspace*{2.1in}}
+	 {\hspace*{2.1in}CL User's Guide (DRAFT)}
+\pagenumbering{arabic}
+
+\begin{center} \vspace*{0.5in} \large \bf
+
+A User's Introduction to the IRAF Command Language \\ \medskip
+Version 2.3 \\
+
+\bigskip
+
+\smcaps Peter MB Shames\\
+\tenrm Space Telescope Science Institute\\
+\medskip
+\smcaps Douglas Tody\\
+\tenrm National Optical Astronomy Observatories\\
+\vskip 1cm
+
+\end{center} \rm
+
+\section*{How to use this book}
+
+\ppind
+This document is an introduction to the IRAF
+Command Language (CL), and is designed to be a tutorial
+for the first-time user.  The examples presented in the text can
+(and should) be tried at a terminal.  Although this text is
+large enough to be a bit daunting at first, it can be tackled
+in easy stages, and need not all be read before trying the system.  
+A basic knowledge of computer systems is assumed.
+
+The first three chapters form an introductory section
+which covers the most basic elements of IRAF.  Reading through these,
+preferably while seated near a terminal where the examples may be tried 
+out, is the recommended entry into the IRAF world.  The fourth and fifth 
+chapters deal with the interface between IRAF and the host system,
+and with some of the more advanced uses of IRAF for normal data
+analysis activities.  These chapters will be of use once you are familiar
+with the basic environment and the examples here are also designed
+to be tried out on a live system.  The rest of this document is for the
+more adventurous user, who is not happy until he can say \usertype{doit}
+and get \irafname{it} done to a turn.  Try some of these last examples
+when you are ready to customize IRAF for your own particular uses.
+
+In spite of its size, this document
+is not intended to be a complete guide to using and programming 
+the IRAF system, but is an introduction to many of the functions
+of the CL and a quick guide to other sources of more detailed information.
+The CL is described as the user's interactive interface to the system,
+and simple commands that use the terminal for starting and controlling tasks
+and for customizing the environment are presented.
+Development of simple functions in the CL are covered briefly here, but
+coverage of all the details of programming in the CL or in the
+IRAF environment is beyond the scope of this document.
+A reasonable amount of documentation is accessible at the terminal via
+the online help facilities, which are described here as well.
+
+More extensive details of the CL may be found in the manual pages for the
+\taskname{language} package, in the \reference{CL Programmer's Manual} and
+in \reference{The IRAF User's Guide}.
+Details of programming in the IRAF system itself are described 
+in the \reference{Programmer's Crib Sheet for the IRAF Program Interface}, 
+in the \reference{Reference Manual for the IRAF Subset Preprocessor Language}
+and in other documents referred to in the last section of this text,
+however, these documents are somewhat dated and most of the documentation
+planned for the IRAF programming environment remains to be written.
+Documentation in the form of manual pages for the suites of applications
+packages being developed at both NOAO and STScI are available both online
+and in printed form.
+
+\section{Introduction}
+
+\subsection{An Overview of IRAF}
+
+\ppind
+The Image Reduction and Analysis Facility (IRAF) has been designed to
+provide a convenient, efficient and yet portable system
+for the analysis of images and other classes of data.  While the
+system has been designed for image data, and for astronomical image data
+in particular, it has general facilities that can be applied to many
+other classes of data.  Some of the functions that are
+provided are quite specialized, dealing as they do with the 
+characteristics of specific instruments, but others are generalized
+functions for plotting data, computing statistics, processing lists, and
+performing other functions that are common to
+data processing tasks in many other fields.
+
+The runtime IRAF system consists of four basic pieces:
+
+\begin{itemize}
+\item Command Language - which provides the user interface to the system.
+
+\item Applications Packages - that are the real data analysis algorithms.
+
+\item Virtual Operating System (VOS) - which is the heart of the portable
+system and provides the foundation for all the higher level functions.
+
+\item Host System Interface (HSI) - the interface between the portable IRAF
+system and a particular host system.  At the heart of the HSI is the IRAF
+\irafname{kernel}, a library of host dependent primitive subroutines that
+connects the system independent VOS routines to the host operating system.
+Each host system requires a different kernel, hence we speak of the UNIX/IRAF
+kernel, VMS/IRAF kernel, and so on.
+\end{itemize}
+
+\noindent
+All of these interconnected, yet separable, subsystems
+act together to form the IRAF data analysis environment.  In
+most cases the user need not be further concerned with this structure,
+except to understand that the specific part of this structure that
+this tutorial addresses is the Command Language or CL.
+
+IRAF is designed as an open system that can be extended to add
+new analysis capabilities, and that can support user customization
+of the existing facilities.  There are several levels of customization
+available, that range from tailoring task parameters to special needs;
+through "re-packaging" existing functions into application specific tasks;
+and extending to installation of new compiled code tasks in the
+environment.  There are a variety of facilities provided in IRAF
+to assist the user in the creation and installation of such new tasks.
+It is not  \emphasize{essential}
+that all of these functions be performed in the IRAF way, but full
+integration of a user task within the IRAF environment can best be 
+accomplished by using the facilities that are provided.  However,
+even without the use of the IRAF interfaces, other tasks may be
+incorporated into the user's operating environment and 
+used as if they were part of the distributed system.
+
+The applications packages and the VOS routines are designed to be
+rather stable, and have been coded in the IRAF SPP language for
+portability.  The kernel layer supports portability across
+operating system architectures, and its interface is stable, but
+the inner details change as a function of the requirements and
+capabilities of the host operating system.  The CL is also 
+rather stable, since it forms the user's interface to the system,
+but it is also an area where change is anticipated, as the system evolves
+to meet the needs of the users.  Because the CL is itself a program
+that is supported by the VOS and isolated from the rest of the system
+by the VOS, it can be evolved as required without perturbing the other
+parts of the system.
+
+\subsection{Function of the Command Language}
+
+\ppind
+The basic function of the Command Language is to 
+provide a clean, consistent interface between the user and the various
+packages of functions that complete the IRAF environment.
+The CL provides an interface between the user and all applications
+programs, giving the user complete control over the parameters, data, and
+system resources (graphics devices, etc.) used by IRAF programs.
+Many features have been incorporated into the CL to provide
+on-line support for users, whether they are old hands or new to the system. 
+
+The packages of programs that are provided offer
+many of the standard functions for data analysis, and they can 
+be invoked interactively, one at a time, to perform many common 
+operations.  The execution of these functions is controlled
+by various parameters, and users may define their
+own values for the parameters as required.  IRAF preserves the 
+last value used, and presents it as the default value upon next
+use.  Furthermore, there are facilities at several levels to allow
+users to assemble existing functions into new tasks that perform
+the specific operations on their data sets.  This
+customization can involve new assemblages of existing functions
+or the inclusion of new functions written in the interactive CL
+language or in compiled languages.
+
+The CL will primarily be used as a \emphasize{command} language, 
+but it is also an interpreted \emphasize{programming} language.
+To be a good  \emphasize{command} language, the CL must make
+it as easy as possible to enter commands that perform common functions.
+To this end the CL provides command menus, minimum-match name abbreviations,
+parameter prompting and parameter defaults, tutoring on command parameters
+and options, and a concise syntax for simple commands.
+There is also a history mechanism that supports recall of previous commands
+and easy error correction within them.
+
+A good interactive  \emphasize{programming} language must
+be reasonably efficient, be able to evaluate complicated expressions,
+to compile and run general procedures, and to offer the user an interpreted
+environment for investigating his data and exploring the applicable
+range of analysis techniques.  This version of the CL (Version 2.3) includes
+all of the command language features of the earlier versions and makes
+major strides in the direction of becoming a powerful interactive
+programming language as well, although much remains to be done before the
+CL provides a reasonably complete and efficient interpreted programming
+environment.
+
+This may sound complicated at this point, but examples
+presented throughout the body of the text will help
+clarify the use of the various features.  We suggest a first reading of
+this introductory section and the next chapter, and then a session at
+the terminal, trying out the examples as presented.
+
+\subsection{Capabilities of the CL}
+
+\ppind
+Besides fulfilling the basic functions of a command language,
+the CL is capable of performing as a programmable desk
+calculator, evaluating expressions, executing CL script tasks
+or external programs, and doing some rather sophisticated
+programming functions. These features provide 
+a means of connecting tasks to build new high level operators.
+The user's interaction with newly created tasks appears the same as 
+interactions with the standard tasks and utility packages,
+as will become apparent in the discussions on usage and script tasks.
+
+The CL has many features familiar to UNIX users in that
+I/O redirection, pipes and filters are provided.
+The output of any task may be routed to a file (redirection)
+or to another task (pipes), and many functions are provided to
+perform standard transformations on a variety of data types (filters).
+Be aware, however, that there are many differences between the CL
+and the UNIX command interpreters.  
+The CL and the IRAF system present the user with a
+complete data analysis environment which is independent of the underlying 
+operating system.  Users running IRAF under UNIX, VMS, AOS, or some
+other operating system have the same analysis environment available
+to them and can type exactly the same commands while in the CL.
+
+The CL supports an open environment in which packages of application
+specific tasks may be created and run.  Some of these packages
+have been prepared by the developers to provide a variety of utility
+services, others that deal with specific instruments and analytic 
+techniques are being made available, 
+and still others can be created by you, to support your
+own view of the data analysis process.  Beyond this, mechanisms exist
+that allow compiled external programs to be inserted in the system in 
+such a way that they appear (and act) as an intrinsic part of IRAF.
+It is this open-ended nature that makes IRAF so powerful in its
+support of a variety of analysis activities.
+
+\newpage
+\section{Getting Started}
+\subsection{Setting up the IRAF environment}
+
+\ppind
+A visitor wishing to use IRAF does not need to take any special
+action to do so.
+Computer support personnel will provide an account on one of the analysis 
+computers and configure the environment as necessary to run IRAF.  
+Staff members and long term visitors will already have established 
+themselves with an account and will only need to perform a few simple 
+operations before the CL and IRAF can be used. \footnote{ {\bf VMS :} The
+command {\eighttt IRAF} must be entered to define system symbolic names.
+This command can be entered at the terminal or stored in your VMS LOGIN.COM
+file; it must be present in the LOGIN.COM file for queued IRAF background
+jobs to startup correctly.}
+After this has been done, all of the other
+commands referenced within this document will be available.
+
+An interactive IRAF session begins with entry of the command 
+\usertype{cl} to run the CL.
+When the CL starts up, it looks for a file called \filename{LOGIN.CL} in the
+user's current directory.  If this directory does not contain a 
+\filename{LOGIN.CL} file, the CL will function for simple things
+such as the evaluation of numerical expressions, but will not work 
+properly for all functions.  Therefore, you should always run the CL 
+from a properly configured IRAF login directory.  
+This directory needs to be initialized for IRAF before the
+CL is invoked; you can use the \usertype{mkiraf} command to setup the
+IRAF environment.  The login directory, once set up, can be used for any number
+of sessions, and if you wish, you can set up several independent login
+directories and data directories for working with different types of data.
+
+\noindent
+Summarizing the steps required to set up the IRAF environment:
+
+\begin{enumerate}
+\item Decide on a login directory.
+\item Go there.
+\item Type \usertype{mkiraf}.
+\end{enumerate}
+
+\noindent
+That is all that is required.  The \usertype{mkiraf} command performs
+several actions, the most important of which are making a
+\filename{LOGIN.CL} file which you may wish to edit to change defaults,
+and the creation of a \filename{UPARM} subdirectory, which is used
+by IRAF to store your customized parameter sets.
+The default login file consists mostly of environment declarations
+(\usertype{set} statements) that define directories, devices, and so on.
+The function of the environment and the significance of the 
+standard \irafname{environment variables} are discussed in \S 4.2.
+
+The \usertype{mkiraf} command can be entered at any time to reinitialize
+the environment, i.e., create a new \filename{LOGIN.CL} from the system
+default and clear the \filename{UPARM} directory.  This is recommended
+periodically to pick up any recent changes in the system, and may be
+required when a major new release of the system is installed.
+
+\subsection{Starting the CL}
+
+\ppind
+After configuring your IRAF directory, type the command \usertype{cl}
+to start the command language.  After a bit the welcome message
+will appear on your terminal, and the first or root ``menu'' of IRAF will 
+be displayed. This menu gives the names of the packages available through
+the CL. The \comptype{cl>} prompt will be issued indicating that the
+CL is ready to accept commands.
+
+\begin{quotation}
+\begin{center}
+\comptype{Welcome to the IRAF.}\\
+\smallskip
+\end{center}
+\begin{verbatim}
+    dataio    images    lists     noao      sdas      system
+    dbms      language  local     plot      softools  utilities
+\end{verbatim}
+\comptype{cl>}
+\end{quotation}
+
+Everything shown in the root menu of IRAF is a \irafname{package} name.
+A package is a set of \irafname{tasks} that are logically connected.
+For example, the \taskname{plot} package contains an assortment of
+general plotting tasks.  You must \emphasize{load} a package before any of the
+tasks therein can be run; you can load any package by simply typing its name.
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{plot}
+\end{quotation}
+
+\noindent
+would load the plot package and make the tasks in the package known to the CL.
+To unload the current package type \taskname{bye}; this frees any system
+resources used by the loaded package and restores the CL to state it was in
+before the package was loaded.
+Note that the system comes up with the \taskname{clpackage, system, language}
+and the default \taskname{user} packages already loaded (the \taskname{user}
+package allows the user to personalize the system, and is discussed in \S 5.6).
+
+A comment should be made at this point about case sensitivity in IRAF.  
+The CL accepts input in both upper 
+and lower case, and distinguishes between them, i.e. a \usertype{'Y'} is 
+different from a \usertype{'y'}.  All command names are purposely
+specified in lower case, which is the default, and all user responses
+are expected to be in lower case as well.  Upper case or mixed case
+names and commands are possible, but should be used with care.
+
+Once the \comptype{cl>} prompt appears, many tasks will be available and
+ready for execution. A list of all loaded packages and the tasks in each
+package may be obtained by typing two question marks (\usertype{??}).
+This will list the tasks organized by package, starting with the current
+package. The packages are listed in the
+order in which they are searched when you type a command. Type one question
+mark (\usertype{?}) to list only the task names in the current package,
+or \usertype{?{\it packagename}} to list the tasks in 
+package ``packagename''.
+
+\subsection{Executing commands from the CL}
+
+\ppind
+At this point you may want to try executing a few simple commands.
+First try the \usertype{help} command.  This will give additional 
+information about the tasks in the current package.
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{help} 
+\end{quotation}
+
+For detailed information about a particular package or task, type
+\usertype{help} followed by the name of the package or task for which help
+documentation is desired.  For example,
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{help system}
+\end{quotation}
+
+\noindent
+will print detailed information about the \taskname{system} package, and
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{help page}
+\end{quotation}
+
+\noindent
+will print detailed information about the \taskname{page} task which is
+in the \taskname{system} package (after each page of text, the \taskname{help}
+program will prompt with a list of keystrokes and pause until you type one
+of them).
+
+Now let's try running some tasks from the \taskname{system} package, which
+is already loaded.  To display the file \filename{LOGIN.CL} on the terminal,
+enter the following command:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{page login.cl}
+\end{quotation}
+
+The \taskname{page} routine, like \taskname{help}, will pause at the end of
+each page of text, waiting for you to type a command keystroke, e.g.,
+to display the next page of text, quit, return to the start of the file,
+go on to the next file if paging a set of files, and so on (typing \key{?}
+in response to the \taskname{page} prompt will cause a summary of the
+acceptable keystrokes to be printed).  To get a directory listing of the
+files in the current directory, type:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{dir}
+\end{quotation}
+
+\noindent
+Observe that all package, task, and parameter names may be abbreviated
+while working interactively.  Any abbreviation may be given which contains
+sufficient characters to identify the name unambiguously; if the 
+abbreviation is not unique, an error message is displayed.  In general
+the first two or three characters are enough to identify most commands,
+but changes to the operating environment, i.e. loading additional packages,
+may require entering more characters or specifying the 
+\emphasize{packagename}
+as a prefix to unambiguously identify the required command.
+
+To list all your files with the \filename{.CL} extension, you can type:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{dir $*$.cl}
+\end{quotation}
+
+As you gain familiarity with the CL you may find that you
+cannot remember the IRAF command to do something, but do know the
+correct command to use in the native operating system.  There is an
+\emphasize{escape} mechanism built into IRAF, in that any operating system
+specific command may be used by prefixing it with a~\usertype{`!'}.
+There are some cautions to be observed that are described in detail
+(\S 4.1), but this knowledge may remove one possible source of frustration.
+Of course, the CL commands \usertype{`?'} or \usertype{`??'} may also be used
+to produce a display of the available package names and functions.
+
+Packages are loaded the same way tasks are run, viz. merely by typing the name
+of the package as a command (a package is in fact a special kind of task).
+If the desired package is a subpackage of a package, the main package must
+be loaded first.  For example, suppose we want to run the \taskname{precess}
+task.  To find out what package \taskname{precess} is in we run \taskname{help}
+on the task \taskname{precess} and observe that the package path (printed at
+the top of the help screen) is "noao.astutil".  This means that the
+\taskname{precess} task is in the \taskname{astutil} package which is in the
+\taskname{noao} package, which we recognize as a root level package.
+
+We load first the \taskname{noao} package and then the \taskname{astutil}
+package by typing:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{noao} \\
+\comptype{no>} \usertype{astutil} \\
+\comptype{as>}
+\end{quotation}
+
+\noindent
+The set of new tasknames now available to you will be displayed automatically.
+Note that the prompt will change from \comptype{cl>} to \comptype{no>}
+to \comptype{as>} to let you know you have entered another package.
+
+One of the astronomical utility programs available is the \taskname{precess}
+program, which is used to precess lists of astronomical coordinates.
+The simplest way to run \taskname{precess} is to type only its name:
+
+\begin{quotation}\noindent
+\comptype{as>} \usertype{precess}
+\end{quotation}
+
+\noindent
+The CL will then prompt you for the parameters it requires to run the program;
+in this case, the CL needs the name of an input file containing a list
+of coordinates to be precessed and the years over which the
+precession is to be computed.  If you do not have the coordinates in a
+file, give the filename as \filename{STDIN} (it must be upper case), and 
+you can then enter the coordinates interactively from the terminal.
+Any number of coordinates (input lines from the special file \filename{STDIN})
+may be entered; signal the ``end of file'' for \filename{STDIN} by typing
+the EOF key, e.g., \key{CTRL/Z}.
+\footnote {\key{CTRL/Z} is the standard EOF (end of file)
+sequence on VMS and most UNIX systems.  Similarly, \key{CTRL/C} is the
+standard interrupt key on these systems.  For simplicity we use the explicit
+control codes to refer to these functions in most of the IRAF documentation,
+but the reader should be aware that different control sequences may be used
+on the local system and be prepared to make the translations.  For example,
+the key \key{CTRL/D} is often used to signal EOF instead of \key{CTRL/Z}.}
+Coordinates are entered in pairs (RA and DEC, delimited by spaces) in either
+decimal or sexagesimal notation (e.g., 12.5 or 12:30:04.2).  If you have any
+problems type \usertype{help precess} for additional information, including
+examples.
+
+If you have a long list of coordinates to precess, try entering
+them into a file.  The command:
+
+\begin{quotation}\noindent
+\comptype{as>} \usertype{edit coord1950.txt}
+\end{quotation}
+
+\noindent
+will call up the default editor (Vi on UNIX systems; EDT or EMACS on VMS
+systems) to edit the file \filename{COORD1950.TXT}.
+After creating your coordinate file and exiting the editor in the usual
+fashion, you will be back in the CL.  Now try executing the \taskname{precess}
+program, using the file \filename{COORD1950.TXT} as input:
+
+\begin{quotation}\noindent
+\comptype{as>} \usertype{precess coord1950.txt}
+\end{quotation}
+
+\noindent
+Of course, the output will still appear on the terminal, and
+you may wish to \irafname{redirect} the output into a file as well:
+
+\begin{quotation}\noindent
+\comptype{as>} \usertype{precess coord1950.txt $>$ coord1984.txt}
+\end{quotation}
+
+If the coordinate list is \emphasize{very} long, you may wish to process
+the list as a background job.  To avoid interruptions from parameter 
+prompts by the background task (it will inquire at the terminal), be sure to
+enter all the necessary parameters on the command line. 
+To execute the task \taskname{precess} in the background, type:
+
+\begin{quotation}\noindent
+\comptype{as>} \usertype{precess coord1950.txt 1950 1984 $>$ coord1984.txt \& }
+\end{quotation}
+
+\noindent
+The final `\usertype{\&}' tells the CL to run the task in the background.
+The two parameters 1950 and 1984 will be passed to the task; you will
+not be prompted for them.
+Once the background task is started, the CL will be available for 
+further interactive use and you will be
+informed when the background job is complete.  The use of background
+tasks for batch processing is treated in more detail in \S 5.4.
+
+\subsection{A Comment on Input and Output}
+
+\ppind
+The notion of output \irafname{redirection} has already been introduced, and the
+topics of input redirection (accepting input from a file rather than
+the terminal) and \irafname{pipes} (connecting the output from one task to the 
+input of the next) will be dealt with in \S 3.3. The point to be
+made at this time is that \emphasize{all} tasks can be thought of as having
+three main I/O paths associated with them:
+
+\begin{quotation}\noindent
+\begin{tabular}{l l}
+\filename{STDIN} & the input path \\
+\filename{STDOUT} & the output path \\
+\filename{STDERR} & where error messages appear
+\end{tabular}
+\end{quotation}
+
+%\begin{quotation}\noindent
+%\begin{description}
+%\item[\filename{STDIN}] the input path
+%\item[\filename{STDOUT}] the output path
+%\item[\filename{STDERR}] where error messages appear
+%\end{description}
+%\end{quotation}
+
+\noindent
+By default, all of these I/O paths are connected to your terminal 
+(referred to as \filename{TTY}) and you may redirect any one or all 
+of them using simple command line requests.  The output 
+\emphasize{redirection} introduced in the previous example of 
+\taskname{precess} is an example of just such an action.  Other 
+examples in \S 3.3 will cover this topic in more detail.  
+
+There are other standard output streams as well that depend on the
+specifics of the task.  Not surprisingly,  graphics tasks
+want to talk to a graphics terminal or other suitable device
+(\filename{STDGRAPH}) and image tasks need access to an image display
+(\filename{STDIMAGE}). There is a stream for the graphics plotter device as well
+(\filename{STDPLOT}). Each of these \emphasize{logical} devices is assigned
+to a physical device, either by commands in your \filename{LOGIN.CL} file
+or by explicit parameters in the function calls.
+
+\subsection{The Graceful Exit}
+
+\ppind
+Now that you are a couple of layers deep into the CL, you may wonder 
+how to get back out again. If you type \usertype{bye}, you will exit the current
+package and return one level of loaded packages.  You cannot, however, type
+\usertype{bye} at the root CL level (\comptype{cl>} prompt).
+The command:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{logout}
+\end{quotation}
+
+\noindent
+may be used to exit directly from the CL at any level.  
+The \usertype{bye} command or the \key{CTRL/Z} sequence that signals
+EOF will exit from any task except the CL itself.  This is to
+prevent an unintended \emphasize{logout} from occuring if a series
+of EOF's are entered from the terminal.
+
+For a less gentle departure from function execution, the interrupt
+sequence \key{CTRL/C} may be used at any level.  
+This will usually terminate any task that appears to
+be hung or is operating in error, but will normally put you
+back in the CL in interactive mode.
+
+\newpage
+\section{Basic Usage}
+
+\ppind
+The CL can be used as both a command language and a programming language,
+but most first-time users (and many experienced ones) will mostly
+use the command features of the language.  Commands to the CL may be
+entered at the terminal, one at a time, or they may be read in from
+a script file; in either case the syntax is the same and abbreviation
+of command names and variable names is supported. When the CL is
+being used for programming the rules are more restrictive, and
+full name specification is required, as is a more formal specification
+of task parameters.  During the early sections of this document
+only the command forms will be used for simplicity.
+Parameters to a task may be specified on the command line for brevity,
+and prompting is automatically enabled for any required parameters that
+are not specified or that are given values that are out of range.  
+
+\subsection{Command Syntax}
+
+\ppind
+The form of a command that calls an IRAF task is the 
+\emphasize{task name}, optionally followed by an
+\emphasize{argument list}. The argument
+list consists of a list of \emphasize{expressions} delimited by spaces. 
+Simple filenames or string arguments that appear in the unparenthesized 
+argument list need not be quoted, but any string that contains an 
+embedded blank or other special characters should be quoted.
+\emphasize{Positional} arguments (typically the first few
+arguments \emphasize{required} for a function must be given first and 
+in order.
+All of these may be followed by \emphasize{param = value} keyword assignments, 
+\emphasize{param$\pm$} switches, and \emphasize{file} I/O redirection
+assignments. These last three types of arguments may appear in any order.
+In general, the form is as follows :
+
+\begin{quotation}\noindent
+\begin{tabular}{lll}
+\comptype{cl>} {\it taskname} [{\it expression} $\ldots$ ] & 
+	  [{\it param=value}]	& [$<${\it filename}] \\
+	& [{\it param}$\pm$]	& [$>${\it filename}] \\
+	&			& [$>>${\it filename}] \\
+	&			& [$>\&${\it filename}] 
+\end{tabular}
+\end{quotation}
+
+\noindent
+Any or all of these types of parameters may be present 
+and defaults are provided for most parameters.  
+In particular, the only parameters that 
+\emphasize{must} be set are the \irafname{required parameters}
+and if these are not specified on the command line, the CL will prompt
+for them.  Other parameters and switch values are defaulted, but may be
+overridden if desired. 
+The I/O streams typically default to the login terminal, but the
+redirection operators may be used to request: input from a file
+(\usertype{$<$}); output to a file(\usertype{$>$}); appending to
+a file (\usertype{$>>$}); or redirecting the standard output and the 
+standard error stream to a file (\usertype{$>$\&}). 
+
+The form of a command line need not be limited to a solitary call to a task.
+Several tasks may be called in sequence on a single command 
+line, using the semicolon character `;' to delimit each call:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{clear; dir}
+\end{quotation}
+
+\newpage
+\noindent
+If the command sequence is too long to fit on a single line, it can be
+enclosed in braces:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{\{ } \\
+\comptype{>>>} \usertype{clear} \\
+\comptype{>>>} \usertype{directory} \\
+\comptype{>>>} \usertype{beep} \\
+\comptype{>>>} \usertype{\} }
+\end{quotation}
+
+\noindent
+Note that the prompt changes to \comptype{>>>} after the first
+line to signal that the CL requires more input before it will execute the
+task. (In this particular example, the CL is waiting for a `\}'.)
+
+Such a construct is called a \irafname{compound statement} and may be
+used to aggregate several simple commands into a single new command.
+Compound statements may be used directly from the terminal (or within
+scripts as we shall see later) and will be treated as a single 
+entity by the display and editing commands.
+An arbitrary number of commands may be entered in a compound statement
+and then executed as a single unit.  
+
+Commands may be strung together in another way too, by use of the
+pipe notation, which requests that the output of one command
+be used as the input to the next.  Creation of the temporary files that
+support this, and connection of the task logical I/O paths to these
+files is handled automatically by IRAF.
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{type coord1950.txt \pipe precess 1950 1984}
+\end{quotation}
+
+\noindent
+The pipe symbol `{\tt |}' directs the CL to feed the output of
+one task (\usertype{type}) to the input of the next (\usertype{precess}).
+
+\noindent
+If an argument list is too long to fit on one line,
+continuation is understood if the last item on a line is a backslash
+`$\backslash$', the pipe symbol, or an operator (e.g., `$+$' or `{\tt //}').
+
+\begin{quotation}\noindent
+\comptype{pl>} \usertype{graph "pix[*,5],pix[*,10],pix[*,15]" po$+$ 
+	marker=circle \bsl } \\
+\comptype{>>>} \usertype{xlabel=column ylabel=intensity \bsl  } \\
+\comptype{>>>} \usertype{title = "lines 5, 10, and 15"}
+\end{quotation}
+
+Quotes \emphasize{may} be used around
+any string of characters, but are generally not required on commands
+entered at the terminal.  In the previous example quotes are used
+around the string value of the \usertype{title} parameter because the
+string contains embedded spaces.
+
+To make precise the rules for quoted strings:
+a string need not be
+quoted provided [1] it appears as an identifier (a name) in an argument
+list \emphasize{not} enclosed in parentheses, AND [2] the string does not
+contain any blanks or other characters which are special to the CL,
+e.g., the i/o redirection symbols, the pipe symbol, semicolon, the begin
+comment character (\usertype{\#}) or curly braces.
+If the string contains any special characters it must be quoted.
+
+Comments may be freely embedded in a command sequence.
+Everything following the comment character on a line is ignored by the parser,
+so entire comment lines may be entered by starting the line with a comment:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{\# This is a full line comment} \\
+\comptype{cl>} \usertype{type login.cl \hfill  \#~Display~the~login~file }
+\end{quotation}
+
+\noindent
+or by appending a comment to the end of a line as in the last example.
+
+\subsection{Task Parameters}
+
+\ppind
+Nearly all tasks have a formally defined set of parameters associated
+with them.  The parameters for a task may be listed with the command
+\usertype{lparam }{\it taskname}.  For example, to list the parameters for
+the task \taskname{delete}, type:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{lparam delete}
+\end{quotation}
+
+\noindent
+The \usertype{lparam} command produces a display of the parameters of the
+named task in the order in
+which they must be given on the command line; it shows the current values
+of the parameters and the prompt strings as well.
+
+After one types \usertype{lparam delete}, the following list will appear,
+giving the parameter name, its
+current value, and the prompt string associated with it:
+
+\begin{verbatim}
+                files =        list of files to be deleted
+             go_ahead = yes    delete or not ?
+              (verify = no)    verify operation before deleting each file ?
+      (default_action = yes)   default delete action for verify query
+         (allversions = yes)   delete all versions of a file ?
+            (subfiles = yes)   delete any subfiles of a file ?
+                (mode = ql)
+\end{verbatim}
+
+Notice that there are two types of parameters, those with 
+parentheses around the \emphasize{param = value} fields and those without.
+The parameters not enclosed in parentheses are called 
+\irafname{positional parameters}; they are required parameters
+and will be queried for if not given on the command line. Positional
+\emphasize{arguments} are the first arguments on the command line (following
+the command itself), and they are associated with parameters by their position
+on the command line. The first positional parameter will be set by the first
+positional argument on the command line, the second positional parameter by
+the second positional argument, and so on. 
+
+The parameters enclosed in
+parentheses are called \irafname{hidden parameters}, and are the topic of
+the next section.  Either type of parameter may be referred to by a
+\usertype{param = value} clause, although these parameter references
+must \emphasize{follow} the positional arguments.  Such name references
+\emphasize{must} be used for the hidden parameters, but may be used for all.
+
+Some of the parameter handling actions in the CL are rather elaborate
+and require discussion.  As was just noted, the CL will automatically
+prompt for any required parameters that have not been provided in some
+way by the user.  Beyond this, the normal action of the CL is to
+remember the parameters that you last used, and when that parameter
+name is next encountered, to offer the last value used as the new
+default value.  This \irafname{learning} of parameters is intended
+to reduce user effort and is a means of customizing use of the system.
+The learned parameters are saved for you in the \filename{UPARM}
+subdirectory, and will be preserved across uses of the system.
+
+\subsubsection{Hidden Parameters}
+
+\ppind
+The parameters of the \usertype{delete} task that appeared in 
+parentheses are \taskname{hidden parameters} for the task.
+The CL does not query for hidden parameters, but automatically
+uses the default values.  However, a query will be generated for 
+even a hidden parameter if there is no
+default value or if the default value is illegal for some reason.
+Hidden parameters may be set on the command line, but unlike positional
+parameters, the value from the command line will not be learned, i.e., it will
+not become the new default value.  The default value of a hidden parameter may
+be changed only by an explicit assignment, or by use of the \taskname{eparam}
+task (\S 3.2.3), and you should exercise caution in doing this,
+because it is easy to forget that hidden parameters have been changed.
+
+Hidden parameters are often used to change the behavior of a task,
+achieving considerable flexibility without requiring many arguments on the
+command line, and without annoying queries for parameters.  Hidden parameters
+make it possible to support functions like \taskname{graph} that
+support different display options,  since users can modify
+the default behavior of the task to make it behave in the manner they want.
+Hidden parameters can also be dangerous if they are used improperly
+(e.g., for data dependent parameters in scientific programs).
+
+The \taskname{delete} task is a good example of a task that is useful to
+personalize.  The default behavior of \taskname{delete} is simply to delete
+the named file or files (provided they are not protected in some way).
+File deletion can be hazardous, of course, particularly since a pattern
+matching template may be used to delete many files. As many of us are unhappily
+aware, inadvertently typing
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{delete $*$}
+\end{quotation}
+
+\noindent
+will bring about the swift deletion of \emphasize{all} of the (unprotected)
+files in the current default directory.
+As IRAF recognizes a number of special pattern matching metacharacters in
+addition to `$*$', one could easily free up a lot of disk space if one were
+not familiar with the use of pattern matching templates.
+
+To reduce the possibility of such devastating side-effects, you might wish to
+change the default behavior of \taskname{delete} to verify each file deletion.
+This is done by changing the value of the hidden parameter \taskname{verify},
+which defaults to \emphasize{no}.  Hidden parameters that are boolean flags 
+(yes/no) may be overridden temporarily on the command line as follows:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{delete $*$.dat verify=yes}
+\end{quotation}
+
+\noindent
+or, equivalently,
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{delete $*$.dat verify$+$}
+\end{quotation}
+
+\noindent
+Either of these commands would cause a prompt to be issued naming
+each file matching the template and asking if you want to delete
+it (this would happen even if the task were running in batch mode).
+
+If you set a hidden parameter on the command line, you override the value
+of that parameter only for that command; the default value is not changed.
+As indicated before, to change the default value of a hidden parameter,
+an explicit assignment is required:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{delete.verify = yes}
+\end{quotation}
+
+\noindent
+which will cause all subsequent file deletions to be verified, unless the
+\usertype{delete} command is issued with the argument \usertype{verify=no}
+or \usertype{verify$-$} on the command line.  The change may be undone by
+another assignment, or by \emphasize{unlearning} the task parameters.  
+
+\subsubsection{Learning and Unlearning parameters}
+
+\ppind
+The CL facility called \irafname{learn mode} is designed
+to simplify the use of the system.
+By default, the CL automatically ``learns'' the value of all task
+\irafname{parameters} that are prompted for or explicitly set.  In practice,
+this means that once a required parameter (such as the precession epoch in
+the \taskname{precess} example)
+has been set, it need not be respecified.  The CL will still prompt for
+required parameters, but the default value displayed will be the
+last value you entered.  Simply hitting \key{RETURN} will cause the CL
+to reuse the old value; but a new value may be entered and it will
+be preserved as the new default. If the required parameters are
+specified on the command line, you will not be prompted for them, and the
+value you specify will still be learned.
+
+The parameter-learning mechanism has other ramifications as well.
+The most recently used parameter values are automatically preserved
+by the CL in \filename{.PAR} files stored in your \filename{UPARM} directory.  
+These saved parameter
+sets are reloaded when you next start the CL, thus providing a
+\emphasize{memory} of the options that you used in a previous session.  
+Any command line arguments
+that you specify will override these \emphasize{learned} defaults, but they
+will be available if you wish to use them.
+
+An explicit command may be used to
+\emphasize{reset} the values of parameters,
+i.e., to restore the defaults. The \usertype{unlearn} command restores the
+system default values of all of the parameters for a single task or for an
+entire package.
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{unlearn delete}
+\end{quotation}
+
+\noindent
+will restore the parameters of the task \taskname{delete} to their default
+values, and
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{unlearn system}
+\end{quotation}
+
+\noindent
+will restore the defaults for \emphasize{all} of the tasks in the system
+package. If you want to restore the defaults for all the parameters in your
+IRAF environment, delete the \filename{.PAR} files from the logical directory
+\filename{UPARM} :
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{delete uparm\$$*$.par}
+\end{quotation}
+
+\subsubsection{Specifying Parameters to a Task}
+
+\ppind
+The simplest and fastest way to invoke a task is to simply type in the name
+of the task followed by the necessary arguments on the command line, as we
+have been doing in most of the examples thus far.
+In many cases, the arguments for a task will be obvious, either from the context
+and the prompts issued by the task, or from the \usertype{lparam} display.
+If you are unsure about how to proceed,
+you can simply type the task name, and answer the questions.
+Each prompt may include minimum and maximum acceptable values,
+if such apply, and the current value of the parameter if such exists. 
+For parameters that have only a fixed set of allowable values the list of
+valid options will be enumerated.
+
+Alternatively, the \usertype{eparam} command may be used to invoke the
+parameter \emphasize{editor}.  The \taskname{eparam} task presents the
+parameters of a task in a tabular display on the screen and supports the
+use of the cursor keys to navigate the options.  It also has commands for
+changing entries, or for recalling previous entries for further editing.
+The command:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{eparam precess}
+\end{quotation}
+
+\noindent
+will display the parameters for \taskname{precess} (the \taskname{noao} and
+\taskname{astutil} packages must first be loaded).  The \key{RETURN}
+key will move you down the list or the cursor keys
+may be used to move among the parameters, and any entries that you
+type will replace the displayed values.  You may exit from
+\taskname{eparam} at any time with a \key{CTRL/Z} and the parameters 
+for the task will be updated with your newly edited values.
+If you wish to exit the editor \emphasize{without} updating the
+parameters, use the interrupt request \key{CTRL/C} instead.
+Specifying parameters via \usertype{eparam} has the same effect as
+does entering them on the command line, they will be remembered by IRAF
+and not prompted for when the function is next invoked.  
+
+\usertype{Eparam} and the history editor \usertype{ehistory} both
+use the same simple set of editor commands, and they can mimic several 
+editors that are common on the currently supported systems.  For any
+of these editors the default style supports use of the cursor (arrow keys)
+on the terminal and the use of the \key{DELETE} key.  The sections on
+editors (\S 5.2-3) describe this in more detail.
+
+If you find that you must invariably run \taskname{eparam} before running
+a particular task, e.g., because the task has too many parameters to be
+specified on the command line, it is possible to get the CL to run
+\taskname{eparam} for you automatically whenever the task is run interactively.
+This is called \usertype{menu mode}.  To set menu mode for a task we
+set the string value of the \taskname{mode} parameter of the task; all
+tasks have such a parameter.  For example,
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{precess.mode = ``ml''}
+\end{quotation}
+
+\noindent
+will set both menu and learn mode for the task \taskname{precess}.
+The default mode for most tasks is \usertype{ql}, i.e., query (the task
+will query for all parameters not set on the command line) plus learn
+(old parameter values are learned).
+
+Once you are familiar with the operation of a task, you can
+enter the parameter values on the command line in the
+order in which they appear in the \usertype{lparam} listing.
+Parameters may also be set using the \usertype{param = value} clause on the
+command line, but remember that any positional arguments must be given first.
+Note that a command line argument may be any general expression, much like
+the arguments to a Fortran subroutine.
+
+\begin{quotation} \noindent
+\comptype{cl>} \usertype{precess stdepoch= (1984$+$i$*$4)}
+\end{quotation}
+
+\noindent
+Here an expression is used to compute the value of the
+hidden parameter \taskname{stdepoch}. Note that the expression must
+be enclosed in parentheses in order to cause it to evaluated, since it
+will otherwise be treated like a string and just passed into the task
+for it to handle.  The variable \usertype{i} must previously have 
+been set to some legal value; otherwise the CL will prompt for it.
+
+\subsection{Pipes and I/O Redirection}
+
+\ppind
+We have already seen how tasks can take their input from either the
+terminal or from a file, and send the output to either the terminal
+or a file.  By default, both the standard input and standard output for a
+task are written to the user terminal; the capability to change them
+on the command line is called \emphasize{I/O redirection}.  The Appendix of
+IRAF commands at the end of this document was created with the 
+following simple command:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{help {\it pkg} $>$ {\it pkg.txt} }
+\end{quotation}
+
+\noindent
+where the name of each package was substituted for {\it pkg}.
+
+The pipe syntax is a powerful kind of I/O redirection. A pipe is formed by
+connecting the output of one task to the input of another task; an arbitrary
+number of tasks may be connected together in this way to form a single command.
+UNIX users will already be familiar with the concept and uses of pipes,
+but be aware that CL pipes differ from UNIX pipes in that the CL tasks
+execute \emphasize{serially} rather than concurrently (i.e., nothing comes out
+of the end of the pipe until \emphasize{all} the input has been processed).
+Another difference between IRAF and the usual UNIX implementation
+is that IRAF pipes are implemented with temporary files which are
+managed by the system.
+Note also that queries for parameters are not affected by the use of 
+I/O redirection or pipes, i.e., required parameters will still be 
+prompted for when requested by a task.
+
+A simple example of the use of a pipe is redirecting the output of a command
+to the line printer.  This can be done with I/O redirection as follows:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{help plot $>$ temp} \\
+\comptype{cl>} \usertype{lprint temp} \\
+\comptype{cl>} \usertype{delete temp}
+\end{quotation}
+
+\noindent
+The pipe notation accomplishes the same thing and is more concise:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{help plot \pipe lprint}
+\end{quotation}
+
+\noindent
+For a more sophisticated example of the use of pipes, load the
+\usertype{lists} package and try out the following command:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{?? \pipe words \pipe match : stop$+$ \pipe
+	sort \pipe table}
+\end{quotation}
+
+\noindent
+This sequence of commands takes the list of menus produced by \usertype{??},
+breaks it into a list of words, filters out the lines that contain the colon
+character (the package names), sorts the list, and prints a menu listing the
+tasks in all loaded packages.
+
+The following example shows the use of a pipe-filter to sort the output
+of a long form directory listing of the system library directory \filename{LIB},
+sorting the list in reverse numeric order by the size of the file, so that
+the largest files come out at the top of the list:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{dir lib l$+$ \pipe sort num$+$ rev$+$ col$=$3}
+\end{quotation}
+
+\noindent
+We can go a bit further and extend the pipe to print only the ten largest
+files and page the output:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{dir lib l$+$ \pipe sort num$+$ rev$+$ col$=$3 \pipe
+	head nlines$=$10 \pipe page}
+\end{quotation}
+
+Any or all of the input, output or error logical I/O streams may be
+redirected with simple command line requests.  The next example shows
+the use of redirected input and output streams:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype {
+	match \upa\usertype{set} $<$ home\$login.cl $>$ names.env }
+\end{quotation}
+
+\noindent
+This command reads from your \filename{LOGIN.CL} file, created by the
+initial \usertype{mkiraf} command, matches all the lines that contain
+\usertype{set} environment statements (the metacharacter \upa (up-arrow)
+causes \usertype{set} to be matched only at the beginning of a line),
+and writes these out into the file \filename{NAMES.ENV}.
+
+The \usertype{$>$} redirection operators will create a new output file.
+To append to an existing file we use the \usertype{$>>$} operator instead:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{set \pipe match tty $>>$ names.env}
+\end{quotation}
+
+\noindent
+which will scan for all the environment variables having something to do with
+the terminal and append them to the file \filename{NAMES.ENV}.
+
+The operators \usertype{$>$} and \usertype{$>>$} will redirect only the
+standard output stream \filename{STDOUT}; error messages will still come
+out on the terminal.  To redirect both \filename{STDOUT} and \filename{STDERR}
+the operators \usertype{$>$\&} and \usertype{$>>$\&} should be used instead.
+
+The graphics output streams may be redirected (but not piped) much as is
+done for the ordinary textual output streams.\footnote{This holds only for
+standard IRAF tasks, i.e., tasks which use the IRAF graphics subsystem.
+This feature is not currently available for the STScI SDAS tasks since they
+do not use the IRAF graphics facilities.}  For example, to redirect the
+standard graphics output of the \taskname{surface} task (in the \taskname{plot}
+package) to produce a graphics metacode file \filename{SURF.MC}:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{ surface dev\$pix $>$G surf.mc}
+\end{quotation}
+
+To redirect the \filename{STDIMAGE} stream, substitute the operator
+\usertype{$>$I}, and to redirect the \filename{STDPLOT} stream, use the
+operator \usertype{$>$P}.  The characters \usertype{GIP} must be uppercase.
+The \usertype{$>$} may be doubled to append to an existing file, as for
+the standard text streams.  As a special case, a graphics stream (or indeed
+any stream) may be redirected to the so-called \emphasize{null} file
+\filename{DEV\$NULL} to discard the output.  For example,
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype {prow dev\$pix 100 $>$G dev\$null}
+\end{quotation}
+
+\noindent
+will plot row 100 of image \filename{DEV\$PIX}, redirecting the graphics output
+into the null file.  The null file can be used anywhere a normal file can be
+used.
+
+\newpage
+\section{Operating System Interface}
+
+\ppind
+Although IRAF provides a quite complete environment for data analysis
+activities, it must be hosted in some particular operating system whenever
+it is being used.  The isolation from the peculiarities of any
+specific operating system command syntax is rather complete, but there
+are instances where the syntax of the underlying system must be
+used (host filenames) or where the user may desire to use familiar
+commands from the host system.  IRAF does allow commands to be passed
+through to the host operating system, but because IRAF maintains all of
+its own environment descriptors, directory structures, and task and
+program information, the operating system commands should only be used
+to bring information into the IRAF environment, but not to modify it.
+In order to change any of the status or control information that
+affect IRAF execution, the commands provided by IRAF must be used.
+
+\subsection{Sending Commands to the Host Operating System}
+
+\ppind
+IRAF allows access to the underlying operating system, and hence to
+other programs that operate within the native operating system
+environment.  There are limitations on some of the system facilities that
+can be used without regard to side-effects, but, in general, almost any
+program can be called from within IRAF.
+External programs can be accessed from within the user's environment and will 
+operate with a standard interface that is compatible with the
+rest of the processing functions that are available.
+
+Any command may be sent to the host operating system by prefixing
+the command with the escape character `\usertype{!}'.  The rest of the
+command line will be passed on unmodified.  For example, to read your mail
+on a UNIX or VMS system:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{!mail}
+\end{quotation}
+
+\noindent
+Upon exiting the mail routine, you will be back in the CL. Almost any
+task that is executable in the normal host environment can be invoked
+from within IRAF by means of this escape mechanism.  The OS escape
+is used to implement some of the standard IRAF commands that request
+operating system information, such as \usertype{spy}.
+The \usertype{edit} command also uses the escape mechanism, so that
+the host supported editors can be used, rather than require that a
+completely new editor be learned in order to use IRAF.
+
+Occasional conflicts will arise if these external tasks re-assign
+their terminal input and output streams or perform other unnatural acts.
+If strange things happen when trying to use such tasks from within
+the CL, consult your \irafname{IRAF Guru}.  The other major source of problems
+with host system tasks is that they may depend upon system specific
+data that have been defined for the OS but are unknown to IRAF.  This
+is a particular problem under VMS, which does not pass system environment
+parameters to sub-tasks, as does UNIX.  Variables that affect the 
+execution of tasks within the environment are controlled by IRAF and
+are passed between the executing tasks, as in described next.
+
+\subsection{Environment Variables}
+
+\ppind
+The CL maintains a table of environment variables which 
+affect the operation of \emphasize{all} IRAF programs.
+The environment variables are used to define logical names for directories,
+to associate logical device names with a specific physical device, 
+and to provide control over the low level functioning of the 
+IRAF file I/O system.
+The default environment is created by IRAF at login time, i.e., when the
+CL is first run.  Part of this initialization uses a standard system-wide,
+site dependent file named \filename{HLIB\$ZZSETENV.DEF}.  Additional
+initialization of personal environment variables, or redefinition
+of standard environment variables, may be done with commands
+in your \filename{LOGIN.CL} file. 
+
+One may add new environment variables, or redefine old ones, at any time during
+a session with the \usertype{set} command.  \usertype{Set} declarations made
+during CL execution, however, may be lost upon exit from a package.  To secure
+environment declarations for a full session, make them \emphasize{immediately}
+after logging in.  To make environment declarations permanent, place the
+relevant \usertype{set} commands in your \filename{LOGIN.CL} file.
+
+The \usertype{set} command is usually used to change the \emphasize{session}
+defaults for output devices and such, but all IRAF programs which write to the
+line printer or to a graphics device also permit the device to be selected on
+the command line.  For example,
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{set terminal = vt100}
+\end{quotation}
+
+\noindent
+informs IRAF that the user is using a VT100-type terminal for this session. 
+When typed without any arguments, e.g.:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{set \pipe page}
+\end{quotation}
+
+\noindent
+\taskname{set} displays a list of the current values of all of the environment
+variables.  Note that abbreviations are \emphasize{not} supported for
+environment variable names, they must be spelled out in full.
+If a shorter name is used the CL will silently create a new environment
+variable for you, which may not be what you desired at all. 
+
+Identifying the kind of terminal you are using, the size of the display
+window to be used, and setting other terminal options may most conveniently
+be done with the \usertype{stty} command:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{stty tek4014 baud$=$1200}
+\end{quotation}
+
+\noindent
+This command should be used early in the session (if not already present in
+the \filename{LOGIN.CL} file) to identify the kind of terminal that you are
+using, since the operation of the various editors and of other functions will
+be affected by these values.  It is only necessary to set baud rate as in
+the example if you are working remotely via modem.  As was the case with
+the \usertype{set} command, typing \usertype{stty} with no arguments will
+display the current terminal type and settings.
+
+The current value of \emphasize{individual} environment variables may be
+displayed with the \usertype{show} command:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{show printer}
+\end{quotation}
+
+\noindent
+A selection of the more important environment variables is shown in the
+following table.
+
+\begin{center}
+\begin{tabular}{|l|l|l|}
+\hline
+\multicolumn{3}{|c|}{\bf Selected Environment Variables}\\
+\hline
+{\it variable}&  {\it sample value}&  {\it usage}\\
+\hline
+terminal&       ``vt100''&      default terminal device\\
+printer&        ``printronix''& default line printer device\\
+stdgraph&       ``vt640''&      name of graphics terminal device\\
+stdplot&        ``versatec''&  	batch plotter device\\
+stdvdm& 	``uparm\$vdm''&	name of graphics metacode file\\
+stdimage&       ``iism75''&	image display device\\
+clobber&        no&     	clobber (overwrite) output files\\
+filewait&       yes&    	wait for busy files to become available\\
+\hline
+\end{tabular}
+\end{center}
+\medskip
+
+\noindent
+Clearly, the permissible names of devices are site dependent; for a list of
+the devices available at a particular site the user should consult their
+\irafname{IRAF Guru} (or look in the \filename{TERMCAP} and \filename{GRAPHCAP}
+files in the IRAF logical directory \filename{DEV}).
+
+Among the set of environment variables that control the operation of
+the CL is a subset of variables that define the user environment.  These
+variables describe the user's home and scratch directories, terminal
+type, and editor preference.  Because these values describe a user's-eye
+view of IRAF, they can be thought of as \emphasize{customization} variables
+and can be \usertype{set} in the \filename{LOGIN.CL} file to your 
+preferred values.  
+
+\begin{center}
+\begin{tabular}{|l|l|l|}
+\hline
+\multicolumn{3}{|c|}{\bf User Environment Variables}\\
+\hline
+{\it variable}&  {\it sample value}&  {\it usage}\\
+\hline
+editor&		``vi'' &	default editor mode\\
+home&		``/{\it user}/iraf/'' \footnotemark & user home directory\\
+uparm&		``home\$uparm/''&	user scratch directory\\
+imdir&  	\emphasize{system-dependent}&directory where bulk data is stored\\
+imtype&  	``imh'' & default image type (header file extension)\\
+userid&		{\it user}&	user identification name (for output)\\
+\hline
+\end{tabular}
+\end{center}
+
+\footnotetext{ {\bf VMS :} an equivalent VMS example might be 
+``DISK\bsl\$1:[USER.IRAF]''.  Note that any dollar sign characters appearing
+in host filenames must be escaped in IRAF since the dollar sign is a reserved
+character in IRAF filenames.}
+
+\noindent
+The \filename{HOME} directory specification, and possibly an 
+\filename{IMDIR} declaration should be the \emphasize{only} places in
+your \filename{LOGIN.CL} file where any system specific names appear
+at all.  All of the IRAF name references (except a single root reference)
+are processed by the virtual name mapping algorithms. If this same
+mechanism is used for all user files as well, then only IRAF
+virtual filenames need to be referenced once the root directory
+has been properly specified.
+
+The default \emphasize{uparm} declaration
+assumes that a \filename{UPARM}
+subdirectory has been set up in your login directory; the \usertype{mkiraf}
+command described earlier (\S 2.1) sets this up for you. If a \filename{UPARM}
+subdirectory does \emphasize{not} exist, the CL will refuse to update
+user parameters and will issue a warning message.
+
+\subsection{File and Directory Names}
+
+\ppind
+The IRAF system employs \irafname{virtual file} names so that all file
+references will look the same on any computer, and IRAF primitives convert 
+virtual filenames into their host operating system equivalents.  In general,
+either the IRAF virtual filename or the operating-system-dependent filename
+may be used in a command entered by the user, but users should avoid
+the use of OS-specific names wherever possible.  Internally IRAF itself 
+uses only virtual filenames for reasons of transportability.
+
+Note that filename mapping does not operate automatically for virtual file
+names that are passed as parameters to foreign (host system) tasks, but a CL
+intrinsic function \taskname{osfn} will perform the mapping if called
+explicitly on the command line.  The host task must be declared as an IRAF
+\taskname{foreign task} (\S 5.6) for this to work.  There is no provision
+for filename mapping when the regular OS escape mechanism (\S 4.1) is used.
+
+The environment variables described in the preceding section play a fundamental
+role in the mapping of virtual filenames.  Environment variables define 
+the logical directories that are used to create host operating system
+specific names from logical names. An example of a virtual filename
+is the default logfile, \filename{HOME\$LOGFILE.CL}. 
+The \filename{HOME} field, delimited by the `\$' character, is the logical
+directory; the file name within that directory is \filename{LOGFILE.CL}.
+Successive translations of `\$'-delimited logical names are performed until the
+operating system dependent name has been generated.  Names such as 
+\filename{HOME\$UPARM/} are \emphasize{directory} references; the trailing `/'
+indicates that a filename or sub-directory name may be appended to produce
+a legal file or directory pathname.
+
+\subsubsection{File Name Templates and Metacharacters}
+
+\ppind
+Although filenames cannot be abbreviated the way commands can,
+pattern matching templates can be constructed that 
+refer to many files.  You need only type a
+short string (the pattern) that serves as a \emphasize{template}, and all
+files whose names match the template are selected.  All of the IRAF
+functions that process filenames (and this is most of them) use the
+same function to expand filename templates into a list of files.
+The pattern matching \irafname{metacharacters} are a super-set of those
+used in the UNIX and VMS operating systems. To print all files having
+the extension \filename{.CL}, type:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{lprint $*$.cl}
+\end{quotation}
+
+\noindent
+To page through all files in the logical directory \filename{FIO} 
+with the \filename{.X} extension, type:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{page fio\$$*$.x}
+\end{quotation}
+
+\noindent
+The filenames matched by the file template are passed to the \usertype{page}
+task which pages through the set of files.  As each file is accessed, the VOS
+filename translation facilities are used internally to generate the host
+system filename, which is passed to the kernel to physically open the file.
+
+\begin{center}
+\begin{tabular}{|l|l|l|}
+\hline
+\multicolumn{3}{|c|}{\bf Pattern Matching Metacharacters} \\
+\hline
+{\it Meta-char}&  {\it Meaning}&  {\it Example}\\
+\hline
+$*$ &		Match zero or more characters &	$*$.cl \\
+\lbox...\rbox &	Any character in class & 	\lbox a-z\rbox \\
+\lbox \upa...\rbox &	Any character not in class & 	\lbox \upa A-Z\rbox \\
+? &		Match any single character & 	a?c \\
+\{...\} &	Ignore case for the enclosed string &	\{Lroff\} \\
+@{\it file} &	Read filenames from a list file&	@listfile \\
+\hline
+\end{tabular}
+\end{center}
+
+\noindent
+To delete a named list of files, type:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{delete file1,file2,file3}
+\end{quotation}
+
+\noindent
+Note that the list of filenames is separated by commas \usertype{','}
+\emphasize{with no intervening blanks}.
+This causes the individual filenames to be treated as one list-form 
+parameter rather than to be processed as three separate parameters.
+A blank is treated as a delimiter by the parser, and thus may not appear
+in a list-form parameter unless the list is enclosed in quotes.
+
+The following is equivalent to the previous example, except that no warning
+will be issued if any of the three files does not exist, since we are asking
+the system to find all files that match the template, rather than naming the
+files explicitly:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{delete file\lbox123\rbox}
+\end{quotation}
+
+\noindent
+Consider the following simple command:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{delete filex}
+\end{quotation}
+
+\noindent
+The name ``filex'' given here is actually ambiguous; it could be either the
+name of a file (a string constant) or the name of a string parameter
+set to the name of the file to delete.  In this simple and common case,
+the CL will quietly assume that ``filex'' is the \emphasize{name} of the
+file.  If the identifier \usertype{filex} is really the \emphasize{name}
+of a variable, it will have to be parenthesized to force it to be evaluated.
+Either of the following forms are equivalent to this command and both are
+unambiguous requests to delete the file named \filename{FILEX}:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{delete 'filex'}\\
+\medskip
+\comptype{cl>} \usertype{delete ('filex')}
+\end{quotation}
+
+\noindent
+Note that within parentheses the \emphasize{string} \usertype{'filex'} 
+must be typed as shown, with quotes, or the CL will attempt to process
+it as a variable name, causing a runtime error if there is no such variable
+currently defined within the scope of the \taskname{delete} task.
+
+The following command is also unambiguous, and it specifies that the CL
+is to take the name of the file from the \emphasize{parameter} ``filename'':
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{delete (filename)}
+\end{quotation}
+
+Note that in many of these examples, a \emphasize{single} string 
+type argument, viz. the file matching template with metacharacters, 
+is used to refer to a list of files.
+This convention is employed by all IRAF tasks which
+operate on lists of files.  Be careful not to confuse a file list template
+with the argument list itself.  Thus:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{delete file,file2,prog.$*$}
+\end{quotation}
+
+\noindent
+is perfectly acceptable, and does what the next example does:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{delete 'file1, file2, prog.$*$'}
+\end{quotation}
+
+\noindent
+as long as there are no blanks between elements of the first name list.
+If blanks were inadvertently included in the unquoted template string the
+CL would interpret the template as several string arguments, probably causing
+an error something like ``\comptype{too many positional arguments}''.
+
+The list file approach is useful when it is difficult to specify a template
+for the desired set of files, when the same set of files will be operated
+upon several times, when a very large number of files are to be operated
+upon, or when a list is already available.  The file list may be generated
+by the editor, or by a task such as \taskname{files}, e.g.:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{files *.im,run[1-4].* $>$ listfile}
+\end{quotation}
+
+\noindent
+The textfile \filename{LISTFILE} may then be referenced in a filename template
+as \usertype{@listfile} to operate upon the listed files.  A variation on
+the listfile approach is \usertype{@STDIN} (must be upper case), which
+allows the filenames to be typed in when the task begins running.
+
+Some tasks use the filename template mechanism to generate the names of a
+\emphasize{new} set of \emphasize{output} files.  The filename template
+expansion code provides two operators for generating new filenames from
+old ones.  The file template \emphasize{operators}, which are used to
+construct new filenames, should not be confused with the pattern matching
+\emphasize{metacharacters}, which are used to match a subset of an existing
+set of files.
+
+The first and simplest operator is the string concatenation operator
+\comptype{//}.  This may be used to concatenate a string suffix to the
+\emphasize{root} field of a filename, to concatenate a filename to a string
+prefix, to concatenate two filenames, or some combination of the above.
+For example,
+
+\begin{quotation}\noindent
+\comptype{cl>} \comptype{files lib\$*.com$//$\_o}
+\end{quotation}
+
+\noindent
+will produce a new list of files by appending the string \comptype{"\_o"} to
+the root of each filename matched by the template at the left.
+
+The second and last operator is the string substitution operator
+\comptype{\%}.  If a sequence of the form \comptype{\%a\%b\%} is inserted
+somewhere in a file template, the string \usertype{a} will participate in
+the pattern matching operation, but will be replaced by \usertype{b} in the
+generated filename.  Either \usertype{a} or \usertype{b} may be omitted to
+insert or delete fields from a filename.  For example,
+
+\begin{quotation}\noindent
+\comptype{cl>} \comptype{files lib\$*\%\%\_o\%.com}
+\end{quotation}
+
+\noindent
+is equivalent to the concatenation operation illustrated in the preceding
+example.  The command
+
+\begin{quotation}\noindent
+\comptype{cl>} \comptype{files lib\$*.\%com\%dat\%}
+\end{quotation}
+
+\noindent
+would find all the \filename{.COM} files in the logical directory
+\filename{LIB}, generating a new list of files with the extension
+\filename{.DAT} substituted for \filename{.COM}.
+
+All IRAF tasks that use pattern matching or template expansion use the same
+syntax and metacharacters as in the examples given here for filename templates.
+This includes, for example, the use of templates in the \taskname{help} task
+to locate manual pages, and the use of pattern matching in the \taskname{match}
+task to search text files for lines that match a pattern.
+
+\subsubsection{Directories and Path Names}
+
+\ppind
+It is often useful to employ several different directories as an aid to 
+organizing your data.  For instance, you may have one directory for M87 data, 
+and one for M8 data, or, as was set up for you by the \usertype{mkiraf} command,
+a login directory \filename{HOME} and a scratch directory \filename{UPARM}.
+New directories may be created with \usertype{mkdir}; use \usertype{chdir}
+or \usertype{cd} to change the default directory, and \usertype{back} to
+return to the most recent default directory.
+
+For example, to display the pathway through the system to your current
+default directory, type:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{path}
+\end{quotation}
+
+\noindent
+To change to a new default directory, type:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{chdir }{\it newdir}
+\end{quotation}
+
+\noindent
+where {\it newdir} may be an IRAF logical directory name defined 
+with a \usertype{set} command, an IRAF pathname to the directory,
+or a host system directory name (provided any dollar sign characters
+therein are escaped).
+
+The \usertype{mkdir} command can be used to create a new sub-directory
+of the current directory:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{mkdir m87}
+\end{quotation}
+
+\noindent
+To define a logical directory name (``m87'') for this subdirectory 
+of your home directory, use the following set command (note the trailing '/'):
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{set m87 = 'home\$m87/' }\footnotemark
+\end{quotation}
+
+\footnotetext{ {\bf VMS :} IRAF supports logical names for
+files and directories that may contain mixed cases and special 
+characters.  However, to avoid unpleasant surprises,
+we recommend that for root directories you use only names valid 
+for the underlying operating system.}
+
+\noindent
+Once this logical name mapping has been established, you may type either
+of the following commands to change the default
+directory to the ``m87'' directory (note \usertype{chdir} may be
+abbreviated \usertype{cd}):
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{chdir m87} \\
+\medskip
+\comptype{cl>} \usertype{cd home\$m87}\footnotemark
+\end{quotation}
+
+\footnotetext{ {\bf VMS :} The characters \comptype{\$} and \comptype{[},
+commonly used in VMS device and directory names, will cause a conflict
+if VMS file or device names using them are passed to IRAF tasks since these
+characters have a special meaning in IRAF filenames and filename templates.
+If either of these characters is used in a VMS filename passed to an IRAF
+program, the character must be escaped to avoid interpretation as a VOS
+metacharacter, e.g., \comptype{page usr\bsl\$0:\bsl[iraf.local]login.cl}.}
+
+\noindent
+If you type \usertype{chdir} or \usertype{cd} without any arguments, the
+default directory will be set to your ``home'' directory.
+
+Once a logical directory has been defined, the IRAF pathname notation may
+be used to reference any file or directory in the vicinity of the new logical
+directory.  For example, the following command would page the file CURSOR.KEY
+in the subdirectory SCR of the subdirectory LIB of the IRAF root directory
+IRAF, a predefined logical directory:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{page iraf\$lib/scr/cursor.key}
+\end{quotation}
+
+The current directory and the directory one level up from the current
+directory may be referenced in pathnames via the synonyms ``\usertype{.}''
+and ``\usertype{..}''.  For example, if the current default directory is PKG,
+a subdirectory of LIB like SCR in the preceding example, the path to the
+CURSOR.KEY file could be entered as follows:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{page ../scr/cursor.key}
+\end{quotation}
+
+It is not necessary to change the default directory to reference
+files located in another directory. Your login directory, for example, has
+the logical name \filename{HOME\$} assigned to it.  
+The following command would page through the \filename{LOGIN.CL} 
+file in your home directory, regardless of the current default directory:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{page home\$login.cl}
+\end{quotation}
+
+\noindent
+The logical directory names (\filename{UPARM} and \filename{IMDIR} are examples
+of directories that are normally appended to the \filename{HOME} 
+directory, and you may set up other logical directories as required.
+The names of all of the standard IRAF system directories are defined 
+automatically when the CL starts up, and may be listed with the
+\taskname{set} command.
+
+\subsubsection{Virtual Filename Processing}
+
+\ppind
+Virtual filenames are used throughout IRAF and the CL in preference
+to operating system specific names.  The obvious reason for this is
+to isolate OS specific interfaces to a small set of locations, as
+a way of ensuring commonality across operating systems and as an
+aid to portability.  There is an obvious benefit to the user as well,
+in that filename references will look the same within IRAF regardless
+of the host environment.  Operating system specific names must
+eventually be generated, but the details of these operations are 
+best buried in dedicated interface routines.
+
+The only place where OS specific names need appear at the user level is 
+in file system directory names and in references to system physical devices.
+Even here, the use of OS specific names should be isolated to only
+one or two root directory names.
+The other place where OS names must appear is calls to operating 
+system routines or to external programs that are accessed from within 
+IRAF via the OS escape mechanism (\S 4.1).  The \taskname{pathnames} task
+and the \taskname{osfn} intrinsic function are used to translate IRAF virtual
+filenames into host system filenames.
+
+Either of the following commands will print the fully qualified OS name
+for the file \filename{HOME\$LOGIN.CL}.
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{path home\$login.cl}\\
+\medskip
+\comptype{cl>} \usertype{= osfn ('home\$login.cl')}\\
+\end{quotation}
+
+\noindent
+The \taskname{pathnames} task writes the translated filename on its standard
+output, while \taskname{osfn} returns the translated filename as the function
+value.  The \usertype{pathnames} task will also expand filename templates,
+and thus can be used to generate the OS names for a list of files:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{path home\$ss433.*\ $>$ ss433files.list}
+\end{quotation}
+
+\noindent
+will generate a list of all of the files in directory \filename{HOME}
+that match the template, and will write the fully qualified OS names
+of these files into \filename{SS433FILES.LIST}.  This ASCII file can
+be edited as necessary, and used as list-structured input to other
+IRAF functions (\S 2.3, \S 6.9, \S 7.3).  
+
+The most common use of the \taskname{pathnames} task is probably to print
+the current default directory, which is its function when called with no
+arguments on the command line.
+
+\subsection{Image Data}
+
+\ppind
+An IRAF \emphasize{image} is an N-dimensional data array with an associated
+\emphasize{image header} describing the physical and derived attributes of
+the image.  The content of the header tends to be very data or application
+specific.  The datatype selected to store the \emphasize{pixels} (data values)
+is also application dependent, and a variety of choices are provided.
+Images of up to seven dimensions are currently supported, although
+in practice most images are either one or two dimensional, and most programs
+are written to operate upon one or two dimensional images.  Any IRAF program
+can be used to operate upon a \emphasize{section} of lesser dimension
+(or extent) than the full image, using the \emphasize{image section} notation
+discussed in \S 4.4.3, hence the dimensionality of the algorithm implemented
+by a program need not prevent use of the program on images of higher dimension.
+
+\subsubsection{Image Names and Storage Formats}
+
+\ppind
+The notation used to refer to images is similar to that used to refer to
+files, except that images are more complex objects than files and hence a
+somewhat more complex notation is required.  Most of the file, directory,
+and pathname notation discussed in \S4.3 carries over to images.
+Sets of images are referred to by an \emphasize{image template} notation
+which is an extension of the file template notation discussed in \S4.3.1.
+
+In most, but not all, cases, an IRAF image is stored on disk in two separate
+files, one containing the image header and the other containing the pixels.
+The basic image name is the filename of the header file.  The filename of an
+image header file always has an extension specifying the format in which the
+image is physically stored on disk. \footnote{In versions of IRAF prior to
+V2.3, only one physical image storage format was supported, hence image header
+files did not have extensions.}  Two storage formats are currently supported,
+the old iraf format (OIF) and the SDAS group data format (STF).  The old IRAF
+format images have the extension \filename{IMH}.  The STF images may have any
+three character extension ending in \filename{H}, e.g., \filename{HHH}
+(the extension \filename{IMH} is reserved for OIF images, of course).
+Both types of images may be accessed at any time, with the extension being
+used to identify the physical storage format to the IRAF software.
+
+For example, the IRAF system is distributed with a standard OIF format test
+image \filename{PIX} stored in the system directory \filename{DEV}.  The full
+filename of the header file is \filename{DEV\$PIX.IMH}.  To make a copy of
+this image in the current directory we could load the \taskname{images}
+package and enter the following command:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{imcopy dev\$pix pix}
+\end{quotation}
+
+\noindent
+or since we don't want to change the image name,
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{imcopy dev\$pix .}
+\end{quotation}
+
+\noindent
+Note that we did not have to specify the image type extension in the copy
+operation.  The extension is optional whenever a single image is referenced;
+in image templates, the template must match the full filename of each image
+as it appears in a directory listing, hence the extension is required in
+image templates.
+
+Sometimes it is necessary to specify the image type extension to force an
+image of a certain type to be created.  For example,
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{imcopy dev\$pix pix.bah}
+\end{quotation}
+
+\noindent
+would create an STF format copy of the standard test image in the current
+directory.
+
+When making a copy of an existing image, the new image will have the same
+format as the old image unless an extension is specified in the output image
+name.  When creating a new image from scratch, e.g., when reading a data
+tape to disk, the default image type is determined by the value of the CL
+environment variable \filename{IMTYPE}, the value of which is the three
+character default image type extension.  If \filename{IMTYPE} is not defined,
+the default value is \usertype{imh}, i.e., an OIF format image will be
+created.  To change the default to be to create an STF format image, add
+a command such as
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{set imtype $=$ hhh}
+\end{quotation}
+
+\noindent
+to your \filename{LOGIN.CL} file.
+
+\subsubsection{Image Templates}
+
+\ppind
+Image templates are equivalent to filename templates except that the character
+\comptype{`['}, a pattern matching character in filename templates, has a
+different meaning in image templates, as we shall see in the next section.
+\footnote {If you really want to perform file template style character class
+expansion in an image template, use the operator \comptype{![} instead
+of \comptype{[}.  The conventional escape mechanism, i.e., \comptype{\bsl[},
+is used to include the \comptype{[} in the \emphasize{filename}, as in a
+filename template.}
+
+\noindent
+For example, given a directory containing the files
+
+\begin{verbatim}
+    irs.log  irs.0030.imh  irs.0031.imh  irs.0032.imh
+\end{verbatim}
+
+\noindent
+the template \usertype {irs.$*$.imh} would match the three image files,
+whereas \usertype{irs.$*$} would match the \filename{LOG} file as well,
+causing \taskname{imheader} to complain about an illegal format image in
+its input list.
+
+\subsubsection{Image Sections}
+
+\ppind
+All IRAF programs which operate upon images may be used to operate on
+the entire image (the default) or any section of the image.
+A special notation is used to specify \irafname{image sections}.  The section
+notation is appended to the name of the image, much like an
+array subscript is appended to an array name in a conventional programming
+language. Note that array or image section \emphasize{index references} 
+are integer only in pixel coordinates, but that the data may be of any valid
+type.
+
+\begin{quote}
+\begin{tabular}{ll}
+{\it section}&   {\it refers to}\\
+\\
+pix&  whole image\\
+pix[]&  whole image\\
+pix[i,j]&       the pixel value (scalar) at [i,j]\\
+pix[$*$,$*$]&       whole image, two dimensions\\
+pix[$*$,-$*$]&      flip y-axis\\
+pix[$*$,$*$,b]&     band B of three dimensional image\\
+pix[$*$,$*$:s]&     subsample in y by S\\
+pix[$*$,l]&       line L of image\\
+pix[c,$*$]&       column C of image\\
+pix[i1:i2,j1:j2]&       subraster of image\\
+pix[i1:i2:sx,j1:j2:sy]& subraster with subsampling
+\end{tabular}
+\end{quote}
+
+\noindent
+A limited set of coordinate transformations may be specified using image
+sections, but please observe that transpose is \emphasize{not} one of them.
+The ``match all'' (asterisk), flip, subsample, index, and range notations
+shown in the table may be combined in just about any way that makes sense.
+As a simple example:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{graph pix[$*$,10]}
+\end{quotation}
+
+\noindent
+will graph line 10 of the image \filename{PIX}.
+To generate a contour plot of an 800-pixel square image
+subsampled by a factor of 16 in both dimensions:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{contour pix[$*$:16,$*$:16]}
+\end{quotation}
+
+\noindent
+To display the fifth $x-z$ plane of a three dimensional image named 
+\usertype{cube} on frame 1 of the image display device:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{display cube[$*$,5,$*$] 1}
+\end{quotation}
+
+\noindent
+The image section string is part of the image name and is processed by
+the IRAF system software (rather than by each applications program),
+hence image sections can be used with all IRAF programs.  A section can
+be used to write into a portion of an existing output image, as well as to
+read from an input image.
+
+\subsubsection{The OIF Image Format}
+
+\ppind
+The old IRAF image format (OIF) is the original IRAF image format,
+unchanged since it was first used in the beginning of the project. 
+It is called the ``old'' format in anticipation of its eventual replacement
+by a new format to be layered upon the planned IRAF database facilities.
+The OIF format is the current standard IRAF image format and is the format
+used to test the IRAF image processing software at NOAO.
+
+In the OIF format, each image is stored in a distinct pair of files, the
+header file (extension \filename{IMH}) and the pixel file (same root name as
+the header file, extension \filename{PIX}).  The pixel file need not reside in
+the same directory as the header file; by default all pixel files are
+created in a user directory on a scratch disk device to permit a different
+file quota, file expiration, and backup policy to be employed than is used
+for the smaller, more permanent ordinary user files.
+
+The CL environment variable \filename{IMDIR} determines where OIF pixel files
+will be created.  \filename{IMDIR} is a required parameter and is normally
+defined in the user's \filename{LOGIN.CL} file.  The value of \filename{IMDIR}
+is only used when the pixel file is created; if the value of \filename{IMDIR}
+is later changed, new pixel files will be created in a different directory,
+but the system will still be able to find the pixel files of the older images.
+
+By default, the \taskname{mkiraf} script will create an image storage
+directory for the user on a public scratch device and place the host pathname
+of the new directory in the user's \filename{LOGIN.CL} file.  For example,
+on a UNIX system, a typical set environment statement might be:
+
+\begin{quotation}\noindent
+\usertype{set imdir $=$ $/$tmp2$/$iraf$/$user$/$}
+\end{quotation}
+
+\noindent
+which will cause the pixel files to be created in the named host directory,
+regardless of the directory in which the image header file resides.
+As an option, we can request that the pixel file be placed in the
+\emphasize{same} directory as the header file:
+
+\begin{quotation}\noindent
+\usertype{set imdir $=$ HDR\$}
+\end{quotation}
+
+\noindent
+or in a subdirectory of the header file directory, e.g., subdirectory
+\filename{PIXELS}:
+
+\begin{quotation}\noindent
+\usertype{set imdir $=$ HDR\$pixels$/$}
+\end{quotation}
+
+\noindent
+Note that the reserved logical directory name \filename{HDR} must be upper
+case, and that a trailing slash is required if the subdirectory option is used.
+The subdirectory will be created automatically by the system when the first
+pixel file is created, if the directory does not already exist.
+The \filename{HDR} option should \emphasize{only} be used if the header file
+itself is created in a directory on a scratch device; it should always be used
+if the image is created on a remote node in the local network.
+
+\subsubsection{The STF Image Format}
+
+\ppind
+The STF image format is the format used by STScI to store Space Telescope
+image data.  IRAF provides a dedicated image kernel to read and write this
+format so that sites reducing binary ST data do not have to carry out expensive
+format conversions to be able to access the data from within IRAF.  SDAS
+users should note that the SDAS software can \emphasize{only} access STF
+format images, hence the STF format must be used if you plan to make extensive
+use of SDAS.  Reductions involving only IRAF programs should not use the STF
+format, since the OIF format is simpler and more efficient, and is the format
+used to test the IRAF software.
+
+In the STF format, an image or a \emphasize{group} of similar images may be
+stored in a pair of files, the image header file (extension \usertype{??H}),
+and the associated pixel storage file (extension \usertype{??D}).  If multiple
+images are stored in a group format image, all member images share the same
+group header.  The group header file is a special VMS format text file which
+can be examined by \taskname{page} and \taskname{type}, as well as with
+\taskname{imheader}.  Each member image in a group format image also has its
+own private binary format header, called the group parameter block.  The STF
+image format supports only single precision real pixels, since that is what
+SDAS programs require.
+
+IRAF programs consider images to be independent entities, with any associations
+between images being left up to the user.  When a member image of an STF
+group format image is accessed from an IRAF program, IRAF constructs the image
+header of the member image by concatenating the group header to the group
+parameter block for the member image; no distinction is made between the two
+classes of header parameters once the image has been opened.
+
+To refer to a specific member image of a group format image, the group
+subscript must be specified in the image name.  If there is an image section
+as well, it comes after the group subscript.  For example, if \filename{WFPC}
+is an STF group format image,
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{implot wfpc[3]}
+\end{quotation}
+
+\noindent
+would call up the interactive image plotting task \taskname{implot} on group
+3 of the group format image.  If no subscript is specified, the default is
+group 1.  To plot the same image with the lines flipped end for end, we add
+an image section:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{implot wfpc[3][$-*,*$]}
+\end{quotation}
+
+\noindent
+To create a new group format image, we must preallocate space for all the
+member images, all of which must be the same dimensionality, size, and
+datatype.  For example,
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{imcopy wfpc wfpc2[1$/$10]}
+\end{quotation}
+
+\noindent
+would create a new group format image \filename{WFPC2} with the same
+dimensionality, size, and group parameter block as the existing STF image
+\filename{WFPC}, then copy the pixels from \filename{WFPC} to
+\filename{WFPC2[1]}.  The new image would inherit the header of the old
+image as well.  Once a new group format image has been created, the remaining
+member images may be written into by specifying the group subscript in the
+output image name passed to an IRAF program.  The group count
+(\usertype{$/$10}) should be omitted, else IRAF will try to create a new
+group format image, rather than write into one of the member images of
+an existing group.  Note that member images cannot be added or deleted
+once a group format image has been created.
+
+\newpage
+\section{Advanced Topics in the CL}
+
+\ppind
+In addition to the basic facilities already described,
+the CL permits user control over many aspects of the environment.
+This includes direct control over the CL itself, control over user tasks
+and background processes, the job logfile and the command history mechanism.
+These features and others will be of use to the more advanced user
+and enable user customization of interactions with the system.
+
+\subsection{CL Control Parameters}
+
+\ppind
+The CL is itself a task which has a set of parameters that
+are used to direct its execution. For example, if you wish to keep
+a permanent record of all the commands you enter, the CL will do this
+if you set its boolean parameter \taskname{keeplog} to yes. (Boolean
+parameters can assume only the values \emphasize{yes} or \emphasize{no}.)
+Simply type:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{keeplog = yes}
+\end{quotation}
+
+\noindent
+and all subsequent commands will be written to the log file.
+The name of this file is defined by the
+string parameter \taskname{logfile} which defaults to the filename
+\filename{HOME\$LOGFILE.CL}.  The name of the logfile may be changed
+by assigning a new value to the parameter, e.g.:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{logfile = "commands.log"}
+\end{quotation}
+
+The important CL parameters which you may wish to alter or otherwise
+access are described in the table below.
+
+\begin{center}
+\begin{tabular}{|l|l|l|}
+\hline
+\multicolumn{3}{|c|}{\bf CL Parameters}\\
+\hline
+{\it parameter} & {\it typical value} & {\it function}\\
+\hline
+echo	& no		& echo CL command input on stderr? \\
+ehinit	& (see manpage)	& ehistory options string \\
+epinit	& (see manpage)	& eparam options string \\
+keeplog	& no		& record all interactive commands in logfile? \\
+logfile	& ``home\$logfile.cl''	& name of the logfile \\
+logmode	& (see manpage)	& logging control \\
+menus	& yes		& display menu when changing packages? \\
+mode	& "ql"		& default mode for servicing parameter queries \\
+notify	& yes		& send done message when bkgrnd task finishes? \\
+szprcache & 3$-$4	& size of the process cache \\
+\hline
+\end{tabular}
+\end{center}
+\medskip
+
+\noindent
+A full list of CL parameters can be obtained with the \emphasize{lparam}
+command, or by typing the command \usertype{help language.cl}.  The latter
+provides a brief description of each CL control parameter including references
+to \taskname{language} package manual pages containing more detailed
+information.
+
+Changes that you make to any of the CL task parameters by assignment during
+a session will be lost when you log out of the CL.
+This is in contrast to the parameters of a normal task, which are learned
+by the CL. If you want the CL to ``remember'' values of CL parameters,
+you should initialize them to your personal default values in your
+\filename{LOGIN.CL} file and they will be reestablished for you each time
+you log in.
+
+\subsection{Setting the Editor Language and Options}
+
+\ppind
+The parameter editor (\usertype{eparam}) command and the history
+editor (\usertype{ehistory}) both use the same simple set of edit commands
+and a choice of editor languages is available.  The command:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{set editor = emacs}
+\end{quotation}
+
+\noindent
+will set the edit mode for both editors to use the Emacs set of keystrokes.
+This also changes the editor that is invoked when
+you issue the \usertype{edit} command, so that all of the editor interfaces
+that are available will appear to operate in the same way. 
+
+Editor choices, with their associated key bindings, are:
+
+\begin{itemize}
+\item EDT (the default for VMS devotees) 
+\item Vi (ditto for their UNIX counterparts)
+\item Emacs (which runs on either system)
+\end{itemize}
+
+For convenience, all of these editor choices support
+use of the cursor keypad keys and the \key{DELETE} key; the 
+ambitious user may define his own personal set of command key bindings. 
+The bindings that are available by default in IRAF are shown in an
+Appendix (\S A.4).  The default editor language that IRAF will start 
+with is as shown above, chosen for compatibility with the host operating
+system.  You may, of course, include a \usertype{set} command in 
+your \filename{LOGIN.CL} file to establish your own preferred editor.
+
+The edit facilities provided within IRAF are limited in scope, since
+they are only intended to facilitate manipulation of user accessible
+internal structures, task parameter blocks and history file. IRAF
+has not implemented a full scale text editor, so the \usertype{edit}
+command invokes the standard system editor which you choose by setting
+the \usertype{editor} parameter.
+A host system editor must be used for all major text manipulations,
+but since it is invoked from within the IRAF environment the continuity
+of your session is not lost.
+
+In addition to selecting the editor language to be used, there are a few user
+settable options available to control the operation of the \taskname{eparam}
+and \taskname{ehistory} tasks.  These options are set by setting the string
+values of the CL parameters \taskname{epinit} and \taskname{ehinit}.
+For example, setting the \taskname{verify} option for \taskname{ehinit}
+will cause the history mechanism to pause waiting for a command to be
+edited or inspected, before executing the command.
+Read the manual pages for the \taskname{eparam} and \taskname{ehistory} tasks
+for a full description of these control options.
+
+\subsection{The History Mechanism}
+
+\ppind
+The CL history mechanism keeps a record of the commands you enter and
+provides a way of reusing commands to invoke new operations with a minimum of
+typing. The history mechanism should not be confused with the logfile;
+the history mechanism does not make a permanent record of commands, 
+and the logfile cannot be used to save typing 
+(except by using the editor on it after the end of the session). 
+With the history editor, previous commands can easily
+be edited to correct errors, without the need to retype the entire command.
+
+The \usertype{history} command is used to \emphasize{display} command lines.
+By default, the last 15 commands entered are printed, each preceded by
+the command number.  To show the last \emphasize{n} commands, 
+add the argument \usertype{n} to the \usertype{history} command line:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{history 3} \\
+\comptype{101 urand 200 2 \pipe graph po+ marker=circle szmarker=.03} \\
+\comptype{102 help graph \pipe lprint} \\
+\comptype{103 history} \\
+\comptype{cl>}
+\end{quotation}
+
+\noindent
+and note that this number (\emphasize{n}) will become the new default. 
+If you ask for a negative number of commands (\emphasize{-n}), 
+the default will not change.
+
+The \usertype{history} command allows previous command sequences to be
+displayed, but a related mechanism must be used to re-execute, or to
+edit and execute, commands. You can use the history file \emphasize{editor} 
+by issuing the command \usertype{ehistory}. Once you are in the history editor,
+the cursor (arrow) keys can be used to move about in the history file. You
+may select any command and edit it using the simple edit commands described
+previously (\S 3.2.3) for the \taskname{eparam} task. Such functions as
+deletions and insertions of words or characters, delete to end of line, and
+a simple string search and replace capabilities are provided. 
+The Appendix lists the full range of commands that are supported. 
+The edited command is executed by hitting
+\key{RETURN}. Note that it is a \emphasize{new} command and, as such, it is
+appended to the history file. The current contents of the history file
+are not changed.
+
+It is possible to recall \emphasize{individual} commands and edit them;
+the special character `\upa' or the \usertype{ehistory} command may be
+used for this.  Given the history record sequence shown above,
+any of the following commands could be used to fetch command 101:
+
+\begin{quotation}\noindent
+\begin{tabbing}
+\comptype{cl>} \usertype{\upa 101} \hspace{2cm} \= \#~fetch~command~101 \\
+\medskip
+\comptype{cl>} \usertype{ehist -3}  \> \#~fetch~third~command~previous \\
+\medskip
+\comptype{cl>} \usertype{\upa ur}  \> \#~fetch~command~starting~with~``ur'' \\
+\medskip
+\comptype{cl>} \usertype{ehist ?mark?} \> \#~fetch~command~containing~``mark''
+\end{tabbing}
+\end{quotation}
+
+The history command \usertype{\upa ur} finds the last command
+\emphasize{beginning} with the string ``ur'', while the command
+\usertype{ehist ?mark?} finds the last command \emphasize{containing} the
+string ``mark'' (the trailing `\usertype{?}' is optional if it is the
+last character on the line). A single `\upa' fetches the last command
+entered.  Successive `\upa' commands 
+will fetch the next preceding command lines from the history file.
+
+The selected command is echoed on the screen, with the cursor pointing at it.
+At that point, the command can be executed just by typing \key{RETURN},
+or it may be edited. The standard set of editor operations also apply
+when you edit a command in single line mode. Note that compound statements
+(those enclosed in pairs of braces~``\{~$\ldots$~\}'') are treated as a
+\emphasize{single} statement by the editor.  Only one command line (which may
+be a compound statement) can be edited at a time with the history editor.
+
+Sometimes you will want to reuse the \emphasize{arguments} of a previous
+command.  The notation `\upa\upa' refers to the \emphasize{first} argument
+of the last command entered, `\upa\$' refers to the \emphasize{last} argument
+of the command, `\upa$*$' refers to the whole argument list, `\upa0' refers
+to the taskname of the last command, and `\upa$N$' refers to argument
+\emphasize{N} of the last command entered.  Thus,
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{dir lib\$$*$.h,home\$login.cl} \\
+\comptype{cl>} \usertype{lprint \upa\upa}
+\end{quotation}
+
+\noindent
+displays a table of the files specified by the template, and then prints
+the same files on the line printer.
+
+One of the most useful features of the history mechanism is the ability to
+repeat a command with additional arguments appended.  Any recalled command
+may be followed by some extra parameters, which are appended to the command.
+For example:
+
+\begin{quotation}\noindent
+\comptype{ut>} \usertype{urand 200 2 \pipe graph po$+$} \\
+\comptype{ut>} \usertype{\upa\upa  title = '200 random numbers'} \\
+\comptype{urand 200 2 \pipe graph po$+$ title = '200 random numbers'}
+\end{quotation}
+
+\noindent
+in this case, the notation `\upa\upa' refers to the last 
+\emphasize{command} entered.
+The notation is unambiguous because the `\upa\upa' appears at the start of
+the command line.  Do not confuse it with the use of `\upa\upa' to reference
+the first argument.
+
+\subsection{Foreign Tasks}
+
+\ppind
+The foreign task mechanism provides an alternative to the OS escape mechanism
+for sending commands to the host operating system.  The advantage of the
+foreign task mechanism is that it allows foreign commands to be made available
+within the IRAF environment just as if they were normal IRAF tasks.
+Such commands may be abbreviated, their output may be redirected or piped,
+the commands may be run in batch mode, and the argument list is parsed and
+evaluated by the CL, hence may contain any valid CL expression.  Users should
+beware, however, that IRAF virtual filenames appearing in the argument list
+of a foreign task are not normally translated to their host equivalents, since
+IRAF knows nothing about the argument list of a foreign task
+(the \taskname{osfn} intrinsic function may be referenced in the argument
+list to explicitly perform the translation, if desired).
+
+To declare several foreign tasks with the same names in IRAF as in the host
+environment, use the following form of the \taskname{task} statement:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{task \$mail \$grep $=$ \$foreign}
+\end{quotation}
+
+\noindent
+This declares the new tasks \taskname{mail} and \taskname{grep} in the current
+package, whatever that may be.  If the current package is subsequently exited,
+the task declarations will be discarded.
+
+To declare a foreign task with a more complex calling sequence, use the
+following form of the foreign task declaration:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{task \$who $=$ "\$show users"}
+\end{quotation}
+
+\noindent
+This example would be used on a VMS host to map the IRAF foreign task
+\taskname{who} to the VMS command \usertype{show users}.  If there are
+any arguments on the command line when the task is called, they will be
+converted to strings and appended to the command prefix given.
+
+The \filename{LOGIN.CL} file contains a default \filename{USER} package
+containing examples of several foreign task statements which may prove
+useful on the local host.  Users should feel free to modify or extend
+the \filename{USER} package, since it is provided with that in mind and
+provides a convenient structure for personalizing the CL environment.
+
+\subsection{Cursor Mode}
+
+\ppind
+Whenever an IRAF program reads the graphics or image display cursor,
+the cursor lights up or starts blinking, indicating that the user should
+position the cursor and type a key on the terminal to return the cursor
+position, keystroke typed, and possibly a character string entered by
+the user, to the calling program.  The user may also read the cursor
+directly, just as a program would.  For example, the command
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{$=$gcur}\\
+\smallskip
+\comptype{345.21 883.13 1 r}
+\end{quotation}
+
+\noindent
+would read the graphics cursor, printing a cursor value string such as that
+shown noting the world coordinates of the cursor, the world coordinate system
+(WCS) of reference, the keystroke typed to terminate the cursor read, and
+the string entered by the user if the key typed was \usertype{:} (colon).
+
+The CL is said to be in \emphasize{cursor mode} whenever the CL is waiting
+for the user to type a key to read a cursor.  Cursor mode reserves the upper
+case keystrokes for itself, providing all sorts of useful functions to the
+user via the reserved keystrokes.  For example, the graphics display can be
+zoomed or panned, a hardcopy of the current screen can be made on a hardcopy
+device, or the screen can be saved in or restored from a graphics metafile.
+For more information on cursor mode, type \usertype{help cursors} while in
+the CL.
+
+\subsection{Background Jobs}
+
+\ppind
+The CL provides facilities for manipulating and displaying data and
+allows interactive development and use of data analysis functions.  However,
+many fully developed image analysis scenarios are very time consuming
+and need not be run interactively.  IRAF allows such functions to
+be developed interactively and then processed in a batch mode as
+a background task, thus freeing the terminal for other interactions
+once the background tasks have been started.  Several
+background tasks can be running at once, and these may be identical
+tasks that are just operating on different data sets.  
+
+Any command, including compound commands that may involve calls to several
+tasks, may be executed in the background by appending the ampersand character
+`\&' to the end of the command block.  The CL will create a new control
+process for the background job, start it, display the job number of the
+background job, and return control to the terminal.  
+Background job numbers are always small integers in the range 1 to n, 
+where n is the maximum permissible number of background jobs (typically 3-6).
+
+\begin{quotation}\noindent
+\comptype{pl>} \usertype{contour m92 dev=stdplot \&} \\
+\comptype{[1]} \\
+\comptype{pl>} 
+\end{quotation}
+
+\noindent
+If a task runs to completion, and if the CL \irafname{notify} parameter 
+is enabled (the default), the message 
+``\comptype{[n] done}'' will be printed on your
+terminal when the task completes. 
+
+Jobs running in the background may use all of the commands and
+perform any of the operations that interactive tasks can, but
+extensive user interaction with background jobs is necessarily 
+somewhat limited (and not too appropriate).  
+Another difference is that background jobs \emphasize{do not} update
+parameter \filename{.PAR} files.  This is done to minimize the 
+confusion that could occur if a background job asynchronously
+updated the parameter set for a task that was running interactively,
+or vice versa.  The implication of this is that parameter values that
+are to be output by a task running in the background must be explicitly
+written into a file if they are to be available outside that job.  
+Parameters passed between tasks in the same job are still processed 
+correctly.
+
+If the background job writes to the standard
+output, and the standard output has not been redirected, the output of
+the background job will come out on your terminal mixed in with the output
+from whatever else you are doing. Since this is generally not desirable, the
+\filename{STDOUT} (and \filename{STDERR})
+for the background job should probably be redirected to a
+file and perused at a later time.  The following example computes image
+statistics and directs these, and any error messages, to the file
+\filename{STATS.TXT}: 
+
+\begin{quotation}\noindent
+\comptype{im>} \usertype{imstatistics m87 $>$\& stats.txt \&} \\
+\comptype{[2]} \\
+\comptype{im>} 
+\end{quotation}
+
+If during the processing of a background job, the job finds it necessary to
+query for a parameter, the message
+
+\begin{quotation}\noindent
+\comptype{[1] stopped waiting for parameter input }
+\end{quotation}
+
+\noindent
+will appear on your terminal.  It is not necessary to respond to such a
+request immediately; when a convenient point is reached, respond with:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{service 1}
+\end{quotation}
+
+\noindent
+The prompt string from the background job will be printed, just as if
+you were running the job interactively.  Respond to the query and the
+background job will continue executing.  If you do not respond to the request
+for service from a background job, it will eventually time out and abort.
+
+More control over the disposition of a batch job is possible by appending
+optional arguments to the \usertype{\&} at the end of the command line,
+when the job is submitted.  The default action if no arguments are appended
+is to run the job as a subprocess of the CL, at a priority level one less
+than the CL, with output coming to the terminal unless redirected.
+To run the job as a subprocess at a specific priority, a numeric string
+specifying the \emphasize{host dependent} priority level may be added after
+the \usertype{\&}.  For example,
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{bigjob \&4}
+\end{quotation}
+
+\noindent
+will submit the job at host priority level 4.  The priority level may also
+be specified relative to the CL priority in a machine independent way,
+e.g., \usertype{\&-1} will submit the job at a priority level one notch
+down from the current CL priority (this is the default).
+
+On systems which support batch queues (e.g., VMS) jobs may also be submitted
+to a batch queue.  To submit a job to a batch queue, simply add the name of
+the queue after the \usertype{\&}, e.g.:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{bigjob \&fast}
+\end{quotation}
+
+\noindent
+will submit the job to the "fast" queue.  IRAF supports three logical batch
+queues, the \usertype{fast} queue, for short jobs to be run at a high priority,
+the \usertype{batch} queue, for medium size jobs, and the \usertype{slow}
+queue, for big jobs that may run a long time.  The host system name of the
+desired queue may also be given.  If a big job is submitted to a high priority
+queue it will be killed by the system when it exceeds the maximum quota
+permitted for that queue; see your system manager for more information on
+the batch queues supported by your system.
+
+Sometimes it is desirable to wait for a background job to complete before
+resuming interactive work.  For example, you might reach a point where
+you cannot proceed until the background job has finished writing a file.
+The \usertype{wait} command is used to wait for currently running
+background tasks to complete.
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{wait 1; beep}
+\end{quotation}
+
+\noindent
+will halt the interactive session until background job 1 completes. Issuing
+a \usertype{wait} command without a job number will cause the interactive
+session to wait for \emphasize{all} background jobs to complete.
+
+In order to discover the status of all background jobs that you
+have running, the command:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{jobs}
+\end{quotation}
+
+\noindent
+may be used.  The job number will be displayed along with information
+about the command that was used to start the job.
+The command \usertype{spy v} may also be used.  It will request the host
+operating system to display the processor status (in an OS-dependent form),
+including information on the status of all processes running on the system.
+
+There are important differences in the behavior of background jobs on different
+IRAF host systems.  Under UNIX, the background tasks are independent of
+activities that may (or may \emphasize{not}) be going on interactively. 
+UNIX users may terminate their IRAF session and even logoff the UNIX system
+altogether, and the background jobs will continue merrily along.
+In the VMS implementation of IRAF, background jobs may run either as
+sub-processes or as regular VMS batch jobs in one of the system wide batch
+queues.  The default is to run background jobs as sub-processes, in which
+case the jobs will be killed if you log out of VMS (even if you have DETACH
+priviledge).  Under \emphasize{both} systems, once the interactive CL session
+is terminated, communication with still-running background jobs
+\emphasize{cannot} be re-established, even by re-entering the CL.
+
+\subsection{Aborting Tasks}
+
+\ppind
+Any interactive task may be aborted by typing the interrupt sequence 
+\key{CTRL/C}.
+Control will return to the point at which the last interactive command was
+entered.  When an IRAF program run from the CL is interrupted, it will
+usually perform some cleanup functions, deleting partially written files and
+so on.  If an error (or another interrupt) should occur during error recovery,
+IRAF will issue the following message:
+
+\begin{quotation}\noindent
+\comptype{PANIC: Error recursion during error recovery}
+\end{quotation}
+
+\noindent
+A panic abort is usually harmless, but may result in some half-written
+dregs of files being left behind.  A more serious problem occurs when
+a subprocess becomes hung (uninterruptable).  Repeatedly interrupting the
+CL when this occurs will eventually cause the CL to give up and shut down,
+necessitating a restart.  A quicker solution might be to use the host system
+facilities to forcibly kill the subprocess.
+
+The \usertype{kill} command may be used to abort a background job. The 
+argument is the logical job number printed by the CL when the background 
+job was spawned. (It may also be a list of jobs to be killed.)
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{kill 1} \\
+\medskip
+\comptype{cl>} \usertype{kill 1 3}
+\end{quotation}
+
+In systems that support batch queues as well as sub-processes,
+the \usertype{kill} command may be used to control these as well.
+
+%#########################
+\newpage
+\thispagestyle{empty}
+
+\begin{center} \vspace*{1in}
+\large NOTE
+\end{center}
+\vskip 1cm
+\rm
+
+The remainder of this document is from the original draft and has not yet
+been brought up to date and may contain minor inaccuracies or omissions.
+
+\newpage
+\section{The CL as a Programming Language}
+
+All of the examples that have been presented thus far treat the use
+of the CL as a \emphasize{command language} for running existing tasks.
+The CL can also be used as a high-powered desk calculator, one that
+can operate on and display arrays of data as well as scalars;
+and that can be fully programmed.
+The following sections introduce the programming oriented functions
+that are provided in the CL as background for understanding
+the creation of new user tasks.  
+
+Extensive use of the CL as a programming language has not been heavily
+emphasized, because there are substantial performance penalties 
+associated with the use of interpreted languages, especially when
+dealing with large amounts of data.  At the same time, the availability
+of an interactive environment that allows easy exploration of
+alternative analysis scenarios is very attractive, since it largely
+does away with the typical development cycles of edit; compile; link;
+test; edit; compile; $\ldots~$.  Interactive development provides 
+immediate, possibly visual, feedback about the effect of the various 
+analytical tools upon your data. 
+
+Before delving into the details of the language however, a comment is in
+order regarding the distinction made in the CL between 
+\irafname{command mode} and \irafname{program mode}. 
+\emphasize{Modes} in user interfaces are not in vogue
+because of the potential source of confusion, the  "How does that command
+work now?" problem.  IRAF is a little schizoid in this regard because of the 
+desire for convenient user commands on the one hand: (to minimize 
+the need for specific command parameter delimiters,
+quotes around character strings and special handling of 
+file names and meta-characters); and the desire for
+a familiar language syntax for programming type activities on the other.
+
+To resolve this dilemma, the CL has two modes: \irafname{command mode} -
+which is the default and is used for most terminal interactions; and
+\irafname{program mode} - which is:
+
+\begin{itemize}
+\item Entered within the body of a procedure.
+\item Entered within parenthesized expressions.
+\item Entered on the right-hand side of an equal sign ('=').
+\end{itemize}
+
+\noindent
+The syntax of the CL2 programming language was chosen to be as 
+compatible as possible with SPP, the portable language in which 
+most of IRAF is written.
+
+Aspects of the command/program dichotomy have
+already crept into the discussions of identifiers, which are treated 
+as character strings in command mode (\S 4.3.1), but which will be
+evaluated as a parameter name if thay are enclosed in parentheses.
+In the same vein, when inserted in a parenthesized expression, 
+an identifier that is handled as a character string
+in command mode will be treated as a variable name unless it is quoted.  
+
+In program mode there is a simple disambiguating rule that can be safely 
+used: always quote character strings and always parenthesize expressions.  
+While this resolves the ambiguity it is not likely to be too popular
+with most users, who typically choose a minimum entropy approach.
+In the following sections, where programming issues come under
+discussion, programming mode will be assumed as the default.
+
+\subsection{Expressions in the CL}
+
+The CL has a conventional modern expression syntax (borrowed heavily
+from C and Ratfor) which should feel familiar to most
+users.  The following operators are provided, presented in order of 
+precedence:
+
+\begin{tabular}{ll}
+{\it Operator}  &   {\it Action} \\
+
+$**$              &  exponentiation \\
+$*, /$    &  the usual arithmetic operators \\
+$+, -$	  &  and the rest of them in precedence order \\
+$//$              &  string concatenation \\\
+\&,  {\tt ||}    &  and, or \\ 
+!                 &  not \\
+$<$,   $<=$        &  less than, less than or equals \\
+$>$,   $>=$        &  greater than, greater than or equals \\
+$!=$,   $ ==$        &  not equal, equal (2 equal signs) 
+
+\end{tabular}
+
+\noindent
+Parentheses may be used to alter the default order of evaluation of an
+expression.  Quotes are not optional in expressions or anywhere inside
+parentheses; identifiers are assumed to be the names of parameters and
+strings \emphasize{must} expressly be quoted using either single 
+or double quotes.
+
+The data types supported by the CL
+are \emphasize{boolean, integer, real, char}, and several exotic types
+(\emphasize{imcur, gcur,} and \emphasize{file}) that are touched upon 
+later in this section.   Observe that although the CL has \emphasize{no}
+complex datatype, operations on complex data is supported in the rest
+of the IRAF system, including the \irafname{SPP} language and
+interface libraries.
+Arrays of the regular data types of up to seven dimensions are supported.
+Explicit type conversion is implemented with the intrinsic functions
+\emphasize{int, real}, and \emphasize{str}, 
+the last converting an argument of any data type into a string.
+Mixed-mode expressions involving integers and reals are permitted,
+the data type of the result is promoted to the type of the target
+of the assignment operator.
+
+The CL provides a special statement, called the \emphasize{immediate}
+statement, for evaluating expressions
+and printing the value at the terminal.  The form of the statement
+is an expression preceded by an equals sign:
+
+\begin{quotation}\noindent
+= {\it expression}
+\end{quotation}
+
+\noindent
+or, if you prefer, the more conventional and more general \usertype{print}
+command can be used with the same results:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{print (}{\it expression} [, {\it expression},
+       $\ldots$ ] \usertype{)}
+\end{quotation}
+
+\subsection{CL Statements and Simple Scripts}
+
+This is not a language reference manual; nonetheless, 
+you will find it helpful to understand a few of the more useful 
+types of statements provided in the CL.
+We will not attempt to present a
+complete definition of the syntax of the command language,
+a compendium of basic statement types is listed in the Appendix.
+The preceding section introduced two statements,
+the \emphasize{immediate} statement and the \emphasize{print} statement.
+The \emphasize{assignment} statement should also be familiar from
+previous examples.
+
+Often we do not want simply to assign a value to a parameter,
+but rather we want to increment, decrement, or scale one.
+These operations can all be performed with assignment statements
+in the CL, using the assignment operators \pluseq, \minuseq, \timeseq,
+\diveq, and \concateq. For example, to increment the 
+value of a parameter, we could use the \pluseq~ assignment statement:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{y \pluseq {} (x $**$ 2)}
+\end{quotation}
+
+This statement increments the CL parameter \usertype{y}
+by the value of the expression \usertype{(x$**$2)}.  The same 
+operation could also be done with the next statement, but with some
+small increase in typing effort.
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{y = y $+$ (x $**$ 2)}
+\end{quotation}
+
+\noindent
+The advantage of having a shorthand notation becomes obvious
+when you contemplate doing arithmetic on a fully specified
+parameter name as in the next examples.
+
+\subsubsection{Assigning Values to Task Parameters}
+
+The assignment statement may be used to set the value of a parameter
+or a variable.
+Most parameters are local to some task, and a ``dot'' notation may
+be used to unambiguously name both the task and the parameter.
+Thus, the statement:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{delete.verify = yes}
+\end{quotation}
+
+\noindent
+may be used to set the value of the \taskname{verify} parameter 
+belonging to the task \taskname{delete}.  Since verify is a hidden
+parameter, direct assignment is the only way to permanently change
+this option setting.
+
+The task \taskname{delete} belongs to the \taskname{system} package.
+Since IRAF permits several packages to be loaded at the same time,
+if there happened to be another task named \taskname{delete} in the
+search-path, we would have to specify the package name as well to make
+the assignment unambiguous:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{system.delete.verify = yes}
+\end{quotation}
+
+\noindent
+In the unfortunate situation of two tasks with the same name in different
+packages, we would also have to specify the package name explicitly
+just to be able to \emphasize{run} the task:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{system.delete {\it files}}
+\end{quotation}
+
+\noindent
+In most cases such name collisions will not occur.  
+
+The ability to have
+the same task names in more than one package has some very positive
+benefits however, in that a new package of tasks that has the 
+same calling conventions as a standard one may be readily inserted 
+in the search path.  This allows new algorithms to be tested without
+impacting the standard system, and also provides the hooks whereby
+alternate implementations of existing functions (using an array processor
+for instance) can be dynamically linked into the system.
+
+\subsubsection{Control Statements in a Script Task}
+
+The CL provides \emphasize{if, if else, while, for, next}, and
+\emphasize{break} statements for controlling the flow 
+of execution in a command sequence.  These statements
+are quite useful for writing control loops at the command
+level.  Other control statements (\emphasize{case, switch,} and
+\emphasize{default}), which may be familiar from C or RATFOR,
+are also provided to ease the programming effort.
+By way of example, to print the values of the first ten powers
+of two the following statements can be used:
+
+\begin{quotation}\noindent\comptype{
+cl> i=1; j=2\\
+cl> while (i $<=$ 10) \{\\
+>>>     print (j)\\
+>>>     j \timeseq {} 2\\
+>>>     i \pluseq {} 1\\
+>>> \}}
+\end{quotation}
+
+\noindent
+The second of these two statements is a compound statement;
+note that the prompt has changed to \comptype{>>>} to indicate this.
+
+Consider the parenthesized argument list in the \usertype{print}
+command in the above loop.  
+If the parameter (\usertype{j} in this example) were not enclosed in 
+parentheses, the CL would interpret it as a string rather than a parameter,
+and would erroneously print ``\comptype{j}'' each time through the loop.
+Remember that the CL will interpret identifiers as a string if found
+outside parentheses, but as the name of a valid parameter or variable
+inside parentheses.  If the CL cannot find the identifier in its
+dictionary an error message will be issued.
+To avoid nasty surprises like this, one should \emphasize{always}
+parenthesize argument lists in loops and within script tasks, and
+make a habit of explicitly quoting items that are to be treated as
+strings.
+
+The example uses the built-in CL variables \usertype{i}
+and \usertype{j}.  A number of variables are provided in the CL for
+interactive use; the integer variables provided with the CL
+are \usertype{i,j,k}; the real variables are \usertype{x,y,z};
+the string variables are \usertype{s1,s2,s3}; the booleans are 
+\usertype{b1,b2,b3}; and a list-structure pointer called 
+\usertype{list} is also provided.
+The CL also has the ability to define new variables interactively;
+which is discussed in section \S 6.4.
+
+\subsection{Intrinsic and Builtin Functions}
+
+The usual Fortran intrinsic functions 
+(with the exception of the hyperbolic and complex functions)
+are provided in the CL,  along with some others specific to IRAF.  
+The other intrinsic and builtin functions are those like
+\usertype{set}, \usertype{if}, \usertype{while}, \usertype{case}; 
+the data declaration and initialization statements; and the
+task and I/O control statements that are described throughout 
+the body of this document, and are listed in Appendix A.   The intrinsic
+functions \emphasize{must} be used in a statement where the returned
+value is explicitly assigned or output in some way. 
+To compute (and display) the value of \usertype{sin(x)}:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{= sin(x)}
+\end{quotation}
+
+\noindent
+must be entered, just typing \usertype{sin(x)} by itself is an error.
+The names of intrinsic functions may be used in other contexts, e.g. as
+parameter names, but care is needed to avoid confusion.
+
+\begin{tabular}{lll}
+{\it Function}  &   {\it Action} 		& {\it Example} \\
+    abs &	absolute value			& z = abs(x) \\
+    atan2 &	arctangent  			& r = atan2(y, x) \\
+    cos &	cosine 				& x = cos(r**2) \\
+    exp &	exponentiation 			& z = exp(3) \\
+    frac &	fractional part of a number 	& i = frac(y) \\
+    int &	convert input to integer 	& j = int(z*3) \\
+    log &	natural logarithm of a number 	& x = log(z) \\
+    log10 &	base 10 logarithm of a number 	& y = log10(x) \\
+    max &	maximum value from input 	& x = min(1,17.4,43) \\
+    min &	minimum value from input	& y = max(47,11,92.3) \\
+    mod &	modulus 			& z = mod(x, {\it base}) \\
+    radix &	radix to any base 		& y = radix(x, {\it base}) \\
+    real &	convert input to real 		& x = real(i) \\
+    sin &	sine 				& y = sin(3*r) \\
+    sqrt &	square root 			& z = sqrt(x**2 + y**2) \\
+    str &	convert input to a string 	& s1 = str(num) \\
+    stridx &	index of character in string 	& i = stridx(s1, 'abc') \\
+    substr &	select substring from string 	& s1 = substr(s2, 3, 7) \\
+    tan &	tangent 			& x = tan(2*theta)
+\end{tabular}
+
+As examples of the use of these functions, try entering the following 
+expressions and see if you can predict the results 
+(the next sections have the clues):
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{= (sin(.5)$**$2 + cos(.5)$**$2)} \\
+\smallskip
+\comptype{cl>} \usertype{= 2 / 3.} \\
+\smallskip
+\comptype{cl>} \usertype{= (mod (int(4.9), 2) $==$ 0)} \\
+\smallskip
+\comptype{cl>} \usertype{= 'map' // radix (512, 8)} \\
+\smallskip
+\comptype{cl>} \usertype{= delete.verify}
+\end{quotation}
+
+\noindent
+You may have been surprised that the result of the last example was
+\comptype{no}.  This is because \usertype{verify} is a boolean 
+parameter which can only take on the values \emphasize{yes} and 
+\emphasize{no}.
+
+\irafname{CL++} \\
+All of the intrinsic functions in IRAF return a value, the builtin
+tasks currently do not.  With the completion of changes to the CL
+that are now in progress, intrinsics and builtin tasks, and any user defined
+functions or tasks may return an optional value.  Tasks can thus be
+called either in the FORTRAN 'subroutine' style or in the 'function'
+style, where a value is expected.  If a task returns a value that is
+not assigned to a variable it will be silently ignored.
+
+\subsection{Defining New Variables and Parameters}
+
+The CL provides a default set of variables that can be used for scratch
+computations, and you may declare other variables as needed.
+Each task that is invoked, whether it is a CL script task
+or an external executable task, may have input or output parameters
+associated with it, and these may be defined within the package for the 
+task or as part of the task itself. Data declarations
+for variables contain the item name and type information,
+and may also contain an optional initialization clause.  Declarations
+for function parameters are identical to those for variables, but they 
+may contain optional fields to specify prompt strings, to define a valid 
+data range, or to enumerate a list of valid values.
+
+The simplest data declarations define local or global variables. 
+The statement:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{int int\_var}
+\end{quotation}
+
+\noindent
+defines a simple integer variable. If this command is entered at the root
+(\comptype{cl>} prompt) level, it will define a variable that is globally
+accessible to any other task that is executed.  When the same statement
+is incorporated into the body of a script task (after the \usertype{begin}
+statement), it will define a local variable visible only to that script task or
+to any other task that is called by that script task. Variables declared within
+the body of a package definition are globally available to all tasks
+within that package, but will be removed from the set of
+addressable variables when that package is unloaded.
+
+User-defined variables may be used just like any standard IRAF
+variables: in expressions, passed as parameters to
+other tasks, or displayed in a variety of ways.  In addition,
+these variables may be initialized when they are declared:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{real e = 2.71828183 }
+\end{quotation}
+
+\noindent
+establishes a real variable and assigns it an initial value.
+This variable may be treated like a constant (as in this case) 
+or may be re-assigned another value during the course of computations.
+
+The formal \taskname{parameters} for a task must be defined if the CL
+is to provide any of the range checking or input prompting activities.
+In the absence of a declaration, or if one is provided that
+does not define these optional fields, only the name of the parameter
+will be used for prompting and no range checking can be performed.
+The simplest case of a \emphasize{parameter} declaration looks just like the
+simple variable declaration shown above; but it must
+occur within a task body \emphasize{before} the \usertype{begin} statement,
+or define a parameter that is named in the calling list for a task.
+
+The syntax of a data declaration statement is:
+
+\begin{quotation}\noindent
+\begin{tabular}{lll}
+\comptype{cl>} {\it type} & [{\it = initializer} [,{\it initializer}] $\ldots$ ] \\ 
+	& \{ \\
+	& [{\it initializer} [,{\it initializer}] $\ldots$ ] \\
+	& [{\it opt\_field=value} [,{\it opt\_field=value}] $\ldots$ ] \\
+	& & \}
+\end{tabular}
+\end{quotation}
+
+\noindent
+where the valid data types for these declaration statements are shown in
+the following table:
+
+\begin{tabular}{ll}
+{\it Data Type}  &   {\it Explanation} \\
+int &		integer (scalar and array) \\
+real &		double precision floating point (scalar and array) \\
+char &		character strings (scalar and array) \\
+bool &		boolean, yes/no (scalar and array) \\
+file &		file name \\
+struct &	special form of mutli-token string \\
+gcur &		graphics cursor struct \\
+imcur &		image cursor struct 	
+\end{tabular}
+
+Most of these data types should be familiar to you, but the IRAF
+\irafname{struct} is a special class of data element that is used to
+hold multi-token strings, mostly for input.  It will be referred to again
+in the section on I/O facilities in the CL (\S 6.8).  \irafname{Gcur}
+and \irafname{imcur} are both structs that return a multi-token result,
+namely a string with RA, DEC and a data value.  List structured parameters,
+which are described in section \S 6.9 are typically declared as
+structs.
+
+The optional fields in a data declaration are used to define the data
+ranges for checking, prompt strings, special file type information,
+or a list of enumerated items.  
+Syntactically, the specification of these optional fields is treated 
+like a special form of initialization; the valid field names are 
+described in the following table.
+
+\begin{tabular}{ll}
+{\it Field Name}  &   {\it Explanation} \\
+mode &		auto, query, hidden processing modes \\
+min &		minimum value for range checking \\
+max &		maximum value for range checking \\
+enum &		enumerated list of valid responses (mutex with min/max) \\
+prompt &	prompt string for undefined values \\
+filetype &	r, rw, w, x file type specification
+\end{tabular}
+
+\noindent
+All of these fields are optional, the \irafname{mode} defaults to
+\irafname{auto}; \irafname{min/max} range checking defaults to NULL;
+and \irafname{filetype}, which is valid only for files, defaults to
+read only (\irafname{'r'}).  The enumerated type (\irafname{enum}),
+which names the specific responses that are acceptable, is
+mutually exclusive with range checking, which defines a continuum
+of values that will be accepted.
+
+To declare an integer parameter, enable range checking for positive
+values and provide a prompt string, use:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{int new\_parm \{ min=0, prompt='Positive integer' \} }
+\end{quotation}
+
+\noindent
+and as an example of an
+enumerated list of valid input values, consider:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{char color \{enum = 'red \pipe green \pipe blue'\} }
+\end{quotation}
+
+\noindent
+which defines a default length character string that is initially undefined
+and that has an enumerated list of three valid input values.
+If  you  attempt to use the variable \usertype{color} before a value has 
+been assigned to it, you will be prompted for a value.
+If you try to assign it a value other than one of those that 
+are enumerated, an error is reported.
+
+\subsection{Declaring Array and Image Data}
+
+Variables and task parameters may be defined as arrays of any of the 
+data types: int, real, char or bool.  Arrays may have up to seven dimensions.
+Array and image data will be referenced identically in the future, 
+but for now there
+are some differences that are worth noting.  Images are treated
+as large arrays of data that are stored on disk, 
+and it is the amount of data to be
+processed that determines the choice of storage mechanism.  Images
+will typically be quite bulky; it is not unusual for a single image
+scene to involve five to ten megabytes of data.  For this reason, image data
+are most efficiently stored in disk files, and operations upon the
+data are performed by buffering it into memory as needed.  The
+\emphasize{main difference} between an array of data and an image is that
+the image will be buffered on disk.
+
+IRAF provides a default \filename{IMDIR} directory that may be used for
+bulk image file storage by all users, but it also has facilities that
+manage the storing, copying, and accessing of such data sets for users who
+wish to store this sort of data in their own directories.
+The logical directory \filename{IMDIR} is where the IRAF system will store
+your image data \emphasize{by default}. IRAF images will appear to be created
+in your local user directory, but in fact it is only the \irafname{image
+header file} which goes there. The bulk pixel data are 
+put in a second file that is part of a temporary files
+system, configured and managed with large datasets in mind. Such
+\irafname{pixel storage files} are transparent to the user, but if you have a 
+great deal of data, you may find it more efficient to set up your own directory
+on a temporary files system, and to redefine \filename{IMDIR} accordingly.
+If one has a personal \filename{IMDIR}, it is also convenient to save data on
+tape and later restore it to disk; the header files are usually small
+enough so that they need not be archived if the data is going to be restored
+within a week or two.
+
+To declare an integer array of length 100, type:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{int iarray[100] = 100(0)}
+\end{quotation}
+
+\noindent
+which also initializes the array \usertype{iarray} to zero.  A two dimensional 
+array with data range checking can be specified by:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{real rarray[50, 50] \{ min=0, max=100 \} }
+\end{quotation}
+
+\noindent
+This array could be defined as an image by using the following declaration
+to indicate the different \emphasize{storage class} of the data:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{real image rarray[50, 50] \{ min=0, max=100 \} }
+\end{quotation}
+
+\noindent
+where the data in this example would be stored on disk.
+
+The choice of whether data is to be stored
+in an array which is stored entirely in memory,
+or as an image on disk is up to the user.
+The choice should be predicated upon the
+amount of data that is to be manipulated, since speed and efficiency
+of operation will be better using the image mode for data arrays
+much larger than a few hundred items.  At present, the
+statements that manipulate these two data forms are somewhat different,
+as is explained in the following section.
+
+During the development of IRAF, the handling of images has
+been a prime concern, representing as it does the major computational
+and I/O load that must be accomodated. Image files currently
+may be created on disk, and there are image processing functions that 
+know how to process this class of data. The IRAF packages 
+\taskname{images, imred}, and \taskname{plot} currently 
+handle image data.
+The specification of this processing is similar, but
+not identical to, the operations performed on array data.
+The next section discusses use of image data and arrays within the CL.
+
+\irafname{CL++} \\
+At the present time the \irafname{IMIO and DBIO} subroutine libraries
+are still undergoing design and enhancement.  As a result of this effort,
+the processing of image type data is not yet in final form.  Existing IRAF
+packages do support image processing and display
+functions and these will appear to be functionally the same after the
+development has been completed.  The SDAS packages also support image
+processing and display functions, but at this point in time the disk 
+format of these two types of data is vastly different, 
+and on this interim system, data from these two packages
+cannot easily be mixed.  This incompatibility is to be rectified when
+the completed \irafname{IMIO and DBIO} libraries are available.
+
+\subsection{Processing of Image Sections}
+
+All IRAF programs which operate upon images may be used to operate on
+the entire image (the default) or any section of the image.
+A special notation is used to specify \irafname{image sections}.  The section
+notation is appended to the name of the image, much like an
+array subscript is appended to an array name in a conventional programming
+language. Note that array or image section \emphasize{index references} 
+are integer only, but that the data may be of any valid type.
+
+\begin{quote}
+\begin{tabular}{ll}
+{\it section}&   {\it refers to}\\
+\\
+pix&  whole image\\
+pix[]&  whole image\\
+pix[i,j]&       the pixel value (scalar) at [i,j]\\
+pix[$*$,$*$]&       whole image, two dimensions\\
+pix[$*$,-$*$]&      flip y-axis\\
+pix[$*$,$*$,b]&     band B of three dimensional image\\
+pix[$*$,$*$:s]&     subsample in y by S\\
+pix[$*$,l]&       line L of image\\
+pix[c,$*$]&       column C of image\\
+pix[i1:i2,j1:j2]&       subraster of image\\
+pix[i1:i2:sx,j1:j2:sy]& subraster with subsampling
+\end{tabular}
+\end{quote}
+
+\noindent
+In the following examples, please note that the references to image
+sections are all enclosed in quotes.  These are \emphasize{required}
+by the present language syntax.  As the note at the end of this
+section indicates, this rule is to be relaxed in future.
+
+A limited set of coordinate transformations may be specified using image
+sections, but please observe that transpose is \emphasize{not} one of them.
+The ``match all'' (asterisk), flip, subsample, index, and range notations
+shown in the table may be combined in just about any way that makes sense.
+As a simple example:
+
+\begin{quotation}\noindent
+\comptype{pl>} \usertype{graph 'pix[$*$,10]'}
+\end{quotation}
+
+\noindent
+will graph line 10 of the image \usertype{pix}.
+To generate a contour plot of an 800-pixel square image
+subsampled by a factor of 16 in both dimensions:
+
+\begin{quotation}\noindent
+\comptype{pl>} \usertype{contour 'pix[$*$:16,$*$:16]'}
+\end{quotation}
+
+\noindent
+To display the fifth $x-z$ plane of a three dimensional image named 
+\usertype{cube}:
+
+\begin{quotation}\noindent
+\comptype{im>} \usertype{display 'cube[$*$,5,$*$]', 1}
+\end{quotation}
+
+\noindent
+on frame 1 of the image display device.
+
+\irafname{CL++} \\
+The image processing sections of IRAF are undergoing further development,
+as was noted in the previous section.  Currently only image data
+can be processed as shown in the previous examples.  Future developments
+will remove the need for quoting the section specifications that identify
+the image portion to be operated upon.  The functional specifications
+will not change substantially, nor will the syntax itself be changed
+in any important way, but the need to remember to quote image section
+references will be removed.  Image data will continue to be
+stored on disk and passed among tasks by passing the \emphasize{name}
+of the file rather than passing the data itself, as a matter of efficiency.
+
+\subsection{Array Processing in the CL}
+
+The processing of \emphasize{array} data is handled directly in the CL, 
+and data arrays may also be passed to script tasks and external tasks.  The
+entire array will be passed, since the CL cannot yet handle passing of 
+sub-arrays to other tasks.  The operations on arrays are handled via
+implicit looping over the array expressions, and only some of the
+operations described in the previous section on image data are valid
+for array data.  References to array data sections need not be quoted
+however, and the syntax is otherwise identical to that supported for
+images.
+
+Given the declaration:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{real a[10], b[20], c[10,20], d[10,20,30], e[10,10]
+}
+\end{quotation}
+
+\noindent
+the following expressions are legal:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{c = 10} \hfill \#~sets~all~elements~of~c~to~10 \\
+\comptype{cl>} \usertype{a = c[*,1]} \hfill \#~copies~row~1~of~c~into~a \\
+\comptype{cl>} \usertype{= b} \hfill \#~prints~all~values~of~b \\
+\comptype{cl>} \usertype{a = b[1:10] } \hfill \#~copies~subrange~of~b~into~a \\
+\comptype{cl>} \usertype{c = d[*,*,1] }
+\end{quotation}
+
+\noindent
+and the following expressions are illegal:
+
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{a = c} \hfill \#~different~dimensionalities \\
+\comptype{cl>} \usertype{a = c[1,*]} \hfill \#~different~limits~on~assign \\
+\comptype{cl>} \usertype{a = b[11:20]} \hfill \#~different~limits  
+\end{quotation}
+
+In general, for an expression to be a legal array expression in the
+CL, all array references must either be completely specified
+(i.e. \usertype{d[1,2,3]}), or they must loop over the same set of indices
+(i.e. \usertype{a = b[1:10]}).  Indices may be 
+specified as just the identifier (\usertype{a} or with an
+asterisk as the index (\usertype{b[*]}), indicating the entire array;
+or as a subrange specified by  \emphasize{integer constants} separated
+by a colon (\usertype{c[3:5]}).  
+
+\irafname{CL++} \\
+Future developments in the CL will eliminate most of the restrictions
+on array operation in the CL and will bring the syntax for operations 
+on images and arrays into complete alignment.
+
+\subsection{Input and Output within the CL}
+
+The CL provides I/O processing for parameters, cursor input and graphics
+output, and controls communications to external tasks.  The communications
+that appear at the terminal in the form of prompts for parameters, 
+error messages, data range checking queries, and much of the other I/O
+is performed in ASCII for portability considerations.  The data items that 
+a user can input in response to a prompt may be:
+integer values; floating point numbers, with or without exponent; 
+yes/no responses for boolean data; or character strings as appropriate.
+
+Image data and other bulk data forms that are processed by the various
+functions are typically \emphasize{not} passed through
+the CL itself, instead the names of the files are passed about, and
+temporary files are dynamically created as needed to hold intermediate
+results of computations.  Cursor input from graphics and image devices
+are passed directly through the CL however, in order that they may be 
+re-directed to a file like any other I/O stream.  The \irafname{imcur} and
+\irafname{gcur} structs are used to handle this type of data.
+
+As was mentioned in \S 2.4 and in the section on I/O and pipes (\S 3.3)
+the CL communicates via its standard input and output,
+which are ASCII streams normally connected to the terminal.  The
+CL functions that manipulate these streams can also be used on
+data in a file, just as the CL itself can be driven with commands 
+from a file.  The control files are all ASCII
+data streams, with no implied structure, and thus are easy to construct
+and to edit, should that be necessary.
+
+The \irafname{scan} and \irafname{fscan} functions are provided 
+in the CL to process ASCII input streams; 
+the only distinction between them is that \usertype{scan} operates
+on the terminal input stream (or its re-directed source) and
+\usertype{fscan} specifically operates on an file.  \usertype{Scan} reads
+from the terminal (there is no prompt) and returns the first token it
+finds in its input stream; where a token is understood to be any string
+of alphanumeric characters delimited by a blank.  Quotes are ignored 
+and no other punctuation has any special meaning.  If a \key{CTRL/Z}
+is entered EOF is signalled and the following 
+print statement will not be executed.
+
+\begin{verbatim}
+cl> if (scan (s1) != EOF)
+>>>     print (s1)
+>>> else
+>>>     return
+\end{verbatim}
+
+The \usertype{print} command takes whatever is passed it as a parameter
+and displays it on the terminal, so the previous example does a simple
+one-line \emphasize{echo} function of input to output.  The argument to
+\usertype{scan} in this example is the character variable \usertype{s1}, 
+but it could as easily be an integer:
+
+\begin{verbatim}
+cl> while (scan (i) != EOF)
+>>>     print ("Input was a ", i)
+\end{verbatim}
+
+\noindent
+This in-line script will continue looping, reading from the input and
+echoing to the output, until EOF is signalled.  All valid numeric inputs
+will be accepted; real input values will be truncated to integers; 
+character constants (single characters) will be processed as though
+\usertype{int} had been called; and any invalid input values will
+be silently ignored.  \usertype{Print} shows another of its features,
+that string constants may be directly inserted into the output stream
+and that \emphasize{no format} specifications need be made.
+
+The I/O functions can be used to process more than one data element
+at a time, with no need for explicit formatting.  If more data is
+presented than there are identifiers in the list, the extra data
+is silently ignored; and if there are more data elements in the 
+parameter list than there is data, 
+the remaining data elements retain their old values.
+
+The output or input for these functions can be explicitly redirected,
+via the usual mechanisms, or the \irafname{fscan} and \irafname{fprint}
+functions can be used instead.  The commands:
+
+\begin{verbatim}
+cl> list = 'infile'
+cl> while (fscan (list, s1) != EOF)
+>>>     fprint ('junque', 'The next input line = ', s1)
+\end{verbatim}
+
+\noindent
+perform exactly the same function as:
+
+\begin{verbatim}
+cl> list = 'infile'
+cl> while (scan (s1, $<$list) != EOF)
+>>>     print ('The next input line = ', s1, $>>$ 'junque')
+\end{verbatim}
+
+\noindent
+where the list structured variable \usertype{list} has been set to the 
+name of the file to be used for input (\filename{INFILE}) and the 
+output is being directed to file \filename{JUNQUE}.  
+These examples are hardly exhaustive, but 
+will serve as background information for the discussion of list
+structured parameters that follows.
+
+\subsection{List Structured Parameters}
+
+For certain data analysis tasks, the ability to define a \emphasize{list}
+of data files for batch processing can be especially useful.  IRAF 
+supports \irafname{list structured parameters} for specifying a list
+of items to be input to a function.  Many, but not all, functions
+will accept this form of input.  List structured parameters are
+associated with a file and have their own peculiar, but useful,
+semantics.
+
+Suppose we want to make a series of contour plots on the standard plotter
+device of a set of data files.  This can be done interactively by
+entering a command to produce each plot, but this is tedious. A better 
+approach would be to prepare a list of image sections (see \S 6.6) to 
+be plotted, naming one section per line in a text file (which we choose 
+to call \filename{SECTIONS}). The following command could then be used
+to generate the plots in the background:
+
+\begin{verbatim}
+pl> list = 'sections'
+pl> while (fscan (list, s1) != EOF)
+>>>     contour (s1, device = 'stdplot') \&
+\end{verbatim}
+
+In this example, the assignment of \usertype{'sections'} to the 
+parameter \usertype{list}
+has two actions, it associates the name of the file \filename{SECTIONS}
+with the list structured parameter, and it causes a \emphasize{logical}
+open of the file.  The actual file open takes place the
+first time that \usertype{fscan} is called.  Successive calls to 
+\usertype{fscan} return successive lines from the file into the
+string \usertype{s1}.  When the end of file (EOF) is encountered
+the \usertype{while} loop terminates.  If additional calls are made to 
+\usertype{fscan} EOF will continue to be returned.  A logical
+reset to the top of the file can be performed by reassignment
+of the same file name
+to the parameter \usertype{list}, or another file name can be
+associated with this parameter.
+
+A user can declare other list structured data elements besides the
+ones that are provided.  The statement:
+
+\begin{verbatim}
+cl> struct *input = uparm\$inlist
+\end{verbatim}
+
+\noindent
+declares a list structured variable named input that is bound
+to the list named \filename{UPARM\$INLIST}.  This file may
+contain several records that define image section specifications
+or the names of other files to be processed.  Once the declaration is
+made, lines may be scanned from the file, as in previous examples, 
+or the records may be fetched by use of a simple assignment operator:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{= input} \hfill \# displays the next record from
+	file \\
+\comptype{cl>} \usertype{s1 = input} \hfill \# sets s1 to the next record  
+\end{quotation}
+
+\noindent
+Successive references to the identifier \usertype{input} will result
+in successive records being read from the file it is bound to.  If
+an EOF is detected it is silently ignored, and the last value
+read will continue to be returned.  List-structured identifiers may be
+integer, real, or character as well as struct type data.
+The binding to a filename is the same regardless of type,
+and the only difference is that data conversion is
+performed on the input record to match the type of the identifier.
+
+If you expect to write commands much more complicated than these
+examples, it is time to learn about \irafname{script tasks}. This topic
+is covered in \S 7 of this document and more detailed information
+is given in the \reference{CL Programmer's Guide}.
+
+\newpage
+\section{Rolling Your Own}
+
+The true power of the CL and the whole IRAF analysis 
+environment lies in its ability to tailor analysis functions to the 
+users' data.  This power comes from the ability to define new
+functions in the CL, and from the capability to extend the
+basic IRAF system by the addition of new analysis packages. 
+These new routines can be developed incrementally, a line at a time,
+and then defined as a new task once the function operates as desired.
+User defined functions and analysis packages look just like any of the standard
+functions that are provided with the system, and are called in the same way.
+All of the same parameter passing, range checking, and prompting operations
+of IRAF are available for user defined functions.  
+
+Beyond the ability of the CL to \emphasize{learn} the value of parameters
+that you have entered, or the creation of "one-liners",
+little user customization has been presented so far. 
+However, all of the programming and extensibility features of the CL
+that have been used in the creation of the standard packages are also 
+available to the intrepid user, enabling the creation of a personalized 
+data analysis environment, one's own set of \taskname{doit} functions.  
+This section introduces the creation of new user script tasks, 
+user executable tasks, and packages of such tasks.
+
+Examination of one of the \filename{.CL} script tasks that
+defines a standard package will reveal that it
+contains several \usertype{set} commands to establish 
+logical directory names; and then defines the set of 
+tasks that compose the package.  Examine the script task 
+for the \irafname{system} package of functions:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{page system\$system.cl}
+\end{quotation}
+
+\noindent
+to reveal the mysteries of these basic functions.  
+The task names that appear 
+in this package description contain a \irafname{logical directory}
+portion (as in \usertype{system\$}) and a filename portion 
+(\usertype{system.cl}).  The logical directory name is separated from 
+the rest of the file name by a dollar sign \usertype{'\$'}, 
+as was discussed in
+the section on virtual file names (\S 4.3).  Use of a logical directory
+specification in public packages, and even in those for your own private
+use, is highly recommended, since it provides an unambiguous 
+specification of where to find the package and tasks.
+
+Note that tasks need not be defined as part of a package; individual tasks 
+can be created and defined at any time, but a package is a convenient
+way of grouping related tasks together. Many package have already been
+provided in IRAF, and should be browsed by anyone who is searching
+for clues about how the CL language can be used for programming.
+
+\subsection{Creating Script Tasks}
+
+All of the IRAF commands can be used within a
+script task and will operate the same way in that environment as they
+do when entered interactively.  A script task need be nothing more than
+a text file that contains normal CL statements or commands.
+Commands may be entered in a script just as they would from a terminal
+in \irafname{command mode}, or \irafname{program mode} 
+may be used, in which case slightly different rules apply (c.f. \S 6.0).  
+For simple process control scripts command mode is likely
+to be satisfactory, but program mode is the obvious choice if more
+complicated tasks are undertaken.  The main distinction
+is that task names must be entered in full and 
+the standard rules should be followed for variable names and character 
+string references.  Program mode will be used in the following
+examples, since it is most likely to be used in any complicated
+script tasks that you might wish to develop.
+
+In order to create a script task one has merely to invoke the editor
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{edit {\it taskname}.cl}
+\end{quotation}
+
+\noindent
+and enter the CL statements that describe the actions you wish to
+have performed.  When you have created the new script task 
+(or modified an existing one), exit the editor in the normal way, 
+so that the file is written in your current directory.  
+
+A script task for demo purposes might look like:
+
+\begin{quotation}\noindent
+\usertype{ \{ } \\ 
+\usertype{ print(' Hello, world !! ') } \\
+\usertype{ \} } 
+\end{quotation}
+
+\noindent
+In order to make this new task available to the CL, you will have to identify
+it and indicate where the script task is to be found:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{task \$my\_new\_task = {\it taskname}.cl}
+\end{quotation}
+
+\noindent
+Note that the name by which you refer to the new task
+need not be the same as the name of the file, although the use of the same
+name is conventional.
+The `\usertype{\$}' in the \usertype{task} statement is optional and
+tells IRAF not to search for a parameter (\filename{.PAR}) file for the task.
+
+Once the task has been created and declared it may be directly invoked:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{my\_new\_task}
+\end{quotation}
+
+\noindent
+will cause the script task file to be parsed and executed by the CL.
+You may change the body of a script task
+without redefining it with another \usertype{task} statement.
+
+While tesing new script tasks, such
+as this one, you may find it useful to turn on echoing:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{echo = yes}
+\end{quotation}
+
+\noindent
+which will cause the CL to echo the commands on the terminal 
+as they are read from the script.
+
+Since all of the commands that you have entered at the terminal are 
+logged a the history file, it is possible to edit all or part 
+of this command log to create a new script task.  You will first have 
+to output part of the history log to a file and then edit it:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{history 30, $>$ temp } \\
+\comptype{cl>} \usertype{edit temp }
+\end{quotation}
+
+\noindent
+which lets you change history (not a bad trick).  Once you have edited
+the file, the commands needed to turn it into 
+a CL script task are the same as those described above.
+
+\subsection{Passing Parameters to Script Tasks}
+
+Parameters are used to control the operation of tasks by defining input 
+and output files, indicating execution options, etc. Script tasks that a user
+defines may have parameters that operate in exactly the same fashion 
+as standard tasks.  
+In fact, the same prompting, learning, and limit checking mechanisms
+that operate for standard tasks are available by default for user script tasks,
+as well as for external user tasks (about which more in \S 7.5).
+
+CL parameters and other variables that are defined external to a new 
+script task may be referenced from within the task with no special action
+being taken on your part. Global variables and variables passed 
+from higher level tasks
+are also accessible to a task. However, named parameters for the task, 
+or variables that are local to the task (and thus protected from 
+external actions), must be declared within the script task itself.
+Parameters are identified by being defined
+in the formal parameter list of the procedure or before the \usertype{begin}
+statement, while local variables are declared only \emphasize{after}
+the \usertype{begin} statement.  N.B. the \usertype{begin} and 
+\usertype{end} statements must appear all by themselves on the line, 
+and anything that appears \emphasize{after} the \usertype{end} will
+be ignored.
+
+The following simple script task description will serve to illustrate 
+many of the salient points:
+
+\begin{verbatim}
+
+procedure doit (inparm, groups, region, outparm)
+
+file    inparm {prompt = 'Input file name:'}
+int     groups {prompt = 'Groups to process (0 for all):'}
+int     region[] {0, mode=hidden}
+file    outparm {prompt = 'Output file name:'}
+
+begin
+        file    cal_file = 'calib$wfpc'         # Wide Field Camera
+        int     n_group, ngp
+
+        n_group = groups                        # get the users group request
+        if (n_group == 0)
+            n_group = 9999
+
+        for (ngp=1;  ngp <= n_groups;  ngp=ngp+1) {
+            calib (inparm, ngp, cal_file) |     # note use of pipe
+                clean() |
+                clip (region= region, >> outparm)
+        }
+end 
+\end{verbatim}
+
+\noindent
+The identifiers {\tt inparm, group, region,} and {\tt outparm} are 
+parameters of the function and are used to pass data 
+into and out of the procedure proper.
+There is one \emphasize{required} parameter, {\tt inparm}, which is the input
+file name that contains the name of
+the file to be operated upon.  The other parameters are {\tt groups}
+the number of data groups to be processed;
+a \emphasize{hidden} parameter, {\tt region}, which will not be
+prompted for; and the parameter, {\tt outparm}, which is
+the name of the file that is to be written by the function.  The variable
+{\tt cal\_file} is local to the procedure and is only
+available within the procedure body (or to any lower level routines to which
+variables may be passed as parameters).
+
+There are some subtleties here that bear mentioning. Hidden parameters,
+such as {\tt region}, may be defined for script tasks and must appear
+\emphasize{before} the \usertype{begin} statement, but need \emphasize{not}
+appear in the formal parameter list.   The {\tt groups} parameter will
+be prompted for if not specified on the command line,
+but is then assigned to a local variable {\tt n\_group}.
+This is not required, but is desirable because of a side-effect of the
+automatic prompting built into IRAF.  Any query mode parameter will be
+prompted for automatically, \emphasize{each time it is referenced}.
+This can be very useful in a script where a new value is to be input
+on each execution of a loop, but can be surprising if one only intends
+to enter the value once.  The obvious fix is to assign the value to
+a local variable (at which time the prompt will occur) and then
+operate only on the local variable.
+
+As with the simple task described before, this procedure must be declared
+with a \usertype{task} statement in order that the CL be able to locate it.
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{task doit = home\$doit.cl}
+\end{quotation}
+
+\noindent
+Remember to specify the logical 
+directory in the declaration so that the task can unambiguously
+be located no matter which directory you use it from.
+When you run this new task, you will be expected to enter a value for
+the input parameters (and you will be prompted if you don't).
+
+ Remember that once you 
+have used the \usertype{task} statement to inform the CL how to find your
+new function, you need not do so again during that session, since the original
+declaration of the task will allow it to be located even if you edit the body
+of the task to change its internal operation.  
+If you need to change the number or type of parameters to a task, 
+or to change the name of a task, move it to another directory,
+or if you wish to redefine the meaning of one of the standard tasks 
+in the system, you will have to use the \usertype{redefine} command.
+
+The following commands:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{rename home\$doit.cl funcs\$doit.cl} \\
+\comptype{cl>} \usertype{redef doit=funcs\$doit.cl}
+\end{quotation}
+
+\noindent
+rename the file \filename{HOME\$DOIT.CL} to \filename{FUNCS\$DOIT.CL}
+and then redefines the \taskname{doit} task to point to the script.
+This redefinition causes the CL to reprocess the script task 
+in order to re-establish pointers to the file and to
+redefine the data declarations.  
+
+Once you have tested your new task and have it 
+debugged, you may wish to enter a \usertype{task} definition for
+it into your \filename{LOGIN.CL} file, or to install it in your own 
+package of private functions.
+
+\subsection{Using List Structured Parameters in a Script Task}
+
+It is possible to define a CL script task such that a sequence of files
+whose names are defined in an input list
+may be processed in one call to the task.  This is convenient
+when a number of files need to be processed in an identical way.  The
+following example shows how the task \usertype{doit\_toit} has been
+setup to accept a list structured input parameter, and then
+to call another task, passing the files from the list one at a time
+to the other task.  The obvious advantage is that the development
+of the task that really does the work, viz. \usertype{doit}, can be done in 
+isolation from the mechanics of batch processing the list of data files.
+
+The \usertype{doit\_toit} function is set up for production use and, 
+as such, it logs all activity in the standard logfile. 
+It may be run as a background task, like any other IRAF function.
+
+\begin{verbatim}
+# DOIT_TOIT -- A driver task for batch operation of DOIT.
+
+procedure doit_toit (images, section)
+
+file    *images { prompt = 'List of images to be changed' }
+char    section { prompt = 'Section of input images to be output' }
+
+begin
+        struct  imgs            # working storage for image file name
+        bool    klog            # default size is 32 chars
+        file    logf
+
+        klog = keeplog          # get global keeplog flag
+        logf = logfile          # ditto the log file name
+
+        while (fscan (images, imgs) != EOF) {                           
+            if (klog) {
+                # Output a startup message if keeplog is true.
+                print (' DOIT_TOIT: Process images ', >>logf)
+                time (>> logfile)
+                print ('    Images  : ', imgs, >>logf)
+                print ('    Section : ', section, >>logf)
+            }
+
+            # Do the actual task by calling the DOIT function, passing
+            # in the file name with the section concatenated.
+
+            doit (imgs // section, imgs)
+
+            if (klog) {     # output the trailing message
+                time (>>logf)
+                print (' DOIT_TOIT: Completed. ', >>logf)
+            }
+        }
+end
+\end{verbatim}
+
+\noindent
+The declaration for the variable \usertype{images} needs
+some explanation.  The asterisk \usertype{'*'} indicates that 
+\usertype{images} is a \irafname{list structured parameter}, i.e. that
+it is to be processed as a pointer to a parameter list, rather than 
+as the parameter itself.  In this instance it will contain the name
+of a file that itself contains a list of the names of files to be
+processed. 
+
+As with the other script tasks that have been described, this one must 
+be declared to the CL via a \usertype{task} statement before it can
+be executed. Once this has been done the task can be called as follows:
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{task doit\_toit = home\$doit\_toit.cl} \\
+\comptype{cl>} \usertype{doit\_toit ( 'images.txt', '[]' )}
+	 \hfill \#~no~sub-sections \\
+\comptype{cl>} \usertype{tail logfile} \hfill \#~check~the~logfile~messages
+\end{quotation}
+
+\noindent
+The name of the file containing the list of images \filename{``IMAGES.TXT''}
+is passed directly into the task as a quoted string.  
+
+\subsection{Establishing Your Own Function Package}
+
+Once you have defined several functions that do a useful set of operations,
+you may wish to set them up so that they are always available to you.
+This can be done by defining them as a package, which is the mechanism 
+that IRAF uses to organize the other groups of tasks that are made 
+available as part of the system proper.  (Or, more easily, by putting
+the \usertype{task} declarations into your \filename{LOGIN.CL} file.)
+
+\newpage
+\begin{verbatim}
+
+package my_package
+
+set 	funcs = "home$func/"           # define the logical directory
+
+task    fib   = funcs$fibonacci.cl
+        glib  = funcs$wordy.cl
+        doit  = funcs$doit.cl
+
+clbye()      # invoke the cl again for interactive use
+
+\end{verbatim}
+
+\noindent
+If you now place the declaration for this package task in your
+\filename{LOGIN.CL} file, these tasks will be available to you whenever
+you login to IRAF.  It is a good practice to always use logical directory
+names in task declarations and in other file names, since changing the
+search path with a \usertype{chdir} may otherwise render tasks not
+locatable.
+
+Packages may, of course, be more complex than the above, since they can
+refer to several logical tasks that may be CL script tasks or executable
+tasks.  User packages may also reference logical tasks that are in other
+packages directly, if only one or two such tasks from another package are 
+needed.  Additionally, a package task may declare variables
+that are to be treated as global to all of the tasks \emphasize{within} 
+the package, but are to remain local to the package itself.  Other IRAF 
+commands can be included in a package task as well, such as a load request
+for a package of utility routines.  As you will recall, the
+load operation for a package is implicitly executed whenever a package
+is named; thus, a utility package such as \taskname{plot} or \taskname{imred}
+can be loaded and made available just by naming it in the package description.
+
+\subsection{Creating Fortran, SPP and other External Tasks}
+
+While the IRAF and SDAS applications packages, along with the CL 
+language, offer substantial facilities for interaction with and 
+analysis of data, it would not be unusual for users  to wish to 
+make their existing algorithms available
+for use in IRAF.  Neither the IRAF packages nor the SDAS packages
+can provide all of the functions that everyone might desire. IRAF has been
+developed as an \emphasize{open system}, and is therefore extendible by the
+user so that externally compiled programs are accessible with the CL.
+These programs may be coded in any language that
+conforms to the standard calling conventions, but Fortran, C, and the
+Subset PreProcessor (SPP, the IRAF portable language) have predefined sets of
+interface routines that establish access to the IRAF \irafname{kernel}
+functions.
+
+It is suggested that the Fortran programmer use the SDAS/ST
+interface routines to access the IRAF environment.  These routines
+provide access to parameters, perform I/O on image files as well as other data
+file formats, provide facilities for header data manipulation, etc.
+The routines are described in the \reference{SDAS Applications Programmer's
+Guide} (the \reference{Green Book}) and in the \reference{Software
+Interface Definition, ST-ECF O-11}, which describes the set of
+interfaces that have been agreed upon between the STScI and the
+European Coordinating Facility (ECF).
+
+The SDAS interface routines (and the ST-ECF interfaces) are all 
+built upon the existing IRAF kernel interfaces as described in the 
+\reference{IRAF Programmer's Crib Sheet}. These interfaces are rather
+more complete than the SDAS/ST ones, providing full access to the facilities
+of the IRAF virtual operating system. These routines can be called directly
+from SPP, but typically \emphasize{cannot} be called directly from
+Fortran programs.
+
+A selection of software development tools are available to the user who wishes
+to integrate personal programs into the IRAF environment. These utilities
+are provided as parts of the \taskname{softools} package, and include such
+functions as IRAF-specialized compilation and linkage, help file creation, etc.
+
+A simple SPP language routine is included here as an example that
+can be tried from the terminal.  It is not a particularly useful
+function (it just feeps the terminal bell), but does show the
+ease with which an external task can be linked into the environment.
+
+\begin{verbatim}
+#------------------------------------------------------------
+# Simple task to show use of SPP external procs
+#	Compile and link using SPP command in Softools
+
+task feep = t_feep
+include	<chars.h>            # include the standard char defs
+
+# FEEP -- Feep the terminal.
+
+procedure t_feep()
+begin
+        call putc (STDOUT, BEL)
+end
+\end{verbatim}
+
+\noindent
+After you have used the editor to create the program source file,
+you should load the \irafname{softools} package that contains
+the \irafname{xc} compile/link tool.  This will compile the
+program, link it, and create an executable named \filename{FEEP.E}.
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{softool} \\
+\comptype{so>} \usertype{xc feep.x}
+\end{quotation}
+
+Once the \usertype{feep} task has been compiled and linked
+it may be made available from within the IRAF environment
+in a fashion analogous to that used for CL script tasks.
+A \usertype{task} statement that names the executable file and binds it
+to a task name must be used to declare the task to the CL.  Once this
+has been done, the executable task can be invoked just like any other
+task. 
+
+\begin{quotation}\noindent
+\comptype{cl>} \usertype{task feep = feep.e } \\
+\comptype{cl>} \usertype{feep} \hfill \#~is~used~to~call~it
+\end{quotation}
+
+\noindent
+N.B. IRAF tasks written in SPP (and other languages) 
+may contain more than one logical task, and the CL 
+\usertype{task} statement must be used to declare each of them.
+The logical task names used on the CL \usertype{task} statement
+\emphasize{must} correspond with the task names from  the {\tt task}
+statement used in the body of the SPP file.
+
+The parameter handling facilities at the user level behave 
+identically for executable 
+external tasks and for CL script tasks.  If the complete facilities
+of parameter range checking, prompt messages, and default values
+are desired, a data declaration statement that defines
+these values will have to be  specified.  If a declaration statement 
+is not provided, the standard prompt processing (naming the
+parameter and soliciting input) will be used when parameters are
+referenced.
+
+The details of parameter and file I/O in SPP, and in the Fortran and
+C interfaces, are sufficiently different from those presented for the 
+CL that the entire subject is best deferred to a separate document.  
+It is important to note however, that the facilities that are available
+in the CL and in the IRAF kernel routines that support it are
+equally available to all executable modules.  The implication of
+this is that any program that has been linked into IRAF will have the
+same apparent interface as all of the existing programs, and thus
+can easily be made to appear as a unified part of the larger system.
+This can, of course, be subverted, and programs may maintain their
+own identities in so far as that is desirable.  However, the advantages
+of a unified user interface and of a well defined and completely
+implemented set of flexible interface routines cannot be stressed enough.
+
+\newpage
+\section{Relevant Documentation (the Yellow Pages)}
+
+This document should serve to get the first-time user started (and if it
+doesn't, we would like to know about it), but there are many topics 
+that have been covered quickly or not at all.  Other documents and
+sources of information about IRAF, SDAS, standard packages, use of
+SPP, IRAF internals, etc. exist and this section will provide pointers
+into that realm for those who would like more information on these topics.
+
+\subsection{IRAF Command Language}
+
+Some of the documents describing the CL are now somewhat out of date
+since there have been at least two revisions to IRAF since they were
+written.  However, these documents are readable and are still
+useful, since, by design, most of the changes made to the CL are 
+compatible with what had gone before.
+
+\noindent
+\reference{CL Programmer's Guide, in preparation}
+
+This is to be the most complete introduction to programming in the
+CL and to the facilities of the CL.  As such, it provides details of language
+use (especially helpful when developing external and/or script tasks in
+Fortran, SPP, and C).  Also included are descriptions of the workings of 
+the CL, the IRAF kernel and inter-process communications as they affect 
+the use of IRAF for program development.
+
+\noindent
+\reference{Detailed Specifications of the IRAF Command Language, rev Jun82}
+
+This paper discusses in technical detail the major functions of the CL
+and some details about how it works.  Since this is a specifications
+document, it is not as readable as a user document, but it
+does cover many of the same areas as the \reference{CL Programmer's Guide}
+in somewhat more detail.
+
+\subsection{IRAF Applications Packages}
+
+Much of the richness of the IRAF environment comes from the packages
+of applications programs that are being made available within the 
+environment. The IRAF group at NOAO and the SDAS group at STScI have been
+developing analysis programs that are available as packages
+within the IRAF environment, and the end-user-oriented documentation of
+these systems is described below.
+
+\noindent
+\reference{IRAF Applications Packages, Structure and Requirements, Aug83}
+
+This document is an attempt to define fully the decomposition of the IRAF
+system and applications software into packages. The functions performed by
+each package are summarized in the form of requirements.
+
+Descriptions of specific IRAF applications packages developed at Kitt Peak
+are available in a set of user-handbooks :
+
+\begin{itemize}
+\item \reference{APPHOT - Digital Aperture Photometry, Aug83}
+\item \reference{GRAPH - Simple Graphics Routine, Mar84}
+\item \reference{SURFACE - 3-D Surface Display, Mar84}
+\item \reference{CONTOUR - Contour Map Display, Mar84} 
+\item \reference{HELP - On-Line HELP for IRAF, Mar84}
+\item \reference{DATAIO - Data Readers and Writers, Mar84}
+\item \reference{LISTS - Basic List Processing Functions (ASCII files), Mar84}
+\item \reference{UTILITIES - Miscellaneous Utility Functions, Mar84} 
+\item \reference{SOFTOOLS - Software Utilities, make, yacc, xc, mklib, Mar84}
+\end{itemize}
+
+\noindent
+\reference{Science Data Analysis Software Requirements, Final, Aug82}
+
+These are the contract requirements of the SDAS system.
+
+\noindent
+\reference{SDAS User's Manual, in preparation}
+
+A descriptive guide to the use of SDAS.
+
+\subsection{Standard Program Interfaces}
+
+There are three sets of interface routines available to the programmer:
+those for SPP, those for C, and those for Fortran. The language that
+you use depends on the nature of the project being undertaken, your 
+own level of expertise, and on the
+need for creating portable code.  SPP is the language of choice for packages
+that are to become part of IRAF or for tasks that require access to the
+entire virtual system interface.  Fortran and the SDAS/ST
+interfaces will remain the choice for existing Fortran codes and for many
+small scientific applications programs.  Users are encouraged to choose 
+the SDAS/ST interface for their Fortran programs.  C has been used
+for the innards of the CL itself, and a set of interfaces (the LIBC library)
+is provided that emulates the UNIX standard I/O facilities and 
+gives access to the IRAF kernel facilities.
+
+\noindent
+\reference{A Reference Manual for the IRAF System Interface, rev May84}
+
+This document is the most complete (and recent) treatment of the
+linkages between the portable IRAF kernel, the CL, the external procedures
+and the system dependent Z-routine layer.  It describes these interfaces
+in detail and has the complete specifications of the
+Z-routine interfaces. It is of particular use to both the individual who is
+trying to port IRAF to another system (it is a \emphasize{must read} for such
+persons) and to the system or applications
+programmer who wants a more detailed understanding of IRAF.
+
+\subsubsection{SPP Interfaces}
+
+\noindent
+\reference{Programmer's Crib Sheet for the IRAF Program Interface, rev Sep83}
+
+This document describes the complete set of interface functions
+for the IRAF virtual 
+operating system as it is available to the SPP programmer.  Several
+sets of library functions are described for accessing images and various
+kinds of data files, terminal capabilities, graphics and image I/O, etc.
+Programs written using only these interfaces
+will be fully portable, along with the main body of IRAF code.
+
+\noindent
+\reference{Reference Manual for the IRAF SPP, rev Sep83}
+
+This is the definitive document about the IRAF Subset Preprocessor
+language.  The language is somewhat like Ratfor (from which
+it derives), but it has extensions for dealing with the memory management
+and referencing issues that arise when operating on large scale image data.
+
+\noindent
+\reference{The Role of the Preprocessor, rev Dec81}
+
+This document is an early discussion of the philosophy behind use of
+the SPP language.  As such, it is valuable
+background reading for anyone who wishes to understand fully the
+benefits of using a preprocessed language for 
+implementing a large body of portable
+code like IRAF.
+
+\subsubsection{Fortran Interfaces}
+
+\noindent
+\reference{SDAS Applications Programmer's Guide}
+
+This is the complete description of the interface set that is now 
+being used to develop the SDAS program suite at STScI.  These interfaces
+are expected to be replaced eventually by the set of SDAS/ST 
+interfaces mentioned in the following document.
+
+\noindent
+\reference{Software Interface Definition, ST-ECF O-11, rev Aug84}
+
+This describes the set of standard interfaces agreed upon between 
+the STScI and the ST-ECF.  It incorporates most of the features of the
+SDAS standard interfaces and is to be used for program development 
+at STScI and for future MIDAS programs developed at ESO.  It is
+a rather complete interface for image data, process parameters,
+and table data structures, but does leave out many of the other 
+facilities provided in the complete IRAF SPP interface.
+
+\newpage
+\section{And into the Future}
+
+This version of IRAF and its CL represents the first external release
+of a system that has been under development for more than three years,
+and which will continue to evolve for several
+more.  IRAF was born out of the need for a system that
+could survive changes in operating systems and hardware, since such
+changes are a normal part of computer system evolution.  To 
+accomodate such changes, and to provide a level of stability 
+and portability across operating systems,
+IRAF is a \emphasize{layered} system: the CL is the user layer;
+the kernel is the operating system independent layer; and the
+z-routines are the system dependent layer.  
+
+Most of the discussion in this document describes the appearance 
+and function of the current command language (CL2), the user layer 
+of IRAF.  As has been noted at various points in the text, 
+the CL is still undergoing
+development and is expected to change over time.  (The paragraphs
+marked \irafname{CL++} in the text hold the clues.)  The intent
+in these changes is two-fold:
+
+\begin{itemize}
+
+\item Provide evolutionary enhancements to the user interface
+to improve utility, functionality, usability and coherence.
+
+\item Bring the programming elements of the CL language
+into line with the SPP language which is used for the bulk of the
+IRAF portable code.
+
+\end{itemize}
+
+\noindent
+These requirements are somewhat at odds, as was noted in \S 6, but
+further attention is being given these issues to try and resolve 
+the dilemma.  Although not all elements of the CL language can
+be mapped easily into the SPP programming language (consider the I/O
+control commands), the notion that one
+can do development in an interactive environment and then
+realize compiled code speeds for execution is an attractive one.
+The CL2 implementation has
+taken steps in this direction and we expect to see how far this idea
+can be taken over the next few years.
+
+\subsection{Near-Term Software Projects}
+
+While the evolution of the CL is an important part of IRAF, there
+are other elements of the system that are even more important which are
+still under development at this time.  The most important single area
+for development is the database and data catalogue.
+Design and prototyping of these important functions, and the
+necessary query language, is in progress
+right now.  These functions are doubly important, since they both represent 
+a user facility for creating and operating on private catalogues 
+of data; and also are at the heart of the effort to merge the
+SDAS functions cleanly into the IRAF control structure.  Only after
+the DBIO and IMIO packages have been fully implemented and integrated
+into the rest of the system will functions from these two large
+applications groups be able to share data and file structures.  
+A tables system is also envisioned that will offer similar capabilities
+to the MIDAS tables, but will be built upon the DBIO routines.  
+
+The areas of graphics and image display will also receive
+attention during the next year.  The current GIO package
+supports a fast kernel and both a GKS and an NCAR emulation.  
+However, image data are not merged into this structure 
+and no common meta-file
+formats exist that allow image, annotation, and overlay graphics
+to be represented in one consistent form.  Some efforts have already
+been made toward understanding what needs to be done and how (or if)
+the requirements can be satisfied within existing standards.
+Further efforts will be made, both at NOAO and STScI, and at
+other facilities like RAL who have expertise in this area, to develop
+an approach that satisfies the requirements.
+
+Developments in the area of networks, both LAN and wide-area; workstations;
+and the related topics of access to distributed data bases and archives
+are also receiving attention.  We believe that IRAF
+has a sufficiently robust and flexible structure that it can operate
+successfully within a distributed operating environment.  Small scale 
+efforts are now underway to explore some of the issues related to network
+file systems.  
+
+At the same time, a prototype project is underway with a
+single platter laser disk, to evaluate the suitability of this media 
+for large scale, long term archival storage of images and other related 
+data.   As a part of this activity, IRAF is currently
+being ported to a SUN workstation and high resolution image display 
+at the STScI.  IRAF and its database package will be important 
+to this effort, since they will provide some of the basic facilities 
+for processing the data and managing the catalogues for this archive. 
+
+These are all components of a distributed data system, a long range goal
+for the Space Telescope community, and probably of interest to the entire 
+astronomy and astrophysics community.  To the extent that IRAF proves
+useful to astronomers, it will play a key role in such a data system.
+
+\subsection{Where Is the Future?}
+
+The usual rapid pace of developments in hardware and software systems 
+will also prompt consideration of changes to the external appearance
+and some of the internal implementation details of IRAF.
+Developments in graphics and image displays, and in various data
+input and storage
+devices promise to make revolutionary changes in the way that
+people and computers interact. High resolution graphics, touch screens,
+mice, WYSIWYG (What You See Is What You Get), DWIM (Do What I Mean),
+and the 'cluttered desk' paradigm pioneered by Xerox PARC and emulated
+by everyone else, will all appear in one form or another in a variety
+of different systems in the next few years.  These presentation
+techniques and differing interactive views of data,
+when well thought out and integrated into a system,
+can serve to make computers more accessible to people.  
+These ideas, however, have been much slower to arrive in the 
+large-scale systems that have been used for data analysis than in
+the super-micro and PC class machines. 
+
+IRAF, in its current version, incorporates only some of these elements,
+but many others will be experimented with as it is ported to
+different hardware environments.  
+Because the CL is a separable piece of the system, 
+it can be changed or replaced, without necessarily making major changes
+to the underlying system structure.  Efforts now underway to move
+IRAF out of the super-mini systems where it has been developed, and
+into super-micro workstations will afford the opportunity to
+explore some of these user interface issues in a prototyping 
+mode.  Depending on the results of such experiments,
+other CL interfaces that take advantage of those
+elements that prove successful are likely to evolve.  
+
+These statements should not be
+construed to mean that constant change will be the norm.  IRAF
+was designed to protect the substantial software investment that any 
+large data analysis system represents, and this it will do, both for
+the developers and for the users.  The IRAF kernel and the layered
+interfaces for applications programs are quite stable, and are not
+expected to change, except to incorporate additional functionality.
+Furthermore, any changes proposed for
+the user interface will be carefully evaluated in terms of their
+impact on the existing user community.  But, just as we expect that
+faster, more efficient FFT or filtering algorithms would receive
+a welcome reception we expect that a stable, but slowly evolving system 
+that continues to serve
+users needs will meet with approval.  Feedback and commentary from the
+users of the system will be vitally important in this development
+process, and we encourage that dialogue.
+
+\newpage
+\appendix
+\section{Appendices}
+
+\subsection{CL Commands and the System Package}
+
+\subsubsection{CL Intrinsic and Builtin Functions}
+
+\begin{tabular}{rcl}
+
+	 access & - & Test to see if a file exists \\
+	    bye & - & Exit a task or package \\
+          cache & - & Cache parameter files, OR \\
+                  & & Print the current cache list (no arguments)\\
+	     cd & - & Change directory \\
+	  chdir & - & Change directory \\
+	     cl & - & Execute commands from the standard input \\
+	  clbye & - & Exit a task or package to save file descriptors \\
+	 defpac & - & Test to see if a package is defined \\
+	 defpar & - & Test to see if a parameter is defined \\
+        deftask & - & Test to see if a task is defined \\
+       ehistory & - & Edit commands from the history log file \\
+	 envget & - & Get the string value of an environment variable \\
+         eparam & - & Edit the parameters for a function \\
+	  error & - & Print error code and message and abort \\
+      flprcache & - & Flush the process cache \\
+	 fprint & - & Format and print a line into a parameter \\
+	  fscan & - & Scan and format an input list \\
+       hidetask & - & Define a new hidden task \\
+        history & - & Print the last few commands entered \\
+	   jobs & - & Show status of background jobs \\
+	   keep & - & Make recent set, task, etc. declarations permanent \\
+	   kill & - & Kill a background job or detached task \\
+	 logout & - & Log out of the CL \\
+	 lparam & - & List the parameters of a task \\
+	 mktemp & - & Make a temporary (unique) file name \\
+	  mkdir & - & Make a new file sub-directory \\
+        package & - & Define a new package, OR\\
+                  & & Print the current package names (no arguments) \\
+	  print & - & Format and print a line on the standard output \\
+	  radix & - & Print a number in the given radix \\
+       redefine & - & Redefine a task \\
+	   scan & - & Scan and format the standard input \\
+        service & - & Service a query from a background job \\
+	    set & - & Set an environment variable, OR \\
+                  & & Print environment (no arguments) \\
+	   show & - & Show the values of one or more environment variables \\
+	  sleep & - & Pause execution for  specified period \\
+	 substr & - & Extract a substring from a string \\
+	   task & - & Define a new task \\
+        unlearn & - & Restore the default parameters for a task or package \\
+	 update & - & Update a task's parameters (flush to disk) \\
+        version & - & Print the revision date of the CL \\
+	   wait & - & Wait for all background jobs to complete
+\end{tabular}
+
+\subsubsection{System Package Functions}
+
+\begin{tabular}{rcl}
+
+       allocate & - & Allocate a device \\
+	   beep & - & Beep the terminal \\
+	  clear & - & Clear the terminal screen \\
+    concatenate & - & Concatenate a list of files to the standard output \\
+	   copy & - & Copy a file, or copy a list of files to a directory \\
+	  count & - & Count the number of lines, words, and characters in a file \\
+     deallocate & - & Deallocate a previously allocated device \\
+         delete & - & Delete a file \\
+      devstatus & - & Print the status of a device \\
+      directory & - & List files in a directory \\
+      diskspace & - & Show how much diskspace is available \\
+	   edit & - & Edit a file \\
+	  files & - & Expand a file template into a list of files \\
+         gripes & - & Post bug reports, complaints, suggestions \\
+	   head & - & Print the first few lines of a file \\
+           help & - & Print online documentation \\
+         lprint & - & Print a file on the line printer device \\
+	  match & - & Print all lines in a file that match a pattern \\
+	   news & - & Page through the system news file \\
+	   page & - & Page through a file \\
+      pathnames & - & Expand a file template into a list of OS pathnames \\
+        protect & - & Protect a file from deletion \\
+         rename & - & Rename a file \\
+      revisions & - & Print/post a revision notice for a package \\
+         rewind & - & Rewind a device \\
+	   sort & - & Sort a text file \\
+	    spy & - & Show processor status \\
+	   stty & - & Show/set terminal characteristics \\
+	   tail & - & Print the last few lines of a file \\
+	    tee & - & Tee the standard output into a file \\
+	   time & - & Print the current time and date \\
+	   type & - & Type a file on the standard output \\
+      unprotect & - & Remove delete protection from a file
+\end{tabular}
+\clearpage
+
+\subsection{SDAS Analysis Packages}
+
+\begin{itemize}
+
+\item General Data Analysis \\
+
+\begin{tabular}{rcl}
+   areavolum & - & Integrate to find the area/volume under a curve/surface\\
+   arrayops & - & Perform arithmetic, logical, and matrix operations on\\
+                  & &  \quad SDAS data arrays\\
+   convert & - & Convert data from one type to another (real, integer,\\
+                   & &  \quad logical, byte)\\
+   curfit & - & Fit curve to one-dimensional data\\
+   dimage & - & General image display package\\
+   extract & - & Extract a subset of a data array\\
+   fitsrd & - & Read a standard FITS tape and create an SDAS disk data file\\
+   fitswr & - & Write a standard FITS tape from an SDAS disk data file\\
+   four1d & - & Perform one-dimensional Fourier analysis\\
+   four2d & - & Perform two-dimensional Fourier analysis\\
+   hstats & - & Compute standard statistics, including histograms\\
+   locate & - & Locate features in a spectrum, time series, or image\\
+   makemask & - & Make a data mask\\
+   plot1d & - & Plot one-dimensional (equally-spaced) data\\
+   plot2d & - & Plot two-dimensional (equally-spaced) data as contour\\
+                    & &  \quad map or ruled-surface map\\
+   probdist & - & Compute standard probability distributions\\
+   register & - & Compute registration parameters for two displaced data\\
+                     & &  \quad arrays (use in conjunction with resample)\\
+   repmod & - & Replace/modify/input data in an existing data array\\
+   resample & - & Resample data from one grid to another (shift, rescale, rotate)\\
+   smooth & - & Smooth data by convolution filtering, median window
+\end{tabular}
+
+\item Spectral Analysis \\
+
+\begin{tabular}{rcl}
+   cntana & - & Continuum analysis (determine reddening, correct for\\
+                     & &  \quad reddening, fit continuum models)\\
+   ewlnst & - & Measure equivalent width/line strength\\
+   gspect & - & Generate a spectrum for testing\\
+   rvdet & - & Measure radial velocities\\
+   specph & - & Spectrophotometry
+\end{tabular}
+
+\item Image Analysis \\
+
+\begin{tabular}{rcl}
+   gimage & - & Generate an image for testing\\
+\end{tabular}
+
+\clearpage
+\item Time Series Analysis \\
+
+\begin{tabular}{rcl}
+   glcurv & - & Generate a light curve for testing\\
+   hldelc$^*$ & - & Correct HSP times for light delay time\\
+   hspcir$^*$ & - & Correct HSP data for instrumental response\\
+   hspolar$^*$ & - & Polarimetry package for HSP data\\
+   hspphot$^*$ & - & Photometry package for HSP data\\
+   hsubbkg$^*$ & - & Subtract background from HSP data
+\end{tabular}
+
+\item Astrometric Analysis \\
+
+\begin{tabular}{rcl}
+   bdresid$^*$ & - & Make histogram of FGS beam deflector residuals\\
+   centroid$^*$ & - & Centroid raw FGS encoder data\\
+   errsig$^*$ & - & Make histogram of FGS error signals
+\end{tabular}
+
+\end{itemize}
+
+\vskip 2cm \noindent
+$*$ --- these programs may not be available
+\clearpage
+
+\subsection{IRAF Application Packages}
+
+\begin{itemize}
+
+\item CRYOMAP Package \\
+
+\begin{tabular}{rcl}
+
+        extract & - & Extract Cryomap spectra\\
+    findspectra & - & Find Cryomap spectra\\
+           iids & - & Convert integrated spectra extractions to IIDS format\\
+        maplist & - & List information about the multi-aperture plate\\
+       specplot & - & Plot extracted integrated spectra
+
+\end{tabular}
+
+\item DATAIO Package \\
+
+\begin{tabular}{rcl}
+
+	 bintxt & - & Convert a binary file to an IRAF text file\\
+	 ldumpf & - & List the permanent files on a Cyber DUMPF tape\\
+      mtexamine & - & Examine the structure of a magnetic tape\\
+        rcamera & - & Convert a Forth/Camera image into an IRAF image\\
+     rcardimage & - & Convert a cardimage file into a text file\\
+	 rdumpf & - & Convert IPPS rasters from a DUMPF tape to IRAF images\\
+        reblock & - & Copy a binary file, optionally reblocking\\
+          rfits & - & Convert a FITS image into an IRAF image\\
+       ridsfile & - & Convert IDSFILES from a DUMPF tape to IRAF images\\
+	ridsmtn & - & Convert mountain format IDS/IRS data to IRAF images\\
+        ridsout & - & Convert a text file in IDSOUT format to IRAF images\\
+           rpds & - & Convert a PDS image into an IRAF image\\
+	 rrcopy & - & Convert IPPS rasters from an RCOPY tape to IRAF images\\
+	 txtbin & - & Convert an IRAF text file to a binary file\\
+     wcardimage & - & Convert text files to cardimage files\\
+	  wfits & - & Convert an IRAF image into a FITS image\\
+	widsout & - & Convert an IRAF image to IDSOUT text format
+\end{tabular}
+
+\item ECHELLE Package \\
+
+\begin{tabular}{rcl}
+
+     background & - & Subtract a scattered light background\\
+	extract & - & Extract Echelle orders\\
+     findorders & - & Find Echelle orders\\
+           iids & - & Convert integrated spectra extractions to IIDS format\\
+      orderplot & - & Plot extracted integrated spectra
+
+\end{tabular}
+\clearpage
+
+\item GENERIC Package \\
+
+\begin{tabular}{rcl}
+
+	biassub & - & Subtract a bias image\\
+       chimages & - & Change images: trim, flip, transpose, rotate\\
+     colbckgrnd & - & Fit and subtract a column by column background\\
+	colflat & - & Create a flat field by fitting a function \\
+		&&	to the image columns\\
+	darksub & - & Scale and subtract a dark count image\\
+	 dcbias & - & Subtract a constant bias and trim images\\
+        flatten & - & Flatten images using a flat field\\
+    linebckgrnd & - & Fit and subtract a line by line background\\
+       lineflat & - & Create a flat field by fitting a function \\
+		&&	to the image lines\\
+      normalize & - & Normalize images\\
+       normflat & - & Create a flat field by normalizing and \\
+		&&	replacing low values
+
+\end{tabular}
+
+\item IMAGES Package \\
+
+\begin{tabular}{rcl}
+
+        imarith & - & Simple image arithmetic\\
+      imaverage & - & Average images together\\
+	 imcopy & - & Copy an image\\
+       imdelete & - & Delete an image\\
+      imlinefit & - & Fit a function to each image line\\
+       imheader & - & Print an image header\\
+    imhistogram & - & Compute image histogram\\
+   imstatistics & - & Compute and print image statistics\\
+    imtranspose & - & Transpose a two dimensional image\\
+     listpixels & - & Convert an image section into a list of pixels\\
+       sections & - & Expand an image template on the standard output\\
+     shiftlines & - & Shift image lines\\
+             tv & - & Image display (see TV-IMAGE Package)
+
+\end{tabular}
+
+\item LISTS Package \\
+
+\begin{tabular}{rcl}
+
+	average & - & Compute the mean and standard deviation of a list\\
+	gcursor & - & Read the graphics cursor\\
+       imcursor & - & Read the image display cursor\\
+	  table & - & Format a list of words into a table\\
+	 tokens & - & Break a file up into a stream of tokens\\
+	 unique & - & Delete redundant elements from a list\\
+	  words & - & Break a file up into a stream of words
+
+\end{tabular}
+
+\clearpage
+\item LOCAL Package \\
+
+\begin{tabular}{rcl}
+
+       binpairs & - & Bin pairs of (x,y) points in log separation\\
+	   epix & - & Edit pixels in an image\\
+	 fields & - & Extract specified fields from a list\\
+      imreplace & - & Replace pixels in a range by a constant\\
+	imscale & - & Scale an image to a specified (windowed) mean\\
+	imstack & - & Stack images into an image of higher dimension\\
+       imsurfit	& - & Fit a surface to an image\\
+	imtitle & - & Change the title of an image\\
+	  notes & - & Record notes\\
+        polyfit & - & Fit polynomial to lists of X,Y pairs
+
+\end{tabular}
+
+\item MULTISPEC Package \\
+
+\begin{tabular}{rcl}
+
+      findpeaks & - & Find the peaks\\
+    fitfunction & - & Fit a function to the spectra parameter values\\
+      fitgauss5 & - & Fit spectra profiles with five parameter \\
+		&&	Gaussian model\\
+      modellist & - & List data and model pixel values\\
+      msextract & - & Extract spectra\\
+         mslist & - & List entries in a MULTISPEC database\\
+         msplot & - & Plot a line of image and model data\\
+          msset & - & Set entries in a MULTISPEC database\\
+  newextraction & - & Create a new MULTISPEC extraction database\\
+       newimage & - & Create a new multi-spectra image
+
+\end{tabular}
+
+\item PLOT Package \\
+
+\begin{tabular}{rcl}
+
+	contour & - & Make a contour plot of an image\\
+	  graph & - & Graph one or more image sections or lists\\
+	   pcol & - & Plot a column of an image\\
+	  pcols & - & Plot the average of a range of image columns\\
+	   prow & - & Plot a line (row) of an image\\
+	  prows & - & Plot the average of a range of image lines\\
+	surface & - & Make a surface plot of an image
+\end{tabular}
+
+\clearpage
+\item SOFTOOLS Package \\
+
+\begin{tabular}{rcl}
+
+     hdbexamine & - & Examine a help database\\
+	  lroff & - & Lroff (line-roff) text formatter\\
+	   make & - & Table driven utility for maintaining programs\\
+       mkhelpdb & - & Make (compile) a help database\\
+	  mklib & - & Make or update an object library\\
+      mkmanpage & - & Make a manual page\\
+       xcompile & - & Compile and/or link an SPP, C or Fortran program\\
+	   yacc & - & Build an SPP language parser
+
+\end{tabular}
+
+\item TV-IMAGE Package \\
+
+\begin{tabular}{rcl}
+
+      blink 	& - & Blink the TV display\\
+      display	& - & Manipulate the TV display\\
+      erase	& - & Erase the TV display\\
+      frame	& - & Define the frames to be manipulated\\
+      lumatch	& - & Match color look up tables\\
+      monochrome& - & Set display into monochrome mode\\
+      pseudocolor& - & Set pseudocolor mode on display\\
+      rgb	& - & Set true RGB mode on display\\
+      window	& - & Define a display window area\\
+      zoom	& - & Zoom the display
+
+\end{tabular}
+
+\item UTILITIES Package \\
+
+\begin{tabular}{rcl}
+
+	airmass & - & Compute the airmass at a given elevation \\
+		&&	above the horizon\\
+	ccdtime	& - & Compute time required to a observe star \\
+		&&	of given magnitude\\
+	  detab	& - & Replace tabs with tabs and blanks\\
+	  entab & - & Replace blanks with tabs and blanks\\
+	  lcase & - & Convert a file to lower case\\
+	precess & - & Precess a list of astronomical coordinates\\
+       translit & - & Replace or delete specified characters in a file\\
+	  ucase & - & Convert a file to upper case\\
+	  urand & - & Uniform random number generator
+\end{tabular}
+
+\end{itemize}
+\clearpage
+
+\subsection{IRAF Editor Functions}
+
+\begin{tabular}{llll}
+
+Command & Emacs  & EDT$^{\dag}$ & Vi$^{\ddag}$ \\
+\\
+move-up & \key{$\uparrow$} or \key{CTRL/P} & \key{$\uparrow$} 
+	& \key{j} or \key{CTRL/P} \\
+move-down & \key{$\downarrow$} or \key{CTRL/N} & \key{$\downarrow$} 
+	& \key{k} or \key{CTRL/N} \\
+move-right & \key{$\rightarrow$} or \key{CTRL/F} & \key{$\rightarrow$} 
+	& \key{l} or \key{$\rightarrow$} \\
+move-left & \key{$\leftarrow$} or \key{CTRL/B} & \key{$\leftarrow$} 
+	& \key{h} or \key{$\leftarrow$} \\
+\\
+ins-chr/word & {\it text} & {\it text} & i/a-{\it text}\ \key{ESC} \\
+del-left & \key{CTRL/H} or \key{DEL} \hspace{1cm} & \key{DEL} & \key{DEL} \\
+del-char & \key{CTRL/D} & \key{,} & \key{x} \\
+del-word & \key{ESC}\ \key{d} & \key{-} & \key{d}\ \key{w} \\
+del-line & \key{CTRL/K} & \key{PF4} & \key{d}  \key{d} \\
+undel-char & \key{ESC}\ \key{CTRL/D} & \key{GOLD}\ \key{,} & \key{u} \\
+undel-word & \key{ESC}\ \key{CTRL/W} & \key{GOLD}\ \key{-} & \key{u} \\
+undel-line & \key{ESC}\ \key{CTRL/K} & \key{GOLD}\ \key{PF4} & \key{u} \\
+\\
+set-fwd & & \key{4} & \\
+set-rev & & \key{5} & \\
+next-word & \key{ESC}\ \key{f} & \key{1} & \key{w} \\
+prev-word & \key{ESC}\ \key{b} & \key{5}\ \key{1} & \key{b} \\
+move-eol & \key{CTRL/E}  & \key{2} & \key{\$} \\
+move-bol & \key{CTRL/A}  & \key{BS} or \key{CTRL/H} \hspace{1cm} 
+	& \key{.} \\
+next-page & \key{CTRL/V}  & \key{7} & \key{CTRL/D} or \key{CTRL/F} \\
+prev-page & \key{ESC}\ \key{V} & \key{5}\ \key{7} 
+	& \key{CTRL/U} or \key{CTRL/B} \\
+move-start & \key{ESC}\ \key{$<$} & \key{GOLD}\ \key{5} & \key{1}\ \key{G} \\
+move-end & \key{ESC}\ \key{$>$} & \key{GOLD}\ \key{4} & \key{G} \\
+\\
+get-help & \key{ESC}\ \key{?} & \key{PF2} & \key{PF2} or \key{ESC}\ \key{?} \\
+repaint & \key{CTRL/L} & \key{CTRL/R} & \key{CTRL/L}\\
+exit-update & \key{CTRL/Z} & \key{CTRL/Z} 
+	& \key{:}\ \key{w}\ \key{q} \\
+exit-no update \hspace{1cm} & \key{CTRL/C} & \key{CTRL/C} 
+	& \key{:}\ \key{q}\ \key{!} \\
+
+\end{tabular}
+
+\hrule width5cm \vskip .15cm \noindent
+\dag{} --- EDT employs the notion of ``direction'' (forward and backward
+cursor motion). Several command sequences are preceded by \key{5} to indicate
+explicitly that they only function after setting ``backward'' mode.  All EDT
+keystrokes, with the exception of \key{CTRL} keys, use the keypad.
+
+\medskip \noindent
+\ddag{} --- Vi has \emphasize{insert/replace/change modes},
+which are entered by command and terminated by the \key{ESC} key.
+Vi-type keystrokes for \usertype{eparam} and \usertype{ehist} are not
+yet implemented.
+
+\twocolumn \columnsep 1cm
+\section{Glossary}
+
+\medskip \noindent \irafname{AAS} --- American Astronomical Society.
+
+\medskip \noindent \irafname{band} --- A two dimensional array. The Nth band
+of a three dimensional array or \irafname{image} is denoted by the subscript
+[$*$,$*$,N], where $*$ refers to all the pixels in that dimension.
+
+\medskip \noindent \irafname{binary file} --- An array or sequence of
+data words.  Data is transferred between a binary file and a buffer in the
+calling program by a simple copy operation, without any form of conversion.
+
+\medskip \noindent \irafname{binary operator} --- An operator which combines
+two operands to produce a single result 
+(e.g., the addition operator in $x + y$).
+
+\medskip \noindent \irafname{brace} --- The left and right braces are 
+the characters `\{' and `\}'.  Braces are used in the CL and in the 
+SPP language to group statements to form a compound statement.
+
+\medskip \noindent \irafname{bracket} --- The left and right brackets 
+are the characters `[' and `]'. Brackets are used in the CL and in the
+SPP language to delimit array subscripts.
+
+\medskip \noindent \irafname{byte} --- The smallest unit of storage on 
+the host machine.  The IRAF system assumes that there are an integral 
+number of bytes in a \irafname{char} and in an address increment 
+(and therefore that the byte is not larger than either).
+On most modern computers, a byte is 8 bits, and a \irafname{char} is 16 bits
+(I$*$2).  If the address increment is one byte, the machine
+is said to be \emphasize{byte addressable}.  Other machines are \emphasize{word
+addressable}, where one word of memory contains two or more bytes.
+In the SPP language, SZB$_{CHAR}$ gives the number of bytes per char,
+and SZB$_{ADDR}$ gives the number of bytes per address increment.
+
+\medskip \noindent \irafname {C} --- A powerful modern language for 
+both systems and general programming.
+C provides data structuring, recursion, automatic storage, a fairly
+standard set of control constructs, a rich set of operators,
+and considerable conciseness of expression.
+
+\medskip \noindent \irafname{char} --- The smallest signed integer that can be
+directly addressed by programs written in the SPP language.  The char
+is also the unit of storage in IRAF programs; the sizes of objects are
+given in units of chars, and binary files and memory are addressed in
+units of chars.  Since the SPP language interfaces to the machine via the
+local Fortran compiler, the Fortran compiler determines the size of a char.
+On most systems, the IRAF data type \emphasize{char} is equivalent to the
+(nonstandard) Fortran datatype I$*$2.
+
+\medskip \noindent \irafname{CL} --- The IRAF Command Language.  The CL is an
+interpreted language designed to execute external \irafname{tasks}, and
+to manage their \irafname{parameters}.
+The CL organizes tasks into a hierarchical structure of independent
+\irafname{packages}.  Tasks may be either \irafname{script tasks}, written in
+the CL, or compiled \irafname{programs}, written in the SPP language, and
+linked together to form \irafname{processes}.  A single process may contain
+an arbitrary number of tasks.
+
+The CL provides \irafname{redirection} of all I/O streams, including graphics
+output, and cursor readback. Other facilities include command logging, an
+on-line help facility, a ``programmable desk
+calculator'' capability, and a \irafname{learn mode}.
+New packages and tasks are easily added by the user,
+and the CL environment is maintained in the user's own directories,
+providing continuity from session to session.
+
+\medskip \noindent \irafname{column} --- a one-dimensional array. The Nth
+column vector of a two dimensional array or image is denoted
+by the subscript [N,$*$],
+where $*$ refers to all the pixels in that dimension.
+The Nth column of the Mth band of a three dimensional array or image
+is denoted by [N,$*$,M].
+
+\medskip \noindent \irafname{coupling} --- A measure of the strength of
+interdependence among modules.
+The independence of modules is maximized when coupling is minimized.
+
+\medskip \noindent \irafname{CTIO} --- Cerro Tollolo Image Observatory,
+one of the NOAO facilities located in Chile.
+
+\medskip \noindent \irafname{data structure} --- An aggregate of two or more 
+data elements, where the elements are not necessarily of the same type. 
+Examples include arrays, files, rec\-ords, linked lists, 
+trees, graphs, and so on.
+
+\medskip \noindent \irafname{data file} --- a data storage file.  Data
+files are used to store program generated \irafname{records} or descriptors,
+that contain the results
+of the analysis performed by a program.  Datafile records may be the
+final output of a program, or may be used as input to a program.  Data
+file may contain ASCII or binary data, and may have implicit or explicit
+data structures.
+
+\medskip \noindent \irafname{environment variables} --- Parameters that
+affect the operation of \emphasize{all} IRAF programs.
+Environment variables define logical names for directories, associate 
+physical devices with logical device names, and provide control
+over the low level functioning of the IRAF file I/O system.
+
+\medskip \noindent \irafname{ECF} --- European Coordination Facility. The
+center that is to coordinate use of Space Telescope data and programs for 
+the European scientific community.
+
+\medskip \noindent \irafname{ESO} ---  European Southern Observatory,
+headquartered at Garching, FDR.
+
+\medskip \noindent \irafname{field} --- An element of a \irafname{data
+structure} or \irafname{record}. Each field has
+a name, a datatype, and a value.
+
+\medskip \noindent \irafname{FITS} --- Flexible Image Transport System. FITS is
+a standard tape format used to transport images (pictures) between computers
+and institutions.  Developed in the late 1970s by Donald Wells (KPNO), 
+Eric Greisen (NRAO), and Ron Harten (Westerbork),  
+the FITS standard is now widely used for the
+interchange of image data between astronomical centers, and is officially
+sanctioned by both the AAS and the IAU.
+
+\medskip \noindent \irafname{Fortran} --- As the most widely used language 
+for scientific computing for the past
+twenty years, Fortran needs little introduction.  Fortran is used in the 
+IRAF system as a sort of ``super assembler'' language.  Programs and procedures
+written in the IRAF \irafname{SPP} language are mechanically translated 
+into a highly
+portable subset of Fortran, and the Fortran modules are in turn translated
+into object modules by the host Fortran compiler.  Existing numerical
+and other modules, already coded in the Fortran language, are easily linked
+with modules written in the SPP language to produce executable programs.
+The IRAF system and applications software does not use any Fortran I/O;
+all I/O facilities are provided by the IRAF \irafname{program interface} and
+\irafname{virtual operating system}.
+
+\medskip \noindent \irafname{function} --- A procedure which returns a value.
+Functions must be declared before they can be used, and functions must only be
+used in expressions. It is illegal to \emphasize{call} a function.
+
+\medskip \noindent \irafname{HSI} --- The IRAF Host System Interface,
+i.e., the interface between the portable IRAF software and the host system.
+The HSI include the \irafname{kernel}, the \irafname{bootstrap utilities},
+and any host dependent graphics device interfaces.
+
+\medskip \noindent \irafname{hidden parameters} --- Parameters that
+are not displayed by the CL.
+The CL does not query for hidden parameters, but automatically
+uses the default values.  Hidden parameters may be set on the command line,
+but the value from the command line will not be \irafname{learned}.
+
+\medskip \noindent \irafname{IAU} --- The International Astronomical Union.
+
+\medskip \noindent \irafname{IKI} --- The Image Kernel Interface.  The IKI
+gives IRAF the capability of dealing with multiple physical image storage
+formats.  The high level image i/o software calls the IKI, which in turn
+calls one of the format specific image kernels, e.g., the OIF kernel or
+the STF kernel.
+
+\medskip \noindent \irafname{identifier} --- A sequence of characters used to
+name a procedure, variable, etc. in a compiled language.  In the CL and 
+SPP languages, an identifier is an upper or lower case letter, followed 
+by any number of upper or lower case letters, digits, or underscore characters.
+
+\medskip \noindent \irafname{image} --- An array of arbitrary dimension 
+and datatype, used for bulk data storage.
+An image is an array of \irafname{pixels}.
+
+\medskip \noindent \irafname{imagefile} --- The form in which images are
+stored in the IRAF system.  IRAF currently supports images of up to seven
+dimensions, in any of eight different data types.
+Only \emphasize{line storage} mode is currently available, but support for
+VMS mapped image sections is planned.
+The imagefile structure is actually implemen\-ted as two separate files,
+an \irafname{image head\-er file} and a \irafname{pixel storage file}.
+
+\medskip \noindent \irafname{image header file} --- a file describing the
+contents of an image. It is a small file that is normally placed in the
+user's own directory system.
+
+\medskip \noindent \irafname{interface} --- The visible portion of a
+system, program or collection of programs.  The only portion of such a
+entity that other entities need to have knowledge of or access to.
+The connection between hardware or software entities.
+
+\medskip \noindent \irafname{IRAF} --- The Image Reduction and Analysis 
+Facility.
+IRAF comprises a \irafname{virtual operating system}, a command language
+(CL), a general purpose programming language (SPP, which
+was developed along with IRAF), a large I/O library, and numerous support
+utilities and scientific applications programs.  The system is designed to be
+transportable to any modern superminicomputer.  The
+system provides extensive facilities for general image processing,
+astronomical data reduction and analysis, scientific programming,
+and general software development.
+
+\medskip \noindent \irafname{IRAF Guru} --- Any individual whose knowledge
+of IRAF is greater than yours. Gurus' wisdom embraces all of the essential
+mysteries of IRAF, and usually includes the locations of good Chinese
+restaurants.
+
+\medskip \noindent \irafname{kernel} --- A host dependent library of SPP
+(or Fortran) callable subroutines implementing the primitive system services
+required by the portable IRAF virtual operating system (VOS).  Most of the
+machine dependence of IRAF is concentrated into the kernel.
+
+\medskip \noindent \irafname{learn mode} --- A facility designed
+to simplify the use of the CL. By default, the CL ``learns'' the value of all
+function \irafname{parameters} that are prompted for or explicitly set.
+
+\medskip \noindent \irafname{line} --- A one-dimensional array. The Nth line
+of a two dimensional array or image is denoted
+by the subscript [$*$,N],
+where $*$ refers to all the pixels in that dimension.
+The Nth line of the Mth band of a three dimensional array or image
+is denoted by [$*$,N,M].
+
+\medskip \noindent \irafname{list structured parameter} --- A text file, each
+line of which is a record that contains one or more fields, separated
+by blanks or commas, that can be interpre\-ted by the CL.
+Not all fields need be present, omitted fields are indicated by insertion
+of an extra comma (fields can only be omitted
+from right to left).
+
+\medskip \noindent \irafname{Lroff} --- The text formatter that is part of
+the portable IRAF system and used to process \irafname{help} file text. 
+Lroff is patterned after the UNIX \irafname{Troff} text formatter.
+
+\medskip \noindent \irafname{macro} --- (1) A \irafname{script task}.
+(2) An inline function with zero or more arguments that is 
+expanded by text substitution during the preprocessing phase
+of compilation.
+
+\medskip \noindent \irafname{metacharacter} --- Characters that have special
+meaning to the CL. For example, the asterisk `$*$' is used as a ``wild card''
+place-holder; any alphanumeric character is considered a match.
+
+\medskip \noindent \irafname{MIDAS} --- Munich Image Data Analysis System.
+An analysis package under development by the ESO.
+
+\medskip \noindent \irafname{NOAO} --- National Optical Astronomy
+Observatories.
+
+\medskip \noindent \irafname{NRAO} --- National Radio Astronomy Observatory.
+
+\medskip \noindent \irafname{operand} --- A data object that is
+operated upon by an operator, \irafname{procedure}, or \irafname{task}.
+Operands may be used for either input or output, or both.
+
+\medskip \noindent \irafname{OIF} --- The old IRAF image format.  Refers to the
+physical format in which images are stored on disk, as well as to the
+\irafname{IKI} kernel used to access images stored externally in the OIF format.
+
+\medskip \noindent \irafname{OS} --- Operating System.
+
+\medskip \noindent \irafname{package} --- (1) A collection of modules that 
+are logically related (e.g., the set of \irafname{system} utilities).
+(2) A set of modules that operates on
+a specific \emphasize{abstract datatype}. The modules in a package may be
+either \irafname{procedures} or \irafname{tasks}.
+Examples of abstract datatypes include the CL, the file,
+the \irafname{imagefile}, and so on.
+
+\medskip \noindent \irafname{parameter} --- An externally supplied 
+argument to a module which directly controls the functioning of the module.
+
+\medskip \noindent \irafname{pathname} --- An absolute OS-dependent filename
+specification.
+
+\medskip \noindent \irafname{pipe} --- An abstraction that connects the output
+of one \irafname{task} to the input of another. The implementation of pipes
+is OS-dependent.
+
+\medskip \noindent \irafname{pixel} --- Picture element. The fundamental unit
+of storage in an \irafname{image}.
+
+\medskip \noindent \irafname{pixel storage file} --- a file that contains image
+pixel data. Typically, it is a bulky file and for this reason it is usually
+placed in a file system designated for such files.
+
+\medskip \noindent \irafname{portable} --- A program is said to be portable
+from computer A to computer B if it can be moved from A to B without change
+to the source code.
+A program is said to be \emphasize{transportable} from computer A to computer B
+if the effort required to move the program from A to B is much less than the
+effort required to write an equivalent program on machine B from scratch.
+
+\medskip \noindent \irafname{positional parameters} --- Parameters
+that are required for the execution of a given \irafname{function},
+and will be queried for by the CL if not given on the command line. Positional
+\emphasize{arguments} are the first arguments on the command line (following
+the command), and they are associated with parameters by their position
+on the command line. The first positional parameter will be set by the first
+positional argument on the command line, the second positional parameter by
+the second positional argument, and so on.
+
+\medskip \noindent \irafname{preprocessor} --- A program which transforms the
+text of a source file prior to compilation.  A preprocessor, unlike a compiler,
+does not fully define a language.  A preprocessor transforms only those
+constructs which it understands; all other text is passed on to the compiler
+without change.  The SPP language is implemented as a pre-processor.
+
+\medskip \noindent \irafname{procedure} --- A separately compiled program unit.
+The procedure is the primary construct provided by programming languages for
+the \emphasize{abstraction of function}.
+The external characteristics of a procedure are its name, argument list,
+and optional return value.
+
+\medskip \noindent \irafname{process} --- An executable partition of 
+memory in the host computer.
+The host OS initiates a process by copying or mapping an executable file
+into main memory. In a multitasking and multiuser system, a number of processes
+will generally be resident simultaneously in main memory,
+and the processor will execute each in turn.
+
+\medskip \noindent \irafname{program} --- A compiled procedure called by the
+CL. The procedure must be referenced in a \irafname{task} statement before it
+can be accessed by the CL.  An arbitrary number of programs may be 
+linked to form a single \irafname{process}.
+
+\medskip \noindent \irafname{program interface} --- The interface between an
+applications program and everything else.  In IRAF, the program interface
+defines access to all I/O devices, system services, files, and several
+other non-computational facilities that pro\-grams require.
+
+\medskip \noindent \irafname{record} --- A \irafname{data structure} consisting
+of an arbitrary set of fields, used to pass information between program modules
+or to permanently record the results of an analysis program in a
+\irafname{data file}.
+
+\medskip \noindent \irafname{redirection} --- The allocation of an input or
+output stream to something other than the standard device.  For example,
+\irafname{tasks} can be made to write output to files instead of terminals
+and the output of one task may be redirected to the input of another.
+
+\medskip \noindent \irafname{script task} --- An interpreted program written
+in the CL. A script task, like a compiled program, may have formal parameters
+and local variables. A script task may call another task, including another
+script task, but may not call itself.
+To the caller, script tasks and compiled programs are equivalent.
+
+\medskip \noindent \irafname{SDAS} --- Science Data Analysis System. A set
+of applications routines that are under development at STScI.
+
+\medskip \noindent \irafname{SPP} --- The IRAF Subset Preprocessor Language.
+A general purpose language patterned after Ratfor and C, the SPP provides
+advanced capabilities, modern control constructs, enhanced portability,
+and support for the IRAF runtime library (CL interface, etc.).
+
+\medskip \noindent \irafname{STF} --- The STScI SDAS group data image format.
+Refers to the physical format in which images are stored on disk, as well as
+to the \irafname{IKI} kernel used to access images stored externally in the
+STF format.
+
+\medskip \noindent \irafname{STScI} --- Space Telescope Science Institute.
+
+\medskip \noindent \irafname{system interface} --- The interface between 
+the portable IRAF software and the host operating
+system.  The system interface is a \irafname{virtual operating system}.
+The system interface routines, described in \reference{A Reference Manual
+for the IRAF System Interface}
+are in principle the only parts of a system that need to be changed
+when porting the system to a new computer.
+
+\medskip \noindent \irafname{task} --- A CL callable program unit.  
+CL tasks may be script tasks, external programs,
+or compiled procedures which are built in to the CL.
+
+\medskip \noindent \irafname{task statement} --- (1) The CL statement that
+enters the name of a task in the IRAF task dictionary,
+defines the type of task, and in the case of a compiled task, the name of
+the process in which it resides.
+(2) The statement in the SPP language that defines a list of programs
+to be linked together to form a single process.
+
+\medskip \noindent \irafname{template} --- A string consisting of one or more
+names, which may or may not contain patterns
+(with \irafname{metacharacters}).
+
+\medskip \noindent \irafname{text file} --- A file which contains only 
+text (ASCII character data), and which is maintained
+in the form expected by the text processing tools of the host OS.
+
+\medskip \noindent \irafname{Troff} --- The UNIX text formatter.
+
+\medskip \noindent \irafname{unary operator} --- An operator which operates on
+a single operand, e.g., the minus sign in the expression ``$-x$''.
+
+\medskip \noindent \irafname{UNIX} --- An operating system developed at Bell
+Labs in the early 1970s by Ken Thompson and Dennis Ritchie. Originally
+developed for the PDP11, UNIX is now available on a wide range of machines,
+ranging from micros to superminis, mainframes, and supercomputers.\\  
+UNIX is the software development system for the IRAF project at NOAO.
+
+\medskip \noindent \irafname{virtual file} --- A file that uses a machine
+independent filename within IRAF. The virtual filename is mapped to its
+host OS counterpart by the CL.
+
+\medskip \noindent \irafname{virtual memory} --- A form of addressing that
+enables a process to address locations that are not in physical memory.
+The amount of physical memory available to a process is known as the
+\emphasize{working set} of a process; the virtual address space is organized
+into a series of fixed size \emphasize{pages}. Pages which are not
+\emphasize{memory resident}, i.e., not in the working set, reside on some form
+of backing store, usually a disk file.  When a page is referenced which is not
+in the working set, a \emphasize{page fault} occurs, causing the page to be
+read into the working set.
+
+\medskip \noindent \irafname{virtual operating system} --- A set of system
+calls that define primitive functions comparable
+to those provided by an actual operating system.
+IRAF provides routines (the so-called
+\irafname{program interface}) for file access, process initiation and control,
+exception handling, logical names, etc.
+
+\medskip \noindent \irafname{VMS} --- The native operating system for the
+Digital VAX series of supermini computers.
+
+\medskip \noindent \irafname{VOS} --- The IRAF Virtual Operating System.
+The VOS implements all of the basic functionality provided by IRAF, and defines
+the environment in which applications programs are written.  For example,
+the VOS provides facilities for file access, image access, access to graphics
+and image display devices, access to the command language to fetch parameters
+etc., process control and exception handling facilities, and so on.  The VOS
+is written in portable SPP using the facilities provided by the IRAF
+\irafname{kernel}.
+
+\medskip \noindent \irafname{Z-routines} --- Machine dependent routines used
+to interface to the host operating system.  The IRAF Z-routines are maintained
+in the package \taskname{OS}.
+
+\onecolumn
+
+\end{document}
-- 
cgit 

