* Jatha - a Common LISP-compatible LISP library in Java.

* Copyright (C) 1997-2005 Micheal Scott Hewett

*

* This library is free software; you can redistribute it and/or

* modify it under the terms of the GNU Lesser General Public

* License as published by the Free Software Foundation; either

* version 2.1 of the License, or (at your option) any later version.

*

* This library is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

* Lesser General Public License for more details.

*

* You should have received a copy of the GNU Lesser General Public

* License along with this library; if not, write to the Free Software

* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

*

*

* For further information, please contact Micheal Hewett at

*   hewett@cs.stanford.edu

*

*/

* Jatha is an Applet supporting a subset of Common LISP,

* with extensions to support some features of Java

* such as networking and graphical interfaces.

* <p>

* Usage: java org.jatha.Jatha [-nodisplay] [-help]

* </p>

* @author  Micheal S. Hewett    hewett@cs.stanford.edu

*

*/

  private static boolean DEBUG = false;

  // 1.2a 14 May 1997

  // 1.3a 03 Oct 2002

  // 1.3b 01 January 2003

  private String VERSION_NAME     = "Jatha";

  private int    VERSION_MAJOR    = 2;

  private int    VERSION_MINOR    = 8;

  private int    VERSION_MICRO    = 0;

  private String VERSION_TYPE     = "";

  private String VERSION_DATE     = "25 Apr 2007";

  private String VERSION_URL      = "http://jatha.sourceforge.net/";

   // @author  Micheal S. Hewett    hewett@cs.stanford.edu

   // @date    Thu Feb  6 09:26:00 1997

   // @version 1.0

   /**

   * EVAL is a pointer to a LISP evaluator.

   * Used for evaluating LISP expressions in Java code.

   *

   */

  public LispEvaluator EVAL;

  // * @author  Micheal S. Hewett    hewett@cs.stanford.edu

  // * @date    Thu Feb  6 09:26:00 1997

  /**

   * PACKAGE is a pointer to the current package (*package*).

   * Its SYMTAB is always the curent SYMTAB of Jatha.

   *

   * @see org.jatha.dynatype.LispPackage

   */

  public LispPackage   PACKAGE;

  public LispValue     PACKAGE_SYMBOL;  // ptr to *package*

  // @author  Micheal S. Hewett    hewett@cs.stanford.edu

  // @date    Thu Feb  6 09:26:00 1997

  /**

   * SYMTAB is a pointer to the namespace used by LISP.

   * Needed for initialization of the parser.  It is

   * always the SYMTAB of the current PACKAGE;

   *

   * @see org.jatha.dynatype.LispPackage

   */

    public SymbolTable   SYMTAB; //TODO: fix so that this is ALWAYS correct, in some way.

  // @author  Micheal S. Hewett    hewett@cs.stanford.edu

  // @date    Thu Feb  6 09:26:00 1997

  /**

   * MACHINE is a pointer to the primary SECD abstract machine

   * used for executing compiled LISP code.

   *

   * @see org.jatha.machine.SECDMachine

   */

  public SECDMachine   MACHINE;

  // @author  Micheal S. Hewett    hewett@cs.stanford.edu

  // @date    Thu Feb  6 09:26:00 1997

  /**

   * COMPILER is a pointer to a LispCompiler.

   *

   * @see org.jatha.compile.LispCompiler

   */

  public LispCompiler  COMPILER;

  // @author  Micheal S. Hewett    hewett@cs.stanford.edu

  // @date    Thu Feb  6 09:26:00 1997

  /**

   * SYSTEM_INFO is a pointer to the Runtime object

   * for this Applet.

   *

   * @see java.lang.Runtime

   */

  public final Runtime  SYSTEM_INFO  = Runtime.getRuntime();

  // @author  Micheal S. Hewett    hewett@cs.stanford.edu

  // @date    Thu Feb  6 09:26:00 1997

  /**

   * PARSER is a pointer to the main parser

   * used by Jatha.  Others may be instantiated to

   * deal with String or Stream input.

   *

   * @see org.jatha.read.LispParser

   *

   */

  public LispParser    PARSER;

  // @author  Micheal S. Hewett    hewett@cs.stanford.edu

  // @date    Thu Feb  6 09:26:00 1997

  /**

   * Listener is a pointer to the I/O Window.

   *

   * @see org.jatha.display.Listener

   */

  public Listener      LISTENER;

  // @author  Micheal S. Hewett    hewett@cs.stanford.edu

  // @date    Thu Feb  6 09:26:00 1997

  /**

   * JATHA is a pointer to the Applet.

   */

  public static int            APROPOS_TAB = 30;

  // The '.' to represent a cons cell.

  public LispValue DOT;

  // The list/symbol NIL.

  public LispConsOrNil NIL;

  // These are used in macros

  public LispValue QUOTE;

  public LispValue BACKQUOTE;

  public LispValue LIST;

  public LispValue APPEND;

  public LispValue CONS;

  public LispValue COMMA_FN;

  public LispValue COMMA_ATSIGN_FN;

  public LispValue COMMA_DOT_FN;

  public LispValue COLON;

  public LispValue NEWLINE;

  public LispValue SPACE;

  // Used in CONCATENATE

  public LispValue STRING;

  // Used in the compiler

  public LispValue ZERO;

  public LispValue ONE;

  public LispValue TWO;

  // Math constants

  public LispValue PI;

  public LispValue E;

  // The symbol T

  public LispValue T;

  // Types

  public LispValue ARRAY_TYPE;

  public LispValue ATOM_TYPE;

  public LispValue BIGNUM_TYPE;

  public LispValue BOOLEAN_TYPE;

  public LispValue CHARACTER_TYPE;

  public LispValue COMPLEX_TYPE;

  public LispValue CONS_TYPE;

  public LispValue DOUBLE_FLOAT_TYPE;

  public LispValue FLOAT_TYPE;

  public LispValue FUNCTION_TYPE;

  public LispValue HASHTABLE_TYPE;

  public LispValue INTEGER_TYPE;

  public LispValue MACRO_TYPE;

  public LispValue NULL_TYPE;

  public LispValue NUMBER_TYPE;

  public LispValue PACKAGE_TYPE;

  public LispValue PATHNAME_TYPE;

  public LispValue REAL_TYPE;

  public LispValue STREAM_TYPE;

  public LispValue STRING_TYPE;

  public LispValue SYMBOL_TYPE;

  public LispValue VECTOR_TYPE;

  /**

   * This is used in apropos_print on StandardLispSymbol.

   * Not really for public consumption.

   * @param object a LispSymbol

   * @return true if it is equal to ARRAY_TYPE, ATOM_TYPE, etc.

   */

  public boolean isType(LispValue object)

  {

    return ((object == ARRAY_TYPE)

            || (object == ATOM_TYPE)

            || (object == BIGNUM_TYPE)

            || (object == BOOLEAN_TYPE)

            || (object == CHARACTER_TYPE)

            || (object == COMPLEX_TYPE)

            || (object == CONS_TYPE)

            || (object == DOUBLE_FLOAT_TYPE)

            || (object == FLOAT_TYPE)

            || (object == FUNCTION_TYPE)

            || (object == HASHTABLE_TYPE)

            || (object == INTEGER_TYPE)

            || (object == MACRO_TYPE)

            || (object == NUMBER_TYPE)

            || (object == NULL_TYPE)

            || (object == PACKAGE_TYPE)

            || (object == PATHNAME_TYPE)

            || (object == REAL_TYPE)

            || (object == STREAM_TYPE)

            || (object == STRING_TYPE)

            || (object == SYMBOL_TYPE)

            || (object == VECTOR_TYPE)

            );

  }

    private LispPackage f_systemPackage = null;

    private LispPackage f_keywordPackage = null;

  private void initializeConstants()

  {

    try

    {

      if (SYMTAB == null)

      {

        System.err.println("In LispValue, symtab is null!");

        throw new Exception("In LispValue init, symtab is null!");

      }

    } catch (Exception e)

    {

      System.out.println(e);

      e.printStackTrace();

    }

    f_systemPackage = new StandardLispPackage(this, makeString("SYSTEM"));

    f_keywordPackage = new StandardLispPackage(this, makeString("KEYWORD"));

    DOT = new StandardLispSymbol(this, ".");

    EVAL.intern(makeString("DOT"), DOT, f_systemPackage);

    NIL = new StandardLispNIL(this, "NIL");

    EVAL.intern(makeString("NIL"), NIL, f_systemPackage);

    QUOTE = new StandardLispSymbol(this, "QUOTE");

    EVAL.intern(makeString("QUOTE"), QUOTE, f_systemPackage);

    BACKQUOTE = new StandardLispSymbol(this, "BACKQUOTE");

    EVAL.intern(makeString("BACKQUOTE"), BACKQUOTE, f_systemPackage);

    LIST = new StandardLispSymbol(this, "LIST");

    EVAL.intern(makeString("LIST"), LIST, f_systemPackage);

    APPEND = new StandardLispSymbol(this, "APPEND");

    EVAL.intern(makeString("APPEND"), APPEND, f_systemPackage);

    CONS = new StandardLispSymbol(this, "CONS");

    EVAL.intern(makeString("CONS"), CONS, f_systemPackage);

    COMMA_FN        = new StandardLispKeyword(this, "COMMA");

    EVAL.intern(makeString("COMMA"), COMMA_FN, f_keywordPackage);

    COMMA_ATSIGN_FN = new StandardLispKeyword(this, "COMMA-ATSIGN");

    EVAL.intern(makeString("COMMA-ATSIGN"), COMMA_ATSIGN_FN, f_keywordPackage);

    COMMA_DOT_FN    = new StandardLispKeyword(this, "COMMA-DOT");

    EVAL.intern(makeString("COMMA-DOT"), COMMA_DOT_FN, f_keywordPackage);

    T = new StandardLispConstant(this, "T");

    EVAL.intern(makeString("T"), T, f_systemPackage);

    T.setf_symbol_value(T);

    ZERO = new StandardLispInteger(this, 0);

    ONE  = new StandardLispInteger(this, 1);

    TWO  = new StandardLispInteger(this, 2);

    E    = new StandardLispReal(this, StrictMath.E);

    PI   = new StandardLispReal(this, StrictMath.PI);

    COLON   = new StandardLispCharacter(this, ':');

    NEWLINE = new StandardLispCharacter(this, '\n');

    SPACE   = new StandardLispCharacter(this, ' ');

    STRING = new StandardLispSymbol(this, "STRING");

    EVAL.intern(makeString("STRING"), STRING, f_systemPackage);

    // Lisp data types  --------------------------------------------

    ARRAY_TYPE = new StandardLispSymbol(this, "ARRAY");

    EVAL.intern(makeString("ARRAY"), ARRAY_TYPE, f_systemPackage);

    ATOM_TYPE = new StandardLispSymbol(this, "ATOM");

    EVAL.intern(makeString("ATOM"), ATOM_TYPE, f_systemPackage);

    BIGNUM_TYPE = new StandardLispSymbol(this, "BIGNUM");

    EVAL.intern(makeString("BIGNUM"), BIGNUM_TYPE, f_systemPackage);

    BOOLEAN_TYPE = new StandardLispSymbol(this, "BOOLEAN");

    EVAL.intern(makeString("BOOLEAN"), BOOLEAN_TYPE, f_systemPackage);

    CHARACTER_TYPE = new StandardLispSymbol(this, "CHARACTER");

    EVAL.intern(makeString("CHARACTER"), CHARACTER_TYPE, f_systemPackage);

    COMPLEX_TYPE = new StandardLispSymbol(this, "COMPLEX");

    EVAL.intern(makeString("COMPLEX"), COMPLEX_TYPE, f_systemPackage);

    CONS_TYPE = new StandardLispSymbol(this, "CONS");

    EVAL.intern(makeString("CONS"), CONS_TYPE, f_systemPackage);

    DOUBLE_FLOAT_TYPE = new StandardLispSymbol(this, "DOUBLE-FLOAT");

    EVAL.intern(makeString("DOUBLE-FLOAT"), DOUBLE_FLOAT_TYPE, f_systemPackage);

    FLOAT_TYPE = new StandardLispSymbol(this, "FLOAT");

    EVAL.intern(makeString("FLOAT"), FLOAT_TYPE, f_systemPackage);

    FUNCTION_TYPE = new StandardLispSymbol(this, "FUNCTION");

    EVAL.intern(makeString("FUNCTION"), FUNCTION_TYPE, f_systemPackage);

    HASHTABLE_TYPE = new StandardLispSymbol(this, "HASH-TABLE");

    EVAL.intern(makeString( "TABLE"), HASHTABLE_TYPE, f_systemPackage);

    INTEGER_TYPE = new StandardLispSymbol(this, "INTEGER");

    EVAL.intern(makeString("INTEGER"), INTEGER_TYPE, f_systemPackage);

    NULL_TYPE = new StandardLispSymbol(this, "NULL");

    EVAL.intern(makeString("NULL"), NULL_TYPE, f_systemPackage);

    MACRO_TYPE = new StandardLispSymbol(this, "MACRO");

    EVAL.intern(makeString("MACRO"), NULL_TYPE, f_systemPackage);

    NUMBER_TYPE = new StandardLispSymbol(this, "NUMBER");

    EVAL.intern(makeString("NUMBER"), NUMBER_TYPE, f_systemPackage);

    PACKAGE_TYPE = new StandardLispSymbol(this, "PACKAGE");

    EVAL.intern(makeString("PACKAGE"), PACKAGE_TYPE, f_systemPackage);

    PATHNAME_TYPE = new StandardLispSymbol(this, "PATHNAME");

    EVAL.intern(makeString("PATHNAME"), PATHNAME_TYPE, f_systemPackage);

    REAL_TYPE = new StandardLispSymbol(this, "REAL");

    EVAL.intern(makeString("REAL"), REAL_TYPE, f_systemPackage);

    STREAM_TYPE = new StandardLispSymbol(this, "STREAM");

    EVAL.intern(makeString("STREAM"), STREAM_TYPE, f_systemPackage);

    STRING_TYPE = new StandardLispSymbol(this, "STRING");

    EVAL.intern(makeString("STRING"), STRING_TYPE, f_systemPackage);

    SYMBOL_TYPE = new StandardLispSymbol(this, "SYMBOL");

    EVAL.intern(makeString("SYMBOL"), SYMBOL_TYPE, f_systemPackage);

    VECTOR_TYPE = new StandardLispSymbol(this, "VECTOR");

    EVAL.intern(makeString("VECTOR"), VECTOR_TYPE, f_systemPackage);

  }

  // Re-initializes the above symbols, after a PACKAGE is available.

  public void initConstants2()

  {

    if (SYMTAB == null)

    {

      System.err.println("In LispValue.init(), symtab is null!");

      System.exit(1);

    }

    if (PACKAGE == null)

    {

      System.err.println("In LispValue.init(), package is null!");

      System.exit(1);

    }

    f_systemPackage.export(DOT);

    f_systemPackage.export(NIL);

    f_systemPackage.export(QUOTE);

    f_systemPackage.export(BACKQUOTE);

    f_systemPackage.export(T);

    f_systemPackage.export(LIST);

    f_systemPackage.export(APPEND);

    f_systemPackage.export(CONS);

    f_keywordPackage.export(COMMA_FN);

    f_keywordPackage.export(COMMA_ATSIGN_FN);

    f_keywordPackage.export(COMMA_DOT_FN);

    f_systemPackage.export(ARRAY_TYPE);

    f_systemPackage.export(ATOM_TYPE);

    f_systemPackage.export(BIGNUM_TYPE);

    f_systemPackage.export(BOOLEAN_TYPE);

    f_systemPackage.export(CHARACTER_TYPE);

    f_systemPackage.export(COMPLEX_TYPE);

    f_systemPackage.export(CONS_TYPE);

    f_systemPackage.export(DOUBLE_FLOAT_TYPE);

    f_systemPackage.export(FLOAT_TYPE);

    f_systemPackage.export(FUNCTION_TYPE);

    f_systemPackage.export(HASHTABLE_TYPE);

    f_systemPackage.export(INTEGER_TYPE);

    f_systemPackage.export(MACRO_TYPE);

    f_systemPackage.export(NULL_TYPE);

    f_systemPackage.export(NUMBER_TYPE);

    f_systemPackage.export(PACKAGE_TYPE);

    f_systemPackage.export(PATHNAME_TYPE);

    f_systemPackage.export(REAL_TYPE);

    f_systemPackage.export(STREAM_TYPE);

    f_systemPackage.export(STRING_TYPE);

    f_systemPackage.export(SYMBOL_TYPE);

    f_systemPackage.export(VECTOR_TYPE);

  }

  LispValue prompt, userPrompt;

  LispValue packages = null;

  LispValue STAR, STARSTAR, STARSTARSTAR;

  LispValue MAX_LIST_LENGTH;

  LispValue LOAD_VERBOSE;

  static  long      MAX_LIST_LENGTH_VALUE = 50000;

  boolean useGUI     = true;    // Whether or not to use GUI-based interaction.

  boolean useConsole = false;   // Whether or not to use command-line interaction.

  /**

   * Create a new Jatha that does not use the GUI, does use the console for I/O and does not display help.

   */

  public Jatha()

  {

    this(false, true, false);

  }

  /**

   * Create a new Jatha that optionally uses the GUI, does use the console for I/O and does not display help.

   */

  public Jatha(boolean useGui)

  {

    this(useGui, false, false);

  }

  /**

   * Create a new Jatha that optionally uses the GUI, optionally uses the console for I/O and does not display help.

   */

  public Jatha(boolean useGui, boolean useText)

  {

    this(useGui, useText, false);

  }

  /**

   * Create a new Jatha that optionally uses the GUI, optionally uses the console for I/O and optionally displays help.

   */

  public Jatha(boolean useDisplay, boolean useText, boolean showHelp)

  {

    super();

    try {

      useGUI     = useDisplay;

      useConsole = useText;

      if (showHelp) showHelp();

    } catch (Throwable e) {

      System.err.println("error initializing Jatha: " + e);

    }

  }

  /**

   * Returns the entire version string.

   * @return a string containing the entire description of Algernon.

   */

  public String getVersionString()

  {

    return getVersionName() + " " +

           getVersionMajor() + "." + getVersionMinor() + "." + getVersionMicro() + getVersionType() + ", " +

           getVersionDate() + ", contact: " + getVersionURL()  ;

  }

  /**

   * Returns the program name, e.g. Algernon.

   */

  public String getVersionName()    { return VERSION_NAME;    };

  /**

   * Returns the date of this version as a string: "nn MONTH yyyy".

   */

  public String getVersionDate()    { return VERSION_DATE;    };

  /**

   * Returns a URL where you can find info about Algernon.

   */

  public String getVersionURL() { return VERSION_URL; };

  /**

   * Returns the type of release: "production", "beta" or "alpha".

   */

  public String getVersionType()    { return VERSION_TYPE;    };

  /**

   * Returns the major version number, that is, 1 in version 1.2.3.

   */

  public int getVersionMajor()      { return VERSION_MAJOR;   };

  /**

   * Returns the minor version number, that is, 2 in version 1.2.3.

   */

  public int getVersionMinor()      { return VERSION_MINOR;   };

  /**

   * Returns the micro version number, that is, 3 in version 1.2.3.

   */

  public int getVersionMicro()      { return VERSION_MICRO;   };

  void showHelp()

  {

    System.out.println("\njava org.jatha.Jatha  [-help] [-nodisplay]\n");

    System.out.println("  This is a small Common LISP compatible LISP environment.");

    System.out.println("  Use the  -nodisplay  option to suppress GUI features.");

    System.out.println("");

    System.exit(0);

  }

  /**

   * Returns the value of *MAX-LIST-LENGTH*.

   * This value is only used to prevent runaway list processing.

   */

  public LispInteger getMaxListLength()

  {

    return (LispInteger)(MAX_LIST_LENGTH.symbol_value());

  }

  /**

   * Sets the value of *MAX-LIST-LENGTH*.

   * This vlaue is only used to prevent runaway list processing.

   */

  public void setMaxListLength(long newLength)

  {

    MAX_LIST_LENGTH.setf_symbol_value(new StandardLispInteger(this, newLength));

  }

  /**

   * Sets the value of *MAX-LIST-LENGTH*.

   * This vlaue is only used to prevent runaway list processing.

   */

  public  void setMaxListLength(LispNumber newLength)

  {

    MAX_LIST_LENGTH.setf_symbol_value(new StandardLispInteger(this, (long)(newLength.getDoubleValue())));

  }

  /**

   * With no arguments, creates a Jatha LISP Listener window

   * and enables the Console I/O stream.  The user can optionally

   * specify -nodisplay to use the console for input.

   *

   * @param args

   */

  public static void main(String args[])

  {

    Jatha   applet;

    boolean useDisplay = true;

    boolean help       = false;

    boolean illegalArg = false;

    for (int i=0; i < args.length; i++)

      if (args[i].equalsIgnoreCase("-nodisplay"))

        useDisplay = false;

      else if (args[i].equalsIgnoreCase("-help"))

        help = true;

      else

      {

        System.out.println("Jatha: unknown argument: " + args[i]);

        illegalArg = true;

      }

    if (illegalArg)

      System.exit(1);

    // Okay to proceed.  Make a text window if we are to use a GUI.

    applet = new Jatha(useDisplay, true, help);

    applet.init();

    applet.start();

  }

  public void init()

  {

    // EVAL must be before SYMTAB.

    EVAL    = new LispEvaluator(this);

    SYMTAB  = new SymbolTable(this);

    initializeConstants();

    // Have to be careful about initializing this...

    f_systemPackage.setNicknames(makeList(makeString("SYS")));

    f_keywordPackage.setNicknames(makeList(makeString("")));

    PACKAGE = new StandardLispPackage(this, makeString("COMMON-LISP-USER"),makeList(makeString("CL-USER"),makeString("USER")),NIL,SYMTAB);

    final LispPackage clPackage = new StandardLispPackage(this, makeString("COMMON-LISP"),makeList(makeString("CL")));

    PACKAGE.setUses(makeList(((StandardLispPackage)clPackage).getName(),((StandardLispPackage)f_systemPackage).getName()));

    ((StandardLispPackage)clPackage).setUses(makeList(((StandardLispPackage)f_systemPackage).getName()));

    ((StandardLispPackage)f_keywordPackage).setUses(NIL);

    ((StandardLispPackage)f_systemPackage).setUses(NIL);

    // Create the rest of the packages

    packages = makeList(f_systemPackage,clPackage,f_keywordPackage,PACKAGE);

    initConstants2();

    COMPILER     = new LispCompiler(this);

    MACHINE      = new SECDMachine(this);

    PARSER       = new LispParser(this, new InputStreamReader(System.in));

    // Need to allow *TOP-LEVEL-PROMPT* to change this.

    prompt = makeString("Jatha> ");

    STAR         = EVAL.intern("*",f_systemPackage);

    STARSTAR     = EVAL.intern("**",f_systemPackage);

    STARSTARSTAR = EVAL.intern("***",f_systemPackage);

    STAR.setf_symbol_value(NIL);

    STARSTAR.setf_symbol_value(NIL);

    STARSTARSTAR.setf_symbol_value(NIL);

    MAX_LIST_LENGTH = EVAL.intern("*MAX-LIST-LENGTH*",f_systemPackage);

    MAX_LIST_LENGTH.setf_symbol_value(new StandardLispInteger(this, MAX_LIST_LENGTH_VALUE));

    f_systemPackage.export(STAR);

    f_systemPackage.export(STARSTAR);

    f_systemPackage.export(STARSTARSTAR);

    f_systemPackage.export(MAX_LIST_LENGTH);

    // Defines global variables, etc.  Should only be called once.

    EVAL.init();

    PACKAGE_SYMBOL = EVAL.intern("*PACKAGE*");

    PACKAGE_SYMBOL.set_special(true);    // 13 Dec 2005 (mh)

    LOAD_VERBOSE = EVAL.intern("*LOAD-VERBOSE*");

    LOAD_VERBOSE.setf_symbol_value(NIL);

    // Registers LISP primitive functions.  Should only be called once.

    COMPILER.init();

    // Load any files in the /init directory  (mh) 11 May 2005

    loadInitFiles();

    if (useGUI)

      LISTENER  = new Listener(this, "Jatha LISP Listener", PACKAGE_SYMBOL.symbol_value().toString() + "> ");

  }

  public void start()

  {

    // javaTrace(true);   // This doesn't seem to do anything...

      if(useConsole) {

          System.err.println(getVersionString());

      }

    if (!useGUI)

      if (useConsole)

        readEvalPrintLoop();

    // PARSER.simple_parser_test();

    // PARSER.test_parser_loop();

    // TestInterpreter();

    // free();

    // gc();

  }

  /**

   * Loads files in the /init directory in Jatha's jar file.

   * They must be named "01.lisp", "02.lisp", etc.  Numbers must

   * be sequential starting from "01".

   */

  protected void loadInitFiles()

  {

    NumberFormat fileNF = new DecimalFormat("00");

    String filePrefix = "init/";

    String fileSuffix = ".lisp";

    if(useConsole) {

        System.out.println("Loading init files.");

    }

    int fileNumber  = 1;

    int fileCounter = 0;

    while (true)

    {

      String baseFilename = fileNF.format(fileNumber++) + fileSuffix;

      String filename = filePrefix + baseFilename;

      try {

        LispValue result = loadFromJar(filename);

        if (result == T)

        {

            if(useConsole) {

                System.out.println("  loaded " + baseFilename);

            }

          fileCounter++;

        }

        else if (result == NIL)  // No such file

          break;

        else

        {

            if(useConsole) {

                System.err.println("  error loading " + filename + ", " + result);

            }

        }

      } catch (Exception e) {

        System.err.println("Jatha.loadInitFiles: " + e.getMessage());

        break;

      }

    }

    if(useConsole) {

        System.out.println("Loaded " + fileCounter + " file(s).");

    }

  }

  /**

   * Loads a file from the container holding this class.

   * The container is normally a JAR file.

   * Uses getResource to create a stream, then calls load(Reader).

   * @param filename The file to be loaded, without an initial "/".  Will be converted to a Java String using toStringSimple.

   * @param jarFile The URL of the jar file from which to load the resource.

   * @return T if the file was successfully loaded, NIL if the file doesn't exist and a String containing an error message otherwise.

   */

  public LispValue loadFromJar(LispValue filename, LispValue jarFile)

  {

    return loadFromJar(filename.toStringSimple(), jarFile.toStringSimple());

  }

  /**

   * Loads a file from the container holding this class.

   * The container is normally a JAR file.

   * Uses getResource to create a stream, then calls load(Reader).

   * @param filename The file to be loaded, WITHOUT an initial "/".

   * @param jarFileString The name of the jar file to load the file from.

   * @return T if the file was successfully loaded, NIL if the file doesn't exist and a String containing an error message otherwise.

   */

  public LispValue loadFromJar(String filename, String jarFileString)

  {

    if (DEBUG)

      System.out.println("  Jatha.loadFromJar: looking for " +

                         filename + " in " + jarFileString);

    try {

      JarFile jarFile = new JarFile(jarFileString);

      JarEntry je = jarFile.getJarEntry(filename);

      if (je == null)

        return NIL;

      LispValue result = load(new InputStreamReader(jarFile.getInputStream(je)));

      jarFile.close();

      return result;

    } catch (IOException ioe) {

      return makeString(ioe.getMessage());

    } catch (SecurityException se) {

      return makeString(se.getMessage());

    } catch (CompilerException ce) {

      return makeString(ce.getMessage());

    } catch (Exception e) {

      return makeString(e.getMessage());

    }

  }

  /**

   * Loads a file from the container holding this class.

   * The container is normally a JAR file.

   * Uses getResource to create a stream, then calls load(Reader).

   * @param filename The file to be loaded, without an initial "/".  Will be converted to a Java String using toStringSimple.

   * @return T if the file was successfully loaded, NIL if the file doesn't exist and a String containing an error message otherwise.

   */

  public LispValue loadFromJar(LispValue filename)

  {

    return loadFromJar(filename.toStringSimple());

  }

  /**

   * Loads a file from the container holding this class.

   * The container is normally a JAR file.

   * Uses getResource to create a stream, then calls load(Reader).

   * @param filename The file to be loaded, WITHOUT an initial "/".

   * @return T if the file was successfully loaded, NIL if the file doesn't exist and a String containing an error message otherwise.

   */

  public LispValue loadFromJar(String filename)

  {

    if (DEBUG)

      System.out.println("  Jatha.loadFromJar: looking for " + filename + " in the jar file.");

    InputStream resourceStream =

        getClass().getClassLoader().getResourceAsStream(filename);

    if (resourceStream == null)

      return NIL;

    else

      try {

        load(new InputStreamReader(resourceStream));

        return T;

      } catch (Exception e) {

        return makeString(e.getMessage());

      }

  }

  /**

   * Evaluates a LISP expression in a Java string, such as "(* 5 7)".

   * To evaluate an expression with variables, there are several options:

   * <pre>

   *   eval("(let ((x 7)) (* 5 x)))");

   *   eval("(progn (setq x 7) (* 5 x))");

   * </pre>

   * Or use separate eval statements:

   * <pre>

   *   eval("setq x 7");

   *   eval("(* 5 x)");

   * </pre>

   */

  public LispValue eval(String expr)

  {

    LispValue input = NIL;

    // READ

    try {

      PARSER.setInputString(expr);

      input = PARSER.parse();

      return eval(input);

    } catch (EOFException e) {

      System.err.println("Incomplete input.");

      return NIL;

    }

  }

  /**

   * Standard LISP eval function.

   * @param inValue a parsed LISP expression, such as the output from Jatha.parse().

   * @see #parse(String)

   */

  public LispValue eval(LispValue inValue)

  {

    return eval(inValue, NIL);

  }

  /**

   * Standard LISP eval function.

   * @param inValue a parsed LISp expression such as the output from Jatha.parse()

   * @param vars a nested list of global variables and values, such as (((a . 3) (b . 5)) ((c . 10)))

   * @see #parse(String)

  */

  public LispValue eval(LispValue inValue, final LispValue vars)

  {

    LispValue code, value;

    final LispValue varNames = parseVarNames(vars);

    final LispValue varValues = parseVarValues(vars);

    try {

      // compile

      code  = COMPILER.compile(MACHINE, inValue, varNames);

      // eval

      value = MACHINE.Execute(code, varValues);

    } catch (LispUndefinedFunctionException ufe) {

      System.err.println("ERROR: " + ufe.getMessage());

      return makeString(ufe.getMessage());

    } catch (CompilerException ce) {

      System.err.println("ERROR: " + ce);

      return makeString(ce.toString());

    } catch (LispException le) {

      System.err.println("ERROR: " + le.getMessage());

      le.printStackTrace();

      return makeString(le.getMessage());

    } catch (Exception e) {

      System.err.println("Unknown error: " + e.getMessage());

      return makeString(e.getMessage());

    }

    // useful variable management

    STARSTARSTAR.setf_symbol_value(STARSTAR.symbol_value());

    STARSTAR.setf_symbol_value(STAR.symbol_value());

    STAR.setf_symbol_value(value);

    return value;

  }

  /**

   * Expects a list with this format (((A 13) (C 7))((X "Zeta"))) and returns a list with this format ((A C)(X))

   */

  private LispValue parseVarNames(final LispValue vars) {

    LispValue outp = NIL;

    if (vars.basic_null())

      return outp;

    for(final Iterator iter = vars.iterator();iter.hasNext();) {

      final LispValue current = (LispValue)iter.next();

      LispValue inner = NIL;

      for(final Iterator iter2 = current.iterator();iter2.hasNext();) {

        final LispValue currInt = (LispValue)iter2.next();

        inner = makeCons(currInt.car(),inner);

      }

      outp = makeCons(inner.nreverse(),outp);

    }

    return outp.nreverse();

  }

  /**

   * Not sure why parseVarNames has such a complicated structure.

   * This one expects variables of the form ((A . 7) (B . 13) (C . (foo)))

   * the CAR of each pair is the variable and the CDR of each pair is the value.

   */

  private LispValue parseVarNames_new(final LispValue vars)

  {

    LispValue outp = NIL;

    if (vars.basic_null())

      return outp;

    for (final Iterator iter = vars.iterator(); iter.hasNext();)

    {

      final LispValue current = (LispValue)iter.next();

      outp = makeCons(current.car(), outp);

    }

    return outp.nreverse();

  }

  /**

   * Not sure why parseVarNames has such a complicated structure.

   * This one expects variables of the form ((A . 7) (B . 13) (C . (foo)))

   * the CAR of each pair is the variable and the CDR of each pair is the value.

   */

  private LispValue parseVarValues_new(final LispValue vars)

  {

    LispValue outp = NIL;

    if (vars.basic_null())

      return outp;

    for (final Iterator iter = vars.iterator(); iter.hasNext();)

    {

      final LispValue current = (LispValue)iter.next();

      outp = makeCons(current.cdr(), outp);

    }

    return outp.nreverse();

  }

  /**

   * Expects a list with this format (((A 13) (C 7))((X "Zeta"))) and returns a list with this format ((13 7)("Zeta"))

   */

  private LispValue parseVarValues(final LispValue vars) {

    LispValue outp = NIL;

    if (vars.basic_null())

      return outp;

    for(final Iterator iter = vars.iterator();iter.hasNext();) {

      final LispValue current = (LispValue)iter.next();

      LispValue inner = NIL;

      for(final Iterator iter2 = current.iterator();iter2.hasNext();) {

        final LispValue currInt = (LispValue)iter2.next();

        inner = makeCons(currInt.cdr(),inner);

      }

      outp = makeCons(inner.nreverse(),outp);

    }

    return outp.nreverse();

  }

  void readEvalPrintLoop()

  {

    LispValue input, code, value, prompt;

    LispValue STAR, STARSTAR, STARSTARSTAR;

    boolean   validInput;

    LispValue oldPackageSymbolValue = PACKAGE_SYMBOL.symbol_value();

    // Need to allow *TOP-LEVEL-PROMPT* to change this.

    prompt = makeString("Jatha " + PACKAGE_SYMBOL.symbol_value().toString() + "> ");

    STAR         = EVAL.intern("*");

    STARSTAR     = EVAL.intern("**");

    STARSTARSTAR = EVAL.intern("***");

    STAR.setf_symbol_value(NIL);

    STARSTAR.setf_symbol_value(NIL);

    STARSTARSTAR.setf_symbol_value(NIL);

    System.out.println("Run (EXIT) to stop.");

    input = NIL;

    while (true)

    {

      if (oldPackageSymbolValue != PACKAGE_SYMBOL.symbol_value())

      {

        prompt = makeString("Jatha " + PACKAGE_SYMBOL.symbol_value().toString() + "> ");

        oldPackageSymbolValue = PACKAGE_SYMBOL.symbol_value();

      }

      System.out.println();

      prompt.princ();

      System.out.flush();

      // READ

      validInput = true;

      try { input = PARSER.parse(); }

      catch (EOFException e) {

        validInput = false;

        System.err.println("Incomplete input.");

      }

      if (validInput)

      {

        try {

          code  = COMPILER.compile(MACHINE, input, NIL);  // No globals for now

        } catch (Exception e) {

          System.out.println("Unable to compile " + input + "\n  " + e);

          continue;

        }

        // EVAL

        try