Changeset 10251


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

Cleanup.

File:
1 edited

Legend:

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

    r10242 r10251  
    33 *
    44 * Copyright (C) 2002-2005 Peter Graves, Andras Simon
    5  * $Id: Java.java,v 1.55 2005-10-27 18:32:56 piso Exp $
     5 * $Id: Java.java,v 1.56 2005-10-28 00:13:05 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    4040                      "exception-name condition-symbol")
    4141    {
    42         public LispObject execute(LispObject className, LispObject symbol) throws ConditionThrowable
    43         {
    44             try {
    45                 registeredExceptions.put(classForName(className.getStringValue()),symbol);
    46             }
    47             catch (ClassNotFoundException e) {
    48                 signal(new LispError("exception not found: " + className));
    49             }
     42        public LispObject execute(LispObject className, LispObject symbol)
     43            throws ConditionThrowable
     44        {
     45            registeredExceptions.put(classForName(className.getStringValue()),symbol);
    5046            return T;
    5147        }
     
    5854        public LispObject execute(LispObject arg) throws ConditionThrowable
    5955        {
    60             String className = javaString(arg);
    61             try {
    62                 return new JavaObject(classForName(className));
    63             }
    64             catch (ClassNotFoundException e) {
    65                 signal(new LispError("Class not found: " + className));
    66             }
    67             catch (Throwable t) {
    68                 signal(new LispError(getMessage(t)));
    69             }
    70             // Not reached.
    71             return NIL;
     56            return new JavaObject(classForName(javaString(arg)));
    7257        }
    7358    };
     
    171156                return new JavaObject(f.get(instance));
    172157            }
    173             catch (ClassNotFoundException e) {
    174                 signal(new LispError("class not found: " + e.getMessage()));
    175             }
    176158            catch (NoSuchFieldException e) {
    177159                signal(new LispError("no such field"));
     
    224206                throw new NoSuchMethodException();
    225207            }
    226             catch (ClassNotFoundException e) {
    227                 signal(new LispError("class not found: " + e.getMessage()));
    228             }
    229208            catch (NoSuchMethodException e) {
    230209                signal(new LispError("no such constructor"));
     
    250229            if (args.length < 2)
    251230                signal(new WrongNumberOfArgumentsException(this));
     231            final Class c = forClassRef(args[0]);
    252232            String methodName = args[1].getStringValue();
    253233            try {
    254                 final Class c = forClassRef(args[0]);
    255234                int argCount = 0;
    256235                if (args.length == 3 && args[2] instanceof Fixnum) {
     
    273252                throw new NoSuchMethodException();
    274253            }
    275             catch (ClassNotFoundException e) {
    276                 signal(new LispError("class not found: " + e.getMessage()));
    277             }
    278254            catch (NoSuchMethodException e) {
    279                 signal(new LispError("no such method: " + methodName));
     255                FastStringBuffer sb = new FastStringBuffer("No such method: ");
     256                sb.append(c.getName());
     257                sb.append('.');
     258                sb.append(methodName);
     259                sb.append('(');
     260                for (int i = 2; i < args.length; i++) {
     261                    sb.append(args[i].writeToString());
     262                    if (i < args.length - 1)
     263                        sb.append(',');
     264                }
     265                sb.append(')');
     266                signal(new LispError(sb.toString()));
    280267            }
    281268            catch (ConditionThrowable e) {
     
    413400                return new JavaObject(Array.newInstance(c, dimensions));
    414401            }
    415             catch (ClassNotFoundException e) {
    416                 signal(new LispError("class not found: " + e.getMessage()));
    417             }
    418402            catch (Throwable t) {
    419403                signal(new LispError(getMessage(t)));
     
    631615    };
    632616
    633     // ### jobject-lisp-value
    634     // jobject-lisp-value java-object
     617    // ### jobject-lisp-value java-object
    635618    private static final Primitive JOBJECT_LISP_VALUE =
    636619        new Primitive("jobject-lisp-value", PACKAGE_JAVA, true, "java-object")
     
    642625    };
    643626
    644     private static Class classForName(String className) throws ClassNotFoundException
     627    private static Class classForName(String className) throws ConditionThrowable
    645628    {
    646629        try {
     
    648631        }
    649632        catch (ClassNotFoundException e) {
    650             return Class.forName(className, true, JavaClassLoader.getPersistentInstance());
     633            try {
     634                return Class.forName(className, true, JavaClassLoader.getPersistentInstance());
     635            }
     636            catch (ClassNotFoundException ex) {
     637                signal(new LispError("Class not found: " + className));
     638                // Not reached.
     639                return null;
     640            }
    651641        }
    652642    }
    653643
    654644    // Supports Java primitive types too.
    655     private static Class forClassRef(LispObject classRef)
    656         throws ClassNotFoundException, ConditionThrowable
    657     {
    658         if (classRef instanceof AbstractString) {
    659             String className = classRef.getStringValue();
    660             if (className.equals("boolean"))
     645    private static Class forClassRef(LispObject obj) throws ConditionThrowable
     646    {
     647        if (obj instanceof AbstractString) {
     648            String s = obj.getStringValue();
     649            if (s.equals("boolean"))
    661650                return Boolean.TYPE;
    662             if (className.equals("byte"))
     651            if (s.equals("byte"))
    663652                return Byte.TYPE;
    664             if (className.equals("char"))
     653            if (s.equals("char"))
    665654                return Character.TYPE;
    666             if (className.equals("short"))
     655            if (s.equals("short"))
    667656                return Short.TYPE;
    668             if (className.equals("int"))
     657            if (s.equals("int"))
    669658                return Integer.TYPE;
    670             if (className.equals("long"))
     659            if (s.equals("long"))
    671660                return Long.TYPE;
    672             if (className.equals("float"))
     661            if (s.equals("float"))
    673662                return Float.TYPE;
    674             if (className.equals("double"))
     663            if (s.equals("double"))
    675664                return Double.TYPE;
    676665            // Not a primitive Java type.
    677             return classForName(className);
    678         } else {
    679             try {
    680                 return (Class)JavaObject.getObject(classRef);
    681             }
    682             catch (ClassCastException e) {
    683                 signal(new TypeError(classRef, "Java class"));
    684             }
    685             catch (ConditionThrowable e) {
    686                 throw new ClassNotFoundException(e.getMessage());
    687             }
    688             // Not reached.
     666            return classForName(s);
     667        }
     668        // It's not a string, so it must be a JavaObject.
     669        final JavaObject javaObject;
     670        try {
     671            javaObject = (JavaObject) obj;
     672        }
     673        catch (ClassCastException e) {
     674            signalTypeError(obj, list3(Symbol.OR, Symbol.STRING,
     675                                       Symbol.JAVA_OBJECT));
     676            // Not reached.
     677            return null;
     678        }
     679        try {
     680            return (Class) javaObject.getObject();
     681        }
     682        catch (ClassCastException e) {
     683            signal(new LispError(obj + " does not designate a Java class."));
    689684            return null;
    690685        }
Note: See TracChangeset for help on using the changeset viewer.