org/jpc/luaextensions/Base.java

   1 /*
   2     JPC-RR: A x86 PC Hardware Emulator
   3     Release 1
   4
   5     Copyright (C) 2007-2009 Isis Innovation Limited
   6     Copyright (C) 2009-2010 H. Ilari Liusvaara
   7
   8     This program is free software; you can redistribute it and/or modify
   9     it under the terms of the GNU General Public License version 2 as published by
  10     the Free Software Foundation.
  11
  12     This program is distributed in the hope that it will be useful,
  13     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15     GNU General Public License for more details.
  16
  17     You should have received a copy of the GNU General Public License along
  18     with this program; if not, write to the Free Software Foundation, Inc.,
  19     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20
  21     Based on JPC x86 PC Hardware emulator,
  22     A project from the Physics Dept, The University of Oxford
  23
  24     Details about original JPC can be found at:
  25
  26     www-jpc.physics.ox.ac.uk
  27
  28 */
  29
  30 package org.jpc.luaextensions;
  31
  32 import mnj.lua.*;
  33
  34 import org.jpc.emulator.Clock;
  35 import org.jpc.emulator.PC;
  36 import org.jpc.emulator.EventRecorder;
  37 import org.jpc.plugins.LuaPlugin;
  38
  39 //Locking this class is used for preventing termination and when terminating.
  40 public class Base extends LuaPlugin.LuaResource
  41 {
  42     public void destroy()
  43     {
  44     }
  45
  46     private Base(LuaPlugin plugin)
  47     {
  48         super(plugin);
  49     }
  50
  51     private static int intLuaCBInvoke(Lua l, boolean sync, LuaPlugin plugin)
  52     {
  53         LuaTable args = null;
  54         String[] _args = null;
  55         int elements = 0;
  56         if(l.type(1) != Lua.TSTRING) {
  57             l.error("Unexpected types to invoke");
  58             return 0;
  59         }
  60
  61         String cmd = l.value(1).toString();
  62         if(l.type(2) == Lua.TNONE || l.type(2) == Lua.TNIL) {
  63            ///Nothing.
  64         } else if(l.type(2) == Lua.TTABLE) {
  65            args = (LuaTable)l.value(2);
  66            elements = Lua.objLen(args);
  67            _args = new String[elements];
  68            for(int i = 0; i < elements; i++) {
  69                _args[i] = l.getTable(args, new Double(i + 1)).toString();
  70                if(_args[i] == null)
  71                    _args[i] = "";
  72            }
  73         } else {
  74             l.error("Unexpected types to invoke");
  75             return 0;
  76         }
  77
  78         plugin.callInvokeCommand(cmd, _args, sync);
  79         return 0;
  80     }
  81
  82     public static int luaCB_call(Lua l, LuaPlugin plugin)
  83     {
  84         LuaTable args = null;
  85         String[] _args = null;
  86         int elements = 0;
  87         if(l.type(1) != Lua.TSTRING) {
  88             l.error("Unexpected types to invoke");
  89             return 0;
  90         }
  91
  92         String cmd = l.value(1).toString();
  93         if(l.type(2) == Lua.TNONE || l.type(2) == Lua.TNIL) {
  94            ///Nothing.
  95         } else if(l.type(2) == Lua.TTABLE) {
  96            args = (LuaTable)l.value(2);
  97            elements = Lua.objLen(args);
  98            _args = new String[elements];
  99            for(int i = 0; i < elements; i++) {
 100                _args[i] = l.getTable(args, new Double(i + 1)).toString();
 101                if(_args[i] == null)
 102                    _args[i] = "";
 103            }
 104         } else {
 105             l.error("Unexpected types to invoke");
 106             return 0;
 107         }
 108
 109         Object[] ret = plugin.callCommand(cmd, _args);
 110         if(ret == null) {
 111             //System.err.println("No return values");
 112             return 0;
 113         }
 114         int i = 1;
 115         //System.err.println("" + ret.length + " return value(s)");
 116         LuaTable tab = l.newTable();
 117         for(Object retE : ret) {
 118             if(retE == null)
 119                 i++;
 120             else if(retE instanceof Boolean)
 121                 l.setTable(tab, new Double(i++), retE);
 122             else if(retE instanceof Integer)
 123                 l.setTable(tab, new Double(i++), new Double(((Integer)retE).intValue()));
 124             else if(retE instanceof Long)
 125                 l.setTable(tab, new Double(i++), new Double(((Long)retE).longValue()));
 126             else if(retE instanceof String)
 127                 l.setTable(tab, new Double(i++), retE);
 128             else
 129                 l.setTable(tab, new Double(i++), "<unconvertable object>");
 130         }
 131         l.push(tab);
 132         return 1;
 133     }
 134
 135     public static int luaCB_invoke(Lua l, LuaPlugin plugin)
 136     {
 137         return intLuaCBInvoke(l, false, plugin);
 138     }
 139
 140     public static int luaCB_invoke_synchronous(Lua l, LuaPlugin plugin)
 141     {
 142         return intLuaCBInvoke(l, true, plugin);
 143     }
 144
 145     public static int luaCB_wait_vga(Lua l, LuaPlugin plugin)
 146     {
 147         plugin.doLockVGA();
 148         l.pushBoolean(plugin.getOwnsVGALock());
 149         return 1;
 150     }
 151
 152     public static int luaCB_release_vga(Lua l, LuaPlugin plugin)
 153     {
 154         plugin.doReleaseVGA();
 155         return 0;
 156     }
 157
 158     public static int luaCB_vga_resolution(Lua l, LuaPlugin plugin)
 159     {
 160         l.push(new Double(plugin.getXResolution()));
 161         l.push(new Double(plugin.getYResolution()));
 162         return 2;
 163     }
 164
 165     public static int luaCB_pc_running(Lua l, LuaPlugin plugin)
 166     {
 167         l.pushBoolean(plugin.getPCRunning());
 168         return 1;
 169     }
 170
 171     public static int luaCB_clock_time(Lua l, LuaPlugin plugin)
 172     {
 173         Clock clk = (Clock)plugin.getComponent(Clock.class);
 174         if(clk != null)
 175             l.push(new Double(clk.getTime()));
 176         else
 177             l.pushNil();
 178         return 1;
 179     }
 180
 181     public static int luaCB_wait_pc_attach(Lua l, LuaPlugin plugin)
 182     {
 183         plugin.waitPCAttach();
 184         return 0;
 185     }
 186
 187     public static int luaCB_wait_message(Lua l, LuaPlugin plugin)
 188     {
 189         String msg = plugin.waitMessage();
 190         if(msg != null)
 191             l.push(msg);
 192         else
 193             l.pushNil();
 194         return 1;
 195     }
 196
 197     public static int luaCB_wait_pc_stop(Lua l, LuaPlugin plugin)
 198     {
 199         l.pushBoolean(plugin.waitPCStop());
 200         return 1;
 201     }
 202
 203     public static int luaCB_poll_message(Lua l, LuaPlugin plugin)
 204     {
 205         String msg = plugin.pollMessage();
 206         if(msg != null)
 207             l.push(msg);
 208         else
 209             l.pushNil();
 210         return 1;
 211     }
 212
 213     public static int luaCB_in_frame_hold(Lua l, LuaPlugin plugin)
 214     {
 215         l.pushBoolean(plugin.getOwnsVGALock());
 216         return 1;
 217     }
 218
 219     public static int luaCB_pc_connected(Lua l, LuaPlugin plugin)
 220     {
 221         l.pushBoolean(plugin.getPCConnected());
 222         return 1;
 223     }
 224
 225     public static int luaCB_stringlessthan(Lua l, LuaPlugin plugin)
 226     {
 227         int ret = 0;
 228         String x = l.value(1).toString();
 229         String y = l.value(2).toString();
 230         int xlen = x.length();
 231         int ylen = y.length();
 232         for(int i = 0; i < xlen && i < ylen; i++) {
 233             int xcp = x.charAt(i);
 234             int ycp = y.charAt(i);
 235             boolean xs = (xcp >= 0xD800 && xcp <= 0xDFFF);
 236             boolean ys = (ycp >= 0xD800 && ycp <= 0xDFFF);
 237             if(!xs && ys)
 238                 ret = (ret == 0) ? 1 : ret;
 239             else if(xs && !ys)
 240                 ret = (ret == 0) ? -1 : ret;
 241             else if(xcp < ycp)
 242                 ret = (ret == 0) ? 1 : ret;
 243             else if(xcp > ycp)
 244                 ret = (ret == 0) ? -1 : ret;
 245         }
 246         if(ret == 0 && xlen < ylen)
 247             ret = 1;
 248         if(ret == 0 && xlen > ylen)
 249             ret = -1;
 250
 251         l.pushBoolean(ret == 1);
 252         return 1;
 253     }
 254
 255     public static int luaCB_movie_length(Lua l, LuaPlugin plugin)
 256     {
 257         PC.ResetButton brb = ((PC.ResetButton)plugin.getComponent(PC.ResetButton.class));
 258         if(brb == null) {
 259             l.pushNil();
 260             return 1;
 261         }
 262         EventRecorder rec = brb.getRecorder();
 263         long lastTime = rec.getLastEventTime();
 264         long attachTime = rec.getAttachTime();
 265         long time = 0;
 266         if(attachTime < lastTime)
 267             time = lastTime - attachTime;
 268         l.push(new Double(time));
 269         return 1;
 270     }
 271
 272     public static int luaCB_movie_rerecords(Lua l, LuaPlugin plugin)
 273     {
 274         PC.ResetButton brb = ((PC.ResetButton)plugin.getComponent(PC.ResetButton.class));
 275         if(brb == null) {
 276             l.pushNil();
 277             return 1;
 278         }
 279         EventRecorder rec = brb.getRecorder();
 280         l.push(new Double(rec.getRerecordCount()));
 281         return 1;
 282     }
 283
 284     public static int luaCB_movie_headers(Lua l, LuaPlugin plugin)
 285     {
 286         PC.ResetButton brb = ((PC.ResetButton)plugin.getComponent(PC.ResetButton.class));
 287         if(brb == null) {
 288             l.pushNil();
 289             return 1;
 290         }
 291         EventRecorder rec = brb.getRecorder();
 292         String[][] headers = rec.getHeaders();
 293         LuaTable ret = l.newTable();
 294         if(headers != null)
 295             for(int i = 0; i < headers.length; i++) {
 296                 LuaTable tab = l.newTable();
 297                 int j = 1;
 298                 if(headers[i] != null)
 299                     for(String p : headers[i])
 300                         l.setTable(tab, new Double(j++), p);
 301                 l.setTable(ret, new Double(i + 1), tab);
 302             }
 303         l.push(ret);
 304         return 1;
 305     }
 306 }