KahluaUtil.java

package se.krka.kahlua.vm;

import java.io.IOException;
import java.io.InputStream;

public class KahluaUtil {
	/** @exclude */
    private static final Object WORKER_THREAD_KEY = new Object();
	/** @exclude */
    private static final String TYPE_NIL = "nil";
	/** @exclude */
    private static final String TYPE_STRING = "string";
	/** @exclude */
    private static final String TYPE_NUMBER = "number";
	/** @exclude */
    private static final String TYPE_BOOLEAN = "boolean";
	/** @exclude */
    private static final String TYPE_FUNCTION = "function";
	/** @exclude */
    private static final String TYPE_TABLE = "table";
	/** @exclude */
    private static final String TYPE_COROUTINE = "coroutine";
	/** @exclude */
    private static final String TYPE_USERDATA = "userdata";

	public static double fromDouble(Object o) {
		return ((Double) o).doubleValue();
	}

	public static Double toDouble(double d) {
		return new Double(d);
	}

	public static Double toDouble(long d) {
		return toDouble((double) d);
	}

	public static Boolean toBoolean(boolean b) {
		return b ? Boolean.TRUE : Boolean.FALSE;
	}

	public static boolean boolEval(Object o) {
		return (o != null) && (o != Boolean.FALSE);
	}

	public static LuaClosure loadByteCodeFromResource(String name, KahluaTable environment) {
		InputStream stream = environment.getClass().getResourceAsStream(name + ".lbc");
		if (stream == null) {
			return null;
		}
		try {
			return Prototype.loadByteCode(stream, environment);
		} catch (IOException e) {
			throw new RuntimeException(e.getMessage());
		}
	}

	public static void luaAssert(boolean b, String msg) {
		if (!b) {
			fail(msg);
		}
	}

	public static void fail(String msg) {
		throw new RuntimeException(msg);
	}

    /**
     * Rounds towards even numbers
     * @param x
     */
    public static double round(double x) {
        if (x < 0) {
            return -round(-x);
        }
        x += 0.5;
        double x2 = Math.floor(x);
        if (x2 == x) {
            return x2 - ((long) x2 & 1);
        }
        return x2;
    }

    /* Thanks rici lake for ipow-implementation */

    /**
     * Calculates base^exponent, for non-negative exponents.
     * 0^0 is defined to be 1
     * @return 1 if exponent is zero or negative
     */
    public static long ipow(long base, int exponent) {
        if (exponent <= 0) {
            return 1;
        }
        long b = 1;
        for (b = (exponent & 1) != 0 ? base : 1, exponent >>= 1; exponent != 0; exponent >>= 1) {
            base *= base;
            if ((exponent & 1) != 0) {
                b *= base;
            }
        }
        return b;
    }

    public static boolean isNegative(double vDouble) {
        return Double.doubleToLongBits(vDouble) < 0;
    }

    public static KahluaTable getClassMetatables(Platform platform, KahluaTable env) {
        return getOrCreateTable(platform, env, "__classmetatables");
    }

    public static KahluaThread getWorkerThread(Platform platform, KahluaTable env) {
        Object workerThread = env.rawget(WORKER_THREAD_KEY);
        if (workerThread == null) {
            workerThread = new KahluaThread(platform, env);
            env.rawset(WORKER_THREAD_KEY, workerThread);
        }
        return (KahluaThread) workerThread;
    }

	public static void setWorkerThread(KahluaTable env, KahluaThread thread) {
		env.rawset(WORKER_THREAD_KEY, thread);
	}


    public static KahluaTable getOrCreateTable(Platform platform, KahluaTable env, String name) {
        Object t = env.rawget(name);
        if (t == null || !(t instanceof KahluaTable)) {
            t = platform.newTable();
            env.rawset(name, t);
        }
        return (KahluaTable) t;
    }

    public static void setupLibrary(KahluaTable env, KahluaThread workerThread, String library) {
        LuaClosure closure = loadByteCodeFromResource(library, env);
        if (closure == null) {
            fail("Could not load " + library + ".lbc");
        }
        workerThread.call(closure, null, null, null);
    }

    public static String numberToString(Double num) {
        if (num.isNaN()) {
            return "nan";
        }
        if (num.isInfinite()) {
            if (isNegative(num.doubleValue())) {
                return "-inf";
            }
            return "inf";
        }
        double n = num.doubleValue();
        if (Math.floor(n) == n && Math.abs(n) < 1e14) {
            return String.valueOf(num.longValue());
        }
        return num.toString();
    }

