source: branches/0.20.x/abcl/src/org/armedbear/lisp/Lisp.java

Last change on this file was 12648, checked in by ehuelsmann, 16 years ago

Add (and use) more wrappers for the lisp ERROR function, using
different return types: ierror returns an int, etc.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 88.6 KB
Line 
1/*
2 * Lisp.java
3 *
4 * Copyright (C) 2002-2007 Peter Graves <peter@armedbear.org>
5 * $Id: Lisp.java 12648 2010-05-02 18:30:47Z ehuelsmann $
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version 2
10 * of the License, or (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
20 *
21 * As a special exception, the copyright holders of this library give you
22 * permission to link this library with independent modules to produce an
23 * executable, regardless of the license terms of these independent
24 * modules, and to copy and distribute the resulting executable under
25 * terms of your choice, provided that you also meet, for each linked
26 * independent module, the terms and conditions of the license of that
27 * module.  An independent module is a module which is not derived from
28 * or based on this library.  If you modify this library, you may extend
29 * this exception to your version of the library, but you are not
30 * obligated to do so.  If you do not wish to do so, delete this
31 * exception statement from your version.
32 */
33
34package org.armedbear.lisp;
35
36import java.io.File;
37import java.io.FileInputStream;
38import java.io.FileNotFoundException;
39import java.io.IOException;
40import java.io.InputStream;
41import java.math.BigInteger;
42import java.net.MalformedURLException;
43import java.net.URL;
44import java.net.URLDecoder;
45import java.util.Hashtable;
46import java.util.zip.ZipEntry;
47import java.util.zip.ZipFile;
48
49public final class Lisp
50{
51  public static final boolean debug = true;
52
53  public static boolean cold = true;
54
55  public static boolean initialized;
56
57  // Packages.
58  public static final Package PACKAGE_CL =
59    Packages.createPackage("COMMON-LISP", 1024);
60  public static final Package PACKAGE_CL_USER =
61    Packages.createPackage("COMMON-LISP-USER", 1024);
62  public static final Package PACKAGE_KEYWORD =
63    Packages.createPackage("KEYWORD", 1024);
64  public static final Package PACKAGE_SYS =
65    Packages.createPackage("SYSTEM");
66  public static final Package PACKAGE_MOP =
67    Packages.createPackage("MOP");
68  public static final Package PACKAGE_TPL =
69    Packages.createPackage("TOP-LEVEL");
70  public static final Package PACKAGE_EXT =
71    Packages.createPackage("EXTENSIONS");
72  public static final Package PACKAGE_JVM =
73    Packages.createPackage("JVM");
74  public static final Package PACKAGE_LOOP =
75    Packages.createPackage("LOOP");
76  public static final Package PACKAGE_PROF =
77    Packages.createPackage("PROFILER");
78  public static final Package PACKAGE_JAVA =
79    Packages.createPackage("JAVA");
80  public static final Package PACKAGE_LISP =
81    Packages.createPackage("LISP");
82  public static final Package PACKAGE_THREADS =
83    Packages.createPackage("THREADS");
84  public static final Package PACKAGE_FORMAT =
85    Packages.createPackage("FORMAT");
86  public static final Package PACKAGE_XP =
87    Packages.createPackage("XP");
88  public static final Package PACKAGE_PRECOMPILER =
89    Packages.createPackage("PRECOMPILER");
90  public static final Package PACKAGE_SEQUENCE =
91    Packages.createPackage("SEQUENCE");
92
93
94  // ### nil
95  public static final LispObject NIL = Nil.NIL;
96
97  // We need NIL before we can call usePackage().
98  static
99  {
100    PACKAGE_CL.addNickname("CL");
101    PACKAGE_CL_USER.addNickname("CL-USER");
102    PACKAGE_CL_USER.usePackage(PACKAGE_CL);
103    PACKAGE_CL_USER.usePackage(PACKAGE_EXT);
104    PACKAGE_CL_USER.usePackage(PACKAGE_JAVA);
105    PACKAGE_SYS.addNickname("SYS");
106    PACKAGE_SYS.usePackage(PACKAGE_CL);
107    PACKAGE_SYS.usePackage(PACKAGE_EXT);
108    PACKAGE_MOP.usePackage(PACKAGE_CL);
109    PACKAGE_MOP.usePackage(PACKAGE_EXT);
110    PACKAGE_MOP.usePackage(PACKAGE_SYS);
111    PACKAGE_TPL.addNickname("TPL");
112    PACKAGE_TPL.usePackage(PACKAGE_CL);
113    PACKAGE_TPL.usePackage(PACKAGE_EXT);
114    PACKAGE_EXT.addNickname("EXT");
115    PACKAGE_EXT.usePackage(PACKAGE_CL);
116    PACKAGE_EXT.usePackage(PACKAGE_THREADS);
117    PACKAGE_JVM.usePackage(PACKAGE_CL);
118    PACKAGE_JVM.usePackage(PACKAGE_EXT);
119    PACKAGE_JVM.usePackage(PACKAGE_SYS);
120    PACKAGE_LOOP.usePackage(PACKAGE_CL);
121    PACKAGE_PROF.addNickname("PROF");
122    PACKAGE_PROF.usePackage(PACKAGE_CL);
123    PACKAGE_PROF.usePackage(PACKAGE_EXT);
124    PACKAGE_JAVA.usePackage(PACKAGE_CL);
125    PACKAGE_JAVA.usePackage(PACKAGE_EXT);
126    PACKAGE_LISP.usePackage(PACKAGE_CL);
127    PACKAGE_LISP.usePackage(PACKAGE_EXT);
128    PACKAGE_LISP.usePackage(PACKAGE_SYS);
129    PACKAGE_THREADS.usePackage(PACKAGE_CL);
130    PACKAGE_THREADS.usePackage(PACKAGE_EXT);
131    PACKAGE_THREADS.usePackage(PACKAGE_SYS);
132    PACKAGE_FORMAT.usePackage(PACKAGE_CL);
133    PACKAGE_FORMAT.usePackage(PACKAGE_EXT);
134    PACKAGE_XP.usePackage(PACKAGE_CL);
135    PACKAGE_PRECOMPILER.addNickname("PRE");
136    PACKAGE_PRECOMPILER.usePackage(PACKAGE_CL);
137    PACKAGE_PRECOMPILER.usePackage(PACKAGE_EXT);
138    PACKAGE_PRECOMPILER.usePackage(PACKAGE_SYS);
139    PACKAGE_SEQUENCE.usePackage(PACKAGE_CL);
140  }
141
142  // End-of-file marker.
143  public static final LispObject EOF = new LispObject();
144
145  public static boolean profiling;
146
147  public static boolean sampling;
148
149  public static volatile boolean sampleNow;
150
151  // args must not be null!
152  public static final LispObject funcall(LispObject fun, LispObject[] args,
153                                         LispThread thread)
154
155  {
156    thread._values = null;
157
158    // 26-07-2009: For some reason we cannot "just" call the array version;
159    // it causes an error (Wrong number of arguments for LOOP-FOR-IN)
160    // which is probably a sign of an issue in our design?
161    switch (args.length)
162      {
163      case 0:
164        return thread.execute(fun);
165      case 1:
166        return thread.execute(fun, args[0]);
167      case 2:
168        return thread.execute(fun, args[0], args[1]);
169      case 3:
170        return thread.execute(fun, args[0], args[1], args[2]);
171      case 4:
172        return thread.execute(fun, args[0], args[1], args[2], args[3]);
173      case 5:
174        return thread.execute(fun, args[0], args[1], args[2], args[3],
175                              args[4]);
176      case 6:
177        return thread.execute(fun, args[0], args[1], args[2], args[3],
178                              args[4], args[5]);
179      case 7:
180        return thread.execute(fun, args[0], args[1], args[2], args[3],
181                              args[4], args[5], args[6]);
182      case 8:
183        return thread.execute(fun, args[0], args[1], args[2], args[3],
184                              args[4], args[5], args[6], args[7]);
185      default:
186        return thread.execute(fun, args);
187    }
188  }
189
190  public static final LispObject macroexpand(LispObject form,
191                                             final Environment env,
192                                             final LispThread thread)
193
194  {
195    LispObject expanded = NIL;
196    while (true)
197      {
198        form = macroexpand_1(form, env, thread);
199        LispObject[] values = thread._values;
200        if (values[1] == NIL)
201          {
202            values[1] = expanded;
203            return form;
204          }
205        expanded = T;
206      }
207  }
208
209  public static final LispObject macroexpand_1(final LispObject form,
210                                               final Environment env,
211                                               final LispThread thread)
212
213  {
214    if (form instanceof Cons)
215      {
216        LispObject car = ((Cons)form).car;
217        if (car instanceof Symbol)
218          {
219            LispObject obj = env.lookupFunction(car);
220            if (obj instanceof Autoload)
221              {
222                Autoload autoload = (Autoload) obj;
223                autoload.load();
224                obj = car.getSymbolFunction();
225              }
226            if (obj instanceof SpecialOperator)
227              {
228                obj = get(car, Symbol.MACROEXPAND_MACRO, null);
229                if (obj instanceof Autoload)
230                  {
231                    Autoload autoload = (Autoload) obj;
232                    autoload.load();
233                    obj = get(car, Symbol.MACROEXPAND_MACRO, null);
234                  }
235              }
236            if (obj instanceof MacroObject)
237              {
238                LispObject expander = ((MacroObject)obj).expander;
239                if (profiling)
240                  if (!sampling)
241                    expander.incrementCallCount();
242                LispObject hook =
243                  coerceToFunction(Symbol.MACROEXPAND_HOOK.symbolValue(thread));
244                return thread.setValues(hook.execute(expander, form, env),
245                                        T);
246              }
247          }
248      }
249    else if (form instanceof Symbol)
250      {
251        Symbol symbol = (Symbol) form;
252        LispObject obj = null;
253        if (symbol.isSpecialVariable())
254          obj = thread.lookupSpecial(symbol);
255        else
256          obj = env.lookup(symbol);
257        if (obj == null)
258          obj = symbol.getSymbolValue();
259        if (obj instanceof SymbolMacro)
260          return thread.setValues(((SymbolMacro)obj).getExpansion(), T);
261      }
262    // Not a macro.
263    return thread.setValues(form, NIL);
264  }
265
266  // ### interactive-eval
267  private static final Primitive INTERACTIVE_EVAL =
268    new Primitive("interactive-eval", PACKAGE_SYS, true)
269    {
270      @Override
271      public LispObject execute(LispObject object)
272      {
273        final LispThread thread = LispThread.currentThread();
274        thread.setSpecialVariable(Symbol.MINUS, object);
275        LispObject result;
276        try
277          {
278            result = thread.execute(Symbol.EVAL.getSymbolFunction(), object);
279          }
280        catch (OutOfMemoryError e)
281          {
282            return error(new LispError("Out of memory."));
283          }
284        catch (StackOverflowError e)
285          {
286            thread.setSpecialVariable(_SAVED_BACKTRACE_,
287                                      thread.backtrace(0));
288            return error(new StorageCondition("Stack overflow."));
289          }
290        catch (ControlTransfer c)
291          {
292            throw c;
293          }
294        catch (Throwable t) // ControlTransfer handled above
295          {
296            Debug.trace(t);
297            thread.setSpecialVariable(_SAVED_BACKTRACE_,
298                                      thread.backtrace(0));
299            return error(new LispError("Caught " + t + "."));
300          }
301        Debug.assertTrue(result != null);
302        thread.setSpecialVariable(Symbol.STAR_STAR_STAR,
303                                  thread.safeSymbolValue(Symbol.STAR_STAR));
304        thread.setSpecialVariable(Symbol.STAR_STAR,
305                                  thread.safeSymbolValue(Symbol.STAR));
306        thread.setSpecialVariable(Symbol.STAR, result);
307        thread.setSpecialVariable(Symbol.PLUS_PLUS_PLUS,
308                                  thread.safeSymbolValue(Symbol.PLUS_PLUS));
309        thread.setSpecialVariable(Symbol.PLUS_PLUS,
310                                  thread.safeSymbolValue(Symbol.PLUS));
311        thread.setSpecialVariable(Symbol.PLUS,
312                                  thread.safeSymbolValue(Symbol.MINUS));
313        LispObject[] values = thread._values;
314        thread.setSpecialVariable(Symbol.SLASH_SLASH_SLASH,
315                                  thread.safeSymbolValue(Symbol.SLASH_SLASH));
316        thread.setSpecialVariable(Symbol.SLASH_SLASH,
317                                  thread.safeSymbolValue(Symbol.SLASH));
318        if (values != null)
319          {
320            LispObject slash = NIL;
321            for (int i = values.length; i-- > 0;)
322              slash = new Cons(values[i], slash);
323            thread.setSpecialVariable(Symbol.SLASH, slash);
324          }
325        else
326          thread.setSpecialVariable(Symbol.SLASH, new Cons(result));
327        return result;
328      }
329    };
330
331  private static final void pushJavaStackFrames()
332  {
333      final LispThread thread = LispThread.currentThread();
334      final StackTraceElement[] frames = thread.getJavaStackTrace();
335
336      // Search for last Primitive in the StackTrace; that was the
337      // last entry point from Lisp.
338      int last = frames.length - 1;
339      for (int i = 0; i<= last; i++) {
340          if (frames[i].getClassName().startsWith("org.armedbear.lisp.Primitive"))
341            last = i;
342      }
343      // Do not include the first three frames:
344      //   Thread.getStackTrace, LispThread.getJavaStackTrace,
345      //   Lisp.pushJavaStackFrames.
346      while (last > 2) {
347        thread.pushStackFrame(new JavaStackFrame(frames[last]));
348        last--;
349      }
350  }
351
352
353  public static final LispObject error(LispObject condition)
354  {
355    pushJavaStackFrames();
356    return Symbol.ERROR.execute(condition);
357  }
358
359  public static final int ierror(LispObject condition)
360  {
361    error(condition);
362    return 0; // Not reached
363  }
364
365  public static final String serror(LispObject condition)
366  {
367    error(condition);
368    return ""; // Not reached
369  }
370
371
372  public static final LispObject error(LispObject condition, LispObject message)
373  {
374    pushJavaStackFrames();
375    return Symbol.ERROR.execute(condition, Keyword.FORMAT_CONTROL, message);
376  }
377
378  public static final int ierror(LispObject condition, LispObject message)
379  {
380    error(condition, message);
381    return 0; // Not reached
382  }
383
384  public static final String serror(LispObject condition, LispObject message)
385  {
386    error(condition, message);
387    return ""; // Not reached
388  }
389
390
391
392  public static final LispObject type_error(LispObject datum,
393                                            LispObject expectedType)
394
395  {
396    return error(new TypeError(datum, expectedType));
397  }
398
399  public static volatile boolean interrupted;
400
401  public static synchronized final void setInterrupted(boolean b)
402  {
403    interrupted = b;
404  }
405
406  public static final void handleInterrupt()
407  {
408    setInterrupted(false);
409    Symbol.BREAK.getSymbolFunction().execute();
410    setInterrupted(false);
411  }
412
413  // Used by the compiler.
414  public static final LispObject loadTimeValue(LispObject obj)
415
416  {
417    final LispThread thread = LispThread.currentThread();
418    if (Symbol.LOAD_TRUENAME.symbolValue(thread) != NIL)
419      return eval(obj, new Environment(), thread);
420    else
421      return NIL;
422  }
423
424  public static final LispObject eval(LispObject obj)
425
426  {
427    return eval(obj, new Environment(), LispThread.currentThread());
428  }
429
430  public static final LispObject eval(final LispObject obj,
431                                      final Environment env,
432                                      final LispThread thread)
433
434  {
435    thread._values = null;
436    if (interrupted)
437      handleInterrupt();
438    if (thread.isDestroyed())
439      throw new ThreadDestroyed();
440    if (obj instanceof Symbol)
441      {
442        Symbol symbol = (Symbol)obj;
443        LispObject result;
444        if (symbol.isSpecialVariable())
445          {
446            if (symbol.constantp())
447              return symbol.getSymbolValue();
448            else
449              result = thread.lookupSpecial(symbol);
450          }
451        else if (env.isDeclaredSpecial(symbol))
452          result = thread.lookupSpecial(symbol);
453        else
454          result = env.lookup(symbol);
455        if (result == null)
456          {
457            result = symbol.getSymbolValue();
458            if (result == null)
459              return error(new UnboundVariable(obj));
460          }
461        if (result instanceof SymbolMacro)
462          return eval(((SymbolMacro)result).getExpansion(), env, thread);
463        return result;
464      }
465    else if (obj instanceof Cons)
466      {
467        LispObject first = ((Cons)obj).car;
468        if (first instanceof Symbol)
469          {
470            LispObject fun = env.lookupFunction(first);
471            if (fun instanceof SpecialOperator)
472              {
473                if (profiling)
474                  if (!sampling)
475                    fun.incrementCallCount();
476                // Don't eval args!
477                return fun.execute(((Cons)obj).cdr, env);
478              }
479            if (fun instanceof MacroObject)
480              return eval(macroexpand(obj, env, thread), env, thread);
481            if (fun instanceof Autoload)
482              {
483                Autoload autoload = (Autoload) fun;
484                autoload.load();
485                return eval(obj, env, thread);
486              }
487            return evalCall(fun != null ? fun : first,
488                            ((Cons)obj).cdr, env, thread);
489          }
490        else
491          {
492            if (first.car() == Symbol.LAMBDA)
493              {
494                Closure closure = new Closure(first, env);
495                return evalCall(closure, ((Cons)obj).cdr, env, thread);
496              }
497            else
498              return error(new ProgramError("Illegal function object: " +
499                                             first.writeToString()));
500          }
501      }
502    else
503      return obj;
504  }
505
506  public static final int CALL_REGISTERS_MAX = 8;
507
508  // Also used in JProxy.java.
509  public static final LispObject evalCall(LispObject function,
510                                             LispObject args,
511                                             Environment env,
512                                             LispThread thread)
513
514  {
515    if (args == NIL)
516      return thread.execute(function);
517    LispObject first = eval(args.car(), env, thread);
518    args = ((Cons)args).cdr;
519    if (args == NIL)
520      {
521        thread._values = null;
522        return thread.execute(function, first);
523      }
524    LispObject second = eval(args.car(), env, thread);
525    args = ((Cons)args).cdr;
526    if (args == NIL)
527      {
528        thread._values = null;
529        return thread.execute(function, first, second);
530      }
531    LispObject third = eval(args.car(), env, thread);
532    args = ((Cons)args).cdr;
533    if (args == NIL)
534      {
535        thread._values = null;
536        return thread.execute(function, first, second, third);
537      }
538    LispObject fourth = eval(args.car(), env, thread);
539    args = ((Cons)args).cdr;
540    if (args == NIL)
541      {
542        thread._values = null;
543        return thread.execute(function, first, second, third, fourth);
544      }
545    LispObject fifth = eval(args.car(), env, thread);
546    args = ((Cons)args).cdr;
547    if (args == NIL)
548      {
549        thread._values = null;
550        return thread.execute(function, first, second, third, fourth, fifth);
551      }
552    LispObject sixth = eval(args.car(), env, thread);
553    args = ((Cons)args).cdr;
554    if (args == NIL)
555      {
556        thread._values = null;
557        return thread.execute(function, first, second, third, fourth, fifth,
558                              sixth);
559      }
560    LispObject seventh = eval(args.car(), env, thread);
561    args = ((Cons)args).cdr;
562    if (args == NIL)
563      {
564        thread._values = null;
565        return thread.execute(function, first, second, third, fourth, fifth,
566                              sixth, seventh);
567      }
568    LispObject eighth = eval(args.car(), env, thread);
569    args = ((Cons)args).cdr;
570    if (args == NIL)
571      {
572        thread._values = null;
573        return thread.execute(function, first, second, third, fourth, fifth,
574                              sixth, seventh, eighth);
575      }
576    // More than CALL_REGISTERS_MAX arguments.
577    final int length = args.length() + CALL_REGISTERS_MAX;
578    LispObject[] array = new LispObject[length];
579    array[0] = first;
580    array[1] = second;
581    array[2] = third;
582    array[3] = fourth;
583    array[4] = fifth;
584    array[5] = sixth;
585    array[6] = seventh;
586    array[7] = eighth;
587    for (int i = CALL_REGISTERS_MAX; i < length; i++)
588      {
589        array[i] = eval(args.car(), env, thread);
590        args = args.cdr();
591      }
592    thread._values = null;
593    return thread.execute(function, array);
594  }
595
596  public static final LispObject parseBody(LispObject body,
597                                           boolean documentationAllowed)
598
599  {
600      LispObject decls = NIL;
601      LispObject doc = NIL;
602
603      while (body != NIL) {
604        LispObject form = body.car();
605        if (documentationAllowed && form instanceof AbstractString
606            && body.cdr() != NIL) {
607          doc = body.car();
608          documentationAllowed = false;
609        } else if (form instanceof Cons && form.car() == Symbol.DECLARE)
610          decls = new Cons(form, decls);
611        else
612          break;
613
614        body = body.cdr();
615      }
616      return list(body, decls.nreverse(), doc);
617  }
618
619  public static final LispObject parseSpecials(LispObject forms)
620
621  {
622    LispObject specials = NIL;
623    while (forms != NIL) {
624      LispObject decls = forms.car();
625
626      Debug.assertTrue(decls instanceof Cons);
627      Debug.assertTrue(decls.car() == Symbol.DECLARE);
628      decls = decls.cdr();
629      while (decls != NIL) {
630        LispObject decl = decls.car();
631
632        if (decl instanceof Cons && decl.car() == Symbol.SPECIAL) {
633            decl = decl.cdr();
634            while (decl != NIL) {
635              specials = new Cons(checkSymbol(decl.car()), specials);
636              decl = decl.cdr();
637            }
638        }
639
640        decls = decls.cdr();
641      }
642
643      forms = forms.cdr();
644    }
645
646    return specials;
647  }
648
649  public static final LispObject progn(LispObject body, Environment env,
650                                       LispThread thread)
651
652  {
653    LispObject result = NIL;
654    while (body != NIL)
655      {
656        result = eval(body.car(), env, thread);
657        body = ((Cons)body).cdr;
658      }
659    return result;
660  }
661
662  public static final LispObject preprocessTagBody(LispObject body,
663                                                   Environment env)
664
665  {
666    LispObject localTags = NIL; // Tags that are local to this TAGBODY.
667    while (body != NIL)
668      {
669        LispObject current = body.car();
670        body = ((Cons)body).cdr;
671        if (current instanceof Cons)
672          continue;
673        // It's a tag.
674        env.addTagBinding(current, body);
675        localTags = new Cons(current, localTags);
676      }
677    return localTags;
678  }
679
680  /** Throws a Go exception to cause a non-local transfer
681   * of control event, after checking that the extent of
682   * the catching tagbody hasn't ended yet.
683   *
684   * This version is used by the compiler.
685   */
686  public static final LispObject nonLocalGo(LispObject tagbody,
687                                            LispObject tag)
688
689  {
690    if (tagbody == null)
691      return error(new ControlError("Unmatched tag "
692                                    + tag.writeToString() +
693                                    " for GO outside lexical extent."));
694
695    throw new Go(tagbody, tag);
696  }
697
698  /** Throws a Go exception to cause a non-local transfer
699   * of control event, after checking that the extent of
700   * the catching tagbody hasn't ended yet.
701   *
702   * This version is used by the interpreter.
703   */
704  public static final LispObject nonLocalGo(Binding binding,
705                                            LispObject tag)
706
707  {
708    if (binding.env.inactive)
709      return error(new ControlError("Unmatched tag "
710                                    + binding.symbol.writeToString() +
711                                    " for GO outside of lexical extent."));
712
713    throw new Go(binding.env, binding.symbol);
714  }
715
716  /** Throws a Return exception to cause a non-local transfer
717   * of control event, after checking that the extent of
718   * the catching block hasn't ended yet.
719   *
720   * This version is used by the compiler.
721   */
722  public static final LispObject nonLocalReturn(LispObject blockId,
723                                                LispObject blockName,
724                                                LispObject result)
725
726  {
727    if (blockId == null)
728      return error(new ControlError("Unmatched block "
729                                    + blockName.writeToString() + " for " +
730                                    "RETURN-FROM outside lexical extent."));
731
732    throw new Return(blockId, result);
733  }
734
735  /** Throws a Return exception to cause a non-local transfer
736   * of control event, after checking that the extent of
737   * the catching block hasn't ended yet.
738   *
739   * This version is used by the interpreter.
740   */
741  public static final LispObject nonLocalReturn(Binding binding,
742                                                Symbol block,
743                                                LispObject result)
744
745  {
746    if (binding == null)
747      {
748        return error(new LispError("No block named " + block.getName() +
749                                   " is currently visible."));
750      }
751
752    if (binding.env.inactive)
753      return error(new ControlError("Unmatched block "
754                                    + binding.symbol.writeToString() +
755                                    " for RETURN-FROM outside of" +
756                                    " lexical extent."));
757
758    throw new Return(binding.symbol, binding.value, result);
759  }
760
761  public static final LispObject processTagBody(LispObject body,
762                                                LispObject localTags,
763                                                Environment env)
764
765  {
766    LispObject remaining = body;
767    LispThread thread = LispThread.currentThread();
768    while (remaining != NIL)
769      {
770        LispObject current = remaining.car();
771        if (current instanceof Cons)
772          {
773            try {
774              // Handle GO inline if possible.
775              if (((Cons)current).car == Symbol.GO)
776                {
777                  if (interrupted)
778                    handleInterrupt();
779                  LispObject tag = current.cadr();
780                  Binding binding = env.getTagBinding(tag);
781                  if (binding == null)
782                    return error(new ControlError("No tag named " +
783                                                  tag.writeToString() +
784                                                  " is currently visible."));
785                  else if (memql(tag, localTags))
786                    {
787                      if (binding.value != null)
788                        {
789                          remaining = binding.value;
790                          continue;
791                        }
792                    }
793                  throw new Go(binding.env, tag);
794                }
795              eval(current, env, thread);
796            }
797            catch (Go go)
798              {
799                LispObject tag;
800                if (go.getTagBody() == env
801                    && memql(tag = go.getTag(), localTags))
802                  {
803                    Binding binding = env.getTagBinding(tag);
804                    if (binding != null && binding.value != null)
805                      {
806                        remaining = binding.value;
807                        continue;
808                      }
809                  }
810                throw go;
811              }
812          }
813        remaining = ((Cons)remaining).cdr;
814      }
815    thread._values = null;
816    return NIL;
817  }
818
819  // Environment wrappers.
820  private static final boolean isSpecial(Symbol sym, LispObject ownSpecials,
821                                         Environment env)
822
823  {
824    if (ownSpecials != null)
825      {
826        if (sym.isSpecialVariable())
827          return true;
828        for (; ownSpecials != NIL; ownSpecials = ownSpecials.cdr())
829          {
830            if (sym == ownSpecials.car())
831              return true;
832          }
833      }
834    return false;
835  }
836
837  public static final void bindArg(LispObject ownSpecials,
838                                      Symbol sym, LispObject value,
839                                      Environment env, LispThread thread)
840
841  {
842    if (isSpecial(sym, ownSpecials, env)) {
843      env.declareSpecial(sym);
844      thread.bindSpecial(sym, value);
845    }
846    else
847      env.bind(sym, value);
848  }
849
850
851  public static final Cons list(LispObject obj1, LispObject... remaining)
852  {
853    Cons theList = null;
854    if (remaining.length > 0) {
855      theList = new Cons(remaining[remaining.length-1]);
856      for (int i = remaining.length - 2; i >= 0; i--)
857        theList = new Cons(remaining[i], theList);
858    }
859    return (theList == null) ? new Cons(obj1) : new Cons(obj1, theList);
860  }
861
862  @Deprecated
863  public static final Cons list1(LispObject obj1)
864  {
865    return new Cons(obj1);
866  }
867
868  @Deprecated
869  public static final Cons list2(LispObject obj1, LispObject obj2)
870  {
871    return new Cons(obj1, new Cons(obj2));
872  }
873
874  @Deprecated
875  public static final Cons list3(LispObject obj1, LispObject obj2,
876                                 LispObject obj3)
877  {
878    return new Cons(obj1, new Cons(obj2, new Cons(obj3)));
879  }
880
881  @Deprecated
882  public static final Cons list4(LispObject obj1, LispObject obj2,
883                                 LispObject obj3, LispObject obj4)
884  {
885    return new Cons(obj1,
886                    new Cons(obj2,
887                             new Cons(obj3,
888                                      new Cons(obj4))));
889  }
890
891  @Deprecated
892  public static final Cons list5(LispObject obj1, LispObject obj2,
893                                 LispObject obj3, LispObject obj4,
894                                 LispObject obj5)
895  {
896    return new Cons(obj1,
897                    new Cons(obj2,
898                             new Cons(obj3,
899                                      new Cons(obj4,
900                                               new Cons(obj5)))));
901  }
902
903  @Deprecated
904  public static final Cons list6(LispObject obj1, LispObject obj2,
905                                 LispObject obj3, LispObject obj4,
906                                 LispObject obj5, LispObject obj6)
907  {
908    return new Cons(obj1,
909                    new Cons(obj2,
910                             new Cons(obj3,
911                                      new Cons(obj4,
912                                               new Cons(obj5,
913                                                        new Cons(obj6))))));
914  }
915
916  @Deprecated
917  public static final Cons list7(LispObject obj1, LispObject obj2,
918                                 LispObject obj3, LispObject obj4,
919                                 LispObject obj5, LispObject obj6,
920                                 LispObject obj7)
921  {
922    return new Cons(obj1,
923                    new Cons(obj2,
924                             new Cons(obj3,
925                                      new Cons(obj4,
926                                               new Cons(obj5,
927                                                        new Cons(obj6,
928                                                                 new Cons(obj7)))))));
929  }
930
931  @Deprecated
932  public static final Cons list8(LispObject obj1, LispObject obj2,
933                                 LispObject obj3, LispObject obj4,
934                                 LispObject obj5, LispObject obj6,
935                                 LispObject obj7, LispObject obj8)
936  {
937    return new Cons(obj1,
938                    new Cons(obj2,
939                             new Cons(obj3,
940                                      new Cons(obj4,
941                                               new Cons(obj5,
942                                                        new Cons(obj6,
943                                                                 new Cons(obj7,
944                                                                          new Cons(obj8))))))));
945  }
946
947  @Deprecated
948  public static final Cons list9(LispObject obj1, LispObject obj2,
949                                 LispObject obj3, LispObject obj4,
950                                 LispObject obj5, LispObject obj6,
951                                 LispObject obj7, LispObject obj8,
952                                 LispObject obj9)
953  {
954    return new Cons(obj1,
955                    new Cons(obj2,
956                             new Cons(obj3,
957                                      new Cons(obj4,
958                                               new Cons(obj5,
959                                                        new Cons(obj6,
960                                                                 new Cons(obj7,
961                                                                          new Cons(obj8,
962                                                                                   new Cons(obj9)))))))));
963  }
964
965  // Used by the compiler.
966  public static final LispObject multipleValueList(LispObject result)
967
968  {
969    LispThread thread = LispThread.currentThread();
970    LispObject[] values = thread._values;
971    if (values == null)
972      return new Cons(result);
973    thread._values = null;
974    LispObject list = NIL;
975    for (int i = values.length; i-- > 0;)
976      list = new Cons(values[i], list);
977    return list;
978  }
979
980  // Used by the compiler for MULTIPLE-VALUE-CALLs with a single values form.
981  public static final LispObject multipleValueCall1(LispObject result,
982                                                    LispObject function,
983                                                    LispThread thread)
984
985  {
986    LispObject[] values = thread._values;
987    thread._values = null;
988    if (values == null)
989      return thread.execute(coerceToFunction(function), result);
990    else
991      return funcall(coerceToFunction(function), values, thread);
992  }
993
994  public static final void progvBindVars(LispObject symbols,
995                                         LispObject values,
996                                         LispThread thread)
997
998  {
999    for (LispObject list = symbols; list != NIL; list = list.cdr())
1000      {
1001        Symbol symbol = checkSymbol(list.car());
1002        LispObject value;
1003        if (values != NIL)
1004          {
1005            value = values.car();
1006            values = values.cdr();
1007          }
1008        else
1009          {
1010            // "If too few values are supplied, the remaining symbols are
1011            // bound and then made to have no value."
1012            value = null;
1013          }
1014        thread.bindSpecial(symbol, value);
1015      }
1016  }
1017
1018  public static Symbol checkSymbol(LispObject obj)
1019  {             
1020          if (obj instanceof Symbol)     
1021                  return (Symbol) obj;         
1022          return (Symbol)// Not reached.       
1023              type_error(obj, Symbol.SYMBOL);
1024  }
1025
1026  public static final LispObject checkList(LispObject obj)
1027
1028  {
1029    if (obj.listp())
1030      return obj;
1031    return type_error(obj, Symbol.LIST);
1032  }
1033
1034  public static final AbstractArray checkArray(LispObject obj)
1035
1036  {
1037          if (obj instanceof AbstractArray)       
1038                  return (AbstractArray) obj;         
1039          return (AbstractArray)// Not reached.       
1040        type_error(obj, Symbol.ARRAY);
1041  }
1042
1043  public static final AbstractVector checkVector(LispObject obj)
1044
1045  {
1046          if (obj instanceof AbstractVector)     
1047                  return (AbstractVector) obj;         
1048          return (AbstractVector)// Not reached.       
1049        type_error(obj, Symbol.VECTOR);
1050  }
1051
1052  public static final DoubleFloat checkDoubleFloat(LispObject obj)
1053
1054  {
1055          if (obj instanceof DoubleFloat)
1056                  return (DoubleFloat) obj;
1057          return (DoubleFloat)// Not reached.
1058            type_error(obj, Symbol.DOUBLE_FLOAT);
1059  }
1060
1061  public static final SingleFloat checkSingleFloat(LispObject obj)
1062
1063  {
1064          if (obj instanceof SingleFloat)
1065                  return (SingleFloat) obj;
1066          return (SingleFloat)// Not reached.
1067            type_error(obj, Symbol.SINGLE_FLOAT);
1068  }
1069
1070  public static final StackFrame checkStackFrame(LispObject obj)
1071
1072  {
1073          if (obj instanceof StackFrame)     
1074                  return (StackFrame) obj;         
1075          return (StackFrame)// Not reached.       
1076            type_error(obj, Symbol.STACK_FRAME);
1077  }
1078
1079  static
1080  {
1081    // ### *gensym-counter*
1082    Symbol.GENSYM_COUNTER.initializeSpecial(Fixnum.ZERO);
1083  }
1084
1085  public static final Symbol gensym(LispThread thread)
1086
1087  {
1088    return gensym("G", thread);
1089  }
1090
1091  public static final Symbol gensym(String prefix, LispThread thread)
1092
1093  {
1094    StringBuilder sb = new StringBuilder(prefix);
1095    SpecialBinding binding = thread.getSpecialBinding(Symbol.GENSYM_COUNTER);
1096    final LispObject oldValue;
1097    if (binding != null) {
1098        oldValue = binding.value;
1099        if (oldValue instanceof Fixnum
1100                || oldValue instanceof Bignum)
1101          binding.value = oldValue.incr();
1102        else {
1103           Symbol.GENSYM_COUNTER.setSymbolValue(Fixnum.ZERO);
1104           error(new TypeError("The value of *GENSYM-COUNTER* was not a nonnegative integer. Old value: " +
1105                                oldValue.writeToString() + " New value: 0"));
1106        }
1107    } else {
1108        // we're manipulating a global resource
1109        // make sure we operate thread-safely
1110        synchronized (Symbol.GENSYM_COUNTER) {
1111            oldValue = Symbol.GENSYM_COUNTER.getSymbolValue();
1112            if (oldValue instanceof Fixnum
1113                    || oldValue instanceof Bignum)
1114                Symbol.GENSYM_COUNTER.setSymbolValue(oldValue.incr());
1115            else {
1116               Symbol.GENSYM_COUNTER.setSymbolValue(Fixnum.ZERO);
1117               error(new TypeError("The value of *GENSYM-COUNTER* was not a nonnegative integer. Old value: " +
1118                                    oldValue.writeToString() + " New value: 0"));
1119            }
1120        }
1121    }
1122     
1123    // Decimal representation.
1124    if (oldValue instanceof Fixnum)
1125      sb.append(((Fixnum)oldValue).value);
1126    else if (oldValue instanceof Bignum)
1127      sb.append(((Bignum)oldValue).value.toString());
1128
1129    return new Symbol(new SimpleString(sb));
1130  }
1131
1132  public static final String javaString(LispObject arg)
1133
1134  {
1135    if (arg instanceof AbstractString)
1136      return arg.getStringValue();
1137    if (arg instanceof Symbol)
1138      return ((Symbol)arg).getName();
1139    if (arg instanceof LispCharacter)
1140      return String.valueOf(new char[] {((LispCharacter)arg).value});
1141    type_error(arg, list(Symbol.OR, Symbol.STRING, Symbol.SYMBOL,
1142                               Symbol.CHARACTER));
1143    // Not reached.
1144    return null;
1145  }
1146
1147  public static final LispObject number(long n)
1148  {
1149    if (n >= Integer.MIN_VALUE && n <= Integer.MAX_VALUE)
1150      return Fixnum.getInstance((int)n);
1151    else
1152      return Bignum.getInstance(n);
1153  }
1154
1155  private static final BigInteger INT_MIN = BigInteger.valueOf(Integer.MIN_VALUE);
1156  private static final BigInteger INT_MAX = BigInteger.valueOf(Integer.MAX_VALUE);
1157
1158  public static final LispObject number(BigInteger numerator,
1159                                        BigInteger denominator)
1160
1161  {
1162    if (denominator.signum() == 0)
1163      error(new DivisionByZero());
1164    if (denominator.signum() < 0)
1165      {
1166        numerator = numerator.negate();
1167        denominator = denominator.negate();
1168      }
1169    BigInteger gcd = numerator.gcd(denominator);
1170    if (!gcd.equals(BigInteger.ONE))
1171      {
1172        numerator = numerator.divide(gcd);
1173        denominator = denominator.divide(gcd);
1174      }
1175    if (denominator.equals(BigInteger.ONE))
1176      return number(numerator);
1177    else
1178      return new Ratio(numerator, denominator);
1179  }
1180
1181  public static final LispObject number(BigInteger n)
1182  {
1183    if (n.compareTo(INT_MIN) >= 0 && n.compareTo(INT_MAX) <= 0)
1184      return Fixnum.getInstance(n.intValue());
1185    else
1186      return Bignum.getInstance(n);
1187  }
1188
1189  public static final int mod(int number, int divisor)
1190
1191  {
1192    final int r;
1193    try
1194      {
1195        r = number % divisor;
1196      }
1197    catch (ArithmeticException e)
1198      {
1199        error(new ArithmeticError("Division by zero."));
1200        // Not reached.
1201        return 0;
1202      }
1203    if (r == 0)
1204      return r;
1205    if (divisor < 0)
1206      {
1207        if (number > 0)
1208          return r + divisor;
1209      }
1210    else
1211      {
1212        if (number < 0)
1213          return r + divisor;
1214      }
1215    return r;
1216  }
1217
1218  // Adapted from SBCL.
1219  public static final int mix(long x, long y)
1220  {
1221    long xy = x * 3 + y;
1222    return (int) (536870911L & (441516657L ^ xy ^ (xy >> 5)));
1223  }
1224
1225  // Used by the compiler.
1226  public static final LispObject readObjectFromString(String s)
1227  {
1228    return new StringInputStream(s).read(true, NIL, false,
1229                                         LispThread.currentThread(),
1230                                         Stream.faslReadtable);
1231  }
1232
1233    @Deprecated
1234  public static final LispObject loadCompiledFunction(final String namestring)
1235  {
1236      Pathname name = new Pathname(namestring);
1237      byte[] bytes = readFunctionBytes(name);
1238      if (bytes != null)
1239        return loadClassBytes(bytes);
1240
1241      return null;
1242  }
1243
1244  public static final byte[] readFunctionBytes(final Pathname name) {
1245      final LispThread thread = LispThread.currentThread();
1246      Pathname load = null;
1247      LispObject truenameFasl = Symbol.LOAD_TRUENAME_FASL.symbolValue(thread);
1248      LispObject truename = Symbol.LOAD_TRUENAME.symbolValue(thread);
1249      Pathname fasl = null;
1250      if (truenameFasl instanceof Pathname) {
1251          load = Pathname.mergePathnames(name, (Pathname)truenameFasl, Keyword.NEWEST);
1252      } else if (truename instanceof Pathname) {
1253          load = Pathname.mergePathnames(name, (Pathname) truename, Keyword.NEWEST);
1254      } else {
1255          if (!Pathname.truename(name).equals(NIL)) {
1256              load = name;
1257          } else {
1258              load = null;
1259          }
1260      }
1261      InputStream input = null;
1262      if (load != null) {
1263          input = load.getInputStream();
1264      } else { 
1265          // Make a last-ditch attempt to load from the boot classpath XXX OSGi hack
1266          URL url = null;
1267          try {
1268              url = Lisp.class.getResource(name.getNamestring());
1269              input = url.openStream();
1270          } catch (IOException e) {
1271              error(new LispError("Failed to read class bytes from boot class " + url));
1272          }
1273      }
1274      byte[] bytes = new byte[4096];
1275      try {
1276          if (input == null) {
1277                  Debug.trace("Pathname: " + name);
1278                  Debug.trace("LOAD_TRUENAME_FASL: " + truenameFasl);
1279                  Debug.trace("LOAD_TRUENAME: " + truename);
1280                  Debug.assertTrue(input != null);
1281          }
1282
1283          int n = 0;
1284          java.io.ByteArrayOutputStream baos = new java.io.ByteArrayOutputStream();
1285          try {
1286              while (n >= 0) {
1287                  n = input.read(bytes, 0, 4096);
1288                if (n >= 0) {
1289                    baos.write(bytes, 0, n);
1290                }
1291            }
1292          } catch (IOException e) {
1293              Debug.trace("Failed to read bytes from "
1294                          + "'" + name.getNamestring() + "'");
1295              return null;
1296          }
1297          bytes = baos.toByteArray();
1298      } finally {
1299          try {
1300              input.close();
1301          } catch (IOException e) {
1302              Debug.trace("Failed to close InputStream: " + e);
1303          }
1304      }
1305      return bytes;
1306  }
1307
1308    public static final Function makeCompiledFunctionFromClass(Class<?> c) {
1309      try {
1310  if (c != null) {
1311      Function obj = (Function)c.newInstance();
1312      return obj;
1313        } else {
1314            return null;
1315        }
1316      }
1317      catch (InstantiationException e) {} // ### FIXME
1318      catch (IllegalAccessException e) {} // ### FIXME
1319
1320      return null;
1321    }
1322
1323
1324  public static final LispObject loadCompiledFunction(InputStream in, int size)
1325  {
1326      byte[] bytes = readFunctionBytes(in, size);
1327      if (bytes != null)
1328        return loadClassBytes(bytes);
1329      else
1330        return error(new FileError("Can't read file off stream."));
1331  }
1332
1333
1334
1335  private static final byte[] readFunctionBytes(InputStream in, int size)
1336  {
1337    try
1338      {
1339        byte[] bytes = new byte[size];
1340        int bytesRemaining = size;
1341        int bytesRead = 0;
1342        while (bytesRemaining > 0)
1343          {
1344            int n = in.read(bytes, bytesRead, bytesRemaining);
1345            if (n < 0)
1346              break;
1347            bytesRead += n;
1348            bytesRemaining -= n;
1349          }
1350        in.close();
1351        if (bytesRemaining > 0)
1352          Debug.trace("bytesRemaining = " + bytesRemaining);
1353
1354        return bytes;
1355      }
1356    catch (IOException t)
1357      {
1358        Debug.trace(t); // FIXME: call error()?
1359      }
1360    return null;
1361  }
1362
1363    public static final Function loadClassBytes(byte[] bytes)
1364    {
1365      return loadClassBytes(bytes, new JavaClassLoader());
1366    }
1367
1368    public static final Function loadClassBytes(byte[] bytes,
1369                                                JavaClassLoader cl)
1370    {
1371        Class<?> c = cl.loadClassFromByteArray(null, bytes, 0, bytes.length);
1372  Function obj = makeCompiledFunctionFromClass(c);
1373  if (obj != null) {
1374      obj.setClassBytes(bytes);
1375  }
1376  return obj;
1377    }
1378
1379
1380  public static final LispObject makeCompiledClosure(LispObject template,
1381                                                     ClosureBinding[] context)
1382
1383  {
1384    return ((CompiledClosure)template).dup().setContext(context);
1385  }
1386
1387  public static final String safeWriteToString(LispObject obj)
1388  {
1389    try {
1390        return obj.writeToString();
1391      }
1392    catch (NullPointerException e)
1393      {
1394        Debug.trace(e);
1395        return "null";
1396      }
1397  }
1398
1399  public static final boolean isValidSetfFunctionName(LispObject obj)
1400  {
1401    if (obj instanceof Cons)
1402      {
1403        Cons cons = (Cons) obj;
1404        if (cons.car == Symbol.SETF && cons.cdr instanceof Cons)
1405          {
1406            Cons cdr = (Cons) cons.cdr;
1407            return (cdr.car instanceof Symbol && cdr.cdr == NIL);
1408          }
1409      }
1410    return false;
1411  }
1412
1413  public static final boolean isValidMacroFunctionName(LispObject obj)
1414  {
1415    if (obj instanceof Cons)
1416      {
1417        Cons cons = (Cons) obj;
1418        if (cons.car == Symbol.MACRO_FUNCTION && cons.cdr instanceof Cons)
1419          {
1420            Cons cdr = (Cons) cons.cdr;
1421            return (cdr.car instanceof Symbol && cdr.cdr == NIL);
1422          }
1423      }
1424    return false;
1425  }
1426
1427
1428  public static final LispObject FUNCTION_NAME =
1429    list(Symbol.OR,
1430          Symbol.SYMBOL,
1431          list(Symbol.CONS,
1432                list(Symbol.EQL, Symbol.SETF),
1433                list(Symbol.CONS, Symbol.SYMBOL, Symbol.NULL)));
1434
1435  public static final LispObject UNSIGNED_BYTE_8 =
1436    list(Symbol.UNSIGNED_BYTE, Fixnum.constants[8]);
1437
1438  public static final LispObject UNSIGNED_BYTE_16 =
1439    list(Symbol.UNSIGNED_BYTE, Fixnum.constants[16]);
1440
1441  public static final LispObject UNSIGNED_BYTE_32 =
1442    list(Symbol.UNSIGNED_BYTE, Fixnum.constants[32]);
1443
1444  public static final LispObject UNSIGNED_BYTE_32_MAX_VALUE =
1445    Bignum.getInstance(4294967296L);
1446
1447  public static final LispObject getUpgradedArrayElementType(LispObject type)
1448
1449  {
1450    if (type instanceof Symbol)
1451      {
1452        if (type == Symbol.CHARACTER || type == Symbol.BASE_CHAR ||
1453            type == Symbol.STANDARD_CHAR)
1454          return Symbol.CHARACTER;
1455        if (type == Symbol.BIT)
1456          return Symbol.BIT;
1457        if (type == NIL)
1458          return NIL;
1459      }
1460    if (type == BuiltInClass.CHARACTER)
1461      return Symbol.CHARACTER;
1462    if (type instanceof Cons)
1463      {
1464        if (type.equal(UNSIGNED_BYTE_8))
1465          return type;
1466        if (type.equal(UNSIGNED_BYTE_16))
1467          return type;
1468        if (type.equal(UNSIGNED_BYTE_32))
1469          return type;
1470        LispObject car = type.car();
1471        if (car == Symbol.INTEGER)
1472          {
1473            LispObject lower = type.cadr();
1474            LispObject upper = type.cdr().cadr();
1475            // Convert to inclusive bounds.
1476            if (lower instanceof Cons)
1477              lower = lower.car().incr();
1478            if (upper instanceof Cons)
1479              upper = upper.car().decr();
1480            if (lower.integerp() && upper.integerp())
1481              {
1482                if (lower instanceof Fixnum && upper instanceof Fixnum)
1483                  {
1484                    int l = ((Fixnum)lower).value;
1485                    if (l >= 0)
1486                      {
1487                        int u = ((Fixnum)upper).value;
1488                        if (u <= 1)
1489                          return Symbol.BIT;
1490                        if (u <= 255)
1491                          return UNSIGNED_BYTE_8;
1492                        if (u <= 65535)
1493                          return UNSIGNED_BYTE_16;
1494                        return UNSIGNED_BYTE_32;
1495                      }
1496                  }
1497                if (lower.isGreaterThanOrEqualTo(Fixnum.ZERO))
1498                  {
1499                    if (lower.isLessThan(UNSIGNED_BYTE_32_MAX_VALUE))
1500                      {
1501                        if (upper.isLessThan(UNSIGNED_BYTE_32_MAX_VALUE))
1502                          return UNSIGNED_BYTE_32;
1503                      }
1504                  }
1505              }
1506          }
1507        else if (car == Symbol.EQL)
1508          {
1509            LispObject obj = type.cadr();
1510            if (obj instanceof Fixnum)
1511              {
1512                int val = ((Fixnum)obj).value;
1513                if (val >= 0)
1514                  {
1515                    if (val <= 1)
1516                      return Symbol.BIT;
1517                    if (val <= 255)
1518                      return UNSIGNED_BYTE_8;
1519                    if (val <= 65535)
1520                      return UNSIGNED_BYTE_16;
1521                    return UNSIGNED_BYTE_32;
1522                  }
1523              }
1524            else if (obj instanceof Bignum)
1525              {
1526                if (obj.isGreaterThanOrEqualTo(Fixnum.ZERO))
1527                  {
1528                    if (obj.isLessThan(UNSIGNED_BYTE_32_MAX_VALUE))
1529                      return UNSIGNED_BYTE_32;
1530                  }
1531              }
1532          }
1533        else if (car == Symbol.MEMBER)
1534          {
1535            LispObject rest = type.cdr();
1536            while (rest != NIL)
1537              {
1538                LispObject obj = rest.car();
1539                if (obj instanceof LispCharacter)
1540                  rest = rest.cdr();
1541                else
1542                  return T;
1543              }
1544            return Symbol.CHARACTER;
1545          }
1546      }
1547    return T;
1548  }
1549
1550  public static final byte coerceLispObjectToJavaByte(LispObject obj)
1551
1552  {
1553          return (byte)Fixnum.getValue(obj);
1554  }
1555
1556  public static final LispObject coerceJavaByteToLispObject(byte b)
1557  {
1558    return Fixnum.constants[((int)b) & 0xff];
1559  }
1560
1561  public static final LispCharacter checkCharacter(LispObject obj)
1562
1563  {
1564          if (obj instanceof LispCharacter) 
1565                  return (LispCharacter) obj;         
1566          return (LispCharacter) // Not reached.       
1567        type_error(obj, Symbol.CHARACTER);
1568  }
1569
1570  public static final Package checkPackage(LispObject obj)
1571
1572  {
1573          if (obj instanceof Package)     
1574                  return (Package) obj;         
1575          return (Package) // Not reached.       
1576        type_error(obj, Symbol.PACKAGE);
1577  }
1578
1579  public static final Function checkFunction(LispObject obj)
1580
1581  {
1582          if (obj instanceof Function)   
1583                  return (Function) obj;         
1584          return (Function) // Not reached.       
1585        type_error(obj, Symbol.FUNCTION);
1586  }
1587
1588  public static final Stream checkStream(LispObject obj)
1589
1590  {
1591          if (obj instanceof Stream)     
1592                  return (Stream) obj;         
1593          return (Stream) // Not reached.       
1594        type_error(obj, Symbol.STREAM);
1595  }
1596
1597  public static final Stream checkCharacterInputStream(LispObject obj)
1598
1599  {
1600          final Stream stream = checkStream(obj);
1601          if (stream.isCharacterInputStream())     
1602                  return stream;                       
1603          return (Stream) // Not reached.                     
1604          error(new TypeError("The value " + obj.writeToString() +
1605                        " is not a character input stream."));
1606  }
1607
1608  public static final Stream checkCharacterOutputStream(LispObject obj)
1609
1610  {
1611          final Stream stream = checkStream(obj);
1612          if (stream.isCharacterOutputStream())     
1613                  return stream;                       
1614        return (Stream) // Not reached.
1615        error(new TypeError("The value " + obj.writeToString() +
1616                            " is not a character output stream."));
1617  }
1618
1619  public static final Stream checkBinaryInputStream(LispObject obj)
1620
1621  {
1622          final Stream stream = checkStream(obj);
1623          if (stream.isBinaryInputStream())     
1624                  return stream;                       
1625        return (Stream) // Not reached.
1626        error(new TypeError("The value " + obj.writeToString() +
1627                             " is not a binary input stream."));
1628  }
1629 
1630  public static final Stream outSynonymOf(LispObject obj)
1631
1632  {       
1633          if (obj instanceof Stream)
1634            return (Stream) obj;
1635          if (obj == T)
1636            return checkCharacterOutputStream(Symbol.TERMINAL_IO.symbolValue());
1637          if (obj == NIL)
1638            return checkCharacterOutputStream(Symbol.STANDARD_OUTPUT.symbolValue());
1639          return (Stream)         // Not reached.
1640          type_error(obj, Symbol.STREAM);
1641  }
1642
1643  public static final Stream inSynonymOf(LispObject obj)
1644
1645  {
1646    if (obj instanceof Stream)
1647      return (Stream) obj;
1648    if (obj == T)
1649      return checkCharacterInputStream(Symbol.TERMINAL_IO.symbolValue());
1650    if (obj == NIL)
1651      return checkCharacterInputStream(Symbol.STANDARD_INPUT.symbolValue());
1652          return (Stream)         // Not reached.
1653          type_error(obj, Symbol.STREAM);
1654  }
1655
1656  public static final void writeByte(int n, LispObject obj)
1657
1658  {
1659    if (n < 0 || n > 255)
1660      type_error(Fixnum.getInstance(n), UNSIGNED_BYTE_8);
1661    checkStream(obj)._writeByte(n);
1662  }
1663
1664  public static final Readtable checkReadtable(LispObject obj)
1665
1666  {
1667          if (obj instanceof Readtable)   
1668                  return (Readtable) obj;         
1669          return (Readtable)// Not reached.       
1670          type_error(obj, Symbol.READTABLE);
1671  }
1672 
1673  public final static AbstractString checkString(LispObject obj) 
1674
1675  {
1676          if (obj instanceof AbstractString)           
1677                  return (AbstractString) obj;                   
1678          return (AbstractString)// Not reached.               
1679              type_error(obj, Symbol.STRING);
1680  }
1681 
1682  public final static Layout checkLayout(LispObject obj) 
1683
1684  {
1685          if (obj instanceof Layout)           
1686                  return (Layout) obj;                   
1687          return (Layout)// Not reached.               
1688                type_error(obj, Symbol.LAYOUT);
1689  }
1690
1691  public static final Readtable designator_readtable(LispObject obj)
1692
1693  {
1694    if (obj == NIL)
1695      obj = STANDARD_READTABLE.symbolValue();
1696    if (obj == null)
1697        throw new NullPointerException();
1698    return checkReadtable(obj);
1699  }
1700
1701  public static final Environment checkEnvironment(LispObject obj)
1702
1703  {
1704          if (obj instanceof Environment)         
1705                  return (Environment) obj;         
1706          return (Environment)// Not reached.       
1707        type_error(obj, Symbol.ENVIRONMENT);
1708  }
1709
1710  public static final void checkBounds(int start, int end, int length)
1711
1712  {
1713    if (start < 0 || end < 0 || start > end || end > length)
1714      {
1715        StringBuilder sb = new StringBuilder("The bounding indices ");
1716        sb.append(start);
1717        sb.append(" and ");
1718        sb.append(end);
1719        sb.append(" are bad for a sequence of length ");
1720        sb.append(length);
1721        sb.append('.');
1722        error(new TypeError(sb.toString()));
1723      }
1724  }
1725
1726  public static final LispObject coerceToFunction(LispObject obj)
1727
1728  {
1729    if (obj instanceof Function)
1730      return obj;
1731    if (obj instanceof StandardGenericFunction)
1732      return obj;
1733    if (obj instanceof Symbol)
1734      {
1735        LispObject fun = obj.getSymbolFunction();
1736        if (fun instanceof Function)
1737          return (Function) fun;
1738      }
1739    else if (obj instanceof Cons && obj.car() == Symbol.LAMBDA)
1740      return new Closure(obj, new Environment());
1741    error(new UndefinedFunction(obj));
1742    // Not reached.
1743    return null;
1744  }
1745
1746  // Returns package or throws exception.
1747  public static final Package coerceToPackage(LispObject obj)
1748
1749  {
1750    if (obj instanceof Package)
1751      return (Package) obj;
1752    Package pkg = Packages.findPackage(javaString(obj));
1753    if (pkg != null)
1754      return pkg;
1755    error(new PackageError(obj.writeToString() + " is not the name of a package."));
1756    // Not reached.
1757    return null;
1758  }
1759
1760  public static Pathname coerceToPathname(LispObject arg)
1761
1762  {
1763    if (arg instanceof Pathname)
1764      return (Pathname) arg;
1765    if (arg instanceof AbstractString)
1766      return Pathname.parseNamestring((AbstractString)arg);
1767    if (arg instanceof FileStream)
1768      return ((FileStream)arg).getPathname();
1769    if (arg instanceof JarStream)
1770      return ((JarStream)arg).getPathname();
1771    if (arg instanceof URLStream)
1772      return ((URLStream)arg).getPathname();
1773    type_error(arg, list(Symbol.OR, Symbol.PATHNAME,
1774                         Symbol.STRING, Symbol.FILE_STREAM,
1775                         Symbol.JAR_STREAM, Symbol.URL_STREAM));
1776    // Not reached.
1777    return null;
1778  }
1779
1780  public static LispObject assq(LispObject item, LispObject alist)
1781
1782  {
1783    while (alist instanceof Cons)
1784      {
1785        LispObject entry = ((Cons)alist).car;
1786        if (entry instanceof Cons)
1787          {
1788            if (((Cons)entry).car == item)
1789              return entry;
1790          }
1791        else if (entry != NIL)
1792          return type_error(entry, Symbol.LIST);
1793        alist = ((Cons)alist).cdr;
1794      }
1795    if (alist != NIL)
1796      return type_error(alist, Symbol.LIST);
1797    return NIL;
1798  }
1799
1800  public static final boolean memq(LispObject item, LispObject list)
1801
1802  {
1803    while (list instanceof Cons)
1804      {
1805        if (item == ((Cons)list).car)
1806          return true;
1807        list = ((Cons)list).cdr;
1808      }
1809    if (list != NIL)
1810      type_error(list, Symbol.LIST);
1811    return false;
1812  }
1813
1814  public static final boolean memql(LispObject item, LispObject list)
1815
1816  {
1817    while (list instanceof Cons)
1818      {
1819        if (item.eql(((Cons)list).car))
1820          return true;
1821        list = ((Cons)list).cdr;
1822      }
1823    if (list != NIL)
1824      type_error(list, Symbol.LIST);
1825    return false;
1826  }
1827
1828  // Property lists.
1829  public static final LispObject getf(LispObject plist, LispObject indicator,
1830                                      LispObject defaultValue)
1831
1832  {
1833    LispObject list = plist;
1834    while (list != NIL)
1835      {
1836        if (list.car() == indicator)
1837          return list.cadr();
1838        if (list.cdr() instanceof Cons)
1839          list = list.cddr();
1840        else
1841          return error(new TypeError("Malformed property list: " +
1842                                      plist.writeToString()));
1843      }
1844    return defaultValue;
1845  }
1846
1847  public static final LispObject get(LispObject symbol, LispObject indicator)
1848
1849  {
1850    LispObject list = checkSymbol(symbol).getPropertyList();
1851    while (list != NIL)
1852      {
1853        if (list.car() == indicator)
1854          return list.cadr();
1855        list = list.cddr();
1856      }
1857    return NIL;
1858  }
1859
1860  public static final LispObject get(LispObject symbol, LispObject indicator,
1861                                     LispObject defaultValue)
1862
1863  {
1864    LispObject list = checkSymbol(symbol).getPropertyList();
1865    while (list != NIL)
1866      {
1867        if (list.car() == indicator)
1868          return list.cadr();
1869        list = list.cddr();
1870      }
1871    return defaultValue;
1872  }
1873
1874  public static final LispObject put(Symbol symbol, LispObject indicator,
1875                                     LispObject value)
1876
1877  {
1878    LispObject list = symbol.getPropertyList();
1879    while (list != NIL)
1880      {
1881        if (list.car() == indicator)
1882          {
1883            // Found it!
1884            LispObject rest = list.cdr();
1885            rest.setCar(value);
1886            return value;
1887          }
1888        list = list.cddr();
1889      }
1890    // Not found.
1891    symbol.setPropertyList(new Cons(indicator,
1892                                    new Cons(value,
1893                                             symbol.getPropertyList())));
1894    return value;
1895  }
1896
1897  public static final LispObject putf(LispObject plist, LispObject indicator,
1898                                      LispObject value)
1899
1900  {
1901    LispObject list = plist;
1902    while (list != NIL)
1903      {
1904        if (list.car() == indicator)
1905          {
1906            // Found it!
1907            LispObject rest = list.cdr();
1908            rest.setCar(value);
1909            return plist;
1910          }
1911        list = list.cddr();
1912      }
1913    // Not found.
1914    return new Cons(indicator, new Cons(value, plist));
1915  }
1916
1917  public static final LispObject remprop(Symbol symbol, LispObject indicator)
1918
1919  {
1920    LispObject list = checkList(symbol.getPropertyList());
1921    LispObject prev = null;
1922    while (list != NIL)
1923      {
1924        if (!(list.cdr() instanceof Cons))
1925          error(new ProgramError("The symbol " + symbol.writeToString() +
1926                                  " has an odd number of items in its property list."));
1927        if (list.car() == indicator)
1928          {
1929            // Found it!
1930            if (prev != null)
1931              prev.setCdr(list.cddr());
1932            else
1933              symbol.setPropertyList(list.cddr());
1934            return T;
1935          }
1936        prev = list.cdr();
1937        list = list.cddr();
1938      }
1939    // Not found.
1940    return NIL;
1941  }
1942
1943  public static final String format(LispObject formatControl,
1944                                    LispObject formatArguments)
1945
1946  {
1947    final LispThread thread = LispThread.currentThread();
1948    String control = formatControl.getStringValue();
1949    LispObject[] args = formatArguments.copyToArray();
1950    StringBuffer sb = new StringBuffer();
1951    if (control != null)
1952      {
1953        final int limit = control.length();
1954        int j = 0;
1955        final int NEUTRAL = 0;
1956        final int TILDE = 1;
1957        int state = NEUTRAL;
1958        for (int i = 0; i < limit; i++)
1959          {
1960            char c = control.charAt(i);
1961            if (state == NEUTRAL)
1962              {
1963                if (c == '~')
1964                  state = TILDE;
1965                else
1966                  sb.append(c);
1967              }
1968            else if (state == TILDE)
1969              {
1970                if (c == 'A' || c == 'a')
1971                  {
1972                    if (j < args.length)
1973                      {
1974                        LispObject obj = args[j++];
1975                        final SpecialBindingsMark mark = thread.markSpecialBindings();
1976                        thread.bindSpecial(Symbol.PRINT_ESCAPE, NIL);
1977                        thread.bindSpecial(Symbol.PRINT_READABLY, NIL);
1978                        try {
1979                            sb.append(obj.writeToString());
1980                        }
1981                        finally {
1982                            thread.resetSpecialBindings(mark);
1983                        }
1984                      }
1985                  }
1986                else if (c == 'S' || c == 's')
1987                  {
1988                    if (j < args.length)
1989                      {
1990                        LispObject obj = args[j++];
1991                        final SpecialBindingsMark mark = thread.markSpecialBindings();
1992                        thread.bindSpecial(Symbol.PRINT_ESCAPE, T);
1993                        try {
1994                            sb.append(obj.writeToString());
1995                        }
1996                        finally {
1997                            thread.resetSpecialBindings(mark);
1998                        }
1999                      }
2000                  }
2001                else if (c == 'D' || c == 'd')
2002                  {
2003                    if (j < args.length)
2004                      {
2005                        LispObject obj = args[j++];
2006                        final SpecialBindingsMark mark = thread.markSpecialBindings();
2007                        thread.bindSpecial(Symbol.PRINT_ESCAPE, NIL);
2008                        thread.bindSpecial(Symbol.PRINT_RADIX, NIL);
2009                        thread.bindSpecial(Symbol.PRINT_BASE, Fixnum.constants[10]);
2010                        try {
2011                            sb.append(obj.writeToString());
2012                        }
2013                        finally {
2014                            thread.resetSpecialBindings(mark);
2015                        }
2016                      }
2017                  }
2018                else if (c == 'X' || c == 'x')
2019                  {
2020                    if (j < args.length)
2021                      {
2022                        LispObject obj = args[j++];
2023                        final SpecialBindingsMark mark = thread.markSpecialBindings();
2024                        thread.bindSpecial(Symbol.PRINT_ESCAPE, NIL);
2025                        thread.bindSpecial(Symbol.PRINT_RADIX, NIL);
2026                        thread.bindSpecial(Symbol.PRINT_BASE, Fixnum.constants[16]);
2027                        try {
2028                            sb.append(obj.writeToString());
2029                        }
2030                        finally {
2031                            thread.resetSpecialBindings(mark);
2032                        }
2033                      }
2034                  }
2035                else if (c == '%')
2036                  {
2037                    sb.append('\n');
2038                  }
2039                state = NEUTRAL;
2040              }
2041            else
2042              {
2043                // There are no other valid states.
2044                Debug.assertTrue(false);
2045              }
2046          }
2047      }
2048    return sb.toString();
2049  }
2050
2051  public static final Symbol intern(String name, Package pkg)
2052  {
2053    return pkg.intern(name);
2054  }
2055
2056  // Used by the compiler.
2057  public static final Symbol internInPackage(String name, String packageName)
2058
2059  {
2060    Package pkg = Packages.findPackage(packageName);
2061    if (pkg == null)
2062      error(new LispError(packageName + " is not the name of a package."));
2063    return pkg.intern(name);
2064  }
2065
2066  public static final Symbol internKeyword(String s)
2067  {
2068    return PACKAGE_KEYWORD.intern(s);
2069  }
2070
2071  // The compiler's object table.
2072  static final Hashtable<String,LispObject> objectTable =
2073          new Hashtable<String,LispObject>();
2074
2075  public static final LispObject recall(String key)
2076  {
2077    return objectTable.remove(key);
2078  }
2079
2080  public static final LispObject recall(SimpleString key)
2081  {
2082    return objectTable.remove(key.getStringValue());
2083  }
2084
2085  // ### remember
2086  public static final Primitive REMEMBER =
2087    new Primitive("remember", PACKAGE_SYS, true)
2088    {
2089      @Override
2090      public LispObject execute(LispObject key, LispObject value)
2091
2092      {
2093        objectTable.put(key.getStringValue(), value);
2094        return NIL;
2095      }
2096    };
2097
2098  public static final Symbol internSpecial(String name, Package pkg,
2099                                           LispObject value)
2100  {
2101    Symbol symbol = pkg.intern(name);
2102    symbol.setSpecial(true);
2103    symbol.setSymbolValue(value);
2104    return symbol;
2105  }
2106
2107  public static final Symbol internConstant(String name, Package pkg,
2108                                            LispObject value)
2109  {
2110    Symbol symbol = pkg.intern(name);
2111    symbol.initializeConstant(value);
2112    return symbol;
2113  }
2114
2115  public static final Symbol exportSpecial(String name, Package pkg,
2116                                           LispObject value)
2117  {
2118    Symbol symbol = pkg.intern(name);
2119    pkg.export(symbol); // FIXME Inefficient!
2120    symbol.setSpecial(true);
2121    symbol.setSymbolValue(value);
2122    return symbol;
2123  }
2124
2125  public static final Symbol exportConstant(String name, Package pkg,
2126                                            LispObject value)
2127  {
2128    Symbol symbol = pkg.intern(name);
2129    pkg.export(symbol); // FIXME Inefficient!
2130    symbol.initializeConstant(value);
2131    return symbol;
2132  }
2133
2134  static
2135  {
2136    String userDir = System.getProperty("user.dir");
2137    if (userDir != null && userDir.length() > 0)
2138      {
2139        if (userDir.charAt(userDir.length() - 1) != File.separatorChar)
2140          userDir = userDir.concat(File.separator);
2141      }
2142    // This string will be converted to a pathname when Pathname.java is loaded.
2143    Symbol.DEFAULT_PATHNAME_DEFAULTS.initializeSpecial(new SimpleString(userDir));
2144  }
2145
2146  static
2147  {
2148    Symbol._PACKAGE_.initializeSpecial(PACKAGE_CL_USER);
2149  }
2150
2151  public static final Package getCurrentPackage()
2152  {
2153    return (Package) Symbol._PACKAGE_.symbolValueNoThrow();
2154  }
2155
2156
2157
2158  public static final void resetIO(Stream in, Stream out)
2159  {
2160    stdin = in;
2161    stdout = out;
2162    Symbol.STANDARD_INPUT.setSymbolValue(stdin);
2163    Symbol.STANDARD_OUTPUT.setSymbolValue(stdout);
2164    Symbol.ERROR_OUTPUT.setSymbolValue(stdout);
2165    Symbol.TRACE_OUTPUT.setSymbolValue(stdout);
2166    Symbol.TERMINAL_IO.setSymbolValue(new TwoWayStream(stdin, stdout, true));
2167    Symbol.QUERY_IO.setSymbolValue(new TwoWayStream(stdin, stdout, true));
2168    Symbol.DEBUG_IO.setSymbolValue(new TwoWayStream(stdin, stdout, true));
2169  }
2170
2171  // Used in org/armedbear/j/JLisp.java.
2172  public static final void resetIO()
2173  {
2174    resetIO(new Stream(Symbol.SYSTEM_STREAM, System.in, Symbol.CHARACTER, true),
2175            new Stream(Symbol.SYSTEM_STREAM, System.out, Symbol.CHARACTER, true));
2176  }
2177
2178  public static final TwoWayStream getTerminalIO()
2179  {
2180    return (TwoWayStream) Symbol.TERMINAL_IO.symbolValueNoThrow();
2181  }
2182
2183  public static final Stream getStandardInput()
2184  {
2185    return (Stream) Symbol.STANDARD_INPUT.symbolValueNoThrow();
2186  }
2187
2188  public static final Stream getStandardOutput()
2189  {
2190    return checkCharacterOutputStream(Symbol.STANDARD_OUTPUT.symbolValue());
2191  }
2192
2193  static
2194  {
2195    Symbol.CURRENT_READTABLE.initializeSpecial(new Readtable());
2196  }
2197
2198  // ### +standard-readtable+
2199  // internal symbol
2200  public static final Symbol STANDARD_READTABLE =
2201    internConstant("+STANDARD-READTABLE+", PACKAGE_SYS, new Readtable());
2202
2203  public static final Readtable currentReadtable()
2204  {
2205    return (Readtable) Symbol.CURRENT_READTABLE.symbolValue();
2206  }
2207
2208  static
2209  {
2210    Symbol.READ_SUPPRESS.initializeSpecial(NIL);
2211    Symbol.DEBUGGER_HOOK.initializeSpecial(NIL);
2212  }
2213
2214  static
2215  {
2216    Symbol.MOST_POSITIVE_FIXNUM.initializeConstant(Fixnum.getInstance(Integer.MAX_VALUE));
2217    Symbol.MOST_NEGATIVE_FIXNUM.initializeConstant(Fixnum.getInstance(Integer.MIN_VALUE));
2218    Symbol.MOST_POSITIVE_JAVA_LONG.initializeConstant(Bignum.getInstance(Long.MAX_VALUE));
2219    Symbol.MOST_NEGATIVE_JAVA_LONG.initializeConstant(Bignum.getInstance(Long.MIN_VALUE));
2220  }
2221
2222  public static void exit(int status)
2223  {
2224    Interpreter interpreter = Interpreter.getInstance();
2225    if (interpreter != null)
2226      interpreter.kill(status);
2227  }
2228
2229  // ### t
2230  public static final Symbol T = Symbol.T;
2231  static
2232  {
2233    T.initializeConstant(T);
2234  }
2235
2236  static
2237  {
2238    Symbol.READ_EVAL.initializeSpecial(T);
2239  }
2240
2241  // ### *features*
2242  static
2243  {
2244    Symbol.FEATURES.initializeSpecial(NIL);
2245    String osName = System.getProperty("os.name");
2246    if (osName.startsWith("Linux"))
2247      {
2248        Symbol.FEATURES.setSymbolValue(list(Keyword.ARMEDBEAR,
2249                                             Keyword.ABCL,
2250                                             Keyword.COMMON_LISP,
2251                                             Keyword.ANSI_CL,
2252                                             Keyword.UNIX,
2253                                             Keyword.LINUX,
2254                                             Keyword.CDR6));
2255      }
2256    else if (osName.startsWith("SunOS"))
2257      {
2258        Symbol.FEATURES.setSymbolValue(list(Keyword.ARMEDBEAR,
2259                                             Keyword.ABCL,
2260                                             Keyword.COMMON_LISP,
2261                                             Keyword.ANSI_CL,
2262                                             Keyword.UNIX,
2263                                             Keyword.SUNOS,
2264                                             Keyword.CDR6));
2265      }
2266    else if (osName.startsWith("Mac OS X") ||
2267             osName.startsWith("Darwin"))
2268      {
2269        Symbol.FEATURES.setSymbolValue(list(Keyword.ARMEDBEAR,
2270                                             Keyword.ABCL,
2271                                             Keyword.COMMON_LISP,
2272                                             Keyword.ANSI_CL,
2273                                             Keyword.UNIX,
2274                                             Keyword.DARWIN,
2275                                             Keyword.CDR6));
2276      }
2277    else if (osName.startsWith("FreeBSD"))
2278      {
2279        Symbol.FEATURES.setSymbolValue(list(Keyword.ARMEDBEAR,
2280                                             Keyword.ABCL,
2281                                             Keyword.COMMON_LISP,
2282                                             Keyword.ANSI_CL,
2283                                             Keyword.UNIX,
2284                                             Keyword.FREEBSD,
2285                                             Keyword.CDR6));
2286      }
2287    else if (osName.startsWith("OpenBSD"))
2288      {
2289        Symbol.FEATURES.setSymbolValue(list(Keyword.ARMEDBEAR,
2290                                             Keyword.ABCL,
2291                                             Keyword.COMMON_LISP,
2292                                             Keyword.ANSI_CL,
2293                                             Keyword.UNIX,
2294                                             Keyword.OPENBSD,
2295                                             Keyword.CDR6));
2296      }
2297    else if (osName.startsWith("NetBSD"))
2298      {
2299        Symbol.FEATURES.setSymbolValue(list(Keyword.ARMEDBEAR,
2300                                             Keyword.ABCL,
2301                                             Keyword.COMMON_LISP,
2302                                             Keyword.ANSI_CL,
2303                                             Keyword.UNIX,
2304                                             Keyword.NETBSD,
2305                                             Keyword.CDR6));
2306      }
2307    else if (osName.startsWith("Windows"))
2308      {
2309        Symbol.FEATURES.setSymbolValue(list(Keyword.ARMEDBEAR,
2310                                             Keyword.ABCL,
2311                                             Keyword.COMMON_LISP,
2312                                             Keyword.ANSI_CL,
2313                                             Keyword.WINDOWS,
2314                                             Keyword.CDR6));
2315      }
2316    else
2317      {
2318        Symbol.FEATURES.setSymbolValue(list(Keyword.ARMEDBEAR,
2319                                             Keyword.ABCL,
2320                                             Keyword.COMMON_LISP,
2321                                             Keyword.ANSI_CL,
2322                                             Keyword.CDR6));
2323      }
2324  }
2325  static
2326  {
2327    final String version = System.getProperty("java.version");
2328    if (version.startsWith("1.5"))
2329      {
2330        Symbol.FEATURES.setSymbolValue(new Cons(Keyword.JAVA_1_5,
2331                                                Symbol.FEATURES.getSymbolValue()));
2332      }
2333    else if (version.startsWith("1.6"))
2334      {
2335        Symbol.FEATURES.setSymbolValue(new Cons(Keyword.JAVA_1_6,
2336                                                Symbol.FEATURES.getSymbolValue()));
2337      }
2338    else if (version.startsWith("1.7"))
2339      {
2340        Symbol.FEATURES.setSymbolValue(new Cons(Keyword.JAVA_1_7,
2341                                                Symbol.FEATURES.getSymbolValue()));
2342      }
2343  }
2344  static
2345  {
2346    String os_arch = System.getProperty("os.arch");
2347    if(os_arch != null) {
2348      if (os_arch.equals("amd64"))
2349        Symbol.FEATURES.setSymbolValue(new Cons(Keyword.X86_64,
2350                                                Symbol.FEATURES.getSymbolValue()));
2351      else if (os_arch.equals("x86"))
2352        Symbol.FEATURES.setSymbolValue(new Cons(Keyword.X86,
2353                                                Symbol.FEATURES.getSymbolValue()));
2354    }
2355  }
2356
2357  static
2358  {
2359    Symbol.MODULES.initializeSpecial(NIL);
2360  }
2361
2362  static
2363  {
2364    Symbol.LOAD_VERBOSE.initializeSpecial(NIL);
2365    Symbol.LOAD_PRINT.initializeSpecial(NIL);
2366    Symbol.LOAD_PATHNAME.initializeSpecial(NIL);
2367    Symbol.LOAD_TRUENAME.initializeSpecial(NIL);
2368    Symbol.LOAD_TRUENAME_FASL.initializeSpecial(NIL);
2369    Symbol.COMPILE_VERBOSE.initializeSpecial(T);
2370    Symbol.COMPILE_PRINT.initializeSpecial(T);
2371    Symbol._COMPILE_FILE_PATHNAME_.initializeSpecial(NIL);
2372    Symbol.COMPILE_FILE_TRUENAME.initializeSpecial(NIL);
2373  }
2374
2375  // ### *double-colon-package-separators*
2376  // internal symbol
2377  public static final Symbol DOUBLE_COLON_PACKAGE_SEPARATORS =
2378    internSpecial("*DOUBLE-COLON-PACKAGE-SEPARATORS*", PACKAGE_SYS, NIL);
2379
2380  // ### *load-depth*
2381  // internal symbol
2382  public static final Symbol _LOAD_DEPTH_ =
2383    internSpecial("*LOAD-DEPTH*", PACKAGE_SYS, Fixnum.ZERO);
2384
2385  // ### *load-stream*
2386  // internal symbol
2387  public static final Symbol _LOAD_STREAM_ =
2388    internSpecial("*LOAD-STREAM*", PACKAGE_SYS, NIL);
2389
2390  // ### *source*
2391  // internal symbol
2392  public static final Symbol _SOURCE_ =
2393    exportSpecial("*SOURCE*", PACKAGE_SYS, NIL);
2394
2395  // ### *source-position*
2396  // internal symbol
2397  public static final Symbol _SOURCE_POSITION_ =
2398    exportSpecial("*SOURCE-POSITION*", PACKAGE_SYS, NIL);
2399
2400  // ### *autoload-verbose*
2401  // internal symbol
2402  public static final Symbol _AUTOLOAD_VERBOSE_ =
2403    exportSpecial("*AUTOLOAD-VERBOSE*", PACKAGE_EXT, NIL);
2404
2405  // ### *preloading-cache*
2406 public static final Symbol AUTOLOADING_CACHE =
2407   internSpecial("*AUTOLOADING-CACHE*", PACKAGE_SYS, NIL);
2408
2409  // ### *compile-file-type*
2410  public static final String COMPILE_FILE_TYPE = "abcl";
2411  public static final Symbol _COMPILE_FILE_TYPE_ =
2412    internConstant("*COMPILE-FILE-TYPE*", PACKAGE_SYS,
2413                   new SimpleString(COMPILE_FILE_TYPE));
2414
2415  // ### *compile-file-zip*
2416  public static final Symbol _COMPILE_FILE_ZIP_ =
2417    exportSpecial("*COMPILE-FILE-ZIP*", PACKAGE_SYS, T);
2418
2419  static
2420  {
2421    Symbol.MACROEXPAND_HOOK.initializeSpecial(Symbol.FUNCALL);
2422  }
2423
2424  public static final int ARRAY_DIMENSION_MAX = Integer.MAX_VALUE;
2425  static
2426  {
2427    // ### array-dimension-limit
2428    Symbol.ARRAY_DIMENSION_LIMIT.initializeConstant(Fixnum.getInstance(ARRAY_DIMENSION_MAX));
2429  }
2430
2431  // ### char-code-limit
2432  // "The upper exclusive bound on the value returned by the function CHAR-CODE."
2433  public static final int CHAR_MAX = Character.MAX_VALUE;
2434  static
2435  {
2436    Symbol.CHAR_CODE_LIMIT.initializeConstant(Fixnum.getInstance(CHAR_MAX + 1));
2437  }
2438
2439  static
2440  {
2441    Symbol.READ_BASE.initializeSpecial(Fixnum.constants[10]);
2442  }
2443
2444  static
2445  {
2446    Symbol.READ_DEFAULT_FLOAT_FORMAT.initializeSpecial(Symbol.SINGLE_FLOAT);
2447  }
2448
2449  // Printer control variables.
2450  static
2451  {
2452    Symbol.PRINT_ARRAY.initializeSpecial(T);
2453    Symbol.PRINT_BASE.initializeSpecial(Fixnum.constants[10]);
2454    Symbol.PRINT_CASE.initializeSpecial(Keyword.UPCASE);
2455    Symbol.PRINT_CIRCLE.initializeSpecial(NIL);
2456    Symbol.PRINT_ESCAPE.initializeSpecial(T);
2457    Symbol.PRINT_GENSYM.initializeSpecial(T);
2458    Symbol.PRINT_LENGTH.initializeSpecial(NIL);
2459    Symbol.PRINT_LEVEL.initializeSpecial(NIL);
2460    Symbol.PRINT_LINES.initializeSpecial(NIL);
2461    Symbol.PRINT_MISER_WIDTH.initializeSpecial(NIL);
2462    Symbol.PRINT_PPRINT_DISPATCH.initializeSpecial(NIL);
2463    Symbol.PRINT_PRETTY.initializeSpecial(NIL);
2464    Symbol.PRINT_RADIX.initializeSpecial(NIL);
2465    Symbol.PRINT_READABLY.initializeSpecial(NIL);
2466    Symbol.PRINT_RIGHT_MARGIN.initializeSpecial(NIL);
2467  }
2468
2469  public static final Symbol _PRINT_STRUCTURE_ =
2470    exportSpecial("*PRINT-STRUCTURE*", PACKAGE_EXT, T);
2471
2472  // ### *current-print-length*
2473  public static final Symbol _CURRENT_PRINT_LENGTH_ =
2474    exportSpecial("*CURRENT-PRINT-LENGTH*", PACKAGE_SYS, Fixnum.ZERO);
2475
2476  // ### *current-print-level*
2477  public static final Symbol _CURRENT_PRINT_LEVEL_ =
2478    exportSpecial("*CURRENT-PRINT-LEVEL*", PACKAGE_SYS, Fixnum.ZERO);
2479
2480  public static final Symbol _PRINT_FASL_ =
2481    internSpecial("*PRINT-FASL*", PACKAGE_SYS, NIL);
2482
2483  static
2484  {
2485    Symbol._RANDOM_STATE_.initializeSpecial(new RandomState());
2486  }
2487
2488  static
2489  {
2490    Symbol.STAR.initializeSpecial(NIL);
2491    Symbol.STAR_STAR.initializeSpecial(NIL);
2492    Symbol.STAR_STAR_STAR.initializeSpecial(NIL);
2493    Symbol.MINUS.initializeSpecial(NIL);
2494    Symbol.PLUS.initializeSpecial(NIL);
2495    Symbol.PLUS_PLUS.initializeSpecial(NIL);
2496    Symbol.PLUS_PLUS_PLUS.initializeSpecial(NIL);
2497    Symbol.SLASH.initializeSpecial(NIL);
2498    Symbol.SLASH_SLASH.initializeSpecial(NIL);
2499    Symbol.SLASH_SLASH_SLASH.initializeSpecial(NIL);
2500  }
2501
2502  // Floating point constants.
2503  static
2504  {
2505    Symbol.PI.initializeConstant(new DoubleFloat(Math.PI));
2506    Symbol.SHORT_FLOAT_EPSILON.initializeConstant(new SingleFloat((float)5.960465E-8));
2507    Symbol.SINGLE_FLOAT_EPSILON.initializeConstant(new SingleFloat((float)5.960465E-8));
2508    Symbol.DOUBLE_FLOAT_EPSILON.initializeConstant(new DoubleFloat((double)1.1102230246251568E-16));
2509    Symbol.LONG_FLOAT_EPSILON.initializeConstant(new DoubleFloat((double)1.1102230246251568E-16));
2510    Symbol.SHORT_FLOAT_NEGATIVE_EPSILON.initializeConstant(new SingleFloat(2.9802326e-8f));
2511    Symbol.SINGLE_FLOAT_NEGATIVE_EPSILON.initializeConstant(new SingleFloat(2.9802326e-8f));
2512    Symbol.DOUBLE_FLOAT_NEGATIVE_EPSILON.initializeConstant(new DoubleFloat((double)5.551115123125784E-17));
2513    Symbol.LONG_FLOAT_NEGATIVE_EPSILON.initializeConstant(new DoubleFloat((double)5.551115123125784E-17));
2514    Symbol.MOST_POSITIVE_SHORT_FLOAT.initializeConstant(new SingleFloat(Float.MAX_VALUE));
2515    Symbol.MOST_POSITIVE_SINGLE_FLOAT.initializeConstant(new SingleFloat(Float.MAX_VALUE));
2516    Symbol.MOST_POSITIVE_DOUBLE_FLOAT.initializeConstant(new DoubleFloat(Double.MAX_VALUE));
2517    Symbol.MOST_POSITIVE_LONG_FLOAT.initializeConstant(new DoubleFloat(Double.MAX_VALUE));
2518    Symbol.LEAST_POSITIVE_SHORT_FLOAT.initializeConstant(new SingleFloat(Float.MIN_VALUE));
2519    Symbol.LEAST_POSITIVE_SINGLE_FLOAT.initializeConstant(new SingleFloat(Float.MIN_VALUE));
2520    Symbol.LEAST_POSITIVE_DOUBLE_FLOAT.initializeConstant(new DoubleFloat(Double.MIN_VALUE));
2521    Symbol.LEAST_POSITIVE_LONG_FLOAT.initializeConstant(new DoubleFloat(Double.MIN_VALUE));
2522    Symbol.LEAST_POSITIVE_NORMALIZED_SHORT_FLOAT.initializeConstant(new SingleFloat(1.17549435e-38f));
2523    Symbol.LEAST_POSITIVE_NORMALIZED_SINGLE_FLOAT.initializeConstant(new SingleFloat(1.17549435e-38f));
2524    Symbol.LEAST_POSITIVE_NORMALIZED_DOUBLE_FLOAT.initializeConstant(new DoubleFloat(2.2250738585072014e-308d));
2525    Symbol.LEAST_POSITIVE_NORMALIZED_LONG_FLOAT.initializeConstant(new DoubleFloat(2.2250738585072014e-308d));
2526    Symbol.MOST_NEGATIVE_SHORT_FLOAT.initializeConstant(new SingleFloat(- Float.MAX_VALUE));
2527    Symbol.MOST_NEGATIVE_SINGLE_FLOAT.initializeConstant(new SingleFloat(- Float.MAX_VALUE));
2528    Symbol.MOST_NEGATIVE_DOUBLE_FLOAT.initializeConstant(new DoubleFloat(- Double.MAX_VALUE));
2529    Symbol.MOST_NEGATIVE_LONG_FLOAT.initializeConstant(new DoubleFloat(- Double.MAX_VALUE));
2530    Symbol.LEAST_NEGATIVE_SHORT_FLOAT.initializeConstant(new SingleFloat(- Float.MIN_VALUE));
2531    Symbol.LEAST_NEGATIVE_SINGLE_FLOAT.initializeConstant(new SingleFloat(- Float.MIN_VALUE));
2532    Symbol.LEAST_NEGATIVE_DOUBLE_FLOAT.initializeConstant(new DoubleFloat(- Double.MIN_VALUE));
2533    Symbol.LEAST_NEGATIVE_LONG_FLOAT.initializeConstant(new DoubleFloat(- Double.MIN_VALUE));
2534    Symbol.LEAST_NEGATIVE_NORMALIZED_SHORT_FLOAT.initializeConstant(new SingleFloat(-1.17549435e-38f));
2535    Symbol.LEAST_NEGATIVE_NORMALIZED_SINGLE_FLOAT.initializeConstant(new SingleFloat(-1.17549435e-38f));
2536    Symbol.LEAST_NEGATIVE_NORMALIZED_DOUBLE_FLOAT.initializeConstant(new DoubleFloat(-2.2250738585072014e-308d));
2537    Symbol.LEAST_NEGATIVE_NORMALIZED_LONG_FLOAT.initializeConstant(new DoubleFloat(-2.2250738585072014e-308d));
2538  }
2539
2540  static
2541  {
2542    Symbol.BOOLE_CLR.initializeConstant(Fixnum.ZERO);
2543    Symbol.BOOLE_SET.initializeConstant(Fixnum.ONE);
2544    Symbol.BOOLE_1.initializeConstant(Fixnum.TWO);
2545    Symbol.BOOLE_2.initializeConstant(Fixnum.constants[3]);
2546    Symbol.BOOLE_C1.initializeConstant(Fixnum.constants[4]);
2547    Symbol.BOOLE_C2.initializeConstant(Fixnum.constants[5]);
2548    Symbol.BOOLE_AND.initializeConstant(Fixnum.constants[6]);
2549    Symbol.BOOLE_IOR.initializeConstant(Fixnum.constants[7]);
2550    Symbol.BOOLE_XOR.initializeConstant(Fixnum.constants[8]);
2551    Symbol.BOOLE_EQV.initializeConstant(Fixnum.constants[9]);
2552    Symbol.BOOLE_NAND.initializeConstant(Fixnum.constants[10]);
2553    Symbol.BOOLE_NOR.initializeConstant(Fixnum.constants[11]);
2554    Symbol.BOOLE_ANDC1.initializeConstant(Fixnum.constants[12]);
2555    Symbol.BOOLE_ANDC2.initializeConstant(Fixnum.constants[13]);
2556    Symbol.BOOLE_ORC1.initializeConstant(Fixnum.constants[14]);
2557    Symbol.BOOLE_ORC2.initializeConstant(Fixnum.constants[15]);
2558  }
2559
2560  static
2561  {
2562    // ### call-arguments-limit
2563    Symbol.CALL_ARGUMENTS_LIMIT.initializeConstant(Fixnum.constants[50]);
2564  }
2565
2566  static
2567  {
2568    // ### lambda-parameters-limit
2569    Symbol.LAMBDA_PARAMETERS_LIMIT.initializeConstant(Fixnum.constants[50]);
2570  }
2571
2572  static
2573  {
2574    // ### multiple-values-limit
2575    Symbol.MULTIPLE_VALUES_LIMIT.initializeConstant(Fixnum.constants[20]);
2576  }
2577
2578  static
2579  {
2580    // ### internal-time-units-per-second
2581    Symbol.INTERNAL_TIME_UNITS_PER_SECOND.initializeConstant(Fixnum.getInstance(1000));
2582  }
2583
2584  static
2585  {
2586    Symbol.LAMBDA_LIST_KEYWORDS
2587      .initializeConstant(list(Symbol.AND_OPTIONAL,
2588                               Symbol.AND_REST,
2589                               Symbol.AND_KEY,
2590                               Symbol.AND_AUX,
2591                               Symbol.AND_BODY,
2592                               Symbol.AND_WHOLE,
2593                               Symbol.AND_ALLOW_OTHER_KEYS,
2594                               Symbol.AND_ENVIRONMENT));
2595  }
2596
2597  // ### call-registers-limit
2598  public static final Symbol CALL_REGISTERS_LIMIT =
2599    exportConstant("CALL-REGISTERS-LIMIT", PACKAGE_SYS,
2600                   Fixnum.constants[CALL_REGISTERS_MAX]);
2601
2602  // ### *warn-on-redefinition*
2603  public static final Symbol _WARN_ON_REDEFINITION_ =
2604    exportSpecial("*WARN-ON-REDEFINITION*", PACKAGE_EXT, T);
2605
2606  // ### *saved-backtrace*
2607  public static final Symbol _SAVED_BACKTRACE_ =
2608    exportSpecial("*SAVED-BACKTRACE*", PACKAGE_EXT, NIL);
2609
2610  // ### *command-line-argument-list*
2611  public static final Symbol _COMMAND_LINE_ARGUMENT_LIST_ =
2612    exportSpecial("*COMMAND-LINE-ARGUMENT-LIST*", PACKAGE_EXT, NIL);
2613
2614  // ### *batch-mode*
2615  public static final Symbol _BATCH_MODE_ =
2616    exportSpecial("*BATCH-MODE*", PACKAGE_EXT, NIL);
2617
2618  // ### *noinform*
2619  public static final Symbol _NOINFORM_ =
2620    exportSpecial("*NOINFORM*", PACKAGE_SYS, NIL);
2621
2622  // ### *disassembler*
2623  public static final Symbol _DISASSEMBLER_ =
2624    exportSpecial("*DISASSEMBLER*", PACKAGE_EXT,
2625                  new SimpleString("jad -a -p")); // or "jad -dis -p"
2626
2627  // ### *speed* compiler policy
2628  public static final Symbol _SPEED_ =
2629    exportSpecial("*SPEED*", PACKAGE_SYS, Fixnum.ONE);
2630
2631  // ### *space* compiler policy
2632  public static final Symbol _SPACE_ =
2633    exportSpecial("*SPACE*", PACKAGE_SYS, Fixnum.ONE);
2634
2635  // ### *safety* compiler policy
2636  public static final Symbol _SAFETY_ =
2637    exportSpecial("*SAFETY*", PACKAGE_SYS, Fixnum.ONE);
2638
2639  // ### *debug* compiler policy
2640  public static final Symbol _DEBUG_ =
2641    exportSpecial("*DEBUG*", PACKAGE_SYS, Fixnum.ONE);
2642
2643  // ### *explain* compiler policy
2644  public static final Symbol _EXPLAIN_ =
2645    exportSpecial("*EXPLAIN*", PACKAGE_SYS, NIL);
2646
2647  // ### *enable-inline-expansion*
2648  public static final Symbol _ENABLE_INLINE_EXPANSION_ =
2649    exportSpecial("*ENABLE-INLINE-EXPANSION*", PACKAGE_EXT, T);
2650
2651  // ### *require-stack-frame*
2652  public static final Symbol _REQUIRE_STACK_FRAME_ =
2653    exportSpecial("*REQUIRE-STACK-FRAME*", PACKAGE_EXT, NIL);
2654
2655  static
2656  {
2657    Symbol.SUPPRESS_COMPILER_WARNINGS.initializeSpecial(NIL);
2658  }
2659
2660  public static final Symbol _COMPILE_FILE_ENVIRONMENT_ =
2661    exportSpecial("*COMPILE-FILE-ENVIRONMENT*", PACKAGE_SYS, NIL);
2662
2663  public static final LispObject UNBOUND_VALUE = new unboundValue();
2664  static class unboundValue extends LispObject
2665  {
2666    @Override
2667    public String writeToString()
2668    {
2669      return "#<UNBOUND>";
2670    }
2671  }
2672
2673  public static final LispObject NULL_VALUE = new nullValue();
2674  static class nullValue extends LispObject
2675  {
2676    @Override
2677    public String writeToString()
2678    {
2679      return "null";
2680    }
2681  }
2682
2683  public static final Symbol _SLOT_UNBOUND_ =
2684    exportConstant("+SLOT-UNBOUND+", PACKAGE_SYS, UNBOUND_VALUE);
2685
2686  public static final Symbol _CL_PACKAGE_ =
2687    exportConstant("+CL-PACKAGE+", PACKAGE_SYS, PACKAGE_CL);
2688
2689  public static final Symbol _KEYWORD_PACKAGE_ =
2690    exportConstant("+KEYWORD-PACKAGE+", PACKAGE_SYS, PACKAGE_KEYWORD);
2691
2692  // ### *backquote-count*
2693  public static final Symbol _BACKQUOTE_COUNT_ =
2694    internSpecial("*BACKQUOTE-COUNT*", PACKAGE_SYS, Fixnum.ZERO);
2695
2696  // ### *bq-vector-flag*
2697  public static final Symbol _BQ_VECTOR_FLAG_ =
2698    internSpecial("*BQ-VECTOR-FLAG*", PACKAGE_SYS, list(new Symbol("bqv")));
2699
2700  // ### *traced-names*
2701  public static final Symbol _TRACED_NAMES_ =
2702    exportSpecial("*TRACED-NAMES*", PACKAGE_SYS, NIL);
2703
2704  // Floating point traps.
2705  protected static boolean TRAP_OVERFLOW  = true;
2706  protected static boolean TRAP_UNDERFLOW = true;
2707
2708
2709  // Extentions
2710  static {
2711    Symbol._INSPECTOR_HOOK_.initializeSpecial(NIL);
2712  }
2713
2714  private static final void loadClass(String className)
2715  {
2716    try
2717      {
2718        Class.forName(className);
2719      }
2720    catch (ClassNotFoundException e)
2721      {
2722        Debug.trace(e);
2723      }
2724  }
2725
2726  static
2727  {
2728    loadClass("org.armedbear.lisp.Primitives");
2729    loadClass("org.armedbear.lisp.SpecialOperators");
2730    loadClass("org.armedbear.lisp.Extensions");
2731    loadClass("org.armedbear.lisp.CompiledClosure");
2732    loadClass("org.armedbear.lisp.Autoload");
2733    loadClass("org.armedbear.lisp.AutoloadMacro");
2734    loadClass("org.armedbear.lisp.cxr");
2735    loadClass("org.armedbear.lisp.Do");
2736    loadClass("org.armedbear.lisp.dolist");
2737    loadClass("org.armedbear.lisp.dotimes");
2738    loadClass("org.armedbear.lisp.Pathname");
2739    loadClass("org.armedbear.lisp.LispClass");
2740    loadClass("org.armedbear.lisp.BuiltInClass");
2741    loadClass("org.armedbear.lisp.StructureObject");
2742    loadClass("org.armedbear.lisp.ash");
2743    loadClass("org.armedbear.lisp.Java");
2744    loadClass("org.armedbear.lisp.PackageFunctions");
2745    cold = false;
2746  }
2747
2748    private static Stream stdin = new Stream(Symbol.SYSTEM_STREAM, System.in, Symbol.CHARACTER, true);
2749
2750    private static Stream stdout = new Stream(Symbol.SYSTEM_STREAM,System.out, Symbol.CHARACTER, true);
2751
2752  static
2753  {
2754    Symbol.STANDARD_INPUT.initializeSpecial(stdin);
2755    Symbol.STANDARD_OUTPUT.initializeSpecial(stdout);
2756    Symbol.ERROR_OUTPUT.initializeSpecial(stdout);
2757    Symbol.TRACE_OUTPUT.initializeSpecial(stdout);
2758    Symbol.TERMINAL_IO.initializeSpecial(new TwoWayStream(stdin, stdout, true));
2759    Symbol.QUERY_IO.initializeSpecial(new TwoWayStream(stdin, stdout, true));
2760    Symbol.DEBUG_IO.initializeSpecial(new TwoWayStream(stdin, stdout, true));
2761  }
2762
2763}
Note: See TracBrowser for help on using the repository browser.