Changeset 13168


Ignore:
Timestamp:
01/21/11 22:12:08 (11 years ago)
Author:
ehuelsmann
Message:

Merge r13141-13146 and r13156: Make sure ABCL doesn't call System.exit()
in order to be a well-behaving library.

Location:
branches/0.24.x/abcl/src/org/armedbear/lisp
Files:
7 edited
2 copied

Legend:

Unmodified
Added
Removed
  • branches/0.24.x/abcl/src/org/armedbear/lisp/Autoload.java

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

    r13090 r13168  
    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  }
  • branches/0.24.x/abcl/src/org/armedbear/lisp/Interpreter.java

    r13106 r13168  
    9090            out._writeString(help());
    9191            out._finishOutput();
    92             exit(0);
     92            exit(0); // FIXME
    9393        }
    9494        if (noinform)
     
    254254                    } else {
    255255                        System.err.println("No argument supplied to --eval");
    256                         exit(1);
     256                        exit(1); // FIXME
    257257                    }
    258258                } else if (arg.equals("--load") ||
     
    262262                    } else {
    263263                        System.err.println("No argument supplied to --load");
    264                         exit(1);
     264                        exit(1); // FIXME
    265265                    }
    266266                } else {
     
    302302                            sb.append(separator);
    303303                            System.err.print(sb.toString());
    304                             exit(2);
     304                            exit(2); // FIXME
    305305                        }
    306306                        ++i;
     
    308308                        // Shouldn't happen.
    309309                        System.err.println("No argument supplied to --eval");
    310                         exit(1);
     310                        exit(1); // FIXME
    311311                    }
    312312                } else if (arg.equals("--load") ||
     
    323323                        // Shouldn't happen.
    324324                        System.err.println("No argument supplied to --load");
    325                         exit(1);
     325                        exit(1);  // FIXME
    326326                    }
    327327                }
     
    329329        }
    330330        if (_BATCH_MODE_.getSymbolValue() == T) {
    331             exit(0);
    332         }
    333     }
    334 
     331            exit(0); // FIXME
     332        }
     333    }
     334
     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 (ProcessingTerminated e) {
     410                throw e;
     411            }
     412            catch (IntegrityError e) {
     413                return;
     414            }
     415            catch (Throwable t) {
     416                getStandardInput().clearInput();
     417                out.printStackTrace(t);
     418                thread.printBacktrace();
     419            }
    405420        }
    406421    }
  • branches/0.24.x/abcl/src/org/armedbear/lisp/Lisp.java

    r13167 r13168  
    287287          }
    288288        catch (ControlTransfer c)
     289          {
     290            throw c;
     291          }
     292        catch (ProcessingTerminated c)
     293          {
     294            throw c;
     295          }
     296        catch (IntegrityError c)
    289297          {
    290298            throw c;
  • branches/0.24.x/abcl/src/org/armedbear/lisp/Main.java

    r11391 r13168  
    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               try {
     46                    Interpreter interpreter = Interpreter.createDefaultInstance(args);
     47                    if (interpreter != null)
     48                            interpreter.run();
     49                } catch (ProcessingTerminated e) {
     50                    System.exit(e.getStatus());
     51                }
     52            }
     53        };
     54        new Thread(null, r, "interpreter", 4194304L).start();
     55    }
    5556}
  • branches/0.24.x/abcl/src/org/armedbear/lisp/Primitives.java

    r13090 r13168  
    15831583        @Override
    15841584        public LispObject execute(LispObject[] args) {
    1585             Error e = new Error();
     1585            Error e = new IntegrityError();
    15861586
    15871587            e.printStackTrace();
     
    15961596                    System.out.println(a.writeToString());
    15971597
    1598             //###FIXME: Bail out, but do it nicer...
    1599             exit(1);
    1600             return NIL;
     1598            throw e;
    16011599        }
    16021600    };
  • branches/0.24.x/abcl/src/org/armedbear/lisp/ProcessingTerminated.java

    r13146 r13168  
    5353    }
    5454
    55     int getStatus() {
     55    public int getStatus() {
    5656        return status;
    5757    }
  • branches/0.24.x/abcl/src/org/armedbear/lisp/java/swing/REPLConsole.java

    r13090 r13168  
    303303    } catch (Throwable e) {
    304304      e.printStackTrace();
    305       exit(1);
     305      System.exit(1);  // Ok. We haven't done anything useful yet.
    306306    }
    307307    final REPLConsole d = new REPLConsole(repl);
Note: See TracChangeset for help on using the changeset viewer.