Java API By Example, From Geeks To Geeks.

1 /* 2  * Lisp.java 3  * 4  * Copyright (C) 2002-2004 Peter Graves 5  * $Id: Lisp.java,v 1.280 2004/09/18 01:05:26 piso Exp $ 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 20  */ 21 22 package org.armedbear.lisp; 23 24 import java.io.File ; 25 import java.io.IOException ; 26 import java.io.InputStream ; 27 import java.math.BigInteger ; 28 import java.net.URL ; 29 import java.util.Hashtable ; 30 import java.util.zip.ZipEntry ; 31 import java.util.zip.ZipFile ; 32 33 public abstract class Lisp 34 { 35     public static boolean cold = true; 36 37     public static boolean initialized; 38 39     // Packages. 40 public static final Package PACKAGE_CL = 41         Packages.createPackage("COMMON-LISP", 1024); 42     public static final Package PACKAGE_CL_USER = 43         Packages.createPackage("COMMON-LISP-USER", 1024); 44     public static final Package PACKAGE_SYS = 45         Packages.createPackage("SYSTEM"); 46     public static final Package PACKAGE_TPL = 47         Packages.createPackage("TOP-LEVEL"); 48     public static final Package PACKAGE_EXT = 49         Packages.createPackage("EXTENSIONS"); 50     public static final Package PACKAGE_JVM = 51         Packages.createPackage("JVM"); 52     public static final Package PACKAGE_PROF = 53         Packages.createPackage("PROFILER"); 54     public static final Package PACKAGE_JAVA = 55         Packages.createPackage("JAVA"); 56     static { 57         try { 58             PACKAGE_CL.addNickname("CL"); 59             PACKAGE_CL_USER.addNickname("CL-USER"); 60             PACKAGE_CL_USER.usePackage(PACKAGE_CL); 61             PACKAGE_CL_USER.usePackage(PACKAGE_EXT); 62             PACKAGE_CL_USER.usePackage(PACKAGE_JAVA); 63             PACKAGE_SYS.addNickname("SYS"); 64             PACKAGE_SYS.usePackage(PACKAGE_CL); 65             PACKAGE_SYS.usePackage(PACKAGE_EXT); 66             PACKAGE_TPL.addNickname("TPL"); 67             PACKAGE_TPL.usePackage(PACKAGE_CL); 68             PACKAGE_TPL.usePackage(PACKAGE_EXT); 69             PACKAGE_EXT.addNickname("EXT"); 70             PACKAGE_EXT.usePackage(PACKAGE_CL); 71             PACKAGE_JVM.usePackage(PACKAGE_CL); 72             PACKAGE_JVM.usePackage(PACKAGE_EXT); 73             PACKAGE_PROF.addNickname("PROF"); 74             PACKAGE_PROF.usePackage(PACKAGE_CL); 75             PACKAGE_PROF.usePackage(PACKAGE_EXT); 76             PACKAGE_JAVA.usePackage(PACKAGE_CL); 77             PACKAGE_JAVA.usePackage(PACKAGE_EXT); 78         } 79         catch (Throwable t) { 80             t.printStackTrace(); 81         } 82     } 83     public static final Package PACKAGE_KEYWORD = 84         Packages.createPackage("KEYWORD", 1024); 85 86     static { 87         PACKAGE_CL.addInitialExports(Exports.COMMON_LISP_SYMBOL_NAMES); 88     } 89 90     // ### nil 91 public static final LispObject NIL = new Nil(PACKAGE_CL); 92 93     // End-of-file marker. 94 public static final LispObject EOF = new LispObject(); 95 96     // Functional types. 97 static final int FTYPE_SPECIAL_OPERATOR = 1; 98     static final int FTYPE_MACRO = 2; 99     static final int FTYPE_AUTOLOAD = 3; 100 101     private static boolean debug = true; 102 103     public static boolean profiling; 104 105     public static boolean sampling; 106 107     public static volatile boolean sampleNow; 108 109     // argv must not be null! 110 public static final LispObject funcall(LispObject fun, LispObject[] argv, 111                                            LispThread thread) 112         throws ConditionThrowable 113     { 114         if (fun instanceof Autoload) { 115             Autoload autoload = (Autoload) fun; 116             autoload.load(); 117             fun = autoload.getSymbol().getSymbolFunction(); 118         } 119         LispObject stack = thread.getStack(); 120         thread.pushStackFrame(fun, argv); 121         thread.clearValues(); 122         LispObject result; 123         if (profiling) 124             if (!sampling) 125                 fun.incrementCallCount(); 126         try { 127             switch (argv.length) { 128                 case 0: 129                     result = fun.execute(); 130                     break; 131                 case 1: 132                     result = fun.execute(argv[0]); 133                     break; 134                 case 2: 135                     result = fun.execute(argv[0], argv[1]); 136                     break; 137                 case 3: 138                     result = fun.execute(argv[0], argv[1], argv[2]); 139                     break; 140                 case 4: 141                     result = fun.execute(argv[0], argv[1], argv[2], argv[3]); 142                     break; 143                 default: 144                     result = fun.execute(argv); 145                     break; 146             } 147         } 148         finally { 149             thread.setStack(stack); 150         } 151         return result; 152     } 153 154     public static final LispObject funcall0(LispObject fun, LispThread thread) 155         throws ConditionThrowable 156     { 157         if (fun instanceof Autoload) { 158             Autoload autoload = (Autoload) fun; 159             autoload.load(); 160             fun = autoload.getSymbol().getSymbolFunction(); 161         } 162         LispObject stack = thread.getStack(); 163         LispObject[] argv = new LispObject[0]; 164         thread.pushStackFrame(fun, argv); 165         thread.clearValues(); 166         LispObject result; 167         if (profiling) 168             if (!sampling) 169                 fun.incrementCallCount(); 170         try { 171             result = fun.execute(); 172         } 173         finally { 174             thread.setStack(stack); 175         } 176         return result; 177     } 178 179     public static final LispObject funcall1(LispObject fun, LispObject arg, 180                                             LispThread thread) 181         throws ConditionThrowable 182     { 183         if (fun instanceof Autoload) { 184             Autoload autoload = (Autoload) fun; 185             autoload.load(); 186             fun = autoload.getSymbol().getSymbolFunction(); 187         } 188         LispObject stack = thread.getStack(); 189         LispObject[] argv = new LispObject[1]; 190         argv[0] = arg; 191         thread.pushStackFrame(fun, argv); 192         thread.clearValues(); 193         LispObject result; 194         if (profiling) 195             if (!sampling) 196                 fun.incrementCallCount(); 197         try { 198             result = fun.execute(arg); 199         } 200         finally { 201             thread.setStack(stack); 202         } 203         return result; 204     } 205 206     public static final LispObject funcall2(LispObject fun, LispObject first, 207                                             LispObject second, LispThread thread) 208         throws ConditionThrowable 209     { 210         if (fun instanceof Autoload) { 211             Autoload autoload = (Autoload) fun; 212             autoload.load(); 213             fun = autoload.getSymbol().getSymbolFunction(); 214         } 215         LispObject stack = thread.getStack(); 216         LispObject[] argv = new LispObject[2]; 217         argv[0] = first; 218         argv[1] = second; 219         thread.pushStackFrame(fun, argv); 220         thread.clearValues(); 221         LispObject result; 222         if (profiling) 223             if (!sampling) 224                 fun.incrementCallCount(); 225         try { 226             result = fun.execute(first, second); 227         } 228         finally { 229             thread.setStack(stack); 230         } 231         return result; 232     } 233 234     public static final LispObject funcall3(LispObject fun, LispObject first, 235                                             LispObject second, LispObject third, 236                                             LispThread thread) 237         throws ConditionThrowable 238     { 239         if (fun instanceof Autoload) { 240             Autoload autoload = (Autoload) fun; 241             autoload.load(); 242             fun = autoload.getSymbol().getSymbolFunction(); 243         } 244         LispObject stack = thread.getStack(); 245         LispObject[] argv = new LispObject[3]; 246         argv[0] = first; 247         argv[1] = second; 248         argv[2] = third; 249         thread.pushStackFrame(fun, argv); 250         thread.clearValues(); 251         LispObject result; 252         if (profiling) 253             if (!sampling) 254                 fun.incrementCallCount(); 255         try { 256             result = fun.execute(first, second, third); 257         } 258         finally { 259             thread.setStack(stack); 260         } 261         return result; 262     } 263 264     public static final LispObject macroexpand(LispObject form, 265                                                final Environment env, 266                                                final LispThread thread) 267         throws ConditionThrowable 268     { 269         LispObject expanded = NIL; 270         while (true) { 271             form = macroexpand_1(form, env, thread); 272             LispObject[] values = thread.getValues(); 273             if (values[1] == NIL) { 274                 values[1] = expanded; 275                 return form; 276             } 277             expanded = T; 278         } 279     } 280 281     public static final LispObject macroexpand_1(final LispObject form, 282                                                  final Environment env, 283                                                  final LispThread thread) 284         throws ConditionThrowable 285     { 286         if (form instanceof Cons) { 287             LispObject car = form.car(); 288             if (car instanceof Symbol) { 289                 LispObject obj = env.lookupFunctional(car); 290                 if (obj instanceof Autoload) { 291                     Autoload autoload = (Autoload) obj; 292                     autoload.load(); 293                     obj = autoload.getSymbol().getSymbolFunction(); 294                 } 295                 if (obj instanceof SpecialOperator) { 296                     obj = get((Symbol)car, Symbol.MACROEXPAND_MACRO); 297                     if (obj instanceof Autoload) { 298                         Autoload autoload = (Autoload) obj; 299                         autoload.load(); 300                         obj = get((Symbol)car, Symbol.MACROEXPAND_MACRO); 301                     } 302                 } 303                 if (obj instanceof MacroObject) { 304                     LispObject expander = ((MacroObject)obj).getExpander(); 305                     if (profiling) 306                         if (!sampling) 307                             expander.incrementCallCount(); 308                     LispObject hook = 309                         coerceToFunction(_MACROEXPAND_HOOK_.symbolValue(thread)); 310                     return thread.setValues(hook.execute(expander, form, env), 311                                             T); 312                 } 313             } 314         } else if (form instanceof Symbol) { 315             Symbol symbol = (Symbol) form; 316             LispObject obj = null; 317             if (symbol.isSpecialVariable()) 318                 obj = thread.lookupSpecial(symbol); 319             else 320                 obj = env.lookup(symbol); 321             if (obj == null) 322                 obj = symbol.getSymbolValue(); 323             if (obj instanceof SymbolMacro) 324                 return thread.setValues(((SymbolMacro)obj).getExpansion(), T); 325         } 326         // Not a macro. 327 return thread.setValues(form, NIL); 328     } 329 330     // ### interactive-eval 331 private static final Primitive1 INTERACTIVE_EVAL = 332         new Primitive1("interactive-eval", PACKAGE_SYS, false) 333     { 334         public LispObject execute(LispObject object) throws ConditionThrowable 335         { 336             final LispThread thread = LispThread.currentThread(); 337             Symbol.MINUS.setSymbolValue(object); 338             LispObject result; 339             try { 340                 result = funcall1(Symbol.EVAL.getSymbolFunction(), object, thread); 341             } 342             catch (OutOfMemoryError e) { 343                 return signal(new LispError("Out of memory.")); 344             } 345             catch (StackOverflowError e) { 346                 return signal(new StorageCondition("Stack overflow.")); 347             } 348             catch (ConditionThrowable t) { 349                 throw t; 350             } 351             catch (Throwable t) { 352                 Debug.trace(t); 353                 thread.bindSpecial(_SAVED_BACKTRACE_, 354                                    thread.backtraceAsList(0)); 355                 return signal(new LispError("Caught " + t + ".")); 356             } 357             Debug.assertTrue(result != null); 358             Symbol.STAR_STAR_STAR.setSymbolValue(Symbol.STAR_STAR.getSymbolValue()); 359             Symbol.STAR_STAR.setSymbolValue(Symbol.STAR.getSymbolValue()); 360             Symbol.STAR.setSymbolValue(result); 361             Symbol.PLUS_PLUS_PLUS.setSymbolValue(Symbol.PLUS_PLUS.getSymbolValue()); 362             Symbol.PLUS_PLUS.setSymbolValue(Symbol.PLUS.getSymbolValue()); 363             Symbol.PLUS.setSymbolValue(Symbol.MINUS.getSymbolValue()); 364             LispObject[] values = thread.getValues(); 365             Symbol.SLASH_SLASH_SLASH.setSymbolValue(Symbol.SLASH_SLASH.getSymbolValue()); 366             Symbol.SLASH_SLASH.setSymbolValue(Symbol.SLASH.getSymbolValue()); 367             if (values != null) { 368                 LispObject slash = NIL; 369                 for (int i = values.length; i-- > 0;) 370                     slash = new Cons(values[i], slash); 371                 Symbol.SLASH.setSymbolValue(slash); 372             } else { 373                 Symbol.SLASH.setSymbolValue(new Cons(result)); 374             } 375             return result; 376         } 377     }; 378 379     public static final LispObject signal(Condition condition) 380         throws ConditionThrowable 381     { 382         return Symbol.SIGNAL.getSymbolFunction().execute(condition); 383     } 384 385     protected static volatile boolean interrupted; 386 387     public static synchronized final void setInterrupted(boolean b) 388     { 389         interrupted = b; 390     } 391 392     public static final void handleInterrupt() throws ConditionThrowable 393     { 394         setInterrupted(false); 395         Symbol.BREAK.getSymbolFunction().execute(); 396         setInterrupted(false); 397     } 398 399     public static final LispObject eval(final LispObject obj, 400                                         final Environment env, 401                                         final LispThread thread) 402         throws ConditionThrowable 403     { 404         if (profiling && sampling) { 405             // FIXME 406 // This is not exactly the right place to do this. We should 407 // include the current call as well. 408 if (sampleNow) 409                 Profiler.sample(thread); 410         } 411         thread.clearValues(); 412         if (interrupted) 413             handleInterrupt(); 414         if (thread.isDestroyed()) 415             throw new ThreadDestroyed(); 416         if (obj instanceof Symbol) { 417             LispObject result = null; 418             if (env.isDeclaredSpecial((Symbol)obj) || obj.isSpecialVariable()) 419                 result = thread.lookupSpecial(obj); 420             else 421                 result = env.lookup(obj); 422             if (result == null) { 423                 result = obj.getSymbolValue(); 424                 if (result == null) 425                     return signal(new UnboundVariable(obj)); 426             } 427             if (result instanceof SymbolMacro) 428                 return eval(((SymbolMacro)result).getExpansion(), env, thread); 429             return result; 430         } else if (obj instanceof Cons) { 431             LispObject first = obj.car(); 432             if (first instanceof Symbol) { 433                 LispObject fun = env.lookupFunctional(first); 434                 if (fun == null) 435                     return signal(new UndefinedFunction(first)); 436                 switch (fun.getFunctionalType()) { 437                     case FTYPE_SPECIAL_OPERATOR: { 438                         if (profiling) 439                             if (!sampling) 440                                 fun.incrementCallCount(); 441                         // Don't eval args! 442 return fun.execute(obj.cdr(), env); 443                     } 444                     case FTYPE_MACRO: 445                         return eval(macroexpand(obj, env, thread), env, thread); 446                     case FTYPE_AUTOLOAD: { 447                         Autoload autoload = (Autoload) fun; 448                         autoload.load(); 449                         return eval(obj, env, thread); 450                     } 451                     default: { 452                         return funcall(fun, 453                                        evalList(obj.cdr(), env, thread), 454                                        thread); 455                     } 456                 } 457             } else { 458                 LispObject args = obj.cdr(); 459                 if (!args.listp()) 460                     return signal(new TypeError(args, "list")); 461                 LispObject funcar = first.car(); 462                 LispObject rest = first.cdr(); 463                 Symbol symbol = checkSymbol(funcar); 464                 if (symbol == Symbol.LAMBDA) { 465                     Closure closure = new Closure(rest.car(), rest.cdr(), env); 466                     return closure.execute(evalList(args, env, thread)); 467                 } else 468                     return signal(new ProgramError("Illegal function object: " + 469                                                    first.writeToString())); 470             } 471         } else 472             return obj; 473     } 474 475     private static final LispObject[] evalList(LispObject exps, 476                                                Environment env, 477                                                LispThread thread) 478         throws ConditionThrowable 479     { 480         final int length = exps.length(); 481         LispObject[] results = new LispObject[length]; 482         for (int i = 0; i < length; i++) { 483             results[i] = eval(exps.car(), env, thread); 484             exps = exps.cdr(); 485         } 486         // Ignore multiple values! 487 thread.clearValues(); 488         return results; 489     } 490 491     public static final LispObject progn(LispObject body, Environment env, 492                                          LispThread thread) 493         throws ConditionThrowable 494     { 495         LispObject result = NIL; 496         while (body != NIL) { 497             result = eval(body.car(), env, thread); 498             body = body.cdr(); 499         } 500         return result; 501     } 502 503     // Environment wrappers. 504 public static final void bind(Symbol symbol, LispObject value, 505                                   Environment env) 506         throws ConditionThrowable 507     { 508         if (env.isDeclaredSpecial(symbol) || symbol.isSpecialVariable()) 509             LispThread.currentThread().bindSpecial(symbol, value); 510         else 511             env.bind(symbol, value); 512     } 513 514     public static final void rebind(Symbol symbol, LispObject value, 515                                     Environment env) 516         throws ConditionThrowable 517     { 518         if (env.isDeclaredSpecial(symbol) || symbol.isSpecialVariable()) { 519             Environment dynEnv = 520                 LispThread.currentThread().getDynamicEnvironment(); 521             Debug.assertTrue(dynEnv != null); 522             dynEnv.rebind(symbol, value); 523         } else 524             env.rebind(symbol, value); 525     } 526 527     public static final void bindSpecialVariable(Symbol symbol, 528                                                  LispObject value) 529         throws ConditionThrowable 530     { 531         LispThread.currentThread().bindSpecial(symbol, value); 532     } 533 534     public static final LispObject setSpecialVariable(Symbol symbol, 535                                                       LispObject value, 536                                                       LispThread thread) 537     { 538         Environment dynEnv = thread.getDynamicEnvironment(); 539         if (dynEnv != null) { 540             Binding binding = dynEnv.getBinding(symbol); 541             if (binding != null) { 542                 binding.value = value; 543                 return value; 544             } 545         } 546         symbol.setSymbolValue(value); 547         return value; 548     } 549 550     public static final Cons list1(LispObject obj1) 551     { 552         return new Cons(obj1); 553     } 554 555     public static final Cons list2(LispObject obj1, LispObject obj2) 556     { 557         return new Cons(obj1, new Cons(obj2)); 558     } 559 560     public static final Cons list3(LispObject obj1, LispObject obj2, 561                                    LispObject obj3) 562     { 563         return new Cons(obj1, new Cons(obj2, new Cons(obj3))); 564     } 565 566     public static final Cons list4(LispObject obj1, LispObject obj2, 567                                    LispObject obj3, LispObject obj4) 568     { 569         return new Cons(obj1, 570                         new Cons(obj2, 571                                  new Cons(obj3, 572                                           new Cons(obj4)))); 573     } 574 575     public static final Cons list5(LispObject obj1, LispObject obj2, 576                                    LispObject obj3, LispObject obj4, 577                                    LispObject obj5) 578     { 579         return new Cons(obj1, 580                         new Cons(obj2, 581                                  new Cons(obj3, 582                                           new Cons(obj4, 583                                                    new Cons(obj5))))); 584     } 585 586     public static final Cons list6(LispObject obj1, LispObject obj2, 587                                    LispObject obj3, LispObject obj4, 588                                    LispObject obj5, LispObject obj6) 589     { 590         return new Cons(obj1, 591                         new Cons(obj2, 592                                  new Cons(obj3, 593                                           new Cons(obj4, 594                                                    new Cons(obj5, 595                                                             new Cons(obj6)))))); 596     } 597 598     public static final Cons list7(LispObject obj1, LispObject obj2, 599                                    LispObject obj3, LispObject obj4, 600                                    LispObject obj5, LispObject obj6, 601                                    LispObject obj7) 602     { 603         return new Cons(obj1, 604                         new Cons(obj2, 605                                  new Cons(obj3, 606                                           new Cons(obj4, 607                                                    new Cons(obj5, 608                                                             new Cons(obj6, 609                                                                      new Cons(obj7))))))); 610     } 611 612     public static final Cons list8(LispObject obj1, LispObject obj2, 613                                    LispObject obj3, LispObject obj4, 614                                    LispObject obj5, LispObject obj6, 615                                    LispObject obj7, LispObject obj8) 616     { 617         return new Cons(obj1, 618                         new Cons(obj2, 619                                  new Cons(obj3, 620                                           new Cons(obj4, 621                                                    new Cons(obj5, 622                                                             new Cons(obj6, 623                                                                      new Cons(obj7, 624                                                                               new Cons(obj8)))))))); 625     } 626 627     // Used by JVM compiler. 628 public static final LispObject multipleValueList(LispObject result) 629         throws ConditionThrowable 630     { 631         LispThread thread = LispThread.currentThread(); 632         LispObject[] values = thread.getValues(); 633         if (values == null) 634             return new Cons(result); 635         thread.clearValues(); 636         LispObject list = NIL; 637         for (int i = values.length; i-- > 0;) 638             list = new Cons(values[i], list); 639         return list; 640     } 641 642     // Used by JVM compiler for MULTIPLE-VALUE-CALLs with a single values form. 643 public static final LispObject multipleValueCall1(LispObject result, 644                                                       LispObject function, 645                                                       LispThread thread) 646         throws ConditionThrowable 647     { 648         LispObject[] values = thread.getValues(); 649         thread.clearValues(); 650         if (values == null) 651             return funcall1(coerceToFunction(function), result, thread); 652         else 653             return funcall(coerceToFunction(function), values, thread); 654     } 655 656     public static Symbol checkSymbol(LispObject obj) throws ConditionThrowable 657     { 658         if (obj == null) 659             throw new NullPointerException (); 660         try { 661             return (Symbol) obj; 662         } 663         catch (ClassCastException e) { 664             signal(new TypeError(obj, "symbol")); 665             // Not reached. 666 return null; 667         } 668     } 669 670     public static final Cons checkCons(LispObject obj) throws ConditionThrowable 671     { 672         if (obj == null) 673             throw new NullPointerException (); 674         try { 675             return (Cons) obj; 676         } 677         catch (ClassCastException e) { 678             signal(new TypeError(obj, "cons")); 679             // Not reached. 680 return null; 681         } 682     } 683 684     public static final LispObject checkList(LispObject obj) 685         throws ConditionThrowable 686     { 687         if (obj == null) 688             throw new NullPointerException (); 689         if (obj.listp()) 690             return obj; 691         return signal(new TypeError(obj, Symbol.LIST)); 692     } 693 694     public static final AbstractArray checkArray(LispObject obj) 695         throws ConditionThrowable 696     { 697         if (obj == null) 698             throw new NullPointerException (); 699         try { 700             return (AbstractArray) obj; 701         } 702         catch (ClassCastException e) { 703             signal(new TypeError(obj, Symbol.ARRAY)); 704             // Not reached. 705 return null; 706         } 707     } 708 709     public static final AbstractVector checkVector(LispObject obj) 710         throws ConditionThrowable 711     { 712         if (obj == null) 713             throw new NullPointerException (); 714         try { 715             return (AbstractVector) obj; 716         } 717         catch (ClassCastException e) { 718             signal(new TypeError(obj, Symbol.VECTOR)); 719             // Not reached. 720 return null; 721         } 722     } 723 724     public static final String javaString(LispObject arg) throws ConditionThrowable 725     { 726         if (arg instanceof AbstractString) 727             return arg.getStringValue(); 728         if (arg instanceof Symbol) 729             return arg.getName(); 730         if (arg instanceof LispCharacter) 731             return String.valueOf(new char[] {((LispCharacter)arg).value}); 732         signal(new TypeError(arg.writeToString() + " cannot be coerced to a string.")); 733         // Not reached. 734 return null; 735     } 736 737     public static final LispObject number(long n) 738     { 739         if (n >= Integer.MIN_VALUE && n <= Integer.MAX_VALUE) 740             return new Fixnum((int)n); 741         else 742             return new Bignum(n); 743     } 744 745     private static final BigInteger INT_MIN = BigInteger.valueOf(Integer.MIN_VALUE); 746     private static final BigInteger INT_MAX = BigInteger.valueOf(Integer.MAX_VALUE); 747 748     public static final LispObject number(BigInteger numerator, 749                                           BigInteger denominator) 750         throws ConditionThrowable 751     { 752         if (denominator.signum() == 0) 753             signal(new DivisionByZero()); 754         if (denominator.signum() < 0) { 755             numerator = numerator.negate(); 756             denominator = denominator.negate(); 757         } 758         BigInteger gcd = numerator.gcd(denominator); 759         if (!gcd.equals(BigInteger.ONE)) { 760             numerator = numerator.divide(gcd); 761             denominator = denominator.divide(gcd); 762         } 763         if (denominator.equals(BigInteger.ONE)) 764             return number(numerator); 765         else 766             return new Ratio(numerator, denominator); 767     } 768 769     public static final LispObject number(BigInteger n) 770     { 771         if (n.compareTo(INT_MIN) >= 0 && n.compareTo(INT_MAX) <= 0) 772             return new Fixnum(n.intValue()); 773         else 774             return new Bignum(n); 775     } 776 777     // Adapted from SBCL. 778 public static final int mix(long x, long y) 779     { 780         long xy = x * 3 + y; 781         return (int) (536870911L & (441516657L ^ xy ^ (xy >> 5))); 782     } 783 784     public static final LispObject readObjectFromString(String s) 785     { 786         try { 787             return new StringInputStream(s).read(true, NIL, false); 788         } 789         catch (Throwable t) { 790             return null; 791         } 792     } 793 794     public static final LispObject loadCompiledFunction(String namestring) 795         throws ConditionThrowable 796     { 797         // INIT-FASL binds *DEFAULT-PATHNAME-DEFAULTS* to *LOAD-TRUENAME*. 798 Pathname defaultPathname = 799             Pathname.coerceToPathname(_DEFAULT_PATHNAME_DEFAULTS_.symbolValue()); 800         if (defaultPathname.getDevice() instanceof Pathname) { 801             // We're loading a fasl from j.jar. 802 URL url = Lisp.class.getResource(namestring); 803             if (url != null) { 804                 try { 805                     String s = url.toString(); 806                     String zipFileName; 807                     String entryName; 808                     if (s.startsWith("jar:file:")) { 809                         s = s.substring(9); 810                         int index = s.lastIndexOf('!'); 811                         if (index >= 0) { 812                             zipFileName = s.substring(0, index); 813                             entryName = s.substring(index + 1); 814                             if (entryName.startsWith("/")) 815                                 entryName = entryName.substring(1); 816                             ZipFile zipFile = new ZipFile (zipFileName); 817                             ZipEntry entry = zipFile.getEntry(entryName); 818                             if (entry != null) { 819                                 long size = entry.getSize(); 820                                 InputStream in = zipFile.getInputStream(entry); 821                                 byte[] bytes = new byte[(int)size]; 822                                 int bytesRemaining = (int) size; 823                                 int bytesRead = 0; 824                                 while (bytesRemaining > 0) { 825                                     int n; 826                                     if (bytesRemaining >= 4096) 827                                         n = in.read(bytes, bytesRead, 4096); 828                                     else 829                                         n = in.read(bytes, bytesRead, bytesRemaining); 830                                     if (n < 0) 831                                         break; 832                                     bytesRead += n; 833                                     bytesRemaining -= n; 834                                 } 835                                 in.close(); 836                                 if (bytesRemaining > 0) 837                                     Debug.trace("bytesRemaining = " + bytesRemaining); 838                                 JavaClassLoader loader = new JavaClassLoader(); 839                                 Class c = 840                                     loader.loadClassFromByteArray(null, bytes, 0, bytes.length); 841                                 if (c != null) { 842                                     Class [] parameterTypes = new Class [0]; 843                                     java.lang.reflect.Constructor constructor = 844                                         c.getConstructor(parameterTypes); 845                                     Object [] initargs = new Object [0]; 846                                     LispObject obj = 847                                         (LispObject) constructor.newInstance(initargs); 848                                     return obj; 849                                 } 850                             } 851                         } 852                     } 853                 } 854                 catch (VerifyError e) { 855                     return signal(new LispError("Class verification failed: " + 856                                                 e.getMessage())); 857                 } 858                 catch (IOException e) { 859                     Debug.trace(e); 860                 } 861                 catch (Throwable t) { 862                     Debug.trace(t); 863                 } 864             } 865         } else { 866             Pathname pathname = new Pathname(namestring); 867             File file = Utilities.getFile(pathname); 868             if (file != null && file.isFile()) { 869                 try { 870                     JavaClassLoader loader = new JavaClassLoader(); 871                     Class c = loader.loadClassFromFile(file); 872                     if (c != null) { 873                         Class [] parameterTypes = new Class [0]; 874                         java.lang.reflect.Constructor constructor = 875                             c.getConstructor(parameterTypes); 876                         Object [] initargs = new Object [0]; 877                         LispObject obj = 878                             (LispObject) constructor.newInstance(initargs); 879                         return obj; 880                     } 881                 } 882                 catch (VerifyError e) { 883                     return signal(new LispError("Class verification failed: " + 884                                                 e.getMessage())); 885                 } 886                 catch (Throwable t) { 887                     Debug.trace(t); 888                 } 889                 return signal(new LispError("Unable to load " + 890                                             pathname.writeToString())); 891             } 892         } 893         return signal(new LispError("Unable to load " + namestring)); 894      } 895 896     public static final LispObject makeCompiledClosure(LispObject ctf, 897                                                        LispObject[][] context) 898     { 899         return new CompiledClosure((ClosureTemplateFunction)ctf, context); 900     } 901 902     public static final String safeWriteToString(LispObject obj) 903     { 904         try { 905             return obj.writeToString(); 906         } 907         catch (ConditionThrowable t) { 908             return obj.toString(); 909         } 910         catch (NullPointerException e) { 911             Debug.trace(e); 912             return "null"; 913         } 914     } 915 916     public static final LispObject getUpgradedArrayElementType(LispObject type) 917     { 918         if (type == Symbol.CHARACTER || type == Symbol.BASE_CHAR || type == Symbol.STANDARD_CHAR) 919             return Symbol.CHARACTER; 920         if (type == BuiltInClass.CHARACTER) 921             return Symbol.CHARACTER; 922         if (type == Symbol.BIT) 923             return Symbol.BIT; 924         if (type == NIL) 925             return NIL; 926         return T; 927     } 928 929     public static final LispCharacter checkCharacter(LispObject obj) 930         throws ConditionThrowable 931     { 932         if (obj == null) 933             throw new NullPointerException (); 934         try { 935             return (LispCharacter) obj; 936         } 937         catch (ClassCastException e) { 938             signal(new TypeError(obj, "character")); 939             // Not reached. 940 return null; 941         } 942     } 943 944     public static final Package checkPackage(LispObject obj) 945         throws ConditionThrowable 946     { 947         if (obj == null) 948             throw new NullPointerException (); 949         try { 950             return (Package ) obj; 951         } 952         catch (ClassCastException e) { 953             signal(new TypeError(obj, "package")); 954             // Not reached. 955 return null; 956         } 957     } 958 959     public static final Function checkFunction(LispObject obj) 960         throws ConditionThrowable 961     { 962         if (obj == null) 963             throw new NullPointerException (); 964         try { 965             return (Function) obj; 966         } 967         catch (ClassCastException e) { 968             signal(new TypeError(obj, "function")); 969             // Not reached. 970 return null; 971         } 972     } 973 974     public static final Stream checkStream(LispObject obj) 975         throws ConditionThrowable 976     { 977         if (obj == null) 978             throw new NullPointerException (); 979         try { 980             return (Stream) obj; 981         } 982         catch (ClassCastException e) { 983             signal(new TypeError(obj, Symbol.STREAM)); 984             // Not reached. 985 return null; 986         } 987     } 988 989     public static final Stream checkCharacterInputStream(LispObject obj) 990         throws ConditionThrowable 991     { 992         if (obj instanceof Stream) 993             if (((Stream)obj).isCharacterInputStream()) 994                 return (Stream) obj; 995         if (obj == null) 996             throw new NullPointerException (); 997         signal(new TypeError(obj, "character input stream")); 998         // Not reached. 999 return null; 1000    } 1001 1002    public static final Stream checkCharacterOutputStream(LispObject obj) 1003        throws ConditionThrowable 1004    { 1005        if (obj instanceof Stream) 1006            if (((Stream)obj).isCharacterOutputStream()) 1007                return (Stream) obj; 1008        if (obj == null) 1009            throw new NullPointerException (); 1010        signal(new TypeError(obj, "character output stream")); 1011        // Not reached. 1012 return null; 1013    } 1014 1015    public static final Stream checkBinaryInputStream(LispObject obj) 1016        throws ConditionThrowable 1017    { 1018        if (obj instanceof Stream) 1019            if (((Stream)obj).isBinaryInputStream()) 1020                return (Stream) obj; 1021        if (obj == null) 1022            throw new NullPointerException (); 1023        signal(new TypeError(obj, "binary input stream")); 1024        // Not reached. 1025 return null; 1026    } 1027 1028    public static final Stream checkBinaryOutputStream(LispObject obj) 1029        throws ConditionThrowable 1030    { 1031        if (obj instanceof Stream) 1032            if (((Stream)obj).isBinaryOutputStream()) 1033                return (Stream) obj; 1034        if (obj == null) 1035            throw new NullPointerException (); 1036        signal(new TypeError(obj, "binary output stream")); 1037        // Not reached. 1038 return null; 1039    } 1040 1041    public static final Stream inSynonymOf(LispObject obj) 1042        throws ConditionThrowable 1043    { 1044        if (obj == T) 1045            return checkCharacterInputStream(_TERMINAL_IO_.symbolValue()); 1046        if (obj == NIL) 1047            return checkCharacterInputStream(_STANDARD_INPUT_.symbolValue()); 1048        if (obj instanceof Stream) { 1049            Stream stream = (Stream) obj; 1050            if (stream instanceof TwoWayStream) { 1051                Stream in = ((TwoWayStream)stream).getInputStream(); 1052        return inSynonymOf(in); 1053            } 1054            if (stream.isCharacterInputStream()) 1055                return stream; 1056        } 1057        signal(new TypeError(obj, "character input stream")); 1058        // Not reached. 1059 return null; 1060    } 1061 1062    public static final Stream outSynonymOf(LispObject obj) 1063        throws ConditionThrowable 1064    { 1065        if (obj == T) 1066            return checkCharacterOutputStream(_TERMINAL_IO_.symbolValue()); 1067        if (obj == NIL) 1068            return checkCharacterOutputStream(_STANDARD_OUTPUT_.symbolValue()); 1069        if (obj instanceof Stream) { 1070            Stream stream = (Stream) obj; 1071            if (stream instanceof TwoWayStream) { 1072                Stream out = ((TwoWayStream)obj).getOutputStream(); 1073        return outSynonymOf(out); 1074            } 1075            if (stream.isCharacterOutputStream()) 1076                return stream; 1077        } 1078        signal(new TypeError(obj, "character output stream")); 1079        // Not reached. 1080 return null; 1081    } 1082 1083    public static final Readtable checkReadtable(LispObject obj) 1084        throws ConditionThrowable 1085    { 1086        if (obj == null) 1087            throw new NullPointerException (); 1088        try { 1089            return (Readtable) obj; 1090        } 1091        catch (ClassCastException e) { 1092            signal(new TypeError(obj, Symbol.READTABLE)); 1093            // Not reached. 1094 return null; 1095        } 1096    } 1097 1098    public static final Environment checkEnvironment(LispObject obj) 1099        throws ConditionThrowable 1100    { 1101        if (obj == null) 1102            throw new NullPointerException (); 1103        try { 1104            return (Environment) obj; 1105        } 1106        catch (ClassCastException e) { 1107            signal(new TypeError(obj, "environment")); 1108            // Not reached. 1109 return null; 1110        } 1111    } 1112 1113    public static final void checkBounds(int start, int end, int length) 1114        throws ConditionThrowable 1115    { 1116        if (start < 0 || end < 0 || start > end || end > length) { 1117            StringBuffer sb = new StringBuffer ("The bounding indices "); 1118            sb.append(start); 1119            sb.append(" and "); 1120            sb.append(end); 1121            sb.append(" are bad for a sequence of length "); 1122            sb.append(length); 1123            sb.append('.'); 1124            signal(new TypeError(sb.toString())); 1125        } 1126    } 1127 1128    public static final LispObject coerceToFunction(LispObject obj) 1129        throws ConditionThrowable 1130    { 1131        if (obj instanceof Function) 1132            return obj; 1133        if (obj instanceof GenericFunction) 1134            return obj; 1135        if (obj instanceof Symbol) { 1136            LispObject fun = obj.getSymbolFunction(); 1137            if (fun instanceof Function) 1138                return (Function) fun; 1139        } else if (obj instanceof Cons && obj.car() == Symbol.LAMBDA) 1140            return new Closure(obj.cadr(), obj.cddr(), new Environment()); 1141        signal(new UndefinedFunction(obj)); 1142        // Not reached. 1143 return null; 1144    } 1145 1146    public static final Functional coerceToFunctional(LispObject obj) 1147        throws ConditionThrowable 1148    { 1149        if (obj instanceof Functional) 1150            return (Functional) obj; 1151        if (obj instanceof Symbol) { 1152            LispObject fun = obj.getSymbolFunction(); 1153            if (fun instanceof Functional) 1154                return (Functional) fun; 1155        } else if (obj instanceof Cons && obj.car() == Symbol.LAMBDA) 1156            return new Closure(obj.cadr(), obj.cddr(), new Environment()); 1157        signal(new UndefinedFunction(obj)); 1158        // Not reached. 1159 return null; 1160    } 1161 1162    // Returns package or throws exception. 1163 public static final Package coerceToPackage(LispObject obj) 1164        throws ConditionThrowable 1165    { 1166        if (obj instanceof Package ) 1167            return (Package ) obj; 1168        Package pkg = Packages.findPackage(javaString(obj)); 1169        if (pkg != null) 1170            return pkg; 1171        signal(new PackageError(obj.writeToString() + " is not the name of a package.")); 1172        // Not reached. 1173 return null; 1174    } 1175 1176    public static final boolean memq(LispObject item, LispObject listArg) 1177        throws ConditionThrowable 1178    { 1179        LispObject list = listArg; 1180        while (list instanceof Cons) { 1181            if (item == list.car()) 1182                return true; 1183            list = list.cdr(); 1184        } 1185        if (list != NIL) 1186            signal(new TypeError(String.valueOf(listArg) + " is not a proper list.")); 1187        return false; 1188    } 1189 1190    public static final boolean memql(LispObject item, LispObject listArg) 1191        throws ConditionThrowable 1192    { 1193        LispObject list = listArg; 1194        while (list instanceof Cons) { 1195            if (item.eql(list.car())) 1196                return true; 1197            list = list.cdr(); 1198        } 1199        if (list != NIL) 1200            signal(new TypeError(String.valueOf(listArg) + " is not a proper list.")); 1201        return false; 1202    } 1203 1204    // Property lists. 1205 public static final LispObject getf(LispObject plist, LispObject indicator, 1206                                        LispObject defaultValue) 1207        throws ConditionThrowable 1208    { 1209        LispObject list = plist; 1210        while (list != NIL) { 1211            if (list.car() == indicator) 1212                return list.cadr(); 1213            if (list.cdr() instanceof Cons) 1214                list = list.cddr(); 1215            else 1216                return signal(new TypeError("Malformed property list: " + plist + ".")); 1217        } 1218        return defaultValue; 1219    } 1220 1221    public static final LispObject get(Symbol symbol, LispObject indicator, 1222                                       LispObject defaultValue) 1223        throws ConditionThrowable 1224    { 1225        LispObject list = symbol.getPropertyList(); 1226        while (list != NIL) { 1227            if (list.car() == indicator) 1228                return list.cadr(); 1229            list = list.cddr(); 1230        } 1231        return defaultValue; 1232    } 1233 1234    // Returns null if there is no property with the specified indicator. 1235 public static final LispObject get(Symbol symbol, LispObject indicator) 1236        throws ConditionThrowable 1237    { 1238        LispObject list = symbol.getPropertyList(); 1239        while (list != NIL) { 1240            if (list.car() == indicator) 1241                return list.cadr(); 1242            list = list.cddr(); 1243        } 1244        return null; 1245    } 1246 1247    public static final LispObject put(Symbol symbol, LispObject indicator, 1248                                       LispObject value) 1249        throws ConditionThrowable 1250    { 1251        LispObject list = symbol.getPropertyList(); 1252        while (list != NIL) { 1253            if (list.car() == indicator) { 1254                // Found it! 1255 LispObject rest = list.cdr(); 1256                rest.setCar(value); 1257                return value; 1258            } 1259            list = list.cddr(); 1260        } 1261        // Not found. 1262 symbol.setPropertyList(new Cons(indicator, 1263                                        new Cons(value, 1264                                                 symbol.getPropertyList()))); 1265        return value; 1266    } 1267 1268    public static final LispObject remprop(Symbol symbol, LispObject indicator) 1269        throws ConditionThrowable 1270    { 1271        LispObject list = checkList(symbol.getPropertyList()); 1272        LispObject prev = null; 1273        while (list != NIL) { 1274            if (!(list.cdr() instanceof Cons)) 1275                signal(new ProgramError(String.valueOf(symbol) + 1276                                        " has an odd number of items in its property list.")); 1277            if (list.car() == indicator) { 1278                // Found it! 1279 if (prev != null) 1280                    prev.setCdr(list.cddr()); 1281                else 1282                    symbol.setPropertyList(list.cddr()); 1283                return T; 1284            } 1285            prev = list.cdr(); 1286            list = list.cddr(); 1287        } 1288        // Not found. 1289 return NIL; 1290    } 1291 1292    public static final String format(LispObject formatControl, 1293                                      LispObject formatArguments) 1294        throws ConditionThrowable 1295    { 1296        final LispThread thread = LispThread.currentThread(); 1297        String control = formatControl.getStringValue(); 1298        LispObject[] args = formatArguments.copyToArray(); 1299        StringBuffer sb = new StringBuffer (); 1300        if (control != null) { 1301            final int limit = control.length(); 1302            int j = 0; 1303            final int NEUTRAL = 0; 1304            final int TILDE = 1; 1305            int state = NEUTRAL; 1306            for (int i = 0; i < limit; i++) { 1307                char c = control.charAt(i); 1308                if (state == NEUTRAL) { 1309                    if (c == '~') 1310                        state = TILDE; 1311                    else 1312                        sb.append(c); 1313                } else if (state == TILDE) { 1314                    if (c == 'A' || c == 'a') { 1315                        if (j < args.length) { 1316                            LispObject obj = args[j++]; 1317                            Environment oldDynEnv = thread.getDynamicEnvironment(); 1318                            thread.bindSpecial(_PRINT_ESCAPE_, NIL); 1319                            thread.bindSpecial(_PRINT_READABLY_, NIL); 1320                            sb.append(obj.writeToString()); 1321                            thread.setDynamicEnvironment(oldDynEnv); 1322                        } 1323                    } else if (c == 'S' || c == 's') { 1324                        if (j < args.length) { 1325                            LispObject obj = args[j++]; 1326                            Environment oldDynEnv = thread.getDynamicEnvironment(); 1327                            thread.bindSpecial(_PRINT_ESCAPE_, T); 1328                            sb.append(obj.writeToString()); 1329                            thread.setDynamicEnvironment(oldDynEnv); 1330                        } 1331                    } else if (c == 'D' || c == 'd') { 1332                        if (j < args.length) { 1333                            LispObject obj = args[j++]; 1334                            Environment oldDynEnv = thread.getDynamicEnvironment(); 1335                            thread.bindSpecial(_PRINT_ESCAPE_, NIL); 1336                            thread.bindSpecial(_PRINT_RADIX_, NIL); 1337                            thread.bindSpecial(_PRINT_BASE_, new Fixnum(10)); 1338                            sb.append(obj.writeToString()); 1339                            thread.setDynamicEnvironment(oldDynEnv); 1340                        } 1341                    } else if (c == 'X' || c == 'x') { 1342                        if (j < args.length) { 1343                            LispObject obj = args[j++]; 1344                            Environment oldDynEnv = thread.getDynamicEnvironment(); 1345                            thread.bindSpecial(_PRINT_ESCAPE_, NIL); 1346                            thread.bindSpecial(_PRINT_RADIX_, NIL); 1347                            thread.bindSpecial(_PRINT_BASE_, new Fixnum(16)); 1348                            sb.append(obj.writeToString()); 1349                            thread.setDynamicEnvironment(oldDynEnv); 1350                        } 1351                    } else if (c == '%') { 1352                        sb.append('\n'); 1353                    } 1354                    state = NEUTRAL; 1355                } else { 1356                    // There are no other valid states. 1357 Debug.assertTrue(false); 1358                } 1359            } 1360        } 1361        return sb.toString(); 1362    } 1363 1364    public static final String invert(String s) 1365    { 1366        // "When the readtable case is :INVERT, the case of all alphabetic 1367 // characters in single case symbol names is inverted. Mixed-case 1368 // symbol names are printed as is." (22.1.3.3.2) 1369 final int limit = s.length(); 1370        final int LOWER = 1; 1371        final int UPPER = 2; 1372        int state = 0; 1373        for (int i = 0; i < limit; i++) { 1374            char c = s.charAt(i); 1375            if (Character.isUpperCase(c)) { 1376                if (state == LOWER) 1377                    return s; // Mixed case. 1378 state = UPPER; 1379            } 1380            if (Character.isLowerCase(c)) { 1381                if (state == UPPER) 1382                    return s; // Mixed case. 1383 state = LOWER; 1384            } 1385        } 1386        StringBuffer sb = new StringBuffer (limit); 1387        for (int i = 0; i < limit; i++) { 1388            char c = s.charAt(i); 1389            if (Character.isUpperCase(c)) 1390                sb.append(Character.toLowerCase(c)); 1391            else if (Character.isLowerCase(c)) 1392                sb.append(Character.toUpperCase(c)); 1393            else 1394                sb.append(c); 1395        } 1396        return sb.toString(); 1397    } 1398 1399    public static final Symbol intern(String name, Package pkg) 1400    { 1401        return pkg.intern(name); 1402    } 1403 1404    // Used by jvm compiler. 1405 public static final Symbol internInPackage(String name, String packageName) 1406        throws ConditionThrowable 1407    { 1408        Package pkg = Packages.findPackage(packageName); 1409        if (pkg == null) 1410            signal(new LispError(packageName + " is not the name of a package.")); 1411        return pkg.intern(name); 1412    } 1413 1414    // The jvm compiler's object table. 1415 private static final Hashtable objectTable = new Hashtable (); 1416 1417    public static final LispObject recall(SimpleString key) 1418    { 1419        return (LispObject) objectTable.get(key.getStringValue()); 1420    } 1421 1422    public static final void forget(SimpleString key) 1423    { 1424        objectTable.remove(key.getStringValue()); 1425    } 1426 1427    public static final Primitive2 REMEMBER = 1428        new Primitive2("remember", PACKAGE_SYS, false) 1429    { 1430        public LispObject execute(LispObject key, LispObject value) 1431            throws ConditionThrowable 1432        { 1433            objectTable.put(key.getStringValue(), value); 1434            return NIL; 1435        } 1436    }; 1437 1438    public static final Symbol export(String name, Package pkg) 1439    { 1440        Symbol symbol = pkg.intern(name); 1441        try { 1442            pkg.export(symbol); // FIXME Inefficient! 1443 } 1444        catch (ConditionThrowable t) { 1445            Debug.trace(t); 1446        } 1447        return symbol; 1448    } 1449 1450    public static final Symbol internSpecial(String name, Package pkg, 1451                                             LispObject value) 1452    { 1453        Symbol symbol = pkg.intern(name); 1454        symbol.setSpecial(true); 1455        symbol.setSymbolValue(value); 1456        return symbol; 1457    } 1458 1459    public static final Symbol internConstant(String name, Package pkg, 1460                                              LispObject value) 1461    { 1462        Symbol symbol = pkg.intern(name); 1463        symbol.setSpecial(true); 1464        symbol.setSymbolValue(value); 1465        symbol.setConstant(true); 1466        return symbol; 1467    } 1468 1469    public static final Symbol exportSpecial(String name, Package pkg, 1470                                             LispObject value) 1471    { 1472        Symbol symbol = pkg.intern(name); 1473        try { 1474            pkg.export(symbol); // FIXME Inefficient! 1475 } 1476        catch (ConditionThrowable t) { 1477            Debug.trace(t); 1478        } 1479        symbol.setSpecial(true); 1480        symbol.setSymbolValue(value); 1481        return symbol; 1482    } 1483 1484    public static final Symbol exportConstant(String name, Package pkg, 1485                                              LispObject value) 1486    { 1487        Symbol symbol = pkg.intern(name); 1488        try { 1489            pkg.export(symbol); // FIXME Inefficient! 1490 } 1491        catch (ConditionThrowable t) { 1492            Debug.trace(t); 1493        } 1494        symbol.setSpecial(true); 1495        symbol.setSymbolValue(value); 1496        symbol.setConstant(true); 1497        return symbol; 1498    } 1499 1500    public static final Symbol _DEFAULT_PATHNAME_DEFAULTS_ = 1501        PACKAGE_CL.addExternalSymbol("*DEFAULT-PATHNAME-DEFAULTS*"); 1502    static { 1503        String userDir = System.getProperty("user.dir"); 1504        if (userDir != null && userDir.length() > 0) { 1505            if (userDir.charAt(userDir.length() - 1) != File.separatorChar) 1506                userDir = userDir.concat(File.separator); 1507        } 1508        // This string will be converted to a pathname when Pathname.java is loaded. 1509 _DEFAULT_PATHNAME_DEFAULTS_.setSymbolValue(new SimpleString(userDir)); 1510        _DEFAULT_PATHNAME_DEFAULTS_.setSpecial(true); 1511    } 1512 1513    public static final Symbol _PACKAGE_ = 1514        exportSpecial("*PACKAGE*", PACKAGE_CL, PACKAGE_CL_USER); 1515 1516    public static final Package getCurrentPackage() 1517    { 1518        return (Package ) _PACKAGE_.symbolValueNoThrow(); 1519    } 1520 1521    private static Stream stdin = new Stream(System.in, Symbol.CHARACTER, true); 1522 1523    private static Stream stdout = new Stream(System.out, Symbol.CHARACTER, true); 1524 1525    public static final Symbol _STANDARD_INPUT_ = 1526        exportSpecial("*STANDARD-INPUT*", PACKAGE_CL, stdin); 1527 1528    public static final Symbol _STANDARD_OUTPUT_ = 1529        exportSpecial("*STANDARD-OUTPUT*", PACKAGE_CL, stdout); 1530 1531    public static final Symbol _ERROR_OUTPUT_ = 1532        exportSpecial("*ERROR-OUTPUT*", PACKAGE_CL, stdout); 1533 1534    public static final Symbol _TRACE_OUTPUT_ = 1535        exportSpecial("*TRACE-OUTPUT*", PACKAGE_CL, stdout); 1536 1537    public static final Symbol _TERMINAL_IO_ = 1538        exportSpecial("*TERMINAL-IO*", PACKAGE_CL, 1539                      new TwoWayStream(stdin, stdout, true)); 1540 1541    public static final Symbol _QUERY_IO_ = 1542        exportSpecial("*QUERY-IO*", PACKAGE_CL, 1543                      new TwoWayStream(stdin, stdout, true)); 1544 1545    public static final Symbol _DEBUG_IO_ = 1546        exportSpecial("*DEBUG-IO*", PACKAGE_CL, 1547                      new TwoWayStream(stdin, stdout, true)); 1548 1549    public static final void resetIO(Stream in, Stream out) 1550    { 1551        stdin = in; 1552        stdout = out; 1553        _STANDARD_INPUT_.setSymbolValue(stdin); 1554        _STANDARD_OUTPUT_.setSymbolValue(stdout); 1555        _ERROR_OUTPUT_.setSymbolValue(stdout); 1556        _TRACE_OUTPUT_.setSymbolValue(stdout); 1557        _TERMINAL_IO_.setSymbolValue(new TwoWayStream(stdin, stdout, true)); 1558        _QUERY_IO_.setSymbolValue(new TwoWayStream(stdin, stdout, true)); 1559        _DEBUG_IO_.setSymbolValue(new TwoWayStream(stdin, stdout, true)); 1560    } 1561 1562    public static final void resetIO() 1563    { 1564        resetIO(new Stream(System.in, Symbol.CHARACTER, true), 1565                new Stream(System.out, Symbol.CHARACTER, true)); 1566    } 1567 1568    public static final TwoWayStream getTerminalIO() 1569    { 1570        return (TwoWayStream) _TERMINAL_IO_.symbolValueNoThrow(); 1571    } 1572 1573    public static final Stream getStandardInput() 1574    { 1575        return (Stream) _STANDARD_INPUT_.symbolValueNoThrow(); 1576    } 1577 1578    public static final Stream getStandardOutput() throws ConditionThrowable 1579    { 1580        return checkCharacterOutputStream(_STANDARD_OUTPUT_.symbolValue()); 1581    } 1582 1583    public static final Symbol _READTABLE_ = 1584        exportSpecial("*READTABLE*", PACKAGE_CL, new Readtable()); 1585 1586    public static final Readtable currentReadtable() throws ConditionThrowable 1587    { 1588        return (Readtable) _READTABLE_.symbolValue(); 1589    } 1590 1591    public static final Readtable currentReadtable(LispThread thread) 1592        throws ConditionThrowable 1593    { 1594        return (Readtable) _READTABLE_.symbolValue(thread); 1595    } 1596 1597    public static final Symbol _READ_SUPPRESS_ = 1598        exportSpecial("*READ-SUPPRESS*", PACKAGE_CL, NIL); 1599 1600    public static final Symbol _DEBUGGER_HOOK_ = 1601        exportSpecial("*DEBUGGER-HOOK*", PACKAGE_CL, NIL); 1602 1603    public static final Symbol MOST_POSITIVE_FIXNUM = 1604        exportConstant("MOST-POSITIVE-FIXNUM", PACKAGE_CL, 1605            new Fixnum(Integer.MAX_VALUE)); 1606 1607    public static final Symbol MOST_NEGATIVE_FIXNUM = 1608        exportConstant("MOST-NEGATIVE-FIXNUM", PACKAGE_CL, 1609            new Fixnum(Integer.MIN_VALUE)); 1610 1611    public static void exit() 1612    { 1613        Interpreter interpreter = Interpreter.getInstance(); 1614        if (interpreter != null) 1615            interpreter.kill(); 1616    } 1617 1618    // ### t 1619 // We can't use exportConstant() here since we need to set T's value to 1620 // itself. 1621 public static final Symbol T = PACKAGE_CL.addExternalSymbol("T"); 1622    static { 1623        T.setSpecial(true); 1624        T.setSymbolValue(T); 1625        T.setConstant(true); 1626    } 1627 1628    // ### *read-eval* 1629 public static final Symbol _READ_EVAL_ = 1630        exportSpecial("*READ-EVAL*", PACKAGE_CL, T); 1631 1632    // ### *features* 1633 public static final Symbol _FEATURES_ = 1634        PACKAGE_CL.addExternalSymbol("*FEATURES*"); 1635    static { 1636        _FEATURES_.setSpecial(true); 1637        String osName = System.getProperty("os.name"); 1638        if (osName.startsWith("Linux")) { 1639            _FEATURES_.setSymbolValue(list6(Keyword.ARMEDBEAR, 1640                                            Keyword.ABCL, 1641                                            Keyword.COMMON_LISP, 1642                                            Keyword.ANSI_CL, 1643                                            Keyword.UNIX, 1644                                            Keyword.LINUX)); 1645        } else if (osName.startsWith("Mac OS X")) { 1646            _FEATURES_.setSymbolValue(list6(Keyword.ARMEDBEAR, 1647                                            Keyword.ABCL, 1648                                            Keyword.COMMON_LISP, 1649                                            Keyword.ANSI_CL, 1650                                            Keyword.UNIX, 1651                                            Keyword.DARWIN)); 1652        } else if (osName.startsWith("Windows")) { 1653            _FEATURES_.setSymbolValue(list5(Keyword.ARMEDBEAR, 1654                                            Keyword.ABCL, 1655                                            Keyword.COMMON_LISP, 1656                                            Keyword.ANSI_CL, 1657                                            Keyword.WINDOWS)); 1658        } else { 1659            _FEATURES_.setSymbolValue(list4(Keyword.ARMEDBEAR, 1660                                            Keyword.ABCL, 1661                                            Keyword.COMMON_LISP, 1662                                            Keyword.ANSI_CL)); 1663        } 1664    } 1665 1666    // ### *modules* 1667 public static final Symbol _MODULES_ = 1668        exportSpecial("*MODULES*", PACKAGE_CL, NIL); 1669 1670    // ### *load-verbose* 1671 public static final Symbol _LOAD_VERBOSE_ = 1672        exportSpecial("*LOAD-VERBOSE*", PACKAGE_CL, NIL); 1673 1674    // ### *load-print* 1675 public static final Symbol _LOAD_PRINT_ = 1676        exportSpecial("*LOAD-PRINT*", PACKAGE_CL, NIL); 1677 1678    // ### *load-pathname* 1679 public static final Symbol _LOAD_PATHNAME_ = 1680        exportSpecial("*LOAD-PATHNAME*", PACKAGE_CL, NIL); 1681 1682    // ### *load-truename* 1683 public static final Symbol _LOAD_TRUENAME_ = 1684        exportSpecial("*LOAD-TRUENAME*", PACKAGE_CL, NIL); 1685 1686    // ### *load-depth* 1687 // internal symbol 1688 public static final Symbol _LOAD_DEPTH_ = 1689        internSpecial("*LOAD-DEPTH*", PACKAGE_SYS, new Fixnum(0)); 1690 1691    // ### *load-stream* 1692 // internal symbol 1693 public static final Symbol _LOAD_STREAM_ = 1694        internSpecial("*LOAD-STREAM*", PACKAGE_SYS, NIL); 1695 1696    // ### *autoload-verbose* 1697 // internal symbol 1698 public static final Symbol _AUTOLOAD_VERBOSE_ = 1699        exportSpecial("*AUTOLOAD-VERBOSE*", PACKAGE_EXT, NIL); 1700 1701    // ### *compile-verbose* 1702 public static final Symbol _COMPILE_VERBOSE_ = 1703        exportSpecial("*COMPILE-VERBOSE*", PACKAGE_CL, NIL); 1704 1705    // ### *compile-print* 1706 public static final Symbol _COMPILE_PRINT_ = 1707        exportSpecial("*COMPILE-PRINT*", PACKAGE_CL, NIL); 1708 1709    // ### *compile-file-pathname* 1710 public static final Symbol _COMPILE_FILE_PATHNAME_ = 1711        exportSpecial("*COMPILE-FILE-PATHNAME*", PACKAGE_CL, NIL); 1712 1713    // ### *compile-file-truename* 1714 public static final Symbol _COMPILE_FILE_TRUENAME_ = 1715        exportSpecial("*COMPILE-FILE-TRUENAME*", PACKAGE_CL, NIL); 1716 1717    // ### *compile-file-type* 1718 public static final String COMPILE_FILE_TYPE = "abcl"; 1719    public static final Symbol _COMPILE_FILE_TYPE_ = 1720        internConstant("*COMPILE-FILE-TYPE*", PACKAGE_SYS, 1721                       new SimpleString(COMPILE_FILE_TYPE)); 1722 1723    // ### *macroexpand-hook* 1724 public static final Symbol _MACROEXPAND_HOOK_ = 1725        exportSpecial("*MACROEXPAND-HOOK*", PACKAGE_CL, Symbol.FUNCALL); 1726 1727    // ### array-dimension-limit 1728 public static final int ARRAY_DIMENSION_MAX = 0x1000000; 1729    public static final Symbol ARRAY_DIMENSION_LIMIT = 1730        exportConstant("ARRAY-DIMENSION-LIMIT", PACKAGE_CL, 1731                       new Fixnum(ARRAY_DIMENSION_MAX)); 1732 1733    // ### char-code-limit 1734 // "The upper exclusive bound on the value returned by the function CHAR-CODE." 1735 public static final int CHAR_MAX = 256; 1736    public static final Symbol CHAR_CODE_LIMIT = 1737        exportConstant("CHAR-CODE-LIMIT", PACKAGE_CL, new Fixnum(CHAR_MAX)); 1738 1739    // ### *read-base* 1740 public static final Symbol _READ_BASE_ = 1741        exportSpecial("*READ-BASE*", PACKAGE_CL, new Fixnum(10)); 1742 1743    // ### *read-default-float-format* 1744 public static final Symbol _READ_DEFAULT_FLOAT_FORMAT_ = 1745        exportSpecial("*READ-DEFAULT-FLOAT-FORMAT*", PACKAGE_CL, Symbol.DOUBLE_FLOAT); 1746 1747    // Printer control variables. 1748 public static final Symbol _PRINT_ARRAY_ = 1749        exportSpecial("*PRINT-ARRAY*", PACKAGE_CL, T); 1750 1751    public static final Symbol _PRINT_BASE_ = 1752        exportSpecial("*PRINT-BASE*", PACKAGE_CL, new Fixnum(10)); 1753 1754    public static final Symbol _PRINT_CASE_ = 1755        exportSpecial("*PRINT-CASE*", PACKAGE_CL, Keyword.UPCASE); 1756 1757    public static final Symbol _PRINT_CIRCLE_ = 1758        exportSpecial("*PRINT-CIRCLE*", PACKAGE_CL, NIL); 1759 1760    public static final Symbol _PRINT_ESCAPE_ = 1761        exportSpecial("*PRINT-ESCAPE*", PACKAGE_CL, T); 1762 1763    public static final Symbol _PRINT_GENSYM_ = 1764        exportSpecial("*PRINT-GENSYM*", PACKAGE_CL, T); 1765 1766    public static final Symbol _PRINT_LENGTH_ = 1767        exportSpecial("*PRINT-LENGTH*", PACKAGE_CL, NIL); 1768 1769    public static final Symbol _PRINT_LEVEL_ = 1770        exportSpecial("*PRINT-LEVEL*", PACKAGE_CL, NIL); 1771 1772    public static final Symbol _PRINT_LINES_ = 1773        exportSpecial("*PRINT-LINES*", PACKAGE_CL, NIL); 1774 1775    public static final Symbol _PRINT_MISER_WIDTH_ = 1776        exportSpecial("*PRINT-MISER-WIDTH*", PACKAGE_CL, NIL); 1777 1778    public static final Symbol _PRINT_PPRINT_DISPATCH_ = 1779        exportSpecial("*PRINT-PPRINT-DISPATCH*", PACKAGE_CL, T); 1780 1781    public static final Symbol _PRINT_PRETTY_ = 1782        exportSpecial("*PRINT-PRETTY*", PACKAGE_CL, NIL); 1783 1784    public static final Symbol _PRINT_RADIX_ = 1785        exportSpecial("*PRINT-RADIX*", PACKAGE_CL, NIL); 1786 1787    public static final Symbol _PRINT_READABLY_ = 1788        exportSpecial("*PRINT-READABLY*", PACKAGE_CL, NIL); 1789 1790    public static final Symbol _PRINT_RIGHT_MARGIN_ = 1791        exportSpecial("*PRINT-RIGHT-MARGIN*", PACKAGE_CL, NIL); 1792 1793    public static final Symbol _PRINT_FASL_ = 1794        internConstant("*PRINT-FASL*", PACKAGE_SYS, NIL); 1795 1796    public static final Symbol _RANDOM_STATE_ = 1797        exportSpecial("*RANDOM-STATE*", PACKAGE_CL, new RandomState()); 1798 1799    public static final Symbol STAR = exportSpecial("*", PACKAGE_CL, NIL); 1800    public static final Symbol STAR_STAR = 1801        exportSpecial("**", PACKAGE_CL, NIL); 1802    public static final Symbol STAR_STAR_STAR = 1803        exportSpecial("***", PACKAGE_CL, NIL); 1804 1805    public static final Symbol MINUS = exportSpecial("-", PACKAGE_CL, NIL); 1806 1807    public static final Symbol PLUS = exportSpecial("+", PACKAGE_CL, NIL); 1808    public static final Symbol PLUS_PLUS = 1809        exportSpecial("++", PACKAGE_CL, NIL); 1810    public static final Symbol PLUS_PLUS_PLUS = 1811        exportSpecial("+++", PACKAGE_CL, NIL); 1812 1813    public static final Symbol SLASH = exportSpecial("/", PACKAGE_CL, NIL); 1814    public static final Symbol SLASH_SLASH = 1815        exportSpecial("//", PACKAGE_CL, NIL); 1816    public static final Symbol SLASH_SLASH_SLASH = 1817        exportSpecial("///", PACKAGE_CL, NIL); 1818 1819    public static final Symbol PI = 1820        exportConstant("PI", PACKAGE_CL, LispFloat.PI); 1821 1822    public static final Symbol SHORT_FLOAT_EPSILON = 1823        exportConstant("SHORT-FLOAT-EPSILON", PACKAGE_CL, 1824                       new LispFloat((double)1.1102230246251568E-16)); 1825 1826    public static final Symbol SINGLE_FLOAT_EPSILON = 1827        exportConstant("SINGLE-FLOAT-EPSILON", PACKAGE_CL, 1828                       new LispFloat((double)1.1102230246251568E-16)); 1829 1830    public static final Symbol DOUBLE_FLOAT_EPSILON = 1831        exportConstant("DOUBLE-FLOAT-EPSILON", PACKAGE_CL, 1832                       new LispFloat((double)1.1102230246251568E-16)); 1833 1834    public static final Symbol LONG_FLOAT_EPSILON = 1835        exportConstant("LONG-FLOAT-EPSILON", PACKAGE_CL, 1836                       new LispFloat((double)1.1102230246251568E-16)); 1837 1838    public static final Symbol SHORT_FLOAT_NEGATIVE_EPSILON = 1839        exportConstant("SHORT-FLOAT-NEGATIVE-EPSILON", PACKAGE_CL, 1840                       new LispFloat((double)5.551115123125784E-17)); 1841 1842    public static final Symbol SINGLE_FLOAT_NEGATIVE_EPSILON = 1843        exportConstant("SINGLE-FLOAT-NEGATIVE-EPSILON", PACKAGE_CL, 1844                       new LispFloat((double)5.551115123125784E-17)); 1845 1846    public static final Symbol DOUBLE_FLOAT_NEGATIVE_EPSILON = 1847        exportConstant("DOUBLE-FLOAT-NEGATIVE-EPSILON", PACKAGE_CL, 1848                       new LispFloat((double)5.551115123125784E-17)); 1849 1850    public static final Symbol LONG_FLOAT_NEGATIVE_EPSILON = 1851        exportConstant("LONG-FLOAT-NEGATIVE-EPSILON", PACKAGE_CL, 1852                       new LispFloat((double)5.551115123125784E-17)); 1853 1854    public static final Symbol MOST_POSITIVE_SHORT_FLOAT = 1855        exportConstant("MOST-POSITIVE-SHORT-FLOAT", PACKAGE_CL, 1856                       new LispFloat(Double.MAX_VALUE)); 1857 1858    public static final Symbol MOST_POSITIVE_SINGLE_FLOAT = 1859        exportConstant("MOST-POSITIVE-SINGLE-FLOAT", PACKAGE_CL, 1860                       new LispFloat(Double.MAX_VALUE)); 1861 1862    public static final Symbol MOST_POSITIVE_DOUBLE_FLOAT = 1863        exportConstant("MOST-POSITIVE-DOUBLE-FLOAT", PACKAGE_CL, 1864                       new LispFloat(Double.MAX_VALUE)); 1865 1866    public static final Symbol MOST_POSITIVE_LONG_FLOAT = 1867        exportConstant("MOST-POSITIVE-LONG-FLOAT", PACKAGE_CL, 1868                       new LispFloat(Double.MAX_VALUE)); 1869 1870    public static final Symbol LEAST_POSITIVE_SHORT_FLOAT = 1871        exportConstant("LEAST-POSITIVE-SHORT-FLOAT", PACKAGE_CL, 1872                       new LispFloat(Double.MIN_VALUE)); 1873 1874    public static final Symbol LEAST_POSITIVE_SINGLE_FLOAT = 1875        exportConstant("LEAST-POSITIVE-SINGLE-FLOAT", PACKAGE_CL, 1876                       new LispFloat(Double.MIN_VALUE)); 1877 1878    public static final Symbol LEAST_POSITIVE_DOUBLE_FLOAT = 1879        exportConstant("LEAST-POSITIVE-DOUBLE-FLOAT", PACKAGE_CL, 1880                       new LispFloat(Double.MIN_VALUE)); 1881 1882    public static final Symbol LEAST_POSITIVE_LONG_FLOAT = 1883        exportConstant("LEAST-POSITIVE-LONG-FLOAT", PACKAGE_CL, 1884                       new LispFloat(Double.MIN_VALUE)); 1885 1886    public static final Symbol LEAST_POSITIVE_NORMALIZED_SHORT_FLOAT = 1887        exportConstant("LEAST-POSITIVE-NORMALIZED-SHORT-FLOAT", PACKAGE_CL, 1888                       new LispFloat(Double.MIN_VALUE)); 1889 1890    public static final Symbol LEAST_POSITIVE_NORMALIZED_SINGLE_FLOAT = 1891        exportConstant("LEAST-POSITIVE-NORMALIZED-SINGLE-FLOAT", PACKAGE_CL, 1892                       new LispFloat(Double.MIN_VALUE)); 1893 1894    public static final Symbol LEAST_POSITIVE_NORMALIZED_DOUBLE_FLOAT = 1895        exportConstant("LEAST-POSITIVE-NORMALIZED-DOUBLE-FLOAT", PACKAGE_CL, 1896                       new LispFloat(Double.MIN_VALUE)); 1897 1898    public static final Symbol LEAST_POSITIVE_NORMALIZED_LONG_FLOAT = 1899        exportConstant("LEAST-POSITIVE-NORMALIZED-LONG-FLOAT", PACKAGE_CL, 1900                       new LispFloat(Double.MIN_VALUE)); 1901 1902    public static final Symbol MOST_NEGATIVE_SHORT_FLOAT = 1903        exportConstant("MOST-NEGATIVE-SHORT-FLOAT", PACKAGE_CL, 1904                       new LispFloat(- Double.MAX_VALUE)); 1905 1906    public static final Symbol MOST_NEGATIVE_SINGLE_FLOAT = 1907        exportConstant("MOST-NEGATIVE-SINGLE-FLOAT", PACKAGE_CL, 1908                       new LispFloat(- Double.MAX_VALUE)); 1909 1910    public static final Symbol MOST_NEGATIVE_DOUBLE_FLOAT = 1911        exportConstant("MOST-NEGATIVE-DOUBLE-FLOAT", PACKAGE_CL, 1912                       new LispFloat(- Double.MAX_VALUE)); 1913 1914    public static final Symbol MOST_NEGATIVE_LONG_FLOAT = 1915        exportConstant("MOST-NEGATIVE-LONG-FLOAT", PACKAGE_CL, 1916                       new LispFloat(- Double.MAX_VALUE)); 1917 1918    public static final Symbol LEAST_NEGATIVE_SHORT_FLOAT = 1919        exportConstant("LEAST-NEGATIVE-SHORT-FLOAT", PACKAGE_CL, 1920                       new LispFloat(- Double.MIN_VALUE)); 1921 1922    public static final Symbol LEAST_NEGATIVE_SINGLE_FLOAT = 1923        exportConstant("LEAST-NEGATIVE-SINGLE-FLOAT", PACKAGE_CL, 1924                       new LispFloat(- Double.MIN_VALUE)); 1925 1926    public static final Symbol LEAST_NEGATIVE_DOUBLE_FLOAT = 1927        exportConstant("LEAST-NEGATIVE-DOUBLE-FLOAT", PACKAGE_CL, 1928                       new LispFloat(- Double.MIN_VALUE)); 1929 1930    public static final Symbol LEAST_NEGATIVE_LONG_FLOAT = 1931        exportConstant("LEAST-NEGATIVE-LONG-FLOAT", PACKAGE_CL, 1932                       new LispFloat(- Double.MIN_VALUE)); 1933 1934    public static final Symbol LEAST_NEGATIVE_NORMALIZED_SHORT_FLOAT = 1935        exportConstant("LEAST-NEGATIVE-NORMALIZED-SHORT-FLOAT", PACKAGE_CL, 1936                       new LispFloat(- Double.MIN_VALUE)); 1937 1938    public static final Symbol LEAST_NEGATIVE_NORMALIZED_SINGLE_FLOAT = 1939        exportConstant("LEAST-NEGATIVE-NORMALIZED-SINGLE-FLOAT", PACKAGE_CL, 1940                       new LispFloat(- Double.MIN_VALUE)); 1941 1942    public static final Symbol LEAST_NEGATIVE_NORMALIZED_DOUBLE_FLOAT = 1943        exportConstant("LEAST-NEGATIVE-NORMALIZED-DOUBLE-FLOAT", PACKAGE_CL, 1944                       new LispFloat(- Double.MIN_VALUE)); 1945 1946    public static final Symbol LEAST_NEGATIVE_NORMALIZED_LONG_FLOAT = 1947        exportConstant("LEAST-NEGATIVE-NORMALIZED-LONG-FLOAT", PACKAGE_CL, 1948                       new LispFloat(- Double.MIN_VALUE)); 1949 1950    public static final Symbol BOOLE_CLR = 1951        exportConstant("BOOLE-CLR", PACKAGE_CL, Fixnum.ZERO); 1952 1953    public static final Symbol BOOLE_SET = 1954        exportConstant("BOOLE-SET", PACKAGE_CL, Fixnum.ONE); 1955 1956    public static final Symbol BOOLE_1 = 1957        exportConstant("BOOLE-1", PACKAGE_CL, Fixnum.TWO); 1958 1959    public static final Symbol BOOLE_2 = 1960        exportConstant("BOOLE-2", PACKAGE_CL, new Fixnum(3)); 1961 1962    public static final Symbol BOOLE_C1 = 1963        exportConstant("BOOLE-C1", PACKAGE_CL, new Fixnum(4)); 1964 1965    public static final Symbol BOOLE_C2 = 1966        exportConstant("BOOLE-C2", PACKAGE_CL, new Fixnum(5)); 1967 1968    public static final Symbol BOOLE_AND = 1969        exportConstant("BOOLE-AND", PACKAGE_CL, new Fixnum(6)); 1970 1971    public static final Symbol BOOLE_IOR = 1972        exportConstant("BOOLE-IOR", PACKAGE_CL, new Fixnum(7)); 1973 1974    public static final Symbol BOOLE_XOR = 1975        exportConstant("BOOLE-XOR", PACKAGE_CL, new Fixnum(8)); 1976 1977    public static final Symbol BOOLE_EQV = 1978        exportConstant("BOOLE-EQV", PACKAGE_CL, new Fixnum(9)); 1979 1980    public static final Symbol BOOLE_NAND = 1981        exportConstant("BOOLE-NAND", PACKAGE_CL, new Fixnum(10)); 1982 1983    public static final Symbol BOOLE_NOR = 1984        exportConstant("BOOLE-NOR", PACKAGE_CL, new Fixnum(11)); 1985 1986    public static final Symbol BOOLE_ANDC1 = 1987        exportConstant("BOOLE-ANDC1", PACKAGE_CL, new Fixnum(12)); 1988 1989    public static final Symbol BOOLE_ANDC2 = 1990        exportConstant("BOOLE-ANDC2", PACKAGE_CL, new Fixnum(13)); 1991 1992    public static final Symbol BOOLE_ORC1 = 1993        exportConstant("BOOLE-ORC1", PACKAGE_CL, new Fixnum(14)); 1994 1995    public static final Symbol BOOLE_ORC2 = 1996        exportConstant("BOOLE-ORC2", PACKAGE_CL, new Fixnum(15)); 1997 1998    // ### *saved-backtrace* 1999 public static final Symbol _SAVED_BACKTRACE_ = 2000        exportSpecial("*SAVED-BACKTRACE*", PACKAGE_EXT, NIL); 2001 2002    // ### *speed* compiler policy 2003 public static final Symbol _SPEED_ = 2004        internSpecial("*SPEED*", PACKAGE_JVM, Fixnum.ONE); 2005 2006    // ### *safety* compiler policy 2007 public static final Symbol _SAFETY_ = 2008        internSpecial("*SAFETY*", PACKAGE_JVM, Fixnum.ONE); 2009 2010    // ### *debug* compiler policy 2011 public static final Symbol _DEBUG_ = 2012        internSpecial("*DEBUG*", PACKAGE_JVM, Fixnum.ONE); 2013 2014    public static final LispObject UNBOUND = new LispObject() 2015    { 2016        public LispObject getDescription() 2017        { 2018            return new SimpleString("..unbound.."); 2019        } 2020    }; 2021 2022    public static final Symbol _KEYWORD_PACKAGE_ = 2023        exportConstant("*KEYWORD-PACKAGE*", PACKAGE_SYS, PACKAGE_KEYWORD); 2024 2025    // Initialized in function_info.java. 2026 public static EqualHashTable FUNCTION_TABLE; 2027 2028    private static final void loadClass(String className) 2029    { 2030        try { 2031            Class.forName(className); 2032        } 2033        catch (ClassNotFoundException e) { 2034            e.printStackTrace(); 2035        } 2036    } 2037 2038    static { 2039        loadClass("org.armedbear.lisp.Primitives"); 2040        loadClass("org.armedbear.lisp.SpecialOperators"); 2041        loadClass("org.armedbear.lisp.Extensions"); 2042        loadClass("org.armedbear.lisp.Java"); 2043        loadClass("org.armedbear.lisp.CompiledFunction"); 2044        loadClass("org.armedbear.lisp.Autoload"); 2045        loadClass("org.armedbear.lisp.AutoloadMacro"); 2046        loadClass("org.armedbear.lisp.cxr"); 2047        loadClass("org.armedbear.lisp.Do"); 2048        loadClass("org.armedbear.lisp.dolist"); 2049        loadClass("org.armedbear.lisp.dotimes"); 2050        loadClass("org.armedbear.lisp.Pathname"); 2051        loadClass("org.armedbear.lisp.LispClass"); 2052        loadClass("org.armedbear.lisp.BuiltInClass"); 2053        loadClass("org.armedbear.lisp.StructureObject"); 2054 2055        loadClass("org.armedbear.lisp.ash"); 2056 2057        cold = false; 2058    } 2059} 2060

A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame Popular Tags