/*
JVM-Bridge -- bridge from FP languages and others to the Java VM
Copyright (C) 2001 Ashley Yakeley <ashley@semantic.org>

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/
#include "Configure.h"

package    org.semantic.jvmbridge;
import    java.util.Vector;

public class ExecuteFunction
    {
    public static native JOpaqueAddress    createValueList            ();
    public static native void            destroyValueList        (JOpaqueAddress vlist);

    public static native void        addToValueList            (JOpaqueAddress vlist,boolean value);
    public static native void        addToValueList            (JOpaqueAddress vlist,byte value);
    public static native void        addToValueList            (JOpaqueAddress vlist,char value);
    public static native void        addToValueList            (JOpaqueAddress vlist,short value);
    public static native void        addToValueList            (JOpaqueAddress vlist,int value);
    public static native void        addToValueList            (JOpaqueAddress vlist,long value);
    public static native void        addToValueList            (JOpaqueAddress vlist,float value);
    public static native void        addToValueList            (JOpaqueAddress vlist,double value);
    public static native void        addToValueList            (JOpaqueAddress vlist,Object value);

    /**
    destroys arglist
    */
    public static native void        executeVoidFunctionNow        (JOpaqueAddress f,JOpaqueAddress arglist)
     throws Throwable;
    /**
    destroys arglist
    */
    public static native boolean    executeBooleanFunctionNow    (JOpaqueAddress f,JOpaqueAddress arglist)
     throws Throwable;
    /**
    destroys arglist
    */
    public static native byte        executeByteFunctionNow        (JOpaqueAddress f,JOpaqueAddress arglist)
     throws Throwable;
    /**
    destroys arglist
    */
    public static native char        executeCharFunctionNow        (JOpaqueAddress f,JOpaqueAddress arglist)
     throws Throwable;
    /**
    destroys arglist
    */
    public static native short        executeShortFunctionNow        (JOpaqueAddress f,JOpaqueAddress arglist)
     throws Throwable;
    /**
    destroys arglist
    */
    public static native int        executeIntFunctionNow        (JOpaqueAddress f,JOpaqueAddress arglist)
     throws Throwable;
    /**
    destroys arglist
    */
    public static native long        executeLongFunctionNow        (JOpaqueAddress f,JOpaqueAddress arglist)
     throws Throwable;
    /**
    destroys arglist
    */
    public static native float        executeFloatFunctionNow        (JOpaqueAddress f,JOpaqueAddress arglist)
     throws Throwable;
    /**
    destroys arglist
    */
    public static native double        executeDoubleFunctionNow    (JOpaqueAddress f,JOpaqueAddress arglist)
     throws Throwable;
    /**
    destroys arglist
    */
    public static native Object        executeObjectFunctionNow    (JOpaqueAddress f,JOpaqueAddress arglist)
     throws Throwable;
    public static native void        freeFunctionNow                (JOpaqueAddress f);

#if SYNCH
    private static abstract class DeferredProc
        {
        private    boolean        mDone;
        private    Throwable    mException;
        
        public DeferredProc()
            {
            mDone = false;
            mException = null;
            }
        
        public synchronized void waitUntilDone()
         throws Throwable
            {
            while (!mDone)
                {
                try
                    {
                    wait();
                    }
                catch (InterruptedException x)
                    {
                    // ignore
                    }
                }
            if (mException != null)
             throw mException;
            }
        
        public synchronized void waitUntilDoneNoThrow()
            {
            while (!mDone)
                {
                try
                    {
                    wait();
                    }
                catch (InterruptedException x)
                    {
                    // ignore
                    }
                }
            if (mException != null)
             throw new Error(mException.toString());
            }
        
        protected abstract void doProcNow()
         throws Throwable;
            
        public void doProc()
            {
            try
                {
                doProcNow();
                }
            catch (Throwable x)
                {
                mException = x;
                }
            synchronized (this)
                {
                mDone = true;
                notifyAll();
                }
            }
        };

    private static Thread    mMainThread;
    private static Vector    mDeferredProcs;

    private static void queueProc(DeferredProc proc)
        {
        JDEBUGMESSAGE("J+ DeferredProc.queueProc");
        if (mMainThread == Thread.currentThread())
            {
            JDEBUGMESSAGE("J+ doing proc immediately");
            proc.doProc();
            JDEBUGMESSAGE("J- doing proc immediately");
            }
        else
            {
        //    synchronized (mDeferredProcs) already synchronized
                {
                JDEBUGMESSAGE("J+ adding proc to queue");
                mDeferredProcs.addElement(proc);
                JDEBUGMESSAGE("J- adding proc to queue");
                }
            }
        JDEBUGMESSAGE("J- DeferredProc.queueProc");
        }

    public static boolean procPending()
        {
        synchronized (mDeferredProcs)
            {
            return !mDeferredProcs.isEmpty();
            }
        }

    public static void doNextProc()
        {
        JDEBUGMESSAGE("J+ DeferredProc.doNextProc");
        DeferredProc proc = null;
        synchronized (mDeferredProcs)
            {
            if (!mDeferredProcs.isEmpty())
                {
                JDEBUGMESSAGE("J+ fetching proc");
                proc = (DeferredProc) mDeferredProcs.firstElement();
                mDeferredProcs.removeElementAt(0);
                JDEBUGMESSAGE("J- fetching proc");
                }
            }
        if (proc != null)
            {
            JDEBUGMESSAGE("J+ doing proc");
            proc.doProc();
            JDEBUGMESSAGE("J- doing proc");
            }
        JDEBUGMESSAGE("J- DeferredProc.doNextProc");
        }

    private static class FreeFunctionDeferredProc
    extends DeferredProc
        {
        private JOpaqueAddress    mFunction;
        
        public FreeFunctionDeferredProc(JOpaqueAddress function)
            {
            mFunction = function;
            };
        
        protected void doProcNow()
            {
            freeFunctionNow(mFunction);
            };
        };

    private static abstract class ExecuteFunctionDeferredProc
    extends DeferredProc
        {
        protected JOpaqueAddress    mFunction;
        protected JOpaqueAddress    mArgList;
        
        public ExecuteFunctionDeferredProc(JOpaqueAddress function,JOpaqueAddress arglist)
            {
            mFunction = function;
            mArgList = arglist;
            }
        };

    private static class ExecuteVoidFunctionDeferredProc
    extends ExecuteFunctionDeferredProc
        {
        public ExecuteVoidFunctionDeferredProc(JOpaqueAddress function,JOpaqueAddress arglist)
            {
            super(function,arglist);
            }
        
        protected void doProcNow()
         throws Throwable
            {
            JDEBUGMESSAGE("J+ ExecuteVoidFunctionDeferredProc.doProcNow");
            executeVoidFunctionNow(mFunction,mArgList);
            JDEBUGMESSAGE("J- ExecuteVoidFunctionDeferredProc.doProcNow");
            };
        };

    private static class ExecuteBooleanFunctionDeferredProc
    extends ExecuteFunctionDeferredProc
        {
        public boolean mResult;
        
        public ExecuteBooleanFunctionDeferredProc(JOpaqueAddress function,JOpaqueAddress arglist)
            {
            super(function,arglist);
            }
        
        protected void doProcNow()
         throws Throwable
            {
            mResult = executeBooleanFunctionNow(mFunction,mArgList);
            };
        };

    private static class ExecuteByteFunctionDeferredProc
    extends ExecuteFunctionDeferredProc
        {
        public byte mResult;
        
        public ExecuteByteFunctionDeferredProc(JOpaqueAddress function,JOpaqueAddress arglist)
            {
            super(function,arglist);
            }
        
        protected void doProcNow()
         throws Throwable
            {
            mResult = executeByteFunctionNow(mFunction,mArgList);
            };
        };

    private static class ExecuteCharFunctionDeferredProc
    extends ExecuteFunctionDeferredProc
        {
        public char mResult;
        
        public ExecuteCharFunctionDeferredProc(JOpaqueAddress function,JOpaqueAddress arglist)
            {
            super(function,arglist);
            }
        
        protected void doProcNow()
         throws Throwable
            {
            mResult = executeCharFunctionNow(mFunction,mArgList);
            };
        };

    private static class ExecuteShortFunctionDeferredProc
    extends ExecuteFunctionDeferredProc
        {
        public short mResult;
        
        public ExecuteShortFunctionDeferredProc(JOpaqueAddress function,JOpaqueAddress arglist)
            {
            super(function,arglist);
            }
        
        protected void doProcNow()
         throws Throwable
            {
            mResult = executeShortFunctionNow(mFunction,mArgList);
            };
        };

    private static class ExecuteIntFunctionDeferredProc
    extends ExecuteFunctionDeferredProc
        {
        public int mResult;
        
        public ExecuteIntFunctionDeferredProc(JOpaqueAddress function,JOpaqueAddress arglist)
            {
            super(function,arglist);
            }
        
        protected void doProcNow()
         throws Throwable
            {
            mResult = executeIntFunctionNow(mFunction,mArgList);
            };
        };

    private static class ExecuteLongFunctionDeferredProc
    extends ExecuteFunctionDeferredProc
        {
        public long mResult;
        
        public ExecuteLongFunctionDeferredProc(JOpaqueAddress function,JOpaqueAddress arglist)
            {
            super(function,arglist);
            }
        
        protected void doProcNow()
         throws Throwable
            {
            mResult = executeLongFunctionNow(mFunction,mArgList);
            };
        };

    private static class ExecuteFloatFunctionDeferredProc
    extends ExecuteFunctionDeferredProc
        {
        public float mResult;
        
        public ExecuteFloatFunctionDeferredProc(JOpaqueAddress function,JOpaqueAddress arglist)
            {
            super(function,arglist);
            }
        
        protected void doProcNow()
         throws Throwable
            {
            mResult = executeFloatFunctionNow(mFunction,mArgList);
            };
        };

    private static class ExecuteDoubleFunctionDeferredProc
    extends ExecuteFunctionDeferredProc
        {
        public double mResult;
        
        public ExecuteDoubleFunctionDeferredProc(JOpaqueAddress function,JOpaqueAddress arglist)
            {
            super(function,arglist);
            }
        
        protected void doProcNow()
         throws Throwable
            {
            mResult = executeDoubleFunctionNow(mFunction,mArgList);
            };
        };

    private static class ExecuteObjectFunctionDeferredProc
    extends ExecuteFunctionDeferredProc
        {
        public Object mResult;
        
        public ExecuteObjectFunctionDeferredProc(JOpaqueAddress function,JOpaqueAddress arglist)
            {
            super(function,arglist);
            }
        
        protected void doProcNow()
         throws Throwable
            {
            mResult = executeObjectFunctionNow(mFunction,mArgList);
            };
        };
#endif

    /**
    destroys arglist
    */
    public static void executeVoidFunctionDeferred(JOpaqueAddress f,JOpaqueAddress arglist)
     throws Throwable
        {
        JDEBUGMESSAGE("J+ ExecuteFunction.executeVoidFunctionDeferred");
#if SYNCH
        ExecuteVoidFunctionDeferredProc proc = new ExecuteVoidFunctionDeferredProc(f,arglist);
        queueProc(proc);
        proc.waitUntilDone();
#else
        executeVoidFunctionNow(f,arglist);
#endif
        JDEBUGMESSAGE("J- ExecuteFunction.executeVoidFunctionDeferred");
        }

    /**
    destroys arglist
    */
    public static boolean executeBooleanFunctionDeferred(JOpaqueAddress f,JOpaqueAddress arglist)
     throws Throwable
        {
        JDEBUGMESSAGE("J+ ExecuteFunction.executeBooleanFunctionDeferred");
#if SYNCH
        ExecuteBooleanFunctionDeferredProc proc = new ExecuteBooleanFunctionDeferredProc(f,arglist);
        queueProc(proc);
        proc.waitUntilDone();
        boolean result = proc.mResult;
#else
        boolean result = executeBooleanFunctionNow(f,arglist);
#endif
        JDEBUGMESSAGE("J- ExecuteFunction.executeBooleanFunctionDeferred");
        return result;
        }

    /**
    destroys arglist
    */
    public static byte executeByteFunctionDeferred(JOpaqueAddress f,JOpaqueAddress arglist)
     throws Throwable
        {
        JDEBUGMESSAGE("J+ ExecuteFunction.executeByteFunctionDeferred");
#if SYNCH
        ExecuteByteFunctionDeferredProc proc = new ExecuteByteFunctionDeferredProc(f,arglist);
        queueProc(proc);
        proc.waitUntilDone();
        byte result = proc.mResult;
#else
        byte result = executeByteFunctionNow(f,arglist);
#endif
        JDEBUGMESSAGE("J- ExecuteFunction.executeByteFunctionDeferred");
        return result;
        }

    /**
    destroys arglist
    */
    public static char executeCharFunctionDeferred(JOpaqueAddress f,JOpaqueAddress arglist)
     throws Throwable
        {
        JDEBUGMESSAGE("J+ ExecuteFunction.executeCharFunctionDeferred");
#if SYNCH
        ExecuteCharFunctionDeferredProc proc = new ExecuteCharFunctionDeferredProc(f,arglist);
        queueProc(proc);
        proc.waitUntilDone();
        char result = proc.mResult;
#else
        char result = executeCharFunctionNow(f,arglist);
#endif
        JDEBUGMESSAGE("J- ExecuteFunction.executeCharFunctionDeferred");
        return result;
        }

    /**
    destroys arglist
    */
    public static short executeShortFunctionDeferred(JOpaqueAddress f,JOpaqueAddress arglist)
     throws Throwable
        {
        JDEBUGMESSAGE("J+ ExecuteFunction.executeShortFunctionDeferred");
#if SYNCH
        ExecuteShortFunctionDeferredProc proc = new ExecuteShortFunctionDeferredProc(f,arglist);
        queueProc(proc);
        proc.waitUntilDone();
        short result = proc.mResult;
#else
        short result = executeShortFunctionNow(f,arglist);
#endif
        JDEBUGMESSAGE("J- ExecuteFunction.executeShortFunctionDeferred");
        return result;
        }

    /**
    destroys arglist
    */
    public static int executeIntFunctionDeferred(JOpaqueAddress f,JOpaqueAddress arglist)
     throws Throwable
        {
        JDEBUGMESSAGE("J+ ExecuteFunction.executeIntFunctionDeferred");
#if SYNCH
        ExecuteIntFunctionDeferredProc proc = new ExecuteIntFunctionDeferredProc(f,arglist);
        queueProc(proc);
        proc.waitUntilDone();
        int result = proc.mResult;
#else
        int result = executeIntFunctionNow(f,arglist);
#endif
        JDEBUGMESSAGE("J- ExecuteFunction.executeIntFunctionDeferred");
        return result;
        }

    /**
    destroys arglist
    */
    public static long executeLongFunctionDeferred(JOpaqueAddress f,JOpaqueAddress arglist)
     throws Throwable
        {
        JDEBUGMESSAGE("J+ ExecuteFunction.executeLongFunctionDeferred");
#if SYNCH
        ExecuteLongFunctionDeferredProc proc = new ExecuteLongFunctionDeferredProc(f,arglist);
        queueProc(proc);
        proc.waitUntilDone();
        long result = proc.mResult;
#else
        long result = executeLongFunctionNow(f,arglist);
#endif
        JDEBUGMESSAGE("J- ExecuteFunction.executeLongFunctionDeferred");
        return result;
        }

    /**
    destroys arglist
    */
    public static float executeFloatFunctionDeferred(JOpaqueAddress f,JOpaqueAddress arglist)
     throws Throwable
        {
        JDEBUGMESSAGE("J+ ExecuteFunction.executeFloatFunctionDeferred");
#if SYNCH
        ExecuteFloatFunctionDeferredProc proc = new ExecuteFloatFunctionDeferredProc(f,arglist);
        queueProc(proc);
        proc.waitUntilDone();
        float result = proc.mResult;
#else
        float result = executeFloatFunctionNow(f,arglist);
#endif
        JDEBUGMESSAGE("J- ExecuteFunction.executeFloatFunctionDeferred");
        return result;
        }

    /**
    destroys arglist
    */
    public static double executeDoubleFunctionDeferred(JOpaqueAddress f,JOpaqueAddress arglist)
     throws Throwable
        {
        JDEBUGMESSAGE("J+ ExecuteFunction.executeDoubleFunctionDeferred");
#if SYNCH
        ExecuteDoubleFunctionDeferredProc proc = new ExecuteDoubleFunctionDeferredProc(f,arglist);
        queueProc(proc);
        proc.waitUntilDone();
        double result = proc.mResult;
#else
        double result = executeDoubleFunctionNow(f,arglist);
#endif
        JDEBUGMESSAGE("J- ExecuteFunction.executeDoubleFunctionDeferred");
        return result;
        }

    /**
    destroys arglist
    */
    public static Object executeObjectFunctionDeferred(JOpaqueAddress f,JOpaqueAddress arglist)
     throws Throwable
        {
        JDEBUGMESSAGE("J+ ExecuteFunction.executeObjectFunctionDeferred");
#if SYNCH
        ExecuteObjectFunctionDeferredProc proc = new ExecuteObjectFunctionDeferredProc(f,arglist);
        queueProc(proc);
        proc.waitUntilDone();
        Object result=proc.mResult;
#else
        Object result=executeObjectFunctionNow(f,arglist);
#endif
        JDEBUGMESSAGE("J- ExecuteFunction.executeObjectFunctionDeferred");
        return result;
        }

    public static void freeFunctionDeferred(JOpaqueAddress f)
        {
        JDEBUGMESSAGE("J+ ExecuteFunction.freeFunctionDeferred");
#if SYNCH
        FreeFunctionDeferredProc proc = new FreeFunctionDeferredProc(f);
        queueProc(proc);
        proc.waitUntilDoneNoThrow();
#else
        freeFunctionNow(f);
#endif
        JDEBUGMESSAGE("J- ExecuteFunction.freeFunctionDeferred");
        }

    static
        {
#if SYNCH
        JDEBUGMESSAGE("J+ ExecuteFunction static initialiser");
        mMainThread = Thread.currentThread();
        mDeferredProcs = new Vector();
        JDEBUGMESSAGE("J- ExecuteFunction static initialiser");
#endif
        }    
    }