Changeset 4690


Ignore:
Timestamp:
11/11/03 09:44:08 (19 years ago)
Author:
asimon
Message:

JMETHOD, JCONSTRUCTOR accepts class-refs
extended JCONSTRUCTOR
further simplified JMETHOD
new static method forClassRef in place of forName

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/j/src/org/armedbear/lisp/Java.java

    r4689 r4690  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: Java.java,v 1.21 2003-11-10 09:40:19 asimon Exp $
     5 * $Id: Java.java,v 1.22 2003-11-11 09:44:08 asimon Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
    … …  
    8181            if (args.length < 2 || args.length > 4)
    8282                throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
    83       String fieldName, className = null;
    84       Class c;
    85       Field f;
    86       Object instance = null;
     83            String fieldName, className = null;
     84            Class c;
     85            Field f;
     86            Object instance = null;
    8787            try {
    8888                if (args[1] instanceof LispString) {
    8989                    // Cases 1-5.
    9090                    fieldName = LispString.getValue(args[1]);
    91         if (args[0] instanceof LispString) {
    92           className = LispString.getValue(args[0]);
    93           c = Class.forName(className);
    94         }
    95         else {
    96           c = (Class)JavaObject.getObject(args[0]);
    97           className = c.getName();
    98         }
     91                    if (args[0] instanceof LispString) {
     92                      className = LispString.getValue(args[0]);
     93                      c = Class.forName(className);
     94                    }
     95                    else {
     96                      c = (Class)JavaObject.getObject(args[0]);
     97                      className = c.getName();
     98                    }
    9999                } else {
    100100                    // Cases 6 and 7.
    … …  
    120120                            } else {
    121121                                // Case 3.
    122             f.set(null,args[2].javaInstance());
    123             return args[2];
     122                              f.set(null,args[2].javaInstance());
     123                              return args[2];
    124124                            }
    125125                        } else {
    … …  
    162162
    163163    // ### jconstructor
    164     // jconstructor class-name &rest parameter-class-names
     164    // jconstructor class-ref &rest parameter-class-refs
    165165    private static final Primitive JCONSTRUCTOR =
    166166        new Primitive("jconstructor", PACKAGE_JAVA)
    … …  
    170170            if (args.length < 1)
    171171                throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
    172             String className = LispString.getValue(args[0]);
    173             try {
    174                 final Class c = Class.forName(className);
    175                 Class[] parameterTypes = new Class[args.length-1];
    176                 for (int i = 1; i < args.length; i++) {
    177                     className = LispString.getValue(args[i]);
    178                     parameterTypes[i-1] = forName(className);
    179                 }
    180                 return new JavaObject(c.getConstructor(parameterTypes));
     172            try {
     173                final Class c = forClassRef(args[0]);
     174                int argCount = 0;
     175                if (args.length == 2 && args[1] instanceof Fixnum) {
     176                    argCount = Fixnum.getValue(args[1]);
     177                } else {
     178                    Class[] parameterTypes = new Class[args.length-1];
     179                    for (int i = 1; i < args.length; i++) {
     180                        parameterTypes[i-1] = forClassRef(args[i]);
     181                    }
     182                    return new JavaObject(c.getConstructor(parameterTypes));
     183                }
     184                // Parameter types not explicitly specified.
     185                Constructor[] constructors = c.getConstructors();
     186                for (int i = 0; i < constructors.length; i++) {
     187                    Constructor constructor = constructors[i];
     188                    if (constructor.getParameterTypes().length == argCount)
     189                        return new JavaObject(constructor);
     190                }
     191                throw new NoSuchMethodException();
    181192            }
    182193            catch (ClassNotFoundException e) {
    183                 throw new ConditionThrowable(new LispError("class not found: " + className));
     194              throw new ConditionThrowable(new LispError("class not found: " + e.getMessage()));
    184195            }
    185196            catch (NoSuchMethodException e) {
    186197                throw new ConditionThrowable(new LispError("no such constructor"));
    187198            }
     199            catch (ConditionThrowable e) {
     200              throw e;
     201            }
    188202            catch (Throwable t) {
    189203                throw new ConditionThrowable(new LispError(getMessage(t)));
    … …  
    193207
    194208    // ### jmethod
    195     // jmethod class-ref name &rest parameter-class-names
     209    // jmethod class-ref name &rest parameter-class-refs
    196210    private static final Primitive JMETHOD = new Primitive("jmethod", PACKAGE_JAVA)
    197211    {
    … …  
    200214            if (args.length < 2)
    201215                throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
    202             String className = LispString.getValue(args[0]);
    203216            String methodName = LispString.getValue(args[1]);
    204217            try {
    205                 final Class c = Class.forName(className);
     218                final Class c = forClassRef(args[0]);
    206219                int argCount = 0;
    207220                if (args.length == 3 && args[2] instanceof Fixnum) {
    208221                    argCount = Fixnum.getValue(args[2]);
    209                 } else if (args.length > 2) {
     222                } else {
    210223                    Class[] parameterTypes = new Class[args.length-2];
    211224                    for (int i = 2; i < args.length; i++) {
    212                         className = LispString.getValue(args[i]);
    213                         parameterTypes[i-2] = forName(className);
     225                        parameterTypes[i-2] = forClassRef(args[i]);
    214226                    }
    215227                    return new JavaObject(c.getMethod(methodName,
    … …  
    224236                        return new JavaObject(method);
    225237                }
    226                 throw new ConditionThrowable(new LispError("no such method"));
     238                throw new NoSuchMethodException();
    227239            }
    228240            catch (ClassNotFoundException e) {
    229                 throw new ConditionThrowable(new LispError("class not found: " + className));
     241              throw new ConditionThrowable(new LispError("class not found: " + e.getMessage()));
    230242            }
    231243            catch (NoSuchMethodException e) {
    232                 throw new ConditionThrowable(new LispError("no such method"));
     244                throw new ConditionThrowable(new LispError("no such method: " + methodName));
     245            }
     246            catch (ConditionThrowable e) {
     247              throw e;
    233248            }
    234249            catch (Throwable t) {
    … …  
    282297                Object[] methodArgs = new Object[args.length-2];
    283298                for (int i = 2; i < args.length; i++) {
    284       methodArgs[i-2] = args[i].javaInstance();
     299                  methodArgs[i-2] = args[i].javaInstance();
    285300                }
    286301                Object result = m.invoke(null, methodArgs);
    … …  
    306321                Object[] initargs = new Object[args.length-1];
    307322                for (int i = 1; i < args.length; i++) {
    308         initargs[i-1] = args[i].javaInstance();
     323                    initargs[i-1] = args[i].javaInstance();
    309324                }
    310325                return new JavaObject(constructor.newInstance(initargs));
    … …  
    345360
    346361    // Supports Java primitive types too.
    347     private static Class forName(String className) throws ClassNotFoundException
    348     {
    349         if (className.equals("boolean"))
    350             return Boolean.TYPE;
    351         if (className.equals("byte"))
    352             return Byte.TYPE;
    353         if (className.equals("char"))
    354             return Character.TYPE;
    355         if (className.equals("short"))
    356             return Short.TYPE;
    357         if (className.equals("int"))
    358             return Integer.TYPE;
    359         if (className.equals("long"))
    360             return Long.TYPE;
    361         if (className.equals("float"))
    362             return Float.TYPE;
    363         if (className.equals("double"))
    364             return Double.TYPE;
    365         // Not a primitive Java type.
    366         return Class.forName(className);
     362    private static Class forClassRef(LispObject classRef) throws ClassNotFoundException, ConditionThrowable
     363    {
     364        if (classRef instanceof LispString) {
     365            String className = LispString.getValue(classRef);
     366            if (className.equals("boolean"))
     367                return Boolean.TYPE;
     368            if (className.equals("byte"))
     369                return Byte.TYPE;
     370            if (className.equals("char"))
     371                return Character.TYPE;
     372            if (className.equals("short"))
     373                return Short.TYPE;
     374            if (className.equals("int"))
     375                return Integer.TYPE;
     376            if (className.equals("long"))
     377                return Long.TYPE;
     378            if (className.equals("float"))
     379                return Float.TYPE;
     380            if (className.equals("double"))
     381                return Double.TYPE;
     382            // Not a primitive Java type.
     383            return Class.forName(className);
     384        } else
     385            try {
     386                return (Class)JavaObject.getObject(classRef);
     387            }
     388        catch (ClassCastException e) {
     389            throw new ConditionThrowable(new TypeError(classRef, "Java class"));
     390        }
     391        catch (ConditionThrowable e) {
     392            throw new ClassNotFoundException(e.getMessage());
     393        }
    367394    }
    368395
Note: See TracChangeset for help on using the changeset viewer.