Changeset 5251


Ignore:
Timestamp:
12/24/03 16:09:29 (18 years ago)
Author:
piso
Message:

Minor cleanup.

Location:
trunk/j/src/org/armedbear/lisp
Files:
2 edited

Legend:

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

    r5114 r5251  
    33 *
    44 * Copyright (C) 2003 Peter Graves
    5  * $Id: JHandler.java,v 1.5 2003-12-13 00:58:51 piso Exp $
     5 * $Id: JHandler.java,v 1.6 2003-12-24 16:06:28 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    9999        }
    100100    };
     101   
     102    private static class Entry
     103    {
     104        Function handler;
     105        LispObject data;
     106        int count = -1;
     107        Map entryTable;
     108        String event;
     109       
     110        public Entry (Function handler, LispObject data, String event, Map entryTable)
     111        {
     112            this.entryTable = entryTable;
     113            this.event = event;
     114            this.handler = handler;
     115            this.data = data;
     116        }
     117
     118        public Function getHandler ()
     119        {
     120            return handler;
     121        }
     122
     123        public void addData (LispObject data)
     124        {
     125            this.data = data;
     126        }
     127
     128        public LispObject getData ()
     129        {
     130            return data;
     131        }
     132
     133        public void addCount (int count)
     134        {
     135            this.count = count;
     136        }
     137
     138        public Fixnum getCount ()
     139        {
     140            if (count == 0)
     141                entryTable.remove(event);
     142            return (new Fixnum (count--));
     143        }
     144    }
    101145}
    102 
    103 class Entry
    104 {
    105     public Entry (Function handler, LispObject data, String event, Map entryTable) {
    106         this.entryTable = entryTable;
    107         this.event = event;
    108         this.handler = handler;
    109         this.data = data;
    110     }
    111 
    112     public Function getHandler () {
    113         return handler;
    114     }
    115 
    116     public void addData (LispObject data) {
    117         this.data = data;
    118     }
    119 
    120     public LispObject getData () {
    121         return data;
    122     }
    123 
    124     public void addCount (int count) {
    125         this.count = count;
    126     }
    127 
    128     public Fixnum getCount () {
    129         if (count == 0)
    130             entryTable.remove(event);
    131         return (new Fixnum (count--));
    132     }
    133 
    134     Function handler;
    135     LispObject data;
    136     int count = -1;
    137     Map entryTable;
    138     String event;
    139 }
  • trunk/j/src/org/armedbear/lisp/JProxy.java

    r5250 r5251  
    33 *
    44 * Copyright (C) 2002-2003 Peter Graves
    5  * $Id: JProxy.java,v 1.2 2003-12-24 15:58:53 asimon Exp $
     5 * $Id: JProxy.java,v 1.3 2003-12-24 16:09:29 piso Exp $
    66 *
    77 * This program is free software; you can redistribute it and/or
     
    2222package org.armedbear.lisp;
    2323
     24import java.lang.reflect.InvocationHandler;
     25import java.lang.reflect.Method;
     26import java.lang.reflect.Proxy;
    2427import java.util.HashMap;
    2528import java.util.Map;
    2629import java.util.WeakHashMap;
    27 import java.lang.reflect.Method;
    28 import java.lang.reflect.Proxy;
    29 import java.lang.reflect.InvocationHandler;
    3030
    3131public final class JProxy extends Lisp
     
    3333    private static final Map table = new WeakHashMap();
    3434
    35     // ### %jnew-proxy 
     35    // ### %jnew-proxy
    3636    // %jnew-proxy interface &rest method-names-and-defs
    3737    private static final Primitive _JNEW_PROXY =
     
    4747                lispDefinedMethods.put(LispString.getValue(args[i]),(Function)args[i+1]);
    4848            Class iface = (Class) args[0].javaInstance();
    49             Object proxy = 
    50                 Proxy.newProxyInstance(iface.getClassLoader(), new Class[] { iface }, new LispHandler(table)); 
     49            Object proxy =
     50                Proxy.newProxyInstance(iface.getClassLoader(), new Class[] { iface }, new LispHandler(table));
    5151            table.put(proxy, new Entry(iface, lispDefinedMethods));
    5252            return new JavaObject(proxy);
    5353        }
    5454    };
    55 }
    5655
    57 class LispHandler implements InvocationHandler {
     56    private static class LispHandler implements InvocationHandler
     57    {
     58        Map table;
    5859
    59     LispHandler (Map table) { this.table = table; }
    60  
    61     Map table;
     60        LispHandler (Map table)
     61        {
     62            this.table = table;
     63        }
    6264
    63     public Object invoke(Object proxy, Method method, Object[] args) {
    64         String methodName = method.getName();
     65        public Object invoke(Object proxy, Method method, Object[] args)
     66        {
     67            String methodName = method.getName();
    6568
    66         if (methodName.equals("hashCode"))  {
    67             return new Integer(System.identityHashCode(proxy));   
    68         } else if (methodName.equals("equals")) {
    69             return (proxy == args[0] ? Boolean.TRUE : Boolean.FALSE);
    70         } else if (methodName.equals("toString")) {
    71             return proxy.getClass().getName() + '@' + Integer.toHexString(proxy.hashCode());
    72         }
    73            
    74         if (table.containsKey(proxy)) {
    75             Entry entry = (Entry)table.get(proxy);
    76             Function f = entry.getLispMethod(methodName);
    77             if (f != null) {
    78                 if (args == null) // method needs no argument
    79                     args = new Object[0];
    80                 LispObject[] lispArgs = new LispObject[args.length];
    81                 for (int i = 0 ; i< args.length; i++)
    82                     lispArgs[i] = new JavaObject(args[i]);
    83                 try {
    84                     LispObject result = f.execute(lispArgs);
    85                     return (method.getReturnType() == void.class ? null : result.javaInstance());
    86                 }
    87                 catch (ConditionThrowable t) {
    88                     t.printStackTrace();
     69            if (methodName.equals("hashCode"))  {
     70                return new Integer(System.identityHashCode(proxy));
     71            } else if (methodName.equals("equals")) {
     72                return (proxy == args[0] ? Boolean.TRUE : Boolean.FALSE);
     73            } else if (methodName.equals("toString")) {
     74                return proxy.getClass().getName() + '@' + Integer.toHexString(proxy.hashCode());
     75            }
     76
     77            if (table.containsKey(proxy)) {
     78                Entry entry = (Entry)table.get(proxy);
     79                Function f = entry.getLispMethod(methodName);
     80                if (f != null) {
     81                    if (args == null) // method needs no argument
     82                        args = new Object[0];
     83                    LispObject[] lispArgs = new LispObject[args.length];
     84                    for (int i = 0 ; i< args.length; i++)
     85                        lispArgs[i] = new JavaObject(args[i]);
     86                    try {
     87                        LispObject result = f.execute(lispArgs);
     88                        return (method.getReturnType() == void.class ? null : result.javaInstance());
     89                    }
     90                    catch (ConditionThrowable t) {
     91                        t.printStackTrace();
     92                    }
    8993                }
    9094            }
     95            return null;
    9196        }
    92         return null;
     97    }
     98
     99    private static class Entry
     100    {
     101        Class iface;
     102        Map lispDefinedMethods;
     103
     104        public Entry (Class iface, Map lispDefinedMethods)
     105        {
     106            this.iface = iface;
     107            this.lispDefinedMethods = lispDefinedMethods;
     108        }
     109
     110        public Function getLispMethod(String methodName)
     111        {
     112            if (lispDefinedMethods.containsKey(methodName))
     113                return (Function)lispDefinedMethods.get(methodName);
     114            return null;
     115        }
    93116    }
    94117}
    95 
    96 class Entry
    97 {
    98     public Entry (Class iface, Map lispDefinedMethods) {
    99         this.iface = iface;
    100         this.lispDefinedMethods = lispDefinedMethods;
    101     }
    102 
    103     Class iface;
    104     Map lispDefinedMethods;
    105 
    106     public Function getLispMethod(String methodName) {
    107         if (lispDefinedMethods.containsKey(methodName))
    108             return (Function)lispDefinedMethods.get(methodName);
    109         return null;
    110     }
    111 }
Note: See TracChangeset for help on using the changeset viewer.