Changeset 10053


Ignore:
Timestamp:
09/28/05 15:00:10 (16 years ago)
Author:
piso
Message:

Refactoring.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/j/src/org/armedbear/lisp/Interpreter.java

    r9485 r10053  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves
    5  * $Id: Interpreter.java,v 1.87 2005-06-22 15:30:50 piso Exp $
     5 * $Id: Interpreter.java,v 1.88 2005-09-28 15:00:10 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    3535    public static Interpreter interpreter;
    3636
    37     private static int commandNumber;
    38 
    3937    private final boolean jlisp;
    4038    private final InputStream inputStream;
    4139    private final OutputStream outputStream;
    4240
     41    private static boolean noinit;
     42    private static boolean noinform;
     43
    4344    public static synchronized Interpreter getInstance()
    4445    {
     
    4647    }
    4748
     49    // Interface.
    4850    public static synchronized Interpreter createInstance()
    4951    {
     
    5355    }
    5456
    55     public static synchronized Interpreter createInstance(InputStream in,
    56         OutputStream out, String initialDirectory)
     57    public static synchronized Interpreter createDefaultInstance(String[] args)
    5758    {
    5859        if (interpreter != null)
    5960            return null;
    60         return interpreter = new Interpreter(in, out, initialDirectory);
    61     }
    62 
    63     private final Environment environment = new Environment();
     61        interpreter = new Interpreter();
     62        try {
     63            if (args != null)
     64                preprocessCommandLineArguments(args);
     65            if (!noinform) {
     66                Stream out = getStandardOutput();
     67                out._writeString(banner());
     68                out._finishOutput();
     69            }
     70            if (Utilities.isPlatformUnix()) {
     71                try {
     72                    System.loadLibrary("abcl");
     73                    Class c = Class.forName("org.armedbear.lisp.Native");
     74                    Method m = c.getMethod("initialize", (Class[]) null);
     75                    m.invoke((Object) null, (Object[]) null);
     76                    if (!noinform)
     77                        getStandardOutput()._writeString("Control-C handler installed.\n");
     78                }
     79                catch (Throwable t) {}
     80            }
     81            if (noinform)
     82                _NOINFORM_.setSymbolValue(T);
     83            else {
     84                double uptime = (System.currentTimeMillis() - Main.startTimeMillis) / 1000.0;
     85                getStandardOutput()._writeString("Low-level initialization completed in " +
     86                                                 uptime + " seconds.\n");
     87            }
     88            initializeLisp();
     89            initializeTopLevel();
     90            if (!noinit)
     91                processInitializationFile();
     92            if (args != null)
     93                postprocessCommandLineArguments(args);
     94        }
     95        catch (Throwable t) {
     96            t.printStackTrace();
     97        }
     98        return interpreter;
     99    }
     100
     101    public static synchronized Interpreter createJLispInstance(
     102        InputStream in,
     103        OutputStream out,
     104        String initialDirectory,
     105        String version)
     106    {
     107        if (interpreter != null)
     108            return null;
     109        interpreter = new Interpreter(in, out, initialDirectory);
     110        try {
     111            Stream stdout = getStandardOutput();
     112            stdout._writeLine(version);
     113            stdout._writeString(banner());
     114            stdout._finishOutput();
     115        }
     116        catch (Throwable t) {
     117            t.printStackTrace();
     118        }
     119        initializeJLisp();
     120        initializeTopLevel();
     121        processInitializationFile();
     122        return interpreter;
     123    }
    64124
    65125    private Interpreter()
     
    88148    }
    89149
    90     public static synchronized void initializeLisp(boolean jlisp)
     150    public static synchronized void initializeLisp()
    91151    {
    92152        if (!initialized) {
    93153            try {
    94                 if (jlisp) {
    95                     _FEATURES_.setSymbolValue(new Cons(Keyword.J,
    96                                                        _FEATURES_.getSymbolValue()));
    97                 }
    98154                Load.loadSystemFile("boot.lisp", false, false, false);
    99                 if (jlisp) {
    100                     Class.forName("org.armedbear.j.LispAPI");
    101                     Load.loadSystemFile("j.lisp");
    102                 }
     155            }
     156            catch (ConditionThrowable c) {
     157                reportError(c, LispThread.currentThread());
     158            }
     159            catch (Throwable t) {
     160                t.printStackTrace();
     161            }
     162            initialized = true;
     163        }
     164    }
     165
     166    public static synchronized void initializeJLisp()
     167    {
     168        if (!initialized) {
     169            try {
     170                _FEATURES_.setSymbolValue(new Cons(Keyword.J,
     171                                                   _FEATURES_.getSymbolValue()));
     172                Load.loadSystemFile("boot.lisp", false, false, false);
     173                Class.forName("org.armedbear.j.LispAPI");
     174                Load.loadSystemFile("j.lisp");
    103175            }
    104176            catch (ConditionThrowable c) {
     
    171243    }
    172244
    173     private static boolean noinit;
    174 
    175245    // Check for --noinit; verify that arguments are supplied for --load and
    176246    // --eval options.
    177     private void preprocessCommandLineArguments(String[] args)
     247    private static void preprocessCommandLineArguments(String[] args)
    178248        throws ConditionThrowable
    179249    {
     
    183253                if (arg.equals("--noinit")) {
    184254                    noinit = true;
     255                } else if (arg.equals("--noinform")) {
     256                    noinform = true;
    185257                } else if (arg.equals("--batch")) {
    186258                    _BATCH_MODE_.setSymbolValue(T);
    187                 } else if (arg.equals("--preload")) {
    188                     _PRELOAD_.setSymbolValue(T);
    189259                } else if (arg.equals("--eval")) {
    190260                    if (i + 1 < args.length) {
     
    208278
    209279    // Do the --load and --eval actions.
    210     private void postprocessCommandLineArguments(String[] args)
     280    private static void postprocessCommandLineArguments(String[] args)
    211281        throws ConditionThrowable
    212282    {
     
    223293                            final String separator =
    224294                                System.getProperty("line.separator");
    225                             StringBuffer sb = new StringBuffer();
     295                            FastStringBuffer sb = new FastStringBuffer();
    226296                            sb.append(separator);
    227297                            sb.append("Caught ");
    228298                            sb.append(c.getCondition().typeOf().writeToString());
    229299                            sb.append(" while processing --eval option \"" +
    230                                                args[i + 1] + "\":");
     300                                      args[i + 1] + "\":");
    231301                            sb.append(separator);
    232302                            sb.append("  ");
     
    273343    }
    274344
    275     public void run(String[] args)
     345    public void run()
    276346    {
    277347        final LispThread thread = LispThread.currentThread();
    278         commandNumber = 0;
    279         try {
    280             Stream out = getStandardOutput();
    281             out._writeString(banner());
    282             out._finishOutput();
    283             if (Utilities.isPlatformUnix()) {
    284                 try {
    285                     System.loadLibrary("abcl");
    286                     Class c = Class.forName("org.armedbear.lisp.Native");
    287                     Method m = c.getMethod("initialize", (Class[]) null);
    288                     m.invoke((Object) null, (Object[]) null);
    289                     out._writeString("Control-C handler installed.\n");
    290                 }
    291                 catch (Throwable t) {}
    292             }
    293             if (!jlisp) {
    294                 double uptime = (System.currentTimeMillis() - Main.startTimeMillis) / 1000.0;
    295                 System.out.println("Low-level initialization completed in " +
    296                                    uptime + " seconds.");
    297             }
    298             initializeLisp(jlisp);
    299             initializeTopLevel();
    300             if (jlisp) {
    301                 Debug.assertTrue(args == null);
    302                 processInitializationFile();
    303             } else {
    304                 if (args != null)
    305                     preprocessCommandLineArguments(args);
    306                 if (_PRELOAD_.getSymbolValue() != NIL) {
    307                     thread.execute(PACKAGE_SYS.intern("PRELOAD-PACKAGE"),
    308                                    PACKAGE_CL);
    309                     thread.execute(PACKAGE_CL.intern("REQUIRE"),
    310                                    new SimpleString("LOOP"));
    311                     thread.execute(PACKAGE_SYS.intern("PRELOAD-PACKAGE"),
    312                                    PACKAGE_SYS);
    313                 }
    314                 if (!noinit)
    315                     processInitializationFile();
    316                 if (args != null)
    317                     postprocessCommandLineArguments(args);
    318             }
     348        try {
    319349            Symbol TOP_LEVEL_LOOP = intern("TOP-LEVEL-LOOP", PACKAGE_TPL);
    320350            LispObject tplFun = TOP_LEVEL_LOOP.getSymbolFunction();
     
    323353                return;
    324354            }
     355            // We only arrive here if something went wrong and we weren't able
     356            // to load top-level.lisp and run the normal top-level loop.
     357            Stream out = getStandardOutput();
    325358            while (true) {
    326359                try {
    327360                    thread.resetStack();
    328361                    thread.lastSpecialBinding = null;
    329                     ++commandNumber;
    330362                    out._writeString(prompt());
    331363                    out._finishOutput();
    332                     LispObject
    333                         object = getStandardInput().read(false, EOF, false); // Top level read.
     364                    LispObject object =
     365                        getStandardInput().read(false, EOF, false);
    334366                    if (object == EOF)
    335367                        break;
    336368                    out.setCharPos(0);
    337369                    Symbol.MINUS.setSymbolValue(object);
    338                     LispObject result = eval(object, environment, thread);
     370                    LispObject result = eval(object, new Environment(), thread);
    339371                    Debug.assertTrue(result != null);
    340372                    Symbol.STAR_STAR_STAR.setSymbolValue(Symbol.STAR_STAR.getSymbolValue());
     
    475507    };
    476508
     509    public static final LispObject readFromString(String s)
     510    {
     511        try {
     512            return new StringInputStream(s).read(true, NIL, false);
     513        }
     514        catch (Throwable t) {
     515            return null;
     516        }
     517    }
     518
     519    // For j.
    477520    public static LispObject evaluate(String s) throws ConditionThrowable
    478521    {
    479522        if (!initialized)
    480             initializeLisp(true);
     523            initializeJLisp();
    481524        StringInputStream stream = new StringInputStream(s);
    482525        LispObject obj = stream.read(false, EOF, false);
     
    514557    {
    515558        final String sep = System.getProperty("line.separator");
    516         StringBuffer sb = new StringBuffer("Armed Bear Common Lisp ");
     559        FastStringBuffer sb = new FastStringBuffer("Armed Bear Common Lisp ");
    517560        sb.append(Version.getVersion());
    518561        if (build != null) {
     
    541584        if (pkgName == null)
    542585            pkgName = pkg.getName();
    543         StringBuffer sb = new StringBuffer();
     586        FastStringBuffer sb = new FastStringBuffer();
    544587        sb.append(pkgName);
    545         sb.append('(');
    546         sb.append(commandNumber);
    547         sb.append(")> ");
    548588        return sb.toString();
    549589    }
Note: See TracChangeset for help on using the changeset viewer.