\documentclass{article}
\usepackage{axiom}
\begin{document}
\title{JMAN}
\author{Timothy Daly}
\maketitle
\begin{abstract}
We need a method of doing GUI operations portably in Axiom.
There are various attempts at making a GUI available but few are
really cross-platform. 

Initially we attempted to use TK from lisp. This turned out to be
a huge learning curve since we needed to reproduce pre-defined screens
which already exist in Axiom. Screen configuration was very hard and
there did not appear to be a way to display graphics using the lisp
took (ltk). 

Instead, we've decided to take the long path. We use Java as our
front end and create an API which allows us to produce the required
screens. The downside is that we have to write the Java front end.
The upside is that we have complete control of the primitives.
\end{abstract}
\eject
\tableofcontents
\eject
\section{Overview}
There is a major portability issue in Axiom. The Hyperdoc and
Graphics functions are written in C and use X11 windows.
We need to be able to replace the Graphics and Hyperdoc functions 
with a more portable implementation.

Initially this was going to be a [[cygwin]] mechanism because it
implements an X11 on Windows. This fails because we eventually 
decided to use the [[Msys]] windows environment.

Next it was decided that we would use McClim, the common lisp
graphics. This fails because McClim does not yet work properly.

Next we tried to use [[ltk]] the lisp TK toolkit interface.
This fails because there does not appear to be a way to get TK
to display images.

Finally we settled on rewriting TK into Java which would make it
portable and make the code freely available since we wrote it ourselves.
Thus this is an implementation of the TK replacement code. It is intended
to run in a stand-alone lisp and communicate to the Axiom lisp image
using sockets.

In order to build this from the ground up we need to implement a display
(see the display class) and a console which would accept lisp s-expressions
and return the results. That way we can implement a stand-alone version
of the system. The console is intended to communicate to the display
over sockets. Axiom will work just like the console class and use the
same socket interface.

So for development purposes we need to be able to type a set of
s-expressions and evaluate them. This is done in several steps.

Step 0 is to implement a fixed file that contains a set of display
s-expressions and execute the fixed file.

Step 1 is to implement an all-java solution using a console to
talk to a socket connected to the display class.

Step 2 is to implement a lisp-java interface so commands can be 
typed from the console.

Step 3 is to allow Axiom to start the lisp and let the lisp drive
the display class.

We may also want to explore allowing Axiom to drive the display
class directly.
\subsection{The fixed file development step}
The idea here is to read a line from a file, evaluate the line,
and return the result. In this case we will read a line that says
<<testcase1>>=
"(W1 window make 200 200 400 400)"
"(W1 window layout borderlayout)"
"(I1 image make blueaxiom.jpg)"
"(L2 label make)"
"(L2 label image I1)"
"(P3 panel make)"
"(P3 panel layout borderlayout)"
"(P3 panel add L2 Center)"
"(W1 window add P3 Center)"
"(W1 window show)"
@
<<testcase>>=
"(W1 window make 200 200 400 400)"
"(W1 window layout borderlayout)"
"(B1 button make one)"
"(B2 button make two)"
"(L1 label make)"
"(L1 label text HYPERDOC)"
"(B3 button make three)"
"(B4 button make four)"
"(P1 panel make)"
"(P1 panel layout borderlayout)"
"(P1 panel add B1 West)"
"(P2 panel make)"
"(P2 panel layout borderlayout)"
"(P2 panel add B2 West)"
"(P2 panel add L1 Center)"
"(P2 panel add B3 East)"
"(P1 panel add P2 Center)"
"(P1 panel add B4 East)"
"(W1 window add P1 North)"
"(I1 image make blueaxiom.jpg)"
"(L2 label make)"
"(L2 label image I1)"
"(P3 panel make)"
"(P3 panel layout borderlayout)"
"(P3 panel add L2 Center)"
"(W1 window add P3 Center)"
"(W1 window show)"
@
using a java buffered stream. Next we build a [[Display]] object
and call the eval method, passing the line we read. The [[Display]]
object parses and executes the line. This causes it to build a
window, add it to the hash tble under a new key, and show it.
The key is returned as the ``name'' of the window.
\subsubsection{method readTestCase}
<<method readTestCase>>=
  public void readTestCase(String file)
  { try
    { in = new BufferedReader(new FileReader("testcase"));
      print(eval(readTestFile(in.readLine())));
      print(eval(readTestFile(in.readLine())));
      print(eval(readTestFile(in.readLine())));
    }
    catch(Exception e)
    { e.printStackTrace();
      System.exit(0);
    }
  }

@
\subsubsection{method readTestFile}
<<method readTestFile>>=
  public String readTestFile(String file)
  { return(file);
  }

@
\subsubsection{method eval}
<<method evalline>>=
  public String eval(String line)
  { String result = display.eval(line);
    return(result);
  }

@
\subsubsection{method print}
<<method print>>=
  public void print(String line)
  { System.err.println(line);
  }

@
\subsubsection{step 0 code}
<<step 0 code>>=
class testStep0
{ 
 BufferedReader in = null;
 Display display = new Display();

<<method readTestCase>>
<<method readTestFile>>
<<method evalline>>
<<method print>>
}

@
\section{jman.lisp}
\subsection{jman.lisp}
\subsubsection{function do-execute}
The do-execute function is a lisp-portable function to start a
separate program. We use this function to start the Java program
which is our front end.
<<function do-execute>>=
(defun do-execute (program args &optional (wt nil))
  "execute program with args a list containing the arguments passed to the 
   program if wt is non-nil, the function will wait for the execution of 
   the program to return. returns a two way stream connected to stdin/stdout 
   of the program"
 (format t "do-execute ~a ~a ~a~%" program args wt)
 (let ((fullstring program))
  (dolist (a args)
   (setf fullstring (concatenate 'string fullstring " " a)))
#+(or :ibcl :kcl :akcl :gcl :ccl)
    (let
     ((proc 
       (si::system 
         (apply #'si::string-concatenate program " " args)))))
#+:cmu 
    (let 
      ((proc 
        (run-program program args :input :stream :output :stream :wait wt)))
      (unless proc (error "Cannot create process."))
      (make-two-way-stream
       (ext:process-output proc)
       (ext:process-input proc)))
#+:clisp 
    (let 
      ((proc 
         (ext:run-program program :arguments args 
                         :input :stream :output :stream :wait t)))
       (unless proc (error "Cannot create process."))
       proc)
#+:sbcl 
    (let 
      ((proc 
        (sb-ext:run-program program args :input :stream 
                            :output :stream :wait wt)))
        (unless proc (error "Cannot create process."))
        (make-two-way-stream 
         (process-output proc)              
         (process-input proc)))
#+:lispworks 
    (system:open-pipe fullstring :direction :io)
#+:allegro 
    (let 
      ((proc (excl:run-shell-command
                         (apply #'vector program program args)
                         :input :stream :output :stream :wait wt)))
      (unless proc (error "Cannot create process."))
      proc)
#+:ecl
    (ext:run-program program args :input :stream :output :stream
                                  :error :output)
#+:openmcl 
    (let 
     ((proc (ccl:run-program program args :input
                             :stream :output :stream :wait wt)))
     (unless proc (error "Cannot create process."))
     (make-two-way-stream
      (ccl:external-process-output-stream proc)
      (ccl:external-process-input-stream proc)))))

@
\subsubsection{open-socket}
<<function open-socket>>=
(deftype socket ()
  #+abcl 'to-way-stream
  #+allegro 'excl::socket-stream
  #+clisp 'stream
  #+(or cmu scl) 'sys:fd-stream
  #+gcl 'stream
  #+lispworks 'comm:socket-stream
  #+openmcl 'ccl::socket
  #+(and sbcl db-sockets) 'sb-sys:fd-stream
  #+(and sbcl net.sbcl.sockets) 'net.sbcl.sockets:stream-socket
  #-(or abcl allegro clisp cmu gcl lispworks openmcl
	(and sbcl (or db-sockets net.sbcl.sockets)) scl) 'stream)

(defun open-socket (host port &optional bin)
  "Open a socket connection to HOST at PORT."
  (declare (type (or integer string) host) (fixnum port) (type boolean bin))
  (let ((host (etypecase host
                (string host)
                (integer (hostent-name (resolve-host-ipaddr host))))))
    #+abcl (ext:get-socket-stream
            (sys:make-socket host port)
            :element-type (if bin '(unsigned-byte 8) 'character))
    #+allegro (socket:make-socket :remote-host host :remote-port port
                                  :format (if bin :binary :text))
    #+clisp (#+lisp=cl ext:socket-connect #-lisp=cl lisp:socket-connect
                       port host :element-type
                       (if bin '(unsigned-byte 8) 'character))
    #+(or cmu scl)
    (sys:make-fd-stream (ext:connect-to-inet-socket host port)
                        :buffering (if bin :full :line)
                        :input t :output t :element-type
                        (if bin '(unsigned-byte 8) 'character))
    #+gcl (si:socket port :host host)
    #+lispworks (comm:open-tcp-stream host port :direction :io :element-type
                                      (if bin 'unsigned-byte 'base-char))
    #+mcl (ccl:make-socket :remote-host host :remote-port port
                           :format (if binary-p :binary :text))
    #+(and sbcl db-sockets)
    (let ((socket (make-instance 'sockets:inet-socket
                                 :type :stream :protocol :tcp)))
      (sockets:socket-connect socket
                              (sockets::host-ent-address
                               (sockets:get-host-by-name host))
                              port)
      (sockets:socket-make-stream
       socket :input t :output t :buffering (if bin :none :line)
       :element-type (if bin '(unsigned-byte 8) 'character)))
    #+(and sbcl net.sbcl.sockets)
    (net.sbcl.sockets:make-socket
     (if bin
         'net.sbcl.sockets:binary-stream-socket
         'net.sbcl.sockets:character-stream-socket)
     :port port :host host)
    #-(or abcl allegro clisp cmu gcl lispworks mcl
          (and sbcl (or net.sbcl.sockets db-sockets)) scl)
    (error 'not-implemented :proc (list 'open-socket host port bin))))

@
This is the top level jman process. It runs in a lisp listener.
The lisp used is specified by the [[${LISP}]] variable in the
Makefile.
\subsubsection{jman.lisp}
<<jman.lisp>>=
<<function do-execute>>
<<function open-socket>>

(defun testcase ()
 (mapcar #'send '(
<<testcase>>
  )))

(defun send (sexpr)
 (format *socket* "~a~%" sexpr))

(defun telnet (host port fn)
 (format t "~a~%" (setq *socket* (open-socket "127.0.0.1" 14000)))
 (apply fn nil))

(defun main ()
 (format t "~%hello, world~%")
 (setq jmanconsole (do-execute "java" '("Jman" "accept" "14000")))
 (do ((result nil)) (result) 
   (princ ".") 
   (setq result (read jmanconsole nil)))
 (format t "running testcase~%")
 (telnet "127.0.0.1" 14000 #'testcase)
 (format t "goodbye, world~%")
 (bye))

(main)
@
%java code
\section{Jman.java}
\subsection{java imports}
<<java imports>>=
import com.sun.image.codec.jpeg.*;
import java.awt.*;
import java.awt.event.*;
import java.awt.image.*;
import java.awt.geom.*;
import java.io.*;
import java.net.*;
import java.util.*;
import javax.swing.*;
import javax.swing.border.*;
import javax.swing.event.*;
import javax.swing.text.*;
import javax.swing.text.html.*;


@
\subsection{class Parm}
\subsubsection{Properties props}
The [[props]] is a hashtable containing known initialization constants.
It holds the results from reading the Jman.ini file.
<<Properties props>>=
  public static Properties props;
 
@
\subsubsection{boolean loaded}
The [[loaded]] boolean is true if we found and loaded the initialization file.
<<boolean loaded>>=
  private static boolean loaded = false;
@
\subsubsection{method loadParms}
Load the file Jman.ini and parse all of the initialization forms in it.
These are stored in a hash table and can be retrieved by the various
[[get]] methods, e.g. [[getFont]] for Fonts.
<<method loadParms>>=
  public static void loadParms()
  { props = new Properties();
    initDefaults();
    try
    { props.load(new FileInputStream("Jman.ini"));
      loaded = true;
    }
    catch(IOException e)
    { System.err.println("Parm:file Jman.ini not found. Using defaults.");
    }
  }
 
@
\subsubsection{method debugging}
debugging is a simple predicate used for adding debugging tests.
It can be turned on and off using the flag in Jman.ini
<<method debugging>>=
  public static boolean debugging()
  { if (getParm("Debug").equals("on"))
      return(true);
    return(false);
  }
 
@
\subsubsection{method tracing}
tracing is a simple predicate used for adding trace messages
It can be turned on and off using the flag in Jman.ini
<<method tracing>>=
  public static boolean tracing()
  { if (getParm("CatchTrace").equals("on"))
      return(true);
    return(false);
  }
 
@ 
The [[getColor]] method calls [[getParm]] to look up the value and 
uses [[parseColor]] to parse out a color.
<<method getColor>>=
  public static Color getColor(String key)
  { return(parseColor(getParm(key)));
  }
 
@
\subsubsection{method parseColor}
The [[parseColor]] method takes a 6 hex digit string and returns
a java Color object.
The string argument  should be of the form ``[Color rrggbb]'' where
red=rr green=gg blue=bb in hex
e.g. [Color 123456] == java.awt.Color[r=18,g=52,b=86]
Converts the return value to an java Color object.
<<method parseColor>>=
  public static Color parseColor(String value)
  { int[] nums = new int[6];
    char hexchar;
    for(int i = 0; i<6; i++)
    { hexchar = value.charAt(7+i);
      switch (hexchar)
      { case 'a':
        case 'A':
          nums[i]=10;
          break;
        case 'b':
        case 'B':
          nums[i]=11;
          break;
        case 'c':
        case 'C':
          nums[i]=12;
          break;
        case 'd':
        case 'D':
          nums[i]=13;
          break;
        case 'e':
        case 'E':
          nums[i]=14;
          break;
        case 'f':
        case 'F':
          nums[i]=15;
          break;
        default:
          nums[i]=Integer.parseInt(hexchar+"");
          break;
       }
    }
    int red   = nums[0]*16+nums[1];
    int green = nums[2]*16+nums[3];
    int blue  = nums[4]*16+nums[5];
    return(new Color(red,green,blue));
  }

@  
\subsubsection{method getBorder}
The [[getBorder]] calls getParm to look up the value and parses out a border.
The value should be of the form ``[Border type a b c d]'' where
a b c d are the border insets and
type is one of \{ EMPTY MATTE ETCHED \}
Converts the return value to an border as a java Border object.
<<method getBorder>>=
  public static Border getBorder(String key)
  { String value = getParm(key);
    Border result = new EmptyBorder(1,1,1,1);
    final int EMPTY = 0;
    final int MATTE = 1;
    final int ETCHED = 2;
    int borderType = EMPTY;
    int point = 0;
    int mark = 0;
    int a = 1;
    int b = 1;
    int c = 1;
    int d = 1;
    if ((mark = value.indexOf("EMPTY")) != -1)
      borderType = EMPTY;
    if ((mark = value.indexOf("MATTE")) != -1)
      borderType = MATTE;
    if ((mark = value.indexOf("ETCHED")) != -1)
      borderType = ETCHED;
    if (mark != -1)
    { switch (borderType)
      { case EMPTY:
          point = value.indexOf(' ',mark)+1;
          mark = value.indexOf(' ',point);
          a = Integer.parseInt(value.substring(point,mark));
          point=mark+1;
          mark=value.indexOf(' ',point);
          b = Integer.parseInt(value.substring(point,mark));
          point=mark+1;
          mark=value.indexOf(' ',point);
          c = Integer.parseInt(value.substring(point,mark));
          point=mark+1;
          mark=value.indexOf(']',point);
          d = Integer.parseInt(value.substring(point,mark));
          result = new EmptyBorder(a,b,c,d);
          break;
        case MATTE:
          point = value.indexOf(' ',mark)+1;
          mark = value.indexOf(' ',point);
          a = Integer.parseInt(value.substring(point,mark));
          point=mark+1;
          mark=value.indexOf(' ',point);
          b = Integer.parseInt(value.substring(point,mark));
          point=mark+1;
          mark=value.indexOf(' ',point);
          c = Integer.parseInt(value.substring(point,mark));
          point=mark+1;
          mark=value.indexOf(' ',point);
          d = Integer.parseInt(value.substring(point,mark));
          point=mark+1;
          mark=value.indexOf('[',point);
          if (mark == -1)
          { Catch.log("Parm:parseBorder","bad Color in Border: "+value,
              new Exception("Jman.ini:bad Color in Border: "+value));
            System.err.println(
              "Parm:parseBorder: bad Color in Border: "+value);
          }
          else
            result=new MatteBorder(a,b,c,d,parseColor(value.substring(mark)));
          break;
        case ETCHED:
          point = value.indexOf('[',mark);
          mark = value.indexOf(']',point);
          Color highlight = parseColor(value.substring(point,mark));
          point = value.indexOf('[',mark);
          mark = value.indexOf(']',point);
          Color shadow = parseColor(value.substring(point,mark));
          result = new EtchedBorder(highlight,shadow);
          break;
      }
    }
    return(result);
  }

@
The [[getFont]] calls [[getParm]] to look up the value and parses out a font.
The value should be of the form [Color name type size] where
name=font name, type= font type, size= font pointsize
e.g. [Font Dialog Font.PLAIN 12] == 
java.awt.Font[family=dialog,name=Dialog,style=plain,size=12]
Converts the return value to a java Font object.
<<method getFont>>=
  public static Font getFont(String key)
  { String value = getParm(key);
    int point = 6;
    int mark = value.indexOf(' ',point);
    String name = value.substring(point,mark);
    point = mark+1;
    mark = value.indexOf(' ',point);
    String type = value.substring(point,mark);
    int fonttype = Font.PLAIN;
    if (type.toUpperCase().equals("BOLD"))
      fonttype = Font.BOLD;
    if (type.toUpperCase().equals("ITALIC"))
      fonttype = Font.ITALIC;
    point = mark+1;
    mark = value.indexOf(']',point);
    int size = Integer.parseInt(value.substring(point,mark));
    return(new Font(name,fonttype,size));
  }
 
@
\subsubsection{method getParmQuiet}
The [[getArrayParm]] looks up the key in a hashtable and 
returns the value found.
It will not complain if the key is missing.
If the key is not found a hardcoded default value is returned.
<<method getParmQuiet>>=
  public static String getParmQuiet(String key)
  { if (loaded == false)
      loadParms();
    return((String)props.get(key));
  }
 
@ 
\subsubsection{method getParm}
The [[getParm]] looks up the key in a hashtable and returns the value found.
If the key is not found a hardcoded default value is returned.
Be aware that calling getParm directly will return the exact initialization
string. However some of the initialization strings in [[Jman.ini]] have our
own extended syntax to handle colors, borders, etc. If you want to get the
correct java object you should call the appropriate get method.
<<method getParm>>=
  public static String getParm(String key)
  { if (loaded == false)
      loadParms();
    String value = (String)props.get(key);
    if ((!(key.equals("Debug"))) && ((String)props.get("Debug")).equals("on"))
      System.err.println("Parm:getParm "+key+"="+value);
    if (value == null)
    { Catch.log("Parm:getParm","key="+key+" has no value in Jman.ini",
            new Exception("Jman.ini is missing the key "+key));
      System.err.println("Parm:getParm:key="+key+
                         " has no value in Jman.ini");
    }
    return(value);
  }
 
@ 
\subsubsection{method setParm}
The [[setParm]] can be used to change existing or add new parms.
Be aware that calling getParm directly will return the exact initialization
string. However some of the initialization strings in [[Jman.ini]] have our
own extended syntax to handle colors, borders, etc. There are no setter
methods to handle the extended syntax. This is just a public interface
to the [[parm]] hashtable.
<<method setParm>>=
  public static void setParm(String key, String value)
  { if (loaded == false)
      loadParms();
    props.put(key,value);
  }
 
@
\subsubsection{method getParmInteger}
The [[getParmInteger]] calls getParm to look up the value and 
parses out an int.
If the key is not found a hardcoded default value is returned
Converts the return value to an integer.
<<method getParmInteger>>=
  public static int getParmInteger(String key)
  { return(Integer.parseInt(getParm(key)));
  }
  
@
\subsubsection{method initDefaults}
The [[initDefault]] hardcodes default values for initialization constants.
If the key is not found in Jman.ini we provide a default value here.
<<method initDefaults>>=
  private static void initDefaults()
  { props.put("version","Jman.ini not found");
    props.put("SplashImage","blueaxiom.jpg");
    props.put("SplashWait","2000");
    props.put("Debug","on");
    props.put("CatchLog","on");
  }
 
@
\subsubsection{method main Parm}
This is unit test code for the Parm class.
Note that this is not included in the generated code.
<<method main Parm>>=
  public static void main(String[] args)
  { loadParms();
    setParm("testColor","[Color 123456]");
    System.err.println(getColor("testColor"));
    setParm("testColor","[Color FFFFFF]");
    System.err.println(getColor("testColor"));
    setParm("testBorder","[Border MATTE 5 5 5 5]");
    System.err.println(getBorder("testBorder"));
    System.err.println("MainPanel.defaultFont");
    System.err.println(getFont("MainPanel.defaultFont"));
    for(Enumeration e = props.keys(); e.hasMoreElements();)
    { String next = (String)e.nextElement();
      System.err.println((String)next+"="+props.get(next));
    }
    setParm("Debug","off");
    System.err.println("Debug="+props.get("Debug"));
    setParm("Debug","on");
    System.err.println("Debug="+props.get("Debug"));
  }
@
\subsubsection{class Parm}
The [[Parm]] class manages initialization constants.

This class is the interface to the file "Jman.ini".
The file contains various constants used by the application.
This class loads the Jman.ini constants into a Properties hashtable.
If a required constant is not specified then a hardcoded default value
is used instead. Hardcoded defaults exist here rather than in the
corresponding classes to centralize the management of constants.
<<class Parm>>=
class Parm
{
<<Properties props>>
<<boolean loaded>>
<<method loadParms>>
<<method debugging>>
<<method tracing>>
<<method getColor>>
<<method parseColor>>
<<method getBorder>> 
<<method getFont>>
<<method getParmQuiet>>
<<method getParm>>
<<method setParm>>
<<method getParmInteger>>
<<method initDefaults>>
}

@
\subsection{class Catch}
\subsubsection{method log}
<<method log>>=
  /** if CatchLog=on   in Jman.ini then write log
   *  if CatchTrace=on in Jman.ini then trace to stdout
   *  @param classAndMethod is a string containing both names
   *  @param data is a String of informational values
   *  @param e is the exception that was thrown
   */
  public static void log(String classAndMethod, String data, ActionEvent e)
  { if (Parm.getParm("CatchLog").equals("on"))
    try
    { if (logFile == null)
        logFile = new PrintWriter(
                    new FileOutputStream(Parm.getParm("CatchFile")));
      if (e != null)
      { logFile.println(
          "Catch:"+classAndMethod+" "+data+" "+e.getActionCommand());
      }
      else
        logFile.println("Catch:"+classAndMethod+" "+data);
      logFile.flush();
    }
    catch(Exception ioe)
    { ioe.printStackTrace(System.err);
    }
    if (Parm.getParm("CatchTrace").equals("on"))
    { if (e != null)
      { System.err.println("Catch:"+classAndMethod+" "+data+
                           " "+e.getActionCommand());
      }
      else
        System.err.println("Catch:"+classAndMethod+" "+data);
    }
  }

  /** if CatchLog=on   in Jman.ini then write log
   *  if CatchTrace=on in Jman.ini then trace to stdout
   *  @param classAndMethod is a string containing both names
   *  @param data is a String of informational values
   *  @param e is the exception that was thrown
   */
  public static void log(String classAndMethod, String data, Exception e)
  { if (Parm.getParm("CatchLog").equals("on"))
    try
    { if (logFile == null)
        logFile = new PrintWriter(
                    new FileOutputStream(Parm.getParm("CatchFile")));
      if (e != null)
      { logFile.println("Catch:"+classAndMethod+" "+data+" "+e.getMessage());
        e.printStackTrace(logFile);
      }
      else
        logFile.println("Catch:"+classAndMethod+" "+data);
      logFile.flush();
    }
    catch(Exception ioe)
    { ioe.printStackTrace(System.err);
    }
    if (Parm.getParm("CatchTrace").equals("on"))
    { if (e != null)
      { System.err.println("Catch:"+classAndMethod+" "+data+
                           " "+e.getMessage());
      }
      else
        System.err.println("Catch:"+classAndMethod+" "+data);
    }
  }

  /** if CatchLog=on   in Jman.ini then write log
   *  if CatchTrace=on in Jman.ini then trace to stdout
   *  @param classAndMethod is a string containing both names
   *  @param data is a String of informational values
   *  @param data2 is a String of informational values
   *  @param e is the exception that was thrown
   */
  public static void log(String classAndMethod, String data, String data2)
  { if (Parm.getParm("CatchLog").equals("on"))
    try
    { if (logFile == null)
        logFile = new PrintWriter(
                    new FileOutputStream(Parm.getParm("CatchFile")));
      logFile.println("Catch:"+classAndMethod+" "+data+" "+data2);
      logFile.flush();
    }
    catch(Exception ioe)
    { ioe.printStackTrace(System.err);
    }
    if (Parm.getParm("CatchTrace").equals("on"))
      System.err.println("Catch:"+classAndMethod+" "+data+" "+data2);
  }

  /** if CatchLog=on   in Jman.ini then write log
   *  if CatchTrace=on in Jman.ini then trace to stdout
   *  @param classAndMethod is a string containing both names
   *  @param data is a String of informational values
   *  @param data2 is a String of informational values
   *  @param e is the exception that was thrown
   */
  public static void log(String classAndMethod, int data2, String data)
  { if (Parm.getParm("CatchLog").equals("on"))
    try
    { if (logFile == null)
        logFile = new PrintWriter(
                    new FileOutputStream(Parm.getParm("CatchFile")));
      logFile.println("Catch:"+classAndMethod+" "+data);
      logFile.flush();
    }
    catch(Exception ioe)
    { ioe.printStackTrace(System.err);
    }
    if (Parm.getParm("CatchTrace").equals("on"))
      System.err.println("Catch:"+classAndMethod+" "+data);
  }

  /** if CatchLog=on   in Jman.ini then write log
   *  if CatchTrace=on in Jman.ini then trace to stdout
   *  @param classAndMethod is a string containing both names
   *  @param data is a String of informational values
   *  @param e is the exception that was thrown
   */
  public static void log(String classAndMethod, String data)
  { if (Parm.getParm("CatchLog").equals("on"))
    try
    { if (logFile == null)
        logFile = new PrintWriter(
                    new FileOutputStream(Parm.getParm("CatchFile")));
      logFile.println("Catch:"+classAndMethod+" "+data);
      logFile.flush();
    }
    catch(Exception ioe)
    { ioe.printStackTrace(System.err);
    }
    if (Parm.getParm("CatchTrace").equals("on"))
      System.err.println("Catch:"+classAndMethod+" "+data);
  }


  /** if CatchLog=on   in Jman.ini then write log
   *  if CatchTrace=on in Jman.ini then trace to stdout
   *  @param classAndMethod is a string containing both names
   *  @param data is an array of String of tokens
   *  @param e is the exception that was thrown
   */
  public static void log(String classAndMethod, String[] data)
  { if (Parm.getParm("CatchLog").equals("on"))
    try
    { if (logFile == null)
        logFile = new PrintWriter(
                    new FileOutputStream(Parm.getParm("CatchFile")));
      for(int i=0; i<data.length; i++)
        logFile.print(data[i]+" ");
      logFile.println();
      logFile.flush();
    }
    catch(Exception ioe)
    { ioe.printStackTrace(System.err);
    }
    if (Parm.getParm("CatchTrace").equals("on"))
    { System.err.print("Catch:"+classAndMethod+" ");
      for(int i=0; i<data.length; i++)
        System.err.print(data[i]+" ");
      System.err.println();
      System.err.flush();
    }
  }

@
\subsubsection{method error}
<<method error>>=
  /** if CatchLog=on   in Jman.ini then write log
   *  if CatchTrace=on in Jman.ini then trace to stdout
   *  @param classAndMethod is a string containing both names
   *  @param data is a String of informational values
   *  @param e is the exception that was thrown
   */
  public static void error(String classAndMethod, String data)
  { if (Parm.getParm("ErrorLog").equals("on"))
    try
    { if (logFile == null)
        logFile = new PrintWriter(
                    new FileOutputStream(Parm.getParm("ErrorFile")));
      logFile.println("ERROR:"+classAndMethod+" "+data);
      logFile.flush();
    }
    catch(Exception ioe)
    { ioe.printStackTrace(System.err);
    }
    if (Parm.getParm("ErrorTrace").equals("on"))
      System.err.println("ERROR:"+classAndMethod+" "+data);
  }

@
\subsubsection{method main Catch}
Catch unit test code.
Note that this is not included in the generated sources.
<<method main Catch>>=
  public static void main(String[] args)
  { Catch.log("Catch:main",null,new Exception("main unit test1"));
    Catch.log("Catch:main","unit test 2",new Exception("main unit test2"));
  }

@
\subsubsection{class Catch}
<<class Catch>>=
class Catch
{
  private static PrintWriter logFile;

<<method log>>
<<method error>>
}

@
\subsection{class Splash}
\subsubsection{method splash}
The splash method takes the name of an [[image]] to display (a String),
creates a window in the center of the display and leaves it there
until the [[dwell]] time (an int) runs out. The image is assumed to
be displayable by Java (likely a [[.jpg]] file). 

If the image is given as a null or a zero length string then the
image and the dwell time are gotten from the .ini file.
<<method splash>>=
  public void splash(String image, int dwell)
  { if (image.length() > 0)
    { Catch.log("Splash:splash","start",image);
      splashImage = new ImageIcon(image);
      splashTime = dwell;
    }
    else
    { Catch.log("Splash:splash","start",Parm.getParm("SplashImage"));
      splashImage = new ImageIcon(Parm.getParm("SplashImage"));
      splashTime = Parm.getParmInteger("SplashWait");
    }
    JLabel splashLabel = new JLabel(splashImage);
    splashWindow = new JWindow() {
      public void setVisible(boolean visible) 
      { if (visible)
        { Dimension dim = Toolkit.getDefaultToolkit().getScreenSize();
          setSize(splashImage.getIconWidth(), splashImage.getIconHeight());
          setLocation((dim.width - splashImage.getIconWidth())/2, 
                      (dim.height - splashImage.getIconHeight())/2);
        }
        super.setVisible(visible);
      }
    };
    splashWindow.getContentPane().add(splashLabel);
    splashWindow.validate();
    splashWindow.setVisible(true);
    splashTicker=new javax.swing.Timer(splashTime,this);
    splashTicker.setRepeats(false);
    splashTicker.addActionListener(this);
    splashTicker.start();
   }

@
The Splash class reads in a splash image (named in the [[Jman.ini]] file)
and displays it on the screen for a few moments. When the timer pops the
[[actionPerformed]] message is called and it sets the [[done]] boolean
to true. If you wish to know when the image is gone call [[running]]
which will return true if the image is still visible, false otherwise.

The image to display is given by the [[SplashImage]] entry in [[Jman.ini]].
The time to display the image is given by the [[SplashWait]] entry.
<<class Splash>>=
class Splash implements ActionListener
{
  ImageIcon splashImage;
  javax.swing.Timer splashTicker;
  String splashFile;
  JWindow splashWindow;
  Boolean done = false;
  int splashTime = 3000;
 
  public void actionPerformed(ActionEvent e)
  { splashWindow.setVisible(false);
    splashTicker.stop();
    splashWindow.dispose();
    done = true;
  }
   
<<method splash>>

  public Boolean running()
  { if (! done) 
      return true;
    else
      return false;
  }
 }

@
\subsection{class Jman}
\subsubsection{method listen}
<<method listen>>=
  public static void listen(String args[]) 
  { Ear      master;
    String     m,n,p,u,h;
    long       d=60000;
    m ="";
    n ="";
    p ="";
    u ="daly";
    h ="127.0.0.1";
    System.err.println("listen");
    for(int i = 0; i < args.length; i++) 
    { if (args[i].equals("-mail")) m =args[i+1];	
      if (args[i].equals("-nomail")) n =args[i+1];	
      if (args[i].equals("-pass")) p = args[i+1];
      if (args[i].equals("-user")) u = args[i+1];
      if (args[i].equals("-host")) h = args[i+1];
      if (args[i].equals("-delay")) d = new Long(args[i+1]).longValue();
      if (args[i].equals("-help"))
      {	System.err.println("\nEar -- Ear for Java");
	System.err.println("Mouse click -- see headers");
	System.err.println("Control-mouse click --"+
                           " change parameters/quit");
	System.err.println("	-mail filename ");
	System.err.println("	-nomail filename ");
	System.err.println("	-user username");
	System.err.println("	-pass password");
	System.err.println("	-host mailhost");
	System.err.println("    -delay milliseconds");
	System.err.println("	--help\n\n");
	System.exit(0);
      }
    }
    System.err.println("MailResource");
    MailResource res=new PopServer(d, u, p, h);
    System.err.println("ear");
    master = new Ear("Ear",m,n,res);
    System.err.println("dim");
    Dimension dim=Toolkit.getDefaultToolkit().getScreenSize();
    System.err.println("master");
    master.setLocation(dim.width-70, 65);
  }

@
\subsubsection{method main}
<<method main>>=
 public static void main(String args[])
 {// splash blueaxiom.jpg 
  if (args[0].startsWith("splash"))
  { Splash Splash = new Splash();
    if (args[1].length() > 0)
      Splash.splash(args[1],3000);
    else
      Splash.splash("blueaxiom.jpg",3000);
    while (Splash.running());
    System.err.println("splash done");
  }
  // listen
  if (args[0].startsWith("listen"))
  { System.err.println("marg");
    String marg[] = {"-user","daly","-pass","pass1wor","-host","pop.idsi.net"};
    System.err.println("calling listen");
    listen(marg);
  } 
  // testcase
  if (args[0].startsWith("testcase"))
  { testStep0 test = new testStep0();
    test.readTestCase("testfile");
  }
  // accept 14000
  if (args[0].startsWith("accept"))
  { try
    { ServerSocket serversock = new ServerSocket(Integer.parseInt(args[1]));
      System.out.println(args[1]);  
      Socket sock = serversock.accept();
      System.err.println("accepted");
      InputStream is = sock.getInputStream();
      BufferedReader in = new BufferedReader(new InputStreamReader(is));
      testStep0 ts = new testStep0();
      while(true)
      { String line = in.readLine();
        ts.print(ts.eval(ts.readTestFile(line))); 
      }
    }
    catch(Exception e)
    { }
  }
 }

@
\subsection{class Display}
[[Display]] is a general purpose java object that we can drive from a socket.
The basic idea is that this object implements a set of commands that can
be used to construct and manipulate objects, usually swing objects.

The [[Display]] object maintains a hash table that contains the objects
it knows about. The key is a user-supplied string. So the general
game is that the user supplies a list which consists of an object
name used as a hash table key and a method name which will be invoked
on the result of the hash table lookup. The rest of the list are the
arguments to the method.
\subsubsection{constructor Display}
The constructor does nothing except initialize the class variables.
Notice that there can be many [[Display]] objects and thus many windows.
<<constructor Display>>=
  public Display()
  { widgets = new Hashtable();
    widgettype = new Hashtable();
//    JButton jbutton = null;
//    JFrame jframe = null;
//    JPanel jpanel = null;
  }

@
\subsubsection{method tokenize}
The tokenize method will break the list into an array of strings.
The expected input is of the form:
\begin{verbatim}
"(hashname method arg1 arg2 ...)"
\end{verbatim}
which will result in
\begin{verbatim}
tokens[0] = "("
tokens[1] = "hashname"
tokens[2] = "method"
tokens[3] = "arg1"
tokens[4] = "arg2"
...
tokens[n] = ")"
\end{verbatim}
The first token is the hash table key of an object
in the [[widgets]] hashtable. 

What the hashkey means depends on a couple factors. 
If the object is new and the method normally creates an object
then the object is added to the hash table under the hashkey.
If the object is old and the method normally creates an object
then the object replaces the previous object in the hashtable.
If the object is new and the method expects an existing object
then the method returns [[failed]].
If the object is old and the method expects an existing object
then the object is used to perform the method.

The second token is the method name. It names a method on [[Display]]
which currently must be predefined but it should be possible to
dynamically create new methods.

The third token depends on the method. Sometimes it is the hashkey
of an existing object, such as when you want to add a button to an
existing object. Other times it is used to disambiguate the type
of the object fetched from the hashtable as Java isn't clever 
enough to figure this out.

Tokens that refer to objects where they are required by the method
call use the hashkey of the object.

Notice that the parentheses are preserved in the tokens in case
one of the arguments to a method is itself a list. The [[tokenize]]
function treats everything as strings. Numbers or special handling
have to be done by the various other methods.
<<method tokenize (Display)>>=
  public String[] tokenize(String line)
  { StringTokenizer stk = new StringTokenizer(line,"() \t\n\r\f",true);
    Vector tokenvec = new Vector();
    String[] tokens = null;
    String token = null;
    try
    { while(stk.hasMoreTokens())
      { token = stk.nextToken();
        Boolean keep=false;
        for(int i=0; i<token.length(); i++)
          if (! Character.isWhitespace(token.charAt(i))) keep=true;
        if (keep) tokenvec.add(token);
      }
    }
    catch(Exception e)
    { }
    tokens = (String[])tokenvec.toArray(new String[tokenvec.size()]);
    return(tokens);
  }

@
\subsubsection{method button}
<<variable JButton>>=
  JButton jbutton = null;
@
<<button add panel>>=
      if (type.equals("javax.swing.JButton"))
      { if (tokens[5].equals(""))
          jpanel.add((JButton)widgets.get(tokens[4]));
        else
          jpanel.add((JButton)widgets.get(tokens[4]),tokens[5]);
      }
@
<<button add window>>=
      if (type.equals("javax.swing.JButton"))
      { if (tokens[5].equals(""))
          jframe.add((JButton)widgets.get(tokens[4]));
        else
          jframe.add((JButton)widgets.get(tokens[4]),tokens[5]);
      }
@
<<button eval>>=
    if (tokens[2].equals("button") || tokens[2].equals("BUTTON"))
      return(button(tokens));
@
<<button make>>=
    if (tokens[3].equals("make") || tokens[3].equals("MAKE"))
    { jbutton = new JButton(tokens[4]);
      widgets.put(tokens[1],jbutton);
      return(tokens[1]);
    }
@
<<method button>>=
  private String button(String[] tokens)
  {
<<button make>>
    return("failed");
  }

@
\subsubsection{method image}
<<variable JImage>>=
  ImageIcon jimage = null;
@
<<image add label>>=
      if (type.equals("javax.swing.ImageIcon"))
        { if (tokens[5].equals(""))
          jlabel.add((ImageIcon)widgets.get(tokens[4]));
        else
          jlabel.add((ImageIcon)widgets.get(tokens[4]),tokens[5]);
      }
@
<<image eval>>=
    if (tokens[2].equals("image") || tokens[2].equals("IMAGE"))
      return(image(tokens));
@
<<image make>>=
    if (tokens[3].equals("make") || tokens[3].equals("MAKE"))
    { jimage = new ImageIcon(tokens[4]);
      widgets.put(tokens[1],jimage);
      return(tokens[1]);
    }
@
<<method image>>=
  private String image(String[] tokens)
  {
<<image make>>
    return("failed");
  }

@
\subsubsection{method label}
<<variable JLabel>>=
  JLabel jlabel = null;
@
<<label add panel>>=
      if (type.equals("javax.swing.JLabel"))
      { if (tokens[5].equals(""))
          jpanel.add((JLabel)widgets.get(tokens[4]));
        else
          jpanel.add((JLabel)widgets.get(tokens[4]),tokens[5]);
      }
@
<<label add window>>=
      if (type.equals("javax.swing.JLabel"))
      { if (tokens[5].equals(""))
          jframe.add((JLabel)widgets.get(tokens[4]));
        else
          jframe.add((JLabel)widgets.get(tokens[4]),tokens[5]);
      }
@
<<label eval>>=
    if (tokens[2].equals("label") || tokens[2].equals("LABEL"))
      return(label(tokens));
@
<<label add>>=
    if (tokens[3].equals("add") || tokens[3].equals("ADD"))
    { jlabel = (JLabel)widgets.get(tokens[1]);
      Object obj = widgets.get(tokens[4]);
      String type = obj.getClass().getName();
<<image add label>>
      return(tokens[1]);
    }
@
<<label image>>=
    if (tokens[3].equals("image") || tokens[3].equals("IMAGE"))
    { jlabel = (JLabel)widgets.get(tokens[1]);
      jimage = (ImageIcon)widgets.get(tokens[4]);
      jlabel.setIcon(jimage);
      return(tokens[1]);
    }
@
<<label text>>=
    if (tokens[3].equals("text") || tokens[3].equals("TEXT"))
    { jlabel = (JLabel)widgets.get(tokens[1]);
      jlabel.setText(tokens[4]);
      jlabel.setHorizontalAlignment(SwingConstants.CENTER);
      return(tokens[1]);
    }
@
<<label make>>=
    if (tokens[3].equals("make") || tokens[3].equals("MAKE"))
    { jlabel = new JLabel();
      widgets.put(tokens[1],jlabel);
      return(tokens[1]);
    }
@
<<method label>>=
  private String label(String[] tokens)
  {
<<label image>>
<<label make>>
<<label text>>
    return("failed");
  }

@
\subsubsection{method panel}
<<variable JPanel>>=
  JPanel jpanel = null;
@
<<panel add panel>>=
      if (type.equals("javax.swing.JPanel"))
      { if (tokens[5].equals(""))
          jpanel.add((JPanel)widgets.get(tokens[4]));
        else
          jpanel.add((JPanel)widgets.get(tokens[4]),tokens[5]);
      }
@
<<panel add window>>=
      if (type.equals("javax.swing.JPanel"))
      { if (tokens[5].equals(""))
          jframe.add((JPanel)widgets.get(tokens[4]));
        else
          jframe.add((JPanel)widgets.get(tokens[4]),tokens[5]);
      }
@
<<panel eval>>=
    if (tokens[2].equals("panel") || tokens[2].equals("PANEL"))
      return(panel(tokens));
@
<<panel make>>=
    if (tokens[3].equals("make") || tokens[3].equals("MAKE"))
    { jpanel = new JPanel();
      widgets.put(tokens[1],jpanel);
      return(tokens[1]);
    }
@
<<panel add>>=
    if (tokens[3].equals("add") || tokens[3].equals("ADD"))
    { jpanel = (JPanel)widgets.get(tokens[1]);
      Object obj = widgets.get(tokens[4]);
      String type = obj.getClass().getName();
<<button add panel>>
<<label add panel>>
<<panel add panel>>
      return(tokens[1]);
    }
@
<<panel layout>>=
    if (tokens[3].equals("layout") || tokens[3].equals("LAYOUT"))
    { jpanel = (JPanel)widgets.get(tokens[1]);
      if (tokens[4].equals("borderlayout") || tokens[4].equals("borderlayout"))
      { jpanel.setLayout(new BorderLayout());
        return(tokens[1]);
      }
      if (tokens[4].equals("flowlayout") || tokens[4].equals("flowlayout"))
      { jpanel.setLayout(new FlowLayout());
        return(tokens[1]);
      }
    }
@
<<method panel>>=
  private String panel(String[] tokens)
  { 
<<panel add>>
<<panel layout>>
<<panel make>>
    return("failed");
  }

@
\subsubsection{method window}
<<variable JFrame>>=
  JFrame jframe = null;
@
<<window eval>>=
    if (tokens[2].equals("window") || tokens[2].equals("WINDOW"))
      return(window(tokens));
@
The [[show]] method assumes a [[JFrame]] object. It fetches the object
from the [[widgets]] hashtable and calls [[show]] on the object.
The result is the hashkey of the object in the [[widgets]] hashtable.
<<window show>>=
    if (tokens[3].startsWith("show") || tokens[3].startsWith("SHOW"))
    { jframe = (JFrame)widgets.get(tokens[1]);
      jframe.show();
      return(tokens[1]);
    }
@
<<window add>>=
    if (tokens[3].equals("add") || tokens[3].equals("ADD"))
    { jframe = (JFrame)widgets.get(tokens[1]);
      Object obj = widgets.get(tokens[4]);
      String type = obj.getClass().getName();
<<button add window>>
<<label add window>>
<<panel add window>>
      return(tokens[1]);
    }
@
<<window layout>>=
    if (tokens[3].equals("layout") || tokens[3].equals("LAYOUT"))
    { jframe = (JFrame)widgets.get(tokens[1]);
      if (tokens[4].equals("borderlayout") || tokens[4].equals("BORDERLAYOUT"))
      { jframe.setLayout(new BorderLayout());
        return(tokens[1]);
      }
      if (tokens[4].equals("flowlayout") || tokens[4].equals("FLOWLAYOUT"))
      { jframe.setLayout(new FlowLayout());
        return(tokens[1]);
      }
    }
@
<<window make>>=
    if (tokens[3].equals("make") || tokens[3].equals("MAKE"))
    { try
      { UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
      } 
      catch (Exception exc) 
      { Catch.log("Console:setupMainWindow","Error loading L&F",exc);
      }
      frame = new JFrame(Parm.getParm("Jman.Console.Title"));
      WindowListener listenClose = new WindowAdapter() 
      { public void windowClosing(WindowEvent e) 
        { Window win = e.getWindow();
          win.setVisible(false);
          win.dispose();
          String msg = "Jman console closed";
          Catch.log("Console:setupMainWindow",msg);
          win.dispose();
        }
      };
      frame.addWindowListener(listenClose);
      JOptionPane.setRootFrame(frame);
      Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
      Container contentPane = frame.getContentPane();
      contentPane.removeAll();
      contentPane.setLayout(new BorderLayout());
      contentPane.add(this, BorderLayout.CENTER);
      int mainWidth = Integer.parseInt(tokens[6]);
      int mainHeight = Integer.parseInt(tokens[7]);
      frame.setSize(mainWidth, mainHeight);
      int xlocation = Integer.parseInt(tokens[4]);
      int ylocation = Integer.parseInt(tokens[5]);
      frame.setLocation(xlocation,ylocation);
      frame.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
      frame.validate();
      frame.setLayout(new BorderLayout());
  //    JButton j = new JButton("test");
  //    frame.add(j,BorderLayout.NORTH);
  //    frame.validate();
  //    frame.show();
      widgets.put(tokens[1],frame);
      return(tokens[1]);
    }
@
<<method window>>=
  private String window(String[] tokens)
  {
<<window add>>
<<window layout>>
<<window make>>
<<window show>>
    return("failed");
  }

@
\subsubsection{method eval}
The [[eval]] function is a general dispatch method on the third
argument of the list. It looks up the method name and calls a 
local function of that name. The local function has the responsibility
to fetch the object out of the hashtable and perform the processing.
The result is a string which is the value of the eval.
<<method eval>>=
  public String eval(String line)
  { String[] tokens = tokenize(line);
    Catch.log("Display:eval",tokens);
<<button eval>>
<<image eval>>
<<label eval>>
<<panel eval>>
<<window eval>>
    if (tokens[1].equals("quit") || tokens[1].equals("QUIT"))
      System.exit(0);
    return("failed");
  }

@
\subsubsection{method typedhash}
The [[typedhash]] method takes a key, a type as a string, and the object.
It maintains two parallel hash tables, one with the (key, type) pair and
one with the (key, object) pair. 
<<method typedhash>>=
  public void typedhash(String key, String type, Object obj)
  { widgettype.put(key,type);
    widgets.put(key,obj);
  }

@
\subsubsection{class Display}
<<class Display>>=
class Display extends JPanel
{
  static JFrame frame;     // the root frame of the world
  Hashtable widgets = null;
  Hashtable widgettype = null;
<<variable JFrame>>
<<variable JButton>>
<<variable JImage>>
<<variable JLabel>>
<<variable JPanel>>
<<constructor Display>>
<<method typedhash>>
<<method tokenize (Display)>>
<<method button>>
<<method image>>
<<method label>>
<<method panel>>
<<method window>>
<<method eval>>
}
@
\subsection{Jman.java}
<<Jman.java>>=
<<java imports>>
<<class Parm>>
<<class Catch>>
<<class Splash>>
<<class Display>>
<<step 0 code>>

public class Jman
{
<<method listen>>
<<method main>>
}

@
\section{Jman.ini}
\subsection{debugging parameters}
There are two debugging tools in the system. The first is
simply a general debug flag that can be turned on or off
without recompiling. The second is the Catch facility
(see Catch.java) which has the ability to trace calls,
returns and other information to stdout and to a log file
named here. During development it is probably a good idea
to turn these on. During test be sure to turn them off and
make sure that no debugging/catch messages appear (that is,
you aren't calling println directly

The value of the [[Debug]] parameter can be gotten with a call to
[[Parm.debugging()]] which returns a [[boolean]], true if 'on'
else false.
<<debugging parameters>>=
# general debugging flag
Debug = off
# if on, write Catch.log calls to CatchFile
CatchLog = on
CatchFile = Jman.log
# if on, write Catch.log calls to stdout
CatchTrace = on

# if on, write Error.log calls to CatchFile
ErrorLog = on
ErrorFile = Jman.error
# if on, write Error.log calls to stdout
ErrorTrace = on

@
\subsection{splash screen}
When the system starts we plan to pop up a ``splash screen''.
<<splash screen>>=
SplashImage = blueaxiom.jpg
#  default SplashWait = 2000
SplashWait = 4000

@
\subsection{network parameters}
The remote flag tells us whether to use the network.
If it is set to false we use local calls.
If it is set to true we use UDP packet messaging.

The consoles send and receive messages using this host
and port combination. See the section on UDPio.java for
further information.

<<network parameters>>=
remote = false
UDPio.bufferSize = 4096
UDPio.delay = 2000

Jman.UDPio.host = 127.0.0.1
Jman.UDPio.port = 14001

@
\subsection{console parameters}
We choose a simple font that is available on all Java implementations.
The syntax of the value string for Font and Color are explained in the
Parm class.
<<console parameters>>=
Jman.Console.Title = Jman
Jman.Console.width = 400
Jman.Console.height = 300
Jman.Console.xlocation = 30
Jman.Console.ylocation = 30

Console.background = [Color 0000FF]
Console.foreground = [Color 00FF00]

# the font used by each shell running in the console
Shell.font = [Font Dialog Font.PLAIN 12]

@
<<Jman.ini>>=
#default version = Jman.ini not found
version = 20050205000

<<console parameters>>
<<network parameters>>
<<splash screen>>
<<debugging parameters>>
@
\section{The Makefile}
This is the program we use to extract source code from this pamphlet file.
\subsection{TANGLE}
<<TANGLE>>=
TANGLE=/usr/local/bin/NOTANGLE
@
\subsection{WEAVE}
<<WEAVE>>=
WEAVE=/usr/local/bin/NOWEAVE
@
\subsection{LISP}
<<LISP>>=
LISP=/usr/local/bin/clisp
#LISP=/home/axiom--main--1--patch-30/obj/linux/bin/lisp
@
\subsection{MOVE}
This is the unix 'mv' command but can be changed for other platforms.
<<MOVE>>=
MOVE=mv
@
\subsection{ENVIRONMENT}
<<ENVIRONMENT>>=
<<TANGLE>>
<<WEAVE>>
<<LISP>>
<<MOVE>>
@
<<*>>=
<<ENVIRONMENT>>

all: Jman.ini Jman.class jman.dvi jman.lisp testcase
	@echo starting
	@ echo '(progn (load "jman.lisp") (jman))' | ${LISP}

remake: 
	@echo regenerate Makefile 
	@${TANGLE} -t8 jman.pamphlet >makefile
	@${MOVE} makefile Makefile

axiom.sty: jman.pamphlet
	@echo making axiom.sty from jman.pamphlet
	@${TANGLE} -Raxiom.sty jman.pamphlet >axiom.sty

jman.lisp: jman.pamphlet
	@echo making jman.lisp from jman.pamhlet
	@${TANGLE} -Rjman.lisp jman.pamphlet >jman.lisp

testcase: jman.pamphlet
	@echo making testcase from jman.pamhlet
	@${TANGLE} -Rtestcase jman.pamphlet >testcase

jman.dvi: axiom.sty jman.pamphlet
	@echo making jman.dvi from jman.pamphlet
	@${WEAVE} -delay jman.pamphlet >jman.tex
	@latex jman.tex
	@latex jman.tex
	@rm -f jman.aux
	@rm -f jman.tex
	@rm -f jman.toc
	@rm -f jman.log

Jman.java: jman.pamphlet
	@echo making Jman.java from jman.pamphlet
	@${TANGLE} -RJman.java jman.pamphlet >Jman.java

Jman.class: Jman.java # Ear.class
	@echo making Jman.class from Jman.java
	@javac Jman.java
#	@javac -Xlint:deprecation Jman.java

Jman.ini: jman.pamphlet
	@echo Jman.ini from jman.pamphlet
	@${TANGLE} -RJman.ini jman.pamphlet >Jman.ini

clean:
	@rm -f *~
	@rm -f *.class
	@rm -f axiom.sty
	@rm -f testcase
	@rm -f Jman.log
	@rm -f jman.lisp
	@rm -f Jman.ini
	@rm -f Jman.java
	@rm -f Ear.java
@
\section{The Axiom Style file -- axiom.sty}
<<axiom.sty>>=
% axiom.sty -- LaTeX support for noweb
{\obeyspaces\AtBeginDocument{\global\let =\ }} % from texbook, p 381
\def\nwopt@nomargintag{\let\nwmargintag=\@gobble}
\def\nwopt@margintag{%
  \def\nwmargintag##1{\leavevmode\llap{##1\kern\nwmarginglue\kern\codemargin}}}
\def\nwopt@margintag{%
  \def\nwmargintag##1{\leavevmode\kern-\codemargin\nwthemargintag{##1}\kern\codemargin}}
\def\nwthemargintag#1{\llap{#1\kern\nwmarginglue}}
\nwopt@margintag
\newdimen\nwmarginglue
\nwmarginglue=0.3in
\def\nwtagstyle{\footnotesize\Rm}
% make \hsize in code sufficient for 88 columns
\setbox0=\hbox{\tt m}
\newdimen\codehsize
\codehsize=91\wd0 % 88 columns wasn't enough; I don't know why
\newdimen\codemargin
\codemargin=0pt
\newdimen\nwdefspace
\nwdefspace=\codehsize
% need to use \textwidth in {\LaTeX} to handle styles with
% non-standard margins (David Bruce).  Don't know why we sometimes
% wanted \hsize.  27 August 1997.
%% \advance\nwdefspace by -\hsize\relax
\ifx\textwidth\undefined
  \advance\nwdefspace by -\hsize\relax
\else
  \advance\nwdefspace by -\textwidth\relax
\fi
\chardef\other=12
\def\setupcode{%
  \chardef\\=`\\
  \chardef\{=`\{
  \chardef\}=`\}
  \catcode`\$=\other
  \catcode`\&=\other
  \catcode`\#=\other
  \catcode`\%=\other
  \catcode`\~=\other
  \catcode`\_=\other
  \catcode`\^=\other
  \catcode`\"=\other    % fixes problem with german.sty
  \obeyspaces\Tt
}
\let\nwlbrace=\{
\let\nwrbrace=\}
\def\nwendquote{\relax\ifhmode\spacefactor=1000 \fi}
{\catcode`\^^M=\active % make CR an active character
  \gdef\newlines{\catcode`\^^M=\active % make CR an active character
         \def^^M{\par\startline}}%
  \gdef\eatline#1^^M{\relax}%
}
%%% DON'T   \gdef^^M{\par\startline}}% in case ^^M appears in a \write
\def\startline{\noindent\hskip\parindent\ignorespaces}
\def\nwnewline{\ifvmode\else\hfil\break\leavevmode\hbox{}\fi}
\def\setupmodname{%
  \catcode`\$=3
  \catcode`\&=4
  \catcode`\#=6
  \catcode`\%=14
  \catcode`\~=13
  \catcode`\_=8
  \catcode`\^=7
  \catcode`\ =10
  \catcode`\^^M=5
  \let\{\nwlbrace
  \let\}\nwrbrace
  % bad news --- don't know what catcode to give "
  \Rm}
\def\LA{\begingroup\maybehbox\bgroup\setupmodname\It$\langle$}
\def\RA{\/$\rangle$\egroup\endgroup}
\def\code{\leavevmode\begingroup\setupcode\newlines}
\def\edoc{\endgroup}
\let\maybehbox\relax
\newbox\equivbox
\setbox\equivbox=\hbox{$\equiv$}
\newbox\plusequivbox
\setbox\plusequivbox=\hbox{$\mathord{+}\mathord{\equiv}$}
% \moddef can't have an argument because there might be \code...\edoc
\def\moddef{\leavevmode\kern-\codemargin\LA}
\def\endmoddef{\RA\ifmmode\equiv\else\unhcopy\equivbox\fi
               \nobreak\hfill\nobreak}
\def\plusendmoddef{\RA\ifmmode\mathord{+}\mathord{\equiv}\else\unhcopy\plusequivbox\fi
               \nobreak\hfill\nobreak}
\def\chunklist{%
\errhelp{I changed \chunklist to \nowebchunks.  
I'll try to avoid such incompatible changes in the future.}%
\errmessage{Use \string\nowebchunks\space instead of \string\chunklist}}
\def\nowebchunks{\message{<Warning: You need noweave -x to use \string\nowebchunks>}}
\def\nowebindex{\message{<Warning: You need noweave -index to use \string\nowebindex>}}
% here is support for the new-style (capitalized) font-changing commands
% thanks to Dave Love
\ifx\documentstyle\undefined
  \let\Rm=\rm \let\It=\it \let\Tt=\tt       % plain
\else\ifx\selectfont\undefined
  \let\Rm=\rm \let\It=\it \let\Tt=\tt       % LaTeX OFSS
\else                                       % LaTeX NFSS
  \def\Rm{\reset@font\rm}
  \def\It{\reset@font\it}
  \def\Tt{\reset@font\tt}
  \def\Bf{\reset@font\bf}
\fi\fi
\ifx\reset@font\undefined \let\reset@font=\relax \fi
\def\noweboptions#1{%
  \def\@nwoptionlist{#1}%
  \@for\@nwoption:=\@nwoptionlist\do{%
    \@ifundefined{nwopt@\@nwoption}{%
        \@latexerr{There is no such noweb option as '\@nwoption'}\@eha}{%
        \csname nwopt@\@nwoption\endcsname}}}
\codemargin=10pt
\advance\codehsize by \codemargin       % make room for indentation of code
\advance\nwdefspace by \codemargin      % and fix adjustment for def/use
\def\setcodemargin#1{%
  \advance\codehsize by -\codemargin       % make room for indentation of code
  \advance\nwdefspace by -\codemargin   % and fix adjustment for def/use
  \codemargin=#1
  \advance\codehsize by \codemargin       % make room for indentation of code
  \advance\nwdefspace by \codemargin    % and fix adjustment for
                                        % def/use
}
\def\nwopt@shift{%
  \dimen@=-0.8in
  \if@twoside                 % Values for two-sided printing:
     \advance\evensidemargin by \dimen@
  \else                       % Values for one-sided printing:
     \advance\evensidemargin by \dimen@
     \advance\oddsidemargin by \dimen@
  \fi
%  \advance \marginparwidth -\dimen@
}
\let\nwopt@noshift\@empty
\def\nwbegincode#1{%
  \begingroup
    \topsep \nwcodetopsep
    \@beginparpenalty \@highpenalty
    \@endparpenalty -\@highpenalty
  \@begincode }
\def\nwendcode{\endtrivlist \endgroup \filbreak} % keeps code on 1 page

\newenvironment{webcode}{%
  \@begincode
}{%
  \endtrivlist}
\def\@begincode{%
    \trivlist \item[]%
    \leftskip\@totalleftmargin \advance\leftskip\codemargin
    \rightskip\hsize \advance\rightskip -\codehsize
    \parskip\z@ \parindent\z@ \parfillskip\@flushglue
  \linewidth\codehsize
    \@@par
    \def\par{\leavevmode\null \@@par \penalty\nwcodepenalty}%
    \obeylines
    \@noligs   \ifx\verbatim@nolig@list\undefined\else
                 \let\do=\nw@makeother \verbatim@nolig@list \do@noligs\`
               \fi
    \setupcode \frenchspacing \@vobeyspaces
  \nowebsize \setupcode
  \let\maybehbox\mbox }
  \newskip\nwcodetopsep \nwcodetopsep = 3pt plus 1.2pt minus 1pt
  \let\nowebsize=\normalsize
  \def\nwopt@tinycode{\let\nowebsize=\tiny}
  \def\nwopt@footnotesizecode{\let\nowebsize=\footnotesize}
  \def\nwopt@scriptsizecode{\let\nowebsize=\scriptsize}
  \def\nwopt@smallcode{\let\nowebsize=\small}
  \def\nwopt@normalsizecode{\let\nowebsize=\normalsize}
  \def\nwopt@largecode{\let\nowebsize=\large}
  \def\nwopt@Largecode{\let\nowebsize=\Large}
  \def\nwopt@LARGEcode{\let\nowebsize=\LARGE}
  \def\nwopt@hugecode{\let\nowebsize=\huge}
  \def\nwopt@Hugecode{\let\nowebsize=\Huge}
\newcount\nwcodepenalty  \nwcodepenalty=\@highpenalty
\def\nw@makeother#1{\catcode`#1=12 }
\def\nwbegindocs#1{\ifvmode\noindent\fi}
\let\nwenddocs=\relax
\let\nwdocspar=\filbreak
\raggedbottom
\def\code{\leavevmode\begingroup\setupcode\@vobeyspaces\obeylines}
\let\edoc=\endgroup
\newdimen\@original@textwidth
\def\ps@noweb{%
  \@original@textwidth=\textwidth
  \let\@mkboth\@gobbletwo
  \def\@oddfoot{}\def\@evenfoot{}%       No feet.
  \if@twoside         % If two-sided printing.
    \def\@evenhead{\hbox to \@original@textwidth{%
           \Rm \thepage\qquad{\Tt\leftmark}\hfil\today}}%        Left heading.
    \def\@oddhead{\hbox to \@original@textwidth{%
           \Rm \today\hfil{\Tt\leftmark}\qquad\thepage}}% Right heading.
  \else               % If one-sided printing.
    \def\@oddhead{\hbox to \@original@textwidth{%
           \Rm \today\hfil{\Tt\leftmark}\qquad\thepage}}% Right heading.
    \let\@evenhead\@oddhead
  \fi
  \let\chaptermark\@gobble
  \let\sectionmark\@gobble
  \let\subsectionmark\@gobble
  \let\subsubsectionmark\@gobble
  \let\paragraphmark\@gobble
  \let\subparagraphmark\@gobble
  \def\nwfilename{\begingroup\let\do\@makeother\dospecials
                \catcode`\{=1 \catcode`\}=2 \nw@filename}
  \def\nw@filename##1{\endgroup\markboth{##1}{##1}\let\nw@filename=\nw@laterfilename}%
}
\def\nw@laterfilename#1{\endgroup\clearpage \markboth{#1}{#1}}
\let\nwfilename=\@gobble
\def\nwcodecomment#1{\@@par\penalty\nwcodepenalty
    \if@firstnwcodecomment
      \vskip\nwcodecommentsep\penalty\nwcodepenalty\@firstnwcodecommentfalse
    \fi%
    \hspace{-\codemargin}{%
        \rightskip=0pt plus1in
        \interlinepenalty\nwcodepenalty
        \let\\\relax\footnotesize\Rm #1\@@par\penalty\nwcodepenalty}}
\def\@nwalsodefined#1{\nwcodecomment{\@nwlangdepdef\ \nwpageprep\ \@pagesl{#1}.}}
\def\@nwused#1{\nwcodecomment{\@nwlangdepcud\ \nwpageprep\ \@pagesl{#1}.}}
\def\@nwnotused#1{\nwcodecomment{\@nwlangdeprtc.}}
\def\nwoutput#1{\nwcodecomment{\@nwlangdepcwf\ {\Tt \@stripstar#1*\stripped}.}}
\def\@stripstar#1*#2\stripped{#1}
\newcommand{\nwprevdefptr}[1]{%
  \mbox{$\mathord{\triangleleft}\,\mathord{\mbox{\subpageref{#1}}}$}}
\newcommand{\nwnextdefptr}[1]{%
  \mbox{$\mathord{\mbox{\subpageref{#1}}}\,\mathord{\triangleright}$}}

\newcommand{\@nwprevnextdefs}[2]{%
  {\nwtagstyle
  \ifx\relax#1\else ~~\nwprevdefptr{#1}\fi
  \ifx\relax#2\else ~~\nwnextdefptr{#2}\fi}}
\newcommand{\@nwusesondefline}[1]{{\nwtagstyle~~(\@pagenumsl{#1})}}
\newcommand{\@nwstartdeflinemarkup}{\nobreak\hskip 1.5em plus 1fill\nobreak}
\newcommand{\@nwenddeflinemarkup}{\nobreak\hskip \nwdefspace minus\nwdefspace\nobreak}
\def\nwopt@longxref{%
  \let\nwalsodefined\@nwalsodefined
  \let\nwused\@nwused
  \let\nwnotused\@nwnotused
  \let\nwprevnextdefs\@gobbletwo
  \let\nwusesondefline\@gobble
  \let\nwstartdeflinemarkup\relax
  \let\nwenddeflinemarkup\relax
}
\def\nwopt@shortxref{%
  \let\nwalsodefined\@gobble
  \let\nwused\@gobble
  \let\nwnotused\@gobble
  \let\nwprevnextdefs\@nwprevnextdefs
  \let\nwusesondefline\@nwusesondefline
  \let\nwstartdeflinemarkup\@nwstartdeflinemarkup
  \let\nwenddeflinemarkup\@nwenddeflinemarkup
}
\def\nwopt@noxref{%
  \let\nwalsodefined\@gobble
  \let\nwused\@gobble
  \let\nwnotused\@gobble
  \let\nwprevnextdefs\@gobbletwo
  \let\nwusesondefline\@gobble
  \let\nwstartdeflinemarkup\relax
  \let\nwenddeflinemarkup\relax
}
\nwopt@shortxref % to hell with backward compatibility!
\newskip\nwcodecommentsep \nwcodecommentsep=3pt plus 1pt minus 1pt
\newif\if@firstnwcodecomment\@firstnwcodecommenttrue
\newcount\@nwlopage\newcount\@nwhipage  % range lo..hi-1
\newcount\@nwlosub              % subpage of lo
\newcount\@nwhisub              % subpage of hi
\def\@nwfirstpage#1#2#3{% subpage page xref-tag
  \@nwlopage=#2 \@nwlosub=#1
  \def\@nwloxreftag{#3}%
  \advance\@nwpagecount by \@ne
  \@nwhipage=\@nwlopage\advance\@nwhipage by \@ne }
\def\@nwnextpage#1#2#3{% subpage page xref-tag
  \ifnum\@nwhipage=#2 
    \advance\@nwhipage by \@ne 
    \advance\@nwpagecount by \@ne
    \@nwhisub=#1 
    \def\@nwhixreftag{#3}\else
  \ifnum#2<\@nwlopage \advance\@nwhipage by \m@ne
                      \ifnum\@nwhipage=\@nwlopage
                           \edef\@tempa{\noexpand\noexpand\noexpand\\%
                                             {{\nwthepagenum{\number\@nwlosub}{\number\@nwlopage}}%
                                              {\@nwloxreftag}}}%
                      \else
                        \count@=\@nwhipage \advance\count@ by \m@ne
                        \ifnum\count@=\@nwlopage % consecutive pages
                            \edef\@tempa{\noexpand\noexpand\noexpand\\%
                                             {{\nwthepagenum{\number\@nwlosub}{\number\@nwlopage}}%
                                              {\@nwloxreftag}}%
                                          \noexpand\noexpand\noexpand\\%
                                             {{\nwthepagenum{\number\@nwhisub}{\number\@nwhipage}}
                                              {\@nwhixreftag}}}%
                        \else \ifnum\@nwlopage<110 \edef\@tempa{\noexpand\noexpand\noexpand\\{{\number\@nwlopage--\number\@nwhipage}{}}}\else
                                \count@=\@nwlopage \divide\count@ by 100 \multiply\count@ by 100
                                \ifnum\count@=\@nwlopage \edef\@tempa{\noexpand\noexpand\noexpand\\{{\number\@nwlopage--\number\@nwhipage}{}}}\else
                                  \count@=\@nwlopage \divide\count@ by 100
                                  \@nwpagetemp=\@nwhipage \divide\@nwpagetemp by 100
                                  \ifnum\count@=\@nwpagetemp %  lo--least 2 digits of hi
                                    \multiply\@nwpagetemp by 100
                                    \advance \@nwhipage by -\@nwpagetemp
                                    \edef\@tempa{\noexpand\noexpand\noexpand\\{{\number\@nwlopage--\number\@nwhipage}{}}}%
                                  \else \edef\@tempa{\noexpand\noexpand\noexpand\\{{\number\@nwlopage--\number\@nwhipage}{}}}%
                                  \fi
                                \fi
                              \fi%
                        \fi
                      \fi%
                      \edef\@tempa{\noexpand\nwix@cons\noexpand\nw@pages{\@tempa}}\@tempa\@nwfirstpage{#1}{#2}{#3}\else
  \ifnum#2>\@nwhipage \advance\@nwhipage by \m@ne
                      \ifnum\@nwhipage=\@nwlopage
                           \edef\@tempa{\noexpand\noexpand\noexpand\\%
                                             {{\nwthepagenum{\number\@nwlosub}{\number\@nwlopage}}%
                                              {\@nwloxreftag}}}%
                      \else
                        \count@=\@nwhipage \advance\count@ by \m@ne
                        \ifnum\count@=\@nwlopage % consecutive pages
                            \edef\@tempa{\noexpand\noexpand\noexpand\\%
                                             {{\nwthepagenum{\number\@nwlosub}{\number\@nwlopage}}%
                                              {\@nwloxreftag}}%
                                          \noexpand\noexpand\noexpand\\%
                                             {{\nwthepagenum{\number\@nwhisub}{\number\@nwhipage}}
                                              {\@nwhixreftag}}}%
                        \else \ifnum\@nwlopage<110 \edef\@tempa{\noexpand\noexpand\noexpand\\{{\number\@nwlopage--\number\@nwhipage}{}}}\else
                                \count@=\@nwlopage \divide\count@ by 100 \multiply\count@ by 100
                                \ifnum\count@=\@nwlopage \edef\@tempa{\noexpand\noexpand\noexpand\\{{\number\@nwlopage--\number\@nwhipage}{}}}\else
                                  \count@=\@nwlopage \divide\count@ by 100
                                  \@nwpagetemp=\@nwhipage \divide\@nwpagetemp by 100
                                  \ifnum\count@=\@nwpagetemp %  lo--least 2 digits of hi
                                    \multiply\@nwpagetemp by 100
                                    \advance \@nwhipage by -\@nwpagetemp
                                    \edef\@tempa{\noexpand\noexpand\noexpand\\{{\number\@nwlopage--\number\@nwhipage}{}}}%
                                  \else \edef\@tempa{\noexpand\noexpand\noexpand\\{{\number\@nwlopage--\number\@nwhipage}{}}}%
                                  \fi
                                \fi
                              \fi%
                        \fi
                      \fi%
                      \edef\@tempa{\noexpand\nwix@cons\noexpand\nw@pages{\@tempa}}\@tempa\@nwfirstpage{#1}{#2}{#3}\else
    \@nwlosub=0 \@nwhisub=0
  \fi\fi\fi
  }
\newcount\@nwpagetemp
\newcount\@nwpagecount
\def\@nwfirstpagel#1{% label
  \@ifundefined{r@#1}{\@warning{Reference `#1' on page \thepage \space undefined}%
                      \nwix@cons\nw@pages{\\{\bf ??}}}{%
    \edef\@tempa{\noexpand\@nwfirstpage\subpagepair{#1}{#1}}\@tempa}}
\def\@nwnextpagel#1{% label
  \@ifundefined{r@#1}{\@warning{Reference `#1' on page \thepage \space undefined}%
                      \nwix@cons\nw@pages{\\{\bf ??}}}{%
    \edef\@tempa{\noexpand\@nwnextpage\subpagepair{#1}{#1}}\@tempa}}
\def\@pagesl#1{%  list of labels
  \gdef\nw@pages{}\@nwpagecount=0
  \def\\##1{\@nwfirstpagel{##1}\let\\=\@nwnextpagel}#1%
  \advance\@nwhipage by \m@ne
  \ifnum\@nwhipage=\@nwlopage
       \edef\@tempa{\noexpand\noexpand\noexpand\\%
                         {{\nwthepagenum{\number\@nwlosub}{\number\@nwlopage}}%
                          {\@nwloxreftag}}}%
  \else
    \count@=\@nwhipage \advance\count@ by \m@ne
    \ifnum\count@=\@nwlopage % consecutive pages
        \edef\@tempa{\noexpand\noexpand\noexpand\\%
                         {{\nwthepagenum{\number\@nwlosub}{\number\@nwlopage}}%
                          {\@nwloxreftag}}%
                      \noexpand\noexpand\noexpand\\%
                         {{\nwthepagenum{\number\@nwhisub}{\number\@nwhipage}}
                          {\@nwhixreftag}}}%
    \else \ifnum\@nwlopage<110 \edef\@tempa{\noexpand\noexpand\noexpand\\{{\number\@nwlopage--\number\@nwhipage}{}}}\else
            \count@=\@nwlopage \divide\count@ by 100 \multiply\count@ by 100
            \ifnum\count@=\@nwlopage \edef\@tempa{\noexpand\noexpand\noexpand\\{{\number\@nwlopage--\number\@nwhipage}{}}}\else
              \count@=\@nwlopage \divide\count@ by 100
              \@nwpagetemp=\@nwhipage \divide\@nwpagetemp by 100
              \ifnum\count@=\@nwpagetemp %  lo--least 2 digits of hi
                \multiply\@nwpagetemp by 100
                \advance \@nwhipage by -\@nwpagetemp
                \edef\@tempa{\noexpand\noexpand\noexpand\\{{\number\@nwlopage--\number\@nwhipage}{}}}%
              \else \edef\@tempa{\noexpand\noexpand\noexpand\\{{\number\@nwlopage--\number\@nwhipage}{}}}%
              \fi
            \fi
          \fi%
    \fi
  \fi%
  \edef\@tempa{\noexpand\nwix@cons\noexpand\nw@pages{\@tempa}}\@tempa\def\\##1{\@nwhyperpagenum##1}%
  \ifnum\@nwpagecount=1 \nwpageword \else \nwpagesword\fi~\commafy{\nw@pages}}
\def\@nwhyperpagenum#1#2{\nwhyperreference{#2}{#1}}

\def\@pagenumsl#1{%  list of labels -- doesn't include word `pages', commas, or `and'
  \gdef\nw@pages{}\@nwpagecount=0
  \def\\##1{\@nwfirstpagel{##1}\let\\=\@nwnextpagel}#1%
  \advance\@nwhipage by \m@ne
  \ifnum\@nwhipage=\@nwlopage
       \edef\@tempa{\noexpand\noexpand\noexpand\\%
                         {{\nwthepagenum{\number\@nwlosub}{\number\@nwlopage}}%
                          {\@nwloxreftag}}}%
  \else
    \count@=\@nwhipage \advance\count@ by \m@ne
    \ifnum\count@=\@nwlopage % consecutive pages
        \edef\@tempa{\noexpand\noexpand\noexpand\\%
                         {{\nwthepagenum{\number\@nwlosub}{\number\@nwlopage}}%
                          {\@nwloxreftag}}%
                      \noexpand\noexpand\noexpand\\%
                         {{\nwthepagenum{\number\@nwhisub}{\number\@nwhipage}}
                          {\@nwhixreftag}}}%
    \else \ifnum\@nwlopage<110 \edef\@tempa{\noexpand\noexpand\noexpand\\{{\number\@nwlopage--\number\@nwhipage}{}}}\else
            \count@=\@nwlopage \divide\count@ by 100 \multiply\count@ by 100
            \ifnum\count@=\@nwlopage \edef\@tempa{\noexpand\noexpand\noexpand\\{{\number\@nwlopage--\number\@nwhipage}{}}}\else
              \count@=\@nwlopage \divide\count@ by 100
              \@nwpagetemp=\@nwhipage \divide\@nwpagetemp by 100
              \ifnum\count@=\@nwpagetemp %  lo--least 2 digits of hi
                \multiply\@nwpagetemp by 100
                \advance \@nwhipage by -\@nwpagetemp
                \edef\@tempa{\noexpand\noexpand\noexpand\\{{\number\@nwlopage--\number\@nwhipage}{}}}%
              \else \edef\@tempa{\noexpand\noexpand\noexpand\\{{\number\@nwlopage--\number\@nwhipage}{}}}%
              \fi
            \fi
          \fi%
    \fi
  \fi%
  \edef\@tempa{\noexpand\nwix@cons\noexpand\nw@pages{\@tempa}}\@tempa%
  \def\\##1{\@nwhyperpagenum##1\let\\=\@nwpagenumslrest}\nw@pages}
\def\@nwpagenumslrest#1{~\@nwhyperpagenum#1}
\def\subpages#1{% list of {{subpage}{page}}
  \gdef\nw@pages{}\@nwpagecount=0
  \def\\##1{\edef\@tempa{\noexpand\@nwfirstpage##1{}}\@tempa
            \def\\####1{\edef\@tempa{\noexpand\@nwnextpage####1}\@tempa}}#1%
  \advance\@nwhipage by \m@ne
  \ifnum\@nwhipage=\@nwlopage
       \edef\@tempa{\noexpand\noexpand\noexpand\\%
                         {{\nwthepagenum{\number\@nwlosub}{\number\@nwlopage}}%
                          {\@nwloxreftag}}}%
  \else
    \count@=\@nwhipage \advance\count@ by \m@ne
    \ifnum\count@=\@nwlopage % consecutive pages
        \edef\@tempa{\noexpand\noexpand\noexpand\\%
                         {{\nwthepagenum{\number\@nwlosub}{\number\@nwlopage}}%
                          {\@nwloxreftag}}%
                      \noexpand\noexpand\noexpand\\%
                         {{\nwthepagenum{\number\@nwhisub}{\number\@nwhipage}}
                          {\@nwhixreftag}}}%
    \else \ifnum\@nwlopage<110 \edef\@tempa{\noexpand\noexpand\noexpand\\{{\number\@nwlopage--\number\@nwhipage}{}}}\else
            \count@=\@nwlopage \divide\count@ by 100 \multiply\count@ by 100
            \ifnum\count@=\@nwlopage \edef\@tempa{\noexpand\noexpand\noexpand\\{{\number\@nwlopage--\number\@nwhipage}{}}}\else
              \count@=\@nwlopage \divide\count@ by 100
              \@nwpagetemp=\@nwhipage \divide\@nwpagetemp by 100
              \ifnum\count@=\@nwpagetemp %  lo--least 2 digits of hi
                \multiply\@nwpagetemp by 100
                \advance \@nwhipage by -\@nwpagetemp
                \edef\@tempa{\noexpand\noexpand\noexpand\\{{\number\@nwlopage--\number\@nwhipage}{}}}%
              \else \edef\@tempa{\noexpand\noexpand\noexpand\\{{\number\@nwlopage--\number\@nwhipage}{}}}%
              \fi
            \fi
          \fi%
    \fi
  \fi%
  \edef\@tempa{\noexpand\nwix@cons\noexpand\nw@pages{\@tempa}}\@tempa\def\\##1{\@firstoftwo##1}%
  \ifnum\@nwpagecount=1 \nwpageword \else \nwpagesword\fi~\commafy{\nw@pages}}
\def\@nwaddrange{\advance\@nwhipage by \m@ne
                 \ifnum\@nwhipage=\@nwlopage
                      \edef\@tempa{\noexpand\noexpand\noexpand\\%
                                        {{\nwthepagenum{\number\@nwlosub}{\number\@nwlopage}}%
                                         {\@nwloxreftag}}}%
                 \else
                   \count@=\@nwhipage \advance\count@ by \m@ne
                   \ifnum\count@=\@nwlopage % consecutive pages
                       \edef\@tempa{\noexpand\noexpand\noexpand\\%
                                        {{\nwthepagenum{\number\@nwlosub}{\number\@nwlopage}}%
                                         {\@nwloxreftag}}%
                                     \noexpand\noexpand\noexpand\\%
                                        {{\nwthepagenum{\number\@nwhisub}{\number\@nwhipage}}
                                         {\@nwhixreftag}}}%
                   \else \ifnum\@nwlopage<110 \edef\@tempa{\noexpand\noexpand\noexpand\\{{\number\@nwlopage--\number\@nwhipage}{}}}\else
                           \count@=\@nwlopage \divide\count@ by 100 \multiply\count@ by 100
                           \ifnum\count@=\@nwlopage \edef\@tempa{\noexpand\noexpand\noexpand\\{{\number\@nwlopage--\number\@nwhipage}{}}}\else
                             \count@=\@nwlopage \divide\count@ by 100
                             \@nwpagetemp=\@nwhipage \divide\@nwpagetemp by 100
                             \ifnum\count@=\@nwpagetemp %  lo--least 2 digits of hi
                               \multiply\@nwpagetemp by 100
                               \advance \@nwhipage by -\@nwpagetemp
                               \edef\@tempa{\noexpand\noexpand\noexpand\\{{\number\@nwlopage--\number\@nwhipage}{}}}%
                             \else \edef\@tempa{\noexpand\noexpand\noexpand\\{{\number\@nwlopage--\number\@nwhipage}{}}}%
                             \fi
                           \fi
                         \fi%
                   \fi
                 \fi%
                 \edef\@tempa{\noexpand\nwix@cons\noexpand\nw@pages{\@tempa}}\@tempa}
\def\nwpageword{\@nwlangdepchk}  % chunk, was page
\def\nwpagesword{\@nwlangdepchks}  % chunk, was page
\def\nwpageprep{\@nwlangdepin}     % in, was on
\newcommand\nw@genericref[2]{% what to do, name of ref
  \expandafter\nw@g@nericref\csname r@#2\endcsname#1{#2}}
\newcommand\nw@g@nericref[3]{% control sequence, what to do, name
  \ifx#1\relax
    \ref{#3}% trigger the standard `undefined ref' mechanisms
  \else
    \expandafter#2#1.\\%
  \fi}
\def\nw@selectone#1#2#3\\{#1}
\def\nw@selecttwo#1#2#3\\{#2}
\def\nw@selectonetwo#1#2#3\\{{#1}{#2}}
\newcommand{\subpageref}[1]{%
  \nwhyperreference{#1}{\nw@genericref\@subpageref{#1}}}
\def\@subpageref#1#2#3\\{%
  \@ifundefined{2on#2}{#2}{\nwthepagenum{#1}{#2}}}
\newcommand{\subpagepair}[1]{%  % produces {subpage}{page}
  \@ifundefined{r@#1}%
    {{0}{0}}%
    {\nw@genericref\@subpagepair{#1}}}
\def\@subpagepair#1#2#3\\{%
  \@ifundefined{2on#2}{{0}{#2}}{{#1}{#2}}}
\newcommand{\sublabel}[1]{%
  \@bsphack
  \nwblindhyperanchor{#1}%
  \if@filesw {\let\thepage\relax
   \def\protect{\noexpand\noexpand\noexpand}%
   \edef\@tempa{\write\@auxout{\string
      \newsublabel{#1}{{}{\thepage}}}}%
   \expandafter}\@tempa
   \if@nobreak \ifvmode\nobreak\fi\fi\fi\@esphack}
\newcommand{\nosublabel}[1]{%
  \@bsphack\if@filesw {\let\thepage\relax
   \def\protect{\noexpand\noexpand\noexpand}%
   \edef\@tempa{\write\@auxout{\string
      \newlabel{#1}{{0}{\thepage}}}}%
   \expandafter}\@tempa
   \if@nobreak \ifvmode\nobreak\fi\fi\fi\@esphack}
\newcommand\newsublabel{%
  \nw@settrailers
  \global\let\newsublabel\@newsublabel
  \@newsublabel}
\newcommand{\@newsublabel}[2]{%
  \edef\this@page{\@cdr#2\@nil}%
  \ifx\this@page\last@page\else
    \sub@page=\z@
  \fi
  \edef\last@page{\this@page}
  \advance\sub@page by \@ne
  \ifnum\sub@page=\tw@
    \global\@namedef{2on\this@page}{}%
  \fi
  \pendingsublabel{#1}%
  \edef\@tempa##1{\noexpand\newlabel{##1}%
    {{\number\sub@page}{\this@page}\nw@labeltrailers}}%
  \pending@sublabels
  \def\pending@sublabels{}}
\newcommand\nw@settrailers{% -- won't work on first run
  \@ifpackageloaded{nameref}%
     {\gdef\nw@labeltrailers{{}{}{}}}%
     {\gdef\nw@labeltrailers{}}}
\renewcommand\nw@settrailers{% 
  \@ifundefined{@secondoffive}%
     {\gdef\nw@labeltrailers{}}%
     {\gdef\nw@labeltrailers{{}{}{}}}}
\newcommand{\nextchunklabel}[1]{%
  \nwblindhyperanchor{#1}%   % looks slightly bogus --- nr
  \@bsphack\if@filesw {\let\thepage\relax
      \edef\@tempa{\write\@auxout{\string\pendingsublabel{#1}}}%
      \expandafter}\@tempa
   \if@nobreak \ifvmode\nobreak\fi\fi\fi\@esphack}
\newcommand\pendingsublabel[1]{%
  \def\@tempa{\noexpand\@tempa}%
  \edef\pending@sublabels{\noexpand\@tempa{#1}\pending@sublabels}}
\def\pending@sublabels{}
\def\last@page{\relax}
\newcount\sub@page
\def\@alphasubpagenum#1#2{#2\ifnum#1=0 \else\@alph{#1}\fi}
\def\@nosubpagenum#1#2{#2}
\def\@numsubpagenum#1#2{#2\ifnum#1=0 \else.\@arabic{#1}\fi}
\def\nwopt@nosubpage{\let\nwthepagenum=\@nosubpagenum\nwopt@nomargintag}
\def\nwopt@numsubpage{\let\nwthepagenum=\@numsubpagenum}
\def\nwopt@alphasubpage{\let\nwthepagenum=\@alphasubpagenum}
\nwopt@alphasubpage
\newcount\@nwalph@n
\let\@nwalph@d\@tempcnta
\let\@nwalph@bound\@tempcntb
\def\@nwlongalph#1{{%
  \@nwalph@n=#1\advance\@nwalph@n by-1
  \@nwalph@bound=26
  \loop\ifnum\@nwalph@n<\@nwalph@bound\else
     \advance\@nwalph@n by -\@nwalph@bound
     \multiply\@nwalph@bound by 26
  \repeat
  \loop\ifnum\@nwalph@bound>1
    \divide\@nwalph@bound by 26
    \@nwalph@d=\@nwalph@n\divide\@nwalph@d by \@nwalph@bound
    % d := d * bound ; n -:= d; d := d / bound --- saves a temporary
    \multiply\@nwalph@d by \@nwalph@bound
    \advance\@nwalph@n by -\@nwalph@d
    \divide\@nwalph@d by \@nwalph@bound
    \advance\@nwalph@d by 1 \@alph{\@nwalph@d}%
  \repeat
}}
\newcount\nw@chunkcount
\nw@chunkcount=\@ne
\newcommand{\weblabel}[1]{%
  \@bsphack
  \nwblindhyperanchor{#1}%
  \if@filesw {\let\thepage\relax
   \def\protect{\noexpand\noexpand\noexpand}%
   \edef\@tempa{\write\@auxout{\string
      \newsublabel{#1}{{}{\number\nw@chunkcount}}}}%
   \expandafter}\@tempa
   \global\advance\nw@chunkcount by \@ne
   \if@nobreak \ifvmode\nobreak\fi\fi\fi\@esphack}
\def\nwopt@webnumbering{%
  \let\sublabel=\weblabel
  \def\nwpageword{chunk}\def\nwpagesword{chunks}%
  \def\nwpageprep{in}}
% \nwindexdefn{printable name}{identifying label}{label of chunk}
% \nwindexuse{printable name}{identifying label}{label of chunk}

\def\nwindexdefn#1#2#3{\@auxix{\protect\nwixd}{#2}{#3}}
\def\nwindexuse#1#2#3{\@auxix{\protect\nwixu}{#2}{#3}}

\def\@auxix#1#2#3{% {marker}{id label}{subpage label}
   \@bsphack\if@filesw {\let\nwixd\relax\let\nwixu\relax
   \def\protect{\noexpand\noexpand\noexpand}%
   \edef\@tempa{\write\@auxout{\string\nwixadd{#1}{#2}{#3}}}%
   \expandafter}\@tempa
   \if@nobreak \ifvmode\nobreak\fi\fi\fi\@esphack}
% \nwixadd{marker}{idlabel}{subpage label}
\def\nwixadd#1#2#3{%
  \@ifundefined{nwixl@#2}%
    {\global\@namedef{nwixl@#2}{#1{#3}}}%
    {\expandafter\nwix@cons\csname nwixl@#2\endcsname{#1{#3}}}}
\def\@nwsubscriptident#1#2{\mbox{$\mbox{#1}_{\mathrm{\subpageref{#2}}}$}}
\def\@nwnosubscriptident#1#2{#1}
\def\@nwhyperident#1#2{\leavevmode\nwhyperreference{#2}{#1}}
\def\nwopt@subscriptidents{%
  \let\nwlinkedidentq\@nwsubscriptident
  \let\nwlinkedidentc\@nwsubscriptident
}
\def\nwopt@nosubscriptidents{%
  \let\nwlinkedidentq\@nwnosubscriptident
  \let\nwlinkedidentc\@nwnosubscriptident
}
\def\nwopt@hyperidents{%
  \let\nwlinkedidentq\@nwhyperident
  \let\nwlinkedidentc\@nwhyperident
}
\def\nwopt@nohyperidents{%
  \let\nwlinkedidentq\@nwnosubscriptident
  \let\nwlinkedidentc\@nwnosubscriptident
}
\def\nwopt@subscriptquotedidents{%
  \let\nwlinkedidentq\@nwsubscriptident
}
\def\nwopt@nosubscriptquotedidents{%
  \let\nwlinkedidentq\@nwnosubscriptident
}
\def\nwopt@hyperquotedidents{%
  \let\nwlinkedidentq\@nwhyperident
}
\def\nwopt@nohyperquotedidents{%
  \let\nwlinkedidentq\@nwnosubscriptident
}
\nwopt@hyperidents
\newcount\@commacount
\def\commafy#1{%
  {\nwix@listcount{#1}\@commacount=\nwix@counter
   \let\@comma@each=\\%
   \ifcase\@commacount\let\\=\@comma@each\or\let\\=\@comma@each\or
     \def\\{\def\\{ \@nwlangdepand\ \@comma@each}\@comma@each}\else
     \def\\{\def\\{, %
                   \advance\@commacount by \m@ne
                   \ifnum\@commacount=1 \@nwlangdepand~\fi\@comma@each}\@comma@each}\fi
   #1}}
\def\nwix@cons#1#2{% {list}{\marker{element}}
  {\toks0=\expandafter{#1}\def\@tempa{#2}\toks2=\expandafter{\@tempa}%
   \xdef#1{\the\toks0 \the\toks2 }}}
\def\nwix@uses#1{% {label}
  \def\nwixu{\\}\let\nwixd\@gobble\@nameuse{nwixl@#1}}
\def\nwix@defs#1{% {label}
  \def\nwixd{\\}\let\nwixu\@gobble\@nameuse{nwixl@#1}}
\newcount\nwix@counter
\def\nwix@listcount#1{% {list with \\}
  {\count@=0
   \def\\##1{\advance\count@ by \@ne }%
   #1\global\nwix@counter=\count@ }}
\def\nwix@usecount#1{\nwix@listcount{\nwix@uses{#1}}}
\def\nwix@defcount#1{\nwix@listcount{\nwix@defs{#1}}}
\def\nwix@id@defs#1{% index pair
  {{\Tt \@car#1\@nil}%
  \def\\##1{~\subpageref{##1}}\nwix@defs{\@cdr#1\@nil}}}
\def\nwidentuses#1{% list of index pairs
  \nwcodecomment{\@nwlangdepuss\ \let\\=\nwix@id@defs\commafy{#1}.}}
\def\nwix@totaluses#1{% list of index pairs
  {\count@=0
   \def\\##1{\nwix@usecount{\@cdr##1\@nil}\advance\count@ by\nwix@counter}%
   #1\global\nwix@counter\count@ }}
\def\nwix@id@uses#1#2{% {ident}{label}
  \nwix@usecount{#2}\ifnum\nwix@counter>0
    {\advance\leftskip by \codemargin
     \nwcodecomment{{\Tt #1}, \@nwlangdepusd\ \nwpageprep\ \@pagesl{\nwix@uses{#2}}.}}%
  \else
    \ifnw@hideunuseddefs\else
      {\advance\leftskip by \codemargin \nwcodecomment{{\Tt #1}, \@nwlangdepnvu.}}%
    \fi
  \fi}
\def\nwidentdefs#1{% list of index pairs
  \ifnw@hideunuseddefs\nwix@totaluses{#1}\else\nwix@listcount{#1}\fi
  \ifnum\nwix@counter>0
    \nwcodecomment{\@nwlangdepdfs:}%
    {\def\\##1{\nwix@id@uses ##1}#1}%
  \fi}
\newif\ifnw@hideunuseddefs\nw@hideunuseddefsfalse
\def\nwopt@hideunuseddefs{\nw@hideunuseddefstrue}
\def\nwopt@noidentxref{%
  \let\nwidentdefs\@gobble
  \let\nwidentuses\@gobble}
\def\nw@underlinedefs{% {list with \nwixd, \nwixu}
  \let\\=\relax\def\nw@comma{, }
  \def\nwixd##1{\\\underline{\subpageref{##1}}\let\\\nw@comma}%
  \def\nwixu##1{\\\subpageref{##1}\let\\\nw@comma}}

\def\nw@indexline#1#2{%
   {\indent {\Tt #1}: \nw@underlinedefs\@nameuse{nwixl@#2}\par}}

\newenvironment{thenowebindex}{\parindent=-10pt \parskip=\z@ 
        \advance\leftskip by 10pt 
        \advance\rightskip by 0pt plus1in\par\@afterindenttrue
    \def\\##1{\nw@indexline##1}}{}
\def\nowebindex{%
  \@ifundefined{nwixs@i}%
     {\@warning{The \string\nowebindex\space is empty}}%
     {\begin{thenowebindex}\@nameuse{nwixs@i}\end{thenowebindex}}}
\def\nowebindex@external{%
  {\let\nwixadds@c=\@gobble
   \def\nwixadds@i##1{\nw@indexline##1}%
   \def\nwixaddsx##1##2{\@nameuse{nwixadds@##1}{##2}}%
   \begin{thenowebindex}\@input{\jobname.nwi}\end{thenowebindex}}}
\def\nwixlogsorted#1#2{% list data
   \@bsphack\if@filesw 
     \toks0={#2}\immediate\write\@auxout{\string\nwixadds{#1}{\the\toks0}}
   \if@nobreak \ifvmode\nobreak\fi\fi\fi\@esphack}
\def\nwixadds#1#2{%
  \@ifundefined{nwixs@#1}%
    {\global\@namedef{nwixs@#1}{\\{#2}}}%
    {\expandafter\nwix@cons\csname nwixs@#1\endcsname{\\{#2}}}}
\let\nwixaddsx=\@gobbletwo
\def\nwopt@externalindex{%
  \ifx\nwixadds\@gobbletwo % already called
  \else
    \let\nwixaddsx=\nwixadds \let\nwixadds=\@gobbletwo
    \let\nowebindex=\nowebindex@external
    \let\nowebchunks=\nowebchunks@external
  \fi}
\def\nowebchunks{%
  \@ifundefined{nwixs@c}%
     {\@warning{The are no \string\nowebchunks}}%
     {\begin{thenowebchunks}\@nameuse{nwixs@c}\end{thenowebchunks}}}
\def\nowebchunks@external{%
  {\let\nwixadds@i=\@gobble
   \def\nwixadds@c##1{\nw@onechunk##1}%
   \def\nwixaddsx##1##2{\@nameuse{nwixadds@##1}{##2}}%
   \begin{thenowebchunks}\@input{\jobname.nwi}\end{thenowebchunks}}}
    \@namedef{r@nw@notdef}{{0}{(\@nwlangdepnvd)}}
\def\nw@chunkunderlinedefs{% {list of labels with \nwixd, \nwixu}
  \let\\=\relax\def\nw@comma{, }
  \def\nwixd##1{\\\underline{\subpageref{##1}}\let\\\nw@comma}%
  \def\nwixu##1{\\\subpageref{##1}\let\\\nw@comma}}
\def\nw@onechunk#1#2#3{% {name}{label of first definition}{list with \nwixd, \nwixu}
  \@ifundefined{r@#2}{}{%
    \indent\LA #1~{\nwtagstyle\subpageref{#2}}\RA 
    \if@nwlongchunks{~\nw@chunkunderlinedefs#3}\fi\par}}
\newenvironment{thenowebchunks}{\vskip3pt
  \parskip=\z@\parindent=-10pt \advance\leftskip by 10pt
  \advance\rightskip by 0pt plus10pt \@afterindenttrue
  \def\\##1{\nw@onechunk##1}}{}
\newif\if@nwlongchunks
\@nwlongchunksfalse
\let\nwopt@longchunks\@nwlongchunkstrue
\newcommand\@nw@hyper@ref{\hyperreference} % naras
\newcommand\@nw@hyper@anc{\blindhyperanchor} % naras
\newcommand\@nw@hyperref@ref[2]{\hyperlink{noweb.#1}{#2}}  % nr
\newcommand\@nw@hyperref@anc[1]{\hypertarget{noweb.#1}{\relax}}  % nr
%%\renewcommand\@nw@hyperref@ref[2]{{#2}}  % nr
%%\renewcommand\@nw@hyperref@anc[1]{}  % nr
\newcommand\nwhyperreference{%
  \@ifundefined{hyperlink}
    {\@ifundefined{hyperreference}
       {\global\let\nwhyperreference\@gobble}
       {\global\let\nwhyperreference\@nw@hyper@ref}}
    {\global\let\nwhyperreference\@nw@hyperref@ref}%
  \nwhyperreference
}

\newcommand\nwblindhyperanchor{%
  \@ifundefined{hyperlink}
    {\@ifundefined{hyperreference}
       {\global\let\nwblindhyperanchor\@gobble}
       {\global\let\nwblindhyperanchor\@nw@hyper@anc}}
    {\global\let\nwblindhyperanchor\@nw@hyperref@anc}%
  \nwblindhyperanchor
}
\newcommand\nwanchorto{%
  \begingroup\let\do\@makeother\dospecials
     \catcode`\{=1 \catcode`\}=2 \nw@anchorto}
\newcommand\nw@anchorto[1]{\endgroup\def\nw@next{#1}\nw@anchortofin}
\newcommand\nw@anchortofin[1]{#1\footnote{See URL \texttt{\nw@next}.}}
\let\nwanchorname\@gobble
\newif\ifhtml
\htmlfalse
\let\nwixident=\relax
\def\nwbackslash{\char92}
\def\nwlbrace{\char123}
\def\nwrbrace{\char125}
\def\nwopt@english{%
  \def\@nwlangdepdef{This definition is continued}%
  \def\@nwlangdepcud{This code is used}%
  \def\@nwlangdeprtc{Root chunk (not used in this document)}%
  \def\@nwlangdepcwf{This code is written to file}%
  \def\@nwlangdepchk{chunk}%
  \def\@nwlangdepchks{chunks}%
  \def\@nwlangdepin{in}%
  \def\@nwlangdepand{and}%
  \def\@nwlangdepuss{Uses}%
  \def\@nwlangdepusd{used}%
  \def\@nwlangdepnvu{never used}%
  \def\@nwlangdepdfs{Defines}%
  \def\@nwlangdepnvd{never defined}%
}
\let\nwopt@american\nwopt@english
\def\nwopt@portuges{%
  \def\@nwlangdepdef{Defini\c{c}\~ao continuada em}%
  % This definition is continued
  \def\@nwlangdepcud{C\'odigo usado em}%
  % This code is used
  \def\@nwlangdeprtc{Fragmento de topo (sem uso no documento)}%
  % Root chunk (not used in this document)
  \def\@nwlangdepcwf{Este c\'odigo foi escrito no ficheiro}%
  % This code is written to file
  \def\@nwlangdepchk{fragmento}%
  % chunk
  \def\@nwlangdepchks{fragmentos}%
  % chunks
  \def\@nwlangdepin{no(s)}%
  % in
  \def\@nwlangdepand{e}%
  % and
  \def\@nwlangdepuss{Usa}%
  % Uses
  \def\@nwlangdepusd{usado}%
  % used
  \def\@nwlangdepnvu{nunca usado}%
  % never used
  \def\@nwlangdepdfs{Define}%
  % Defines
  \def\@nwlangdepnvd{nunca definido}%
  % never defined
}
\def\nwopt@frenchb{%
  \def\@nwlangdepdef{Cette d\'efinition suit}%
  % This definition is continued
  \def\@nwlangdepcud{Ce code est employ\'e}%
  % This code is used
  \def\@nwlangdeprtc{Morceau racine (pas employ\'e dans ce document)}%
  % Root chunk (not used in this document)
  \def\@nwlangdepcwf{Ce code est \'ecrit aux fichier}%
  % This code is written to file
  \def\@nwlangdepchk{le morceau}%
  % chunk
  \def\@nwlangdepchks{les morceaux}%
  % chunks
  \def\@nwlangdepin{dans}%
  % in
  \def\@nwlangdepand{et}%
  % and
  \def\@nwlangdepuss{Il emploie}%
  % Uses
  \def\@nwlangdepusd{employ\'{e}}%
  % used
  \def\@nwlangdepnvu{jamais employ\'{e}}%
  % never used
  \def\@nwlangdepdfs{Il d\'{e}fine}%
  % Defines
  % Cannot use the accent here: \def\@nwlangdepnvd{jamais d\'{e}fini}%
  \def\@nwlangdepnvd{jamais defini}%
  % never defined
}
\let\nwopt@french\nwopt@frenchb
\def\nwopt@german{%
  \def\@nwlangdepdef{Diese Definition wird fortgesetzt}%
  % This definition is continued
  \def\@nwlangdepcud{Dieser Code wird benutzt}%
  % This code is used
  \def\@nwlangdeprtc{Hauptteil (nicht in diesem Dokument benutzt)}%
  % Root chunk (not used in this document)
  \def\@nwlangdepcwf{Dieser Code schreibt man zum File}%
  % This code is written to file
  \def\@nwlangdepchk{Teil}%
  % chunk
  \def\@nwlangdepchks{Teils}%
  % chunks
  \def\@nwlangdepin{im}%
  % in
  \def\@nwlangdepand{und}%
  % and
  \def\@nwlangdepuss{Benutztt}%
  % Uses
  \def\@nwlangdepusd{benutzt}%
  % used
  \def\@nwlangdepnvu{nicht benutzt}%
  % never used
  \def\@nwlangdepdfs{Definiert}%
  % Defines
  \def\@nwlangdepnvd{nicht definiert}%
  % never defined
}
\let\nwopt@ngerman\nwopt@german
\ifx\languagename\undefined % default is English
  \noweboptions{english}
\else
  \@ifundefined{nwopt@\languagename}
     {\noweboptions{english}}
     {\expandafter\noweboptions\expandafter{\languagename}}
\fi
% Final names for the system and its components were in doubt so
% Language is used throughout the book to specify what the system is named.
\newcommand{\Language}{AXIOM}

% HyperName was used to specify the name of the browser
\newcommand{\HyperName}{HyperDoc}

% This is nothing more than inline math mode in Tex but has additional
% meaning within the browser.
\newcommand{\spad}[1]{${#1}$}

% This is a way to say 8th, 100th, etc.
\newcommand{\eth}[1]{{#1}-th}

% spadcommands are the actual text that you type at the axiom prompt
\newcommand{\spadcommand}[1]%
{\begin{flushleft}{\tt #1}\end{flushleft}\vskip .1cm }

% returnType is the type signature returned by the axiom interpreter
\newcommand{\returnType}[1]%
{\begin{flushright}{\tt #1}\end{flushright}\vskip .1cm}

% The book begins with some introductory material that is not really
% listed as a chapter. This creates a header similar to \chapter.
\newcommand{\pseudoChapter}[1]%
{\vskip .5in \noindent {\Huge{\bf #1}}\vskip .5in}

% The book begins with some introductory material that is not really
% listed as a section. This creates a header similar to \section.
\newcommand{\pseudoSection}[1]%
{\vskip .25in \noindent {\large{\bf #1}}\vskip .25in}

% These are special markers within the text for Hypertex keywords
% They have no particular meaning in the book form.
\newcommand{\spadfun}[1]{{\it #1}}
\newcommand{\spadgloss}[1]{{\it #1}}
\newcommand{\spadkey}[1]{\index{#1 @\begingroup \string\tt{} #1 \endgroup}}

% spadtype records the domain in the index
\newcommand{\spadtype}[1]{{\bf #1}\index{#1 @\begingroup \string\bf{} #1 \endgroup}}

% This is used to create a caption on an included image
\newcommand{\simpleCaption}[1]{\def\thefigure{\@arabic\c@figure}\caption{#1}}

% This is the name of the ``glossy'' pages in the physical book.
\newcommand{\Gallery}{\Language{} Images}

% spadofFrom records the operation in the index and the domain in the index
\newcommand{\spadopFrom}[2]{\index{library!operations!#1 @\begingroup \string\tt{} #1 \endgroup}\index{#2}``{\tt #1}''}
\newcommand\AXIOM{\vskip\parindent\indent{\bf AXIOM}\vskip\parindent\noindent\ignorespaces}
\newcommand\maxima{\vskip\parindent\noindent{\bf MAXIMA}\vskip\parindent\noindent\ignorespaces}
\newcommand\yacas{\vskip\parindent\noindent{\bf YACAS}\vskip\parindent\noindent\ignorespaces}
@
\eject
\begin{thebibliography}{99}
\bibitem{1} nothing
\end{thebibliography}
\end{document}