Changeset 10330


Ignore:
Timestamp:
11/03/05 14:52:00 (16 years ago)
Author:
piso
Message:

Work in progress (tested).

File:
1 edited

Legend:

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

    r10206 r10330  
    33 *
    44 * Copyright (C) 2003-2005 Peter Graves
    5  * $Id: LispThread.java,v 1.86 2005-10-23 17:38:10 piso Exp $
     5 * $Id: LispThread.java,v 1.87 2005-11-03 14:52:00 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    116116        javaThread.setDaemon(true);
    117117        javaThread.start();
     118    }
     119
     120    public LispObject typeOf()
     121    {
     122        return Symbol.THREAD;
     123    }
     124
     125    public LispObject classOf()
     126    {
     127        return BuiltInClass.THREAD;
     128    }
     129
     130    public LispObject typep(LispObject typeSpecifier) throws ConditionThrowable
     131    {
     132        if (typeSpecifier == Symbol.THREAD)
     133            return T;
     134        if (typeSpecifier == BuiltInClass.THREAD)
     135            return T;
     136        return super.typep(typeSpecifier);
    118137    }
    119138
     
    973992        public LispObject execute(LispObject arg) throws ConditionThrowable
    974993        {
     994            final LispThread lispThread;
    975995            try {
    976                 return ((LispThread)arg).javaThread.isAlive() ? T : NIL;
     996                lispThread = (LispThread) arg;
    977997            }
    978998            catch (ClassCastException e) {
    979                 return signal(new TypeError(arg, "Lisp thread"));
    980             }
     999                return signalTypeError(arg, Symbol.THREAD);
     1000            }
     1001            return lispThread.javaThread.isAlive() ? T : NIL;
    9811002        }
    9821003    };
     
    9921013            }
    9931014            catch (ClassCastException e) {
    994                 return signal(new TypeError(arg, "Lisp thread"));
     1015                return signalTypeError(arg, Symbol.THREAD);
    9951016            }
    9961017        }
     
    10051026                ((DoubleFloat)arg.multiplyBy(new DoubleFloat(1000))).getValue();
    10061027            if (d < 0)
    1007                 return signal(new TypeError(arg, "non-negative real"));
     1028                return signalTypeError(arg, list2(Symbol.REAL, Fixnum.ZERO));
    10081029            long millis = d < Long.MAX_VALUE ? (long) d : Long.MAX_VALUE;
    10091030            try {
     
    10421063        public LispObject execute(LispObject arg) throws ConditionThrowable
    10431064        {
    1044             if (arg instanceof LispThread) {
    1045                 LispThread thread = (LispThread) arg;
    1046                 thread.setDestroyed(true);
    1047                 return T;
    1048             } else
    1049                 return signal(new TypeError(arg, "Lisp thread"));
     1065            final LispThread thread;
     1066            try {
     1067                thread = (LispThread) arg;
     1068            }
     1069            catch (ClassCastException e) {
     1070                return signalTypeError(arg, Symbol.THREAD);
     1071            }
     1072            thread.setDestroyed(true);
     1073            return T;
    10501074        }
    10511075    };
     
    10631087            if (args.length < 2)
    10641088                return signal(new WrongNumberOfArgumentsException(this));
    1065             if (args[0] instanceof LispThread) {
    1066                 LispThread thread = (LispThread) args[0];
    1067                 LispObject fun = args[1];
    1068                 LispObject funArgs = NIL;
    1069                 for (int i = args.length; i-- > 2;)
    1070                     funArgs = new Cons(args[i], funArgs);
    1071                 thread.interrupt(fun, funArgs);
    1072                 return T;
    1073             } else
    1074                 return signal(new TypeError(args[0], "Lisp thread"));
     1089            final LispThread thread;
     1090            try {
     1091                thread = (LispThread) args[0];
     1092            }
     1093            catch (ClassCastException e) {
     1094                return signalTypeError(args[0], Symbol.THREAD);
     1095            }
     1096            LispObject fun = args[1];
     1097            LispObject funArgs = NIL;
     1098            for (int i = args.length; i-- > 2;)
     1099                funArgs = new Cons(args[i], funArgs);
     1100            thread.interrupt(fun, funArgs);
     1101            return T;
    10751102        }
    10761103    };
Note: See TracChangeset for help on using the changeset viewer.