    public static String type(Object o) {
        if (o == null) {
            return TYPE_NIL;
        }
        if (o instanceof String) {
            return TYPE_STRING;
        }
        if (o instanceof Double) {
            return TYPE_NUMBER;
        }
        if (o instanceof Boolean) {
            return TYPE_BOOLEAN;
        }
        if (o instanceof JavaFunction || o instanceof LuaClosure) {
            return TYPE_FUNCTION;
        }
        if (o instanceof KahluaTable) {
            return TYPE_TABLE;
        }
        if (o instanceof Coroutine) {
            return TYPE_COROUTINE;
        }
        return TYPE_USERDATA;
    }

    public static String tostring(Object o, KahluaThread thread) {
        if (o == null) {
            return TYPE_NIL;
        }
        if (o instanceof String) {
            return (String) o;
        }
        if (o instanceof Double) {
            return rawTostring(o);
        }
        if (o instanceof Boolean) {
            return o == Boolean.TRUE ? "true" : "false";
        }
		if (o instanceof LuaClosure) {
			return "closure 0x" + System.identityHashCode(o);
		}
		if (o instanceof JavaFunction) {
			return "function 0x" + System.identityHashCode(o);
		}

		if (thread != null) {
			Object tostringFun = thread.getMetaOp(o, "__tostring");
			if (tostringFun != null) {
				String res = (String) thread.call(tostringFun, o, null, null);
				return res;
			}
		}

		return o.toString();
	}

    public static Double tonumber(String s) {
        return tonumber(s, 10);
    }

    public static Double tonumber(String s, int radix)  {
        if (radix < 2 || radix > 36) {
            throw new RuntimeException("base out of range");
        }

        try {
            if (radix == 10) {
                return Double.valueOf(s);
            } else {
                return toDouble(Integer.parseInt(s, radix));
            }
        } catch (NumberFormatException e) {
            s = s.toLowerCase();
            if (s.endsWith("nan")) {
                return toDouble(Double.NaN);
            }
            if (s.endsWith("inf")) {
                if (s.charAt(0) == '-') {
                    return toDouble(Double.NEGATIVE_INFINITY);
                }
                return toDouble(Double.POSITIVE_INFINITY);
            }
            return null;
        }
    }

    public static String rawTostring(Object o) {
        if (o instanceof String) {
            return (String) o;
        }
        if (o instanceof Double) {
            return numberToString((Double) o);
        }
        return null;
    }

    public static Double rawTonumber(Object o) {
        if (o instanceof Double) {
            return (Double) o;
        }
        if (o instanceof String) {
            return tonumber((String) o);
        }
        return null;
    }

	public static String getStringArg(LuaCallFrame callFrame, int n, String function) {
		Object o = getArg(callFrame, n, function);
		String res = rawTostring(o);
		if (res == null) {
			fail(n, function, "string", type(res));
		}
		return res;
	}

	public static String getOptionalStringArg(LuaCallFrame callFrame, int n) {
		Object o = getOptionalArg(callFrame, n);
		return rawTostring(o);
	}

	public static Double getNumberArg(LuaCallFrame callFrame, int n, String function) {
		Object o = getArg(callFrame, n, function);
		Double res = rawTonumber(o);
		if (res == null) {
			fail(n, function, "double", type(res));
		}
		return res;
	}

	public static Double getOptionalNumberArg(LuaCallFrame callFrame, int n) {
		Object o = getOptionalArg(callFrame, n);
		return rawTonumber(o);
	}

	private static void fail(int n, String function, String wantedType, String gotten) {
		throw new RuntimeException("bad argument #" + n + " to '" + function +
				"' (" + wantedType + " expected, got " + gotten + ")");
	}

	public static void assertArgNotNull(Object o, int n, String type, String function) {
		if (o == null) {
			fail(n, function, type, "null");
		}
	}

	public static Object getOptionalArg(LuaCallFrame callFrame, int n) {
		int top = callFrame.getTop();
		int index = n - 1;
		if (index >= top) {
			return null;
		}
		return callFrame.get(n - 1);
	}

	public static Object getArg(LuaCallFrame callFrame, int n, String function) {
		Object res = getOptionalArg(callFrame, n);
		if (res == null) {
			throw new RuntimeException("missing argument #" + n + "to '" + function + "'");
		}
		return res;
	}

    public static int len(KahluaTable kahluaTable, int low, int high) {
        while (low < high) {
            int middle = (high + low + 1) >> 1;
            Object value = kahluaTable.rawget(middle);
            if (value == null) {
                high = middle - 1;
            } else {
                low = middle;
            }
        }
		while (kahluaTable.rawget(low + 1) != null) {
			low++;
		}
        return low;
    }

	public static double getDoubleArg(LuaCallFrame callFrame, int i, String name) {
		return getNumberArg(callFrame, i, name).doubleValue();
	}
}