Changeset 4545


Ignore:
Timestamp:
10/26/03 14:54:32 (18 years ago)
Author:
piso
Message:

Second JFIELD patch from Andras Simon <asimon@…>.

File:
1 edited

Legend:

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

    r4523 r4545  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: Java.java,v 1.13 2003-10-24 00:05:13 piso Exp $
     5 * $Id: Java.java,v 1.14 2003-10-26 14:54:32 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    4747    };
    4848
    49     // ### jfield
    50     // jfield class-name field-name &optional instance
     49    // ### jfield - retrieve or modify a field in a Java class or instance.
     50    /*
     51     * Supported argument patterns:
     52     *
     53     *   Case 1: class-name  field-name:
     54     *               to retrieve the value of a static field.
     55     *
     56     *   Case 2: class-name  field-name  instance-ref:
     57     *               to retrieve the value of a class field of the instance.
     58     *
     59     *   Case 3: class-name  field-name  primitive-value:
     60     *               to store primitive-value in a static field.
     61     *
     62     *   Case 4: class-name  field-name  instance-ref  value:
     63     *               to store value in a class field of the instance.
     64     *
     65     *   Case 5: class-name  field-name  nil  value:
     66     *               to store value in a static field (when value may be
     67     *               confused with an instance-ref).
     68     *
     69     *   Case 6: field-name  instance:
     70     *               to retrieve the value of a field of the instance. The
     71     *               class is derived from the instance.
     72     *
     73     *   Case 7: field-name  instance  value:
     74     *               to store value in a field of the instance. The class is
     75     *               derived from the instance.
     76     */
    5177    private static final Primitive JFIELD = new Primitive("jfield", PACKAGE_JAVA)
    5278    {
    5379        public LispObject execute(LispObject[] args) throws ConditionThrowable
    5480        {
    55             if (args.length < 2 || args.length > 3)
    56                 throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
    57             String className = LispString.getValue(args[0]);
    58       String fieldName = LispString.getValue(args[1]);
     81            if (args.length < 2 || args.length > 4)
     82                throw new ConditionThrowable(new WrongNumberOfArgumentsException(this));
     83      String fieldName, className = null;
     84      Class c;
     85      Field f;
    5986      Object instance = null;
    6087            try {
    61                 final Class c = Class.forName(className);
    62     final Field f = c.getField(fieldName);
    63     if (args.length == 3) {
    64       if (args[2] instanceof LispString)
    65                     instance = LispString.getValue(args[2]);
    66       else
    67                     instance = JavaObject.getObject(args[2]);
    68                 }
    69     return makeLispObject(f.get(instance));
     88                if (args[1] instanceof LispString) {
     89                    // Cases 1-5.
     90                    fieldName = LispString.getValue(args[1]);
     91                    className = LispString.getValue(args[0]);
     92                    c = Class.forName(className);
     93                } else {
     94                    // Cases 6 and 7.
     95                    fieldName = LispString.getValue(args[0]);
     96                    instance = JavaObject.getObject(args[1]);
     97                    c = instance.getClass();
     98                    className = c.getName(); //needed only for the error message
     99                }
     100                f = c.getField(fieldName);
     101                Class requiredType = f.getType();
     102                switch (args.length) {
     103                    case 2:
     104                        // Cases 1 and 6.
     105                        break;
     106                    case 3:
     107                        // Cases 2,3, and 7.
     108                        if (instance == null) {
     109                            // Cases 2 and 3.
     110                            if (args[2] instanceof JavaObject) {
     111                                // Case 2.
     112                                instance = JavaObject.getObject(args[2]);
     113                                break;
     114                            } else {
     115                                // Case 3.
     116                                if (args[2] instanceof Fixnum)
     117                                    f.set(instance, new Integer(((Fixnum)args[2]).getValue()));
     118                                else if (args[2] instanceof LispFloat)
     119                                    f.set(instance, new Double(((LispFloat)args[2]).getValue()));
     120                                else if (args[2] instanceof LispCharacter)
     121                                    f.set(instance, new Character(((LispCharacter)args[2]).getValue()));
     122                                else
     123                                    throw new ConditionThrowable(new TypeError(
     124                                        "unsupported type in jfield"));
     125                                return args[2];
     126                            }
     127                        } else {
     128                            // Case 7.
     129                            f.set(instance,JavaObject.getObject(args[2]));
     130                            return args[2];
     131                        }
     132                    case 4:
     133                        // Cases 4 and 5.
     134                        if (args[2] != NIL) {
     135                            // Case 4.
     136                            instance = JavaObject.getObject(args[2]);
     137                        }
     138                        f.set(instance,JavaObject.getObject(args[3]));
     139                        return args[3];
     140                }
     141                return makeLispObject(f.get(instance));
    70142            }
    71143            catch (ClassNotFoundException e) {
    72                 throw new ConditionThrowable(new LispError("class not found: " + className));
     144                throw new ConditionThrowable(new LispError("class not found: " +
     145                                                           className));
    73146            }
    74147            catch (NoSuchFieldException e) {
     
    335408        if (obj instanceof String)
    336409            return new LispString((String)obj);
     410        if (obj instanceof Character)
     411            return LispCharacter.getInstance(((Character)obj).charValue());
    337412        if (obj instanceof Object[]) {
    338413            Object[] array = (Object[]) obj;
Note: See TracChangeset for help on using the changeset viewer.