Changeset 13143


Ignore:
Timestamp:
01/13/11 22:49:28 (11 years ago)
Author:
ehuelsmann
Message:

Add IntegrityError? and ProcessingTerminated? error classes
and adjust Interpreter.run() accordingly.
No longer call (directly or indirectly) System.exit(),
throw the relevant errors instead.

Location:
trunk/abcl/src/org/armedbear/lisp
Files:
5 edited
2 copied

Legend:

Unmodified
Added
Removed
  • trunk/abcl/src/org/armedbear/lisp/Autoload.java

    r12773 r13143  
    142142                if (symbol.getSymbolFunction() instanceof Autoload) {
    143143                    Debug.trace("Unable to autoload " + symbol.writeToString());
    144                     System.exit(-1);
     144                    throw new IntegrityError();
    145145                }
    146146            }
  • trunk/abcl/src/org/armedbear/lisp/Extensions.java

    r13090 r13143  
    201201    public LispObject execute()
    202202    {
    203       exit(0);
    204       return LispThread.currentThread().nothing();
     203      throw new ProcessingTerminated();
    205204    }
    206205    @Override
     
    214213            status = ((Fixnum)second).value;
    215214        }
    216       exit(status);
    217       return LispThread.currentThread().nothing();
     215      throw new ProcessingTerminated(status);
    218216    }
    219217  }
     
    230228      ((Stream)Symbol.STANDARD_OUTPUT.getSymbolValue())._finishOutput();
    231229      ((Stream)Symbol.ERROR_OUTPUT.getSymbolValue())._finishOutput();
    232       exit(0);
    233       return LispThread.currentThread().nothing();
     230      throw new ProcessingTerminated();
    234231    }
    235232    @Override
     
    242239            status = ((Fixnum)second).value;
    243240        }
    244       exit(status);
    245       return LispThread.currentThread().nothing();
     241      throw new ProcessingTerminated(status);
    246242    }
    247243  }
  • trunk/abcl/src/org/armedbear/lisp/IntegrityError.java

    r13136 r13143  
    11/*
    2  * ThreadDestroyed.java
     2 * IntegrityError.java
    33 *
    4  * Copyright (C) 2003 Peter Graves
     4 * Copyright (C) 2011 Erik Huelsmann
    55 * $Id$
    66 *
     
    3434package org.armedbear.lisp;
    3535
    36 public class ThreadDestroyed extends Error
     36public class IntegrityError extends Error
    3737{
    38     public ThreadDestroyed()
     38    public IntegrityError()
    3939    {
    4040    }
  • trunk/abcl/src/org/armedbear/lisp/Interpreter.java

    r13142 r13143  
    333333    }
    334334
     335    @SuppressWarnings("CallToThreadDumpStack")
    335336    public void run()
    336337    {
     
    343344                return;
    344345            }
    345             // We only arrive here if something went wrong and we weren't able
    346             // to load top-level.lisp and run the normal top-level loop.
    347             Stream out = getStandardOutput();
    348             while (true) {
    349                 try {
    350                     thread.resetStack();
    351                     thread.clearSpecialBindings();
    352                     out._writeString("* ");
    353                     out._finishOutput();
    354                     LispObject object =
    355                         getStandardInput().read(false, EOF, false, thread,
    356                                                 Stream.currentReadtable);
    357                     if (object == EOF)
    358                         break;
    359                     out.setCharPos(0);
    360                     Symbol.MINUS.setSymbolValue(object);
    361                     LispObject result = Lisp.eval(object, new Environment(), thread);
    362                     Debug.assertTrue(result != null);
    363                     Symbol.STAR_STAR_STAR.setSymbolValue(Symbol.STAR_STAR.getSymbolValue());
    364                     Symbol.STAR_STAR.setSymbolValue(Symbol.STAR.getSymbolValue());
    365                     Symbol.STAR.setSymbolValue(result);
    366                     Symbol.PLUS_PLUS_PLUS.setSymbolValue(Symbol.PLUS_PLUS.getSymbolValue());
    367                     Symbol.PLUS_PLUS.setSymbolValue(Symbol.PLUS.getSymbolValue());
    368                     Symbol.PLUS.setSymbolValue(Symbol.MINUS.getSymbolValue());
    369                     out = getStandardOutput();
    370                     out.freshLine();
    371                     LispObject[] values = thread.getValues();
    372                     Symbol.SLASH_SLASH_SLASH.setSymbolValue(Symbol.SLASH_SLASH.getSymbolValue());
    373                     Symbol.SLASH_SLASH.setSymbolValue(Symbol.SLASH.getSymbolValue());
    374                     if (values != null) {
    375                         LispObject slash = NIL;
    376                         for (int i = values.length; i-- > 0;)
    377                             slash = new Cons(values[i], slash);
    378                         Symbol.SLASH.setSymbolValue(slash);
    379                         for (int i = 0; i < values.length; i++)
    380                             out._writeLine(values[i].writeToString());
    381                     } else {
    382                         Symbol.SLASH.setSymbolValue(new Cons(result));
    383                         out._writeLine(result.writeToString());
    384                     }
    385                     out._finishOutput();
    386                 }
    387                 catch (StackOverflowError e) {
    388                     getStandardInput().clearInput();
    389                     out._writeLine("Stack overflow");
    390                 }
    391                 catch (ControlTransfer c) {
    392                     // We're on the toplevel, if this occurs,
    393                     // we're toast...
    394                     reportError(c, thread);
    395                 }
    396                 catch (Throwable t) {
    397                     getStandardInput().clearInput();
    398                     out.printStackTrace(t);
    399                     thread.printBacktrace();
    400                 }
    401             }
     346        }
     347        catch (ProcessingTerminated e) {
     348            throw e;
     349        }
     350        catch (IntegrityError e) {
     351            return;
    402352        }
    403353        catch (Throwable t) {
    404354            t.printStackTrace();
     355            return;
     356        }
     357       
     358        // We only arrive here if something went wrong and we weren't able
     359        // to load top-level.lisp and run the normal top-level loop.
     360        Stream out = getStandardOutput();
     361        while (true) {
     362            try {
     363                thread.resetStack();
     364                thread.clearSpecialBindings();
     365                out._writeString("* ");
     366                out._finishOutput();
     367                LispObject object =
     368                    getStandardInput().read(false, EOF, false, thread,
     369                                            Stream.currentReadtable);
     370                if (object == EOF)
     371                    break;
     372                out.setCharPos(0);
     373                Symbol.MINUS.setSymbolValue(object);
     374                LispObject result = Lisp.eval(object, new Environment(), thread);
     375                Debug.assertTrue(result != null);
     376                Symbol.STAR_STAR_STAR.setSymbolValue(Symbol.STAR_STAR.getSymbolValue());
     377                Symbol.STAR_STAR.setSymbolValue(Symbol.STAR.getSymbolValue());
     378                Symbol.STAR.setSymbolValue(result);
     379                Symbol.PLUS_PLUS_PLUS.setSymbolValue(Symbol.PLUS_PLUS.getSymbolValue());
     380                Symbol.PLUS_PLUS.setSymbolValue(Symbol.PLUS.getSymbolValue());
     381                Symbol.PLUS.setSymbolValue(Symbol.MINUS.getSymbolValue());
     382                out = getStandardOutput();
     383                out.freshLine();
     384                LispObject[] values = thread.getValues();
     385                Symbol.SLASH_SLASH_SLASH.setSymbolValue(Symbol.SLASH_SLASH.getSymbolValue());
     386                Symbol.SLASH_SLASH.setSymbolValue(Symbol.SLASH.getSymbolValue());
     387                if (values != null) {
     388                    LispObject slash = NIL;
     389                    for (int i = values.length; i-- > 0;)
     390                        slash = new Cons(values[i], slash);
     391                    Symbol.SLASH.setSymbolValue(slash);
     392                    for (int i = 0; i < values.length; i++)
     393                        out._writeLine(values[i].writeToString());
     394                } else {
     395                    Symbol.SLASH.setSymbolValue(new Cons(result));
     396                    out._writeLine(result.writeToString());
     397                }
     398                out._finishOutput();
     399            }
     400            catch (StackOverflowError e) {
     401                getStandardInput().clearInput();
     402                out._writeLine("Stack overflow");
     403            }
     404            catch (ControlTransfer c) {
     405                // We're on the toplevel, if this occurs,
     406                // we're toast...
     407                reportError(c, thread);
     408            }
     409            catch (Throwable t) {
     410                getStandardInput().clearInput();
     411                out.printStackTrace(t);
     412                thread.printBacktrace();
     413            }
    405414        }
    406415    }
  • trunk/abcl/src/org/armedbear/lisp/Main.java

    r11391 r13143  
    3131 * exception statement from your version.
    3232 */
    33 
    3433package org.armedbear.lisp;
    3534
    36 public final class Main
    37 {
    38   public static final long startTimeMillis = System.currentTimeMillis();
     35public final class Main {
    3936
    40   public static void main(final String[] args)
    41   {
    42     // Run the interpreter in a secondary thread so we can control the stack
    43     // size.
    44     Runnable r = new Runnable()
    45       {
    46         public void run()
    47         {
    48           Interpreter interpreter = Interpreter.createDefaultInstance(args);
    49           if (interpreter != null)
    50           interpreter.run();
    51         }
    52       };
    53     new Thread(null, r, "interpreter", 4194304L).start();
    54   }
     37    public static final long startTimeMillis = System.currentTimeMillis();
     38
     39    public static void main(final String[] args) {
     40        // Run the interpreter in a secondary thread so we can control the stack
     41        // size.
     42        Runnable r = new Runnable() {
     43
     44            public void run() {
     45                Interpreter interpreter = Interpreter.createDefaultInstance(args);
     46                if (interpreter != null) {
     47                    try {
     48                        interpreter.run();
     49                    } catch (ProcessingTerminated e) {
     50                        System.exit(e.getStatus());
     51                    }
     52
     53                }
     54            }
     55        };
     56        new Thread(null, r, "interpreter", 4194304L).start();
     57    }
    5558}
  • trunk/abcl/src/org/armedbear/lisp/Primitives.java

    r13139 r13143  
    15841584        @SuppressWarnings("CallToThreadDumpStack")
    15851585        public LispObject execute(LispObject[] args) {
    1586             Error e = new Error();
     1586            Error e = new IntegrityError();
    15871587
    15881588            e.printStackTrace();
     
    15971597                System.out.println(a.writeToString());
    15981598
    1599             //###FIXME: Bail out, but do it nicer...
    1600             exit(1);
    1601             return NIL;
     1599            throw e;
    16021600        }
    16031601    };
  • trunk/abcl/src/org/armedbear/lisp/ProcessingTerminated.java

    r13136 r13143  
    11/*
    2  * ThreadDestroyed.java
     2 * ProcessingTerminated.java
    33 *
    4  * Copyright (C) 2003 Peter Graves
     4 * Copyright (C) 2011 Erik Huelsmann
    55 * $Id$
    66 *
     
    3434package org.armedbear.lisp;
    3535
    36 public class ThreadDestroyed extends Error
     36public class ProcessingTerminated extends Error
    3737{
    38     public ThreadDestroyed()
     38    private int status;
     39
     40    public ProcessingTerminated()
    3941    {
    4042    }
    4143
     44    public ProcessingTerminated(int status)
     45    {
     46        this.status = status;
     47    }
     48
     49    int getStatus() {
     50        return status;
     51    }
    4252}
Note: See TracChangeset for help on using the changeset viewer.