Changeset 10217


Ignore:
Timestamp:
10/24/05 21:13:53 (16 years ago)
Author:
piso
Message:

Work in progress.

File:
1 edited

Legend:

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

    r10181 r10217  
    22 * Java.java
    33 *
    4  * Copyright (C) 2002-2005 Peter Graves
    5  * $Id: Java.java,v 1.52 2005-10-22 14:11:54 piso Exp $
     4 * Copyright (C) 2002-2005 Peter Graves, Andras Simon
     5 * $Id: Java.java,v 1.53 2005-10-24 21:13:53 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    3333public final class Java extends Lisp
    3434{
    35 
    3635    private static final Map registeredExceptions = new WeakHashMap();
    3736
    38     // ### register-java-exception
    39     // register-java-exception exception-name condition-symbol
     37    // ### register-java-exception exception-name condition-symbol => T
    4038    private static final Primitive REGISTER_JAVA_EXCEPTION =
    41         new Primitive("register-java-exception", PACKAGE_JAVA, true, "exception-name condition-symbol")
     39        new Primitive("register-java-exception", PACKAGE_JAVA, true,
     40                      "exception-name condition-symbol")
    4241    {
    4342        public LispObject execute(LispObject className, LispObject symbol) throws ConditionThrowable
     
    195194    };
    196195
    197     // ### jconstructor
    198     // jconstructor class-ref &rest parameter-class-refs
     196    // ### jconstructor class-ref &rest parameter-class-refs
    199197    private static final Primitive JCONSTRUCTOR =
    200         new Primitive("jconstructor", PACKAGE_JAVA, true, "class-ref &rest parameter-class-refs")
     198        new Primitive("jconstructor", PACKAGE_JAVA, true,
     199                      "class-ref &rest parameter-class-refs")
    201200    {
    202201        public LispObject execute(LispObject[] args) throws ConditionThrowable
     
    242241    };
    243242
    244     // ### jmethod
    245     // jmethod class-ref name &rest parameter-class-refs
     243    // ### jmethod class-ref name &rest parameter-class-refs
    246244    private static final Primitive JMETHOD =
    247245        new Primitive("jmethod", PACKAGE_JAVA, true,
     
    257255                int argCount = 0;
    258256                if (args.length == 3 && args[2] instanceof Fixnum) {
    259                     argCount = Fixnum.getValue(args[2]);
     257                    argCount = ((Fixnum)args[2]).value;
    260258                } else {
    261259                    Class[] parameterTypes = new Class[args.length-2];
    262                     for (int i = 2; i < args.length; i++) {
     260                    for (int i = 2; i < args.length; i++)
    263261                        parameterTypes[i-2] = forClassRef(args[i]);
    264                     }
    265262                    return new JavaObject(c.getMethod(methodName,
    266263                                                      parameterTypes));
    267264                }
    268                 // Parameter types not explicitly specified.
     265                // Parameter types were not explicitly specified.
    269266                Method[] methods = c.getMethods();
    270267                for (int i = 0; i < methods.length; i++) {
    271268                    Method method = methods[i];
    272                     if (method.getName().equals(methodName)
    273                         && method.getParameterTypes().length == argCount)
     269                    if (method.getName().equals(methodName) &&
     270                        method.getParameterTypes().length == argCount)
    274271                        return new JavaObject(method);
    275272                }
     
    293290    };
    294291
    295     // ### jstatic
    296     // jstatic method class &rest args
    297     private static final Primitive JSTATIC = new Primitive("jstatic", PACKAGE_JAVA, true,
    298                                                            "method class &rest args")
     292    // ### jstatic method class &rest args
     293    private static final Primitive JSTATIC =
     294        new Primitive("jstatic", PACKAGE_JAVA, true, "method class &rest args")
    299295    {
    300296        public LispObject execute(LispObject[] args) throws ConditionThrowable
     
    304300    };
    305301
    306 
    307     // ### jstatic-raw
    308     // jstatic-raw method class &rest args
    309     private static final Primitive JSTATIC_RAW = new Primitive("jstatic-raw", PACKAGE_JAVA, true,
    310                                                                "method class &rest args")
     302    // ### jstatic-raw method class &rest args
     303    private static final Primitive JSTATIC_RAW =
     304        new Primitive("jstatic-raw", PACKAGE_JAVA, true,
     305                      "method class &rest args")
    311306    {
    312307        public LispObject execute(LispObject[] args) throws ConditionThrowable
     
    402397    };
    403398
    404     // ### jnew-array
    405     // jnew-array element-type &rest dimensions
    406     private static final Primitive JNEW_ARRAY = new Primitive("jnew-array", PACKAGE_JAVA, true,
    407                                                               "element-type &rest dimensions")
     399    // ### jnew-array element-type &rest dimensions
     400    private static final Primitive JNEW_ARRAY =
     401        new Primitive("jnew-array", PACKAGE_JAVA, true,
     402                      "element-type &rest dimensions")
    408403    {
    409404        public LispObject execute(LispObject[] args) throws ConditionThrowable
     
    496491    };
    497492
    498     // ### jcall
    499     // jcall method instance &rest args
    500     private static final Primitive JCALL = new Primitive("jcall", PACKAGE_JAVA, true,
    501                                                          "method instance &rest args")
     493    // ### jcall method instance &rest args
     494    private static final Primitive JCALL =
     495        new Primitive("jcall", PACKAGE_JAVA, true,
     496                      "method instance &rest args")
    502497    {
    503498        public LispObject execute(LispObject[] args) throws ConditionThrowable
     
    507502    };
    508503
    509     // ### jcall-raw
    510     // jcall-raw method instance &rest args
    511     private static final Primitive JCALL_RAW = new Primitive("jcall-raw", PACKAGE_JAVA, true,
    512                                                              "method instance &rest args")
     504    // ### jcall-raw method instance &rest args
     505    private static final Primitive JCALL_RAW =
     506        new Primitive("jcall-raw", PACKAGE_JAVA, true,
     507                      "method instance &rest args")
    513508    {
    514509        public LispObject execute(LispObject[] args) throws ConditionThrowable
     
    519514                Method method = (Method) JavaObject.getObject(args[0]);
    520515                Class[] argTypes = method.getParameterTypes();
    521                 Object instance;
     516                final Object instance;
    522517                if (args[1] instanceof AbstractString)
    523518                    instance = args[1].getStringValue();
    524519                else
    525520                    instance = JavaObject.getObject(args[1]);
    526                 Object[] methodArgs = new Object[args.length-2];
     521                Object[] methodArgs = new Object[args.length - 2];
    527522                for (int i = 2; i < args.length; i++) {
    528523                    LispObject arg = args[i];
     
    535530                return new JavaObject(result);
    536531            }
     532            catch (ConditionThrowable t) {
     533                throw t;
     534            }
    537535            catch (Throwable t) {
    538536                Class tClass = t.getClass();
    539537                if (registeredExceptions.containsKey(tClass)) {
    540                     signal((Symbol)registeredExceptions.get(tClass), new SimpleString(getMessage(t)));
    541                 }
    542                 signal(new LispError(getMessage(t)));
    543             }
    544             // Not reached.
    545             return NIL;
    546         }
    547     };
    548 
    549     // ### make-immediate-object
    550     // make-immediate-object object &optional type
     538                    signal((Symbol)registeredExceptions.get(tClass),
     539                           new SimpleString(getMessage(t)));
     540                }
     541                signal(new LispError(getMessage(t)));
     542            }
     543            // Not reached.
     544            return NIL;
     545        }
     546    };
     547
     548    // ### make-immediate-object object &optional type
    551549    private static final Primitive MAKE_IMMEDIATE_OBJECT =
    552         new Primitive("make-immediate-object", PACKAGE_JAVA, true, "object &optional type")
     550        new Primitive("make-immediate-object", PACKAGE_JAVA, true,
     551                      "object &optional type")
    553552    {
    554553        public LispObject execute(LispObject[] args) throws ConditionThrowable
     
    616615
    617616    // Supports Java primitive types too.
    618     private static Class forClassRef(LispObject classRef) throws ClassNotFoundException, ConditionThrowable
     617    private static Class forClassRef(LispObject classRef)
     618        throws ClassNotFoundException, ConditionThrowable
    619619    {
    620620        if (classRef instanceof AbstractString) {
     
    638638            // Not a primitive Java type.
    639639            return classForName(className);
    640         } else
     640        } else {
    641641            try {
    642642                return (Class)JavaObject.getObject(classRef);
    643643            }
    644         catch (ClassCastException e) {
    645             signal(new TypeError(classRef, "Java class"));
    646         }
    647         catch (ConditionThrowable e) {
    648             throw new ClassNotFoundException(e.getMessage());
    649         }
    650         // Not reached.
    651         return null;
     644            catch (ClassCastException e) {
     645                signal(new TypeError(classRef, "Java class"));
     646            }
     647            catch (ConditionThrowable e) {
     648                throw new ClassNotFoundException(e.getMessage());
     649            }
     650            // Not reached.
     651            return null;
     652        }
    652653    }
    653654
    654     private static final LispObject makeLispObject(Object obj) throws ConditionThrowable
     655    private static final LispObject makeLispObject(Object obj)
     656        throws ConditionThrowable
    655657    {
    656658        if (obj == null)
Note: See TracChangeset for help on using the changeset viewer.