android_luaj

/******************************************************************************* * Copyright (c) 2009-2011 Luaj.org. All rights reserved. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. ******************************************************************************/ package org.luaj.vm2; import org.luaj.vm2.Varargs; /** * Base class for all concrete lua type values. * <p> * Establishes base implementations for all the operations on lua types. * This allows Java clients to deal essentially with one type for all Java values, namely {@link LuaValue}. * <p> * Constructors are provided as static methods for common Java types, such as * {@link LuaValue#valueOf(int)} or {@link LuaValue#valueOf(String)} * to allow for instance pooling. * <p> * Constants are defined for the lua values * {@link #NIL}, {@link #TRUE}, and {@link #FALSE}. * A constant {@link #NONE} is defined which is a {@link Varargs} list having no values. * <p> * Operations are performed on values directly via their Java methods. * For example, the following code divides two numbers: * <pre> {@code * LuaValue a = LuaValue.valueOf( 5 ); * LuaValue b = LuaValue.valueOf( 4 ); * LuaValue c = a.div(b); * } </pre> * Note that in this example, c will be a {@link LuaDouble}, but would be a {@link LuaInteger} * if the value of a were changed to 8, say. * In general the value of c in practice will vary depending on both the types and values of a and b * as well as any metatable/metatag processing that occurs. * <p> * Field access and function calls are similar, with common overloads to simplify Java usage: * <pre> {@code * LuaValue globals = JsePlatform.standardGlobals(); * LuaValue sqrt = globals.get("math").get("sqrt"); * LuaValue print = globals.get("print"); * LuaValue d = sqrt.call( a ); * print.call( LuaValue.valueOf("sqrt(5):"), a ); * } </pre> * <p> * To supply variable arguments or get multiple return values, use * {@link #invoke(Varargs)} or {@link #invokemethod(LuaValue, Varargs)} methods: * <pre> {@code * LuaValue modf = globals.get("math").get("modf"); * Varargs r = modf.invoke( d ); * print.call( r.arg(1), r.arg(2) ); * } </pre> * <p> * To load and run a script, {@link LoadState} is used: * <pre> {@code * LoadState.load( new FileInputStream("main.lua"), "main.lua", globals ).call(); * } </pre> * <p> * although {@code require} could also be used: * <pre> {@code * globals.get("require").call(LuaValue.valueOf("main")); * } </pre> * For this to work the file must be in the current directory, or in the class path, * dependening on the platform. * See {@link org.luaj.vm2.lib.jse.JsePlatform} and {@link org.luaj.vm2.lib.jme.JmePlatform} for details. * <p> * In general a {@link LuaError} may be thrown on any operation when the * types supplied to any operation are illegal from a lua perspective. * Examples could be attempting to concatenate a NIL value, or attempting arithmetic * on values that are not number. * <p> * There are several methods for preinitializing tables, such as: * <ul> * <li>{@link #listOf(LuaValue[])} for unnamed elements</li> * <li>{@link #tableOf(LuaValue[])} for named elements</li> * <li>{@link #tableOf(LuaValue[], LuaValue[], Varargs)} for mixtures</li> * </ul> * <p> * Predefined constants exist for the standard lua type constants * {@link #TNIL}, {@link #TBOOLEAN}, {@link #TLIGHTUSERDATA}, {@link #TNUMBER}, {@link #TSTRING}, * {@link #TTABLE}, {@link #TFUNCTION}, {@link #TUSERDATA}, {@link #TTHREAD}, * and extended lua type constants * {@link #TINT}, {@link #TNONE}, {@link #TVALUE} * <p> * Predefined constants exist for all strings used as metatags: * {@link #INDEX}, {@link #NEWINDEX}, {@link #CALL}, {@link #MODE}, {@link #METATABLE}, * {@link #ADD}, {@link #SUB}, {@link #DIV}, {@link #MUL}, {@link #POW}, * {@link #MOD}, {@link #UNM}, {@link #LEN}, {@link #EQ}, {@link #LT}, * {@link #LE}, {@link #TOSTRING}, and {@link #CONCAT}. * * @see org.luaj.vm2.lib.jse.JsePlatform * @see org.luaj.vm2.lib.jme.JmePlatform * @see LoadState * @see Varargs */ abstract public class LuaValue extends Varargs { /** Type enumeration constant for lua numbers that are ints, for compatibility with lua 5.1 number patch only */ public static final int TINT = (-2); /** Type enumeration constant for lua values that have no type, for example weak table entries */ public static final int TNONE = (-1); /** Type enumeration constant for lua nil */ public static final int TNIL = 0; /** Type enumeration constant for lua booleans */ public static final int TBOOLEAN = 1; /** Type enumeration constant for lua light userdata, for compatibility with C-based lua only */ public static final int TLIGHTUSERDATA = 2; /** Type enumeration constant for lua numbers */ public static final int TNUMBER = 3; /** Type enumeration constant for lua strings */ public static final int TSTRING = 4; /** Type enumeration constant for lua tables */ public static final int TTABLE = 5; /** Type enumeration constant for lua functions */ public static final int TFUNCTION = 6; /** Type enumeration constant for lua userdatas */ public static final int TUSERDATA = 7; /** Type enumeration constant for lua threads */ public static final int TTHREAD = 8; /** Type enumeration constant for unknown values, for compatibility with C-based lua only */ public static final int TVALUE = 9; /** String array constant containing names of each of the lua value types * @see #type() * @see #typename() */ public static final String[] TYPE_NAMES = { "nil", "boolean", "lightuserdata", "number", "string", "table", "function", "userdata", "thread", "value", }; /** LuaValue constant corresponding to lua {@code #NIL} */ public static final LuaValue NIL = LuaNil._NIL; /** LuaBoolean constant corresponding to lua {@code true} */ public static final LuaBoolean TRUE = LuaBoolean._TRUE; /** LuaBoolean constant corresponding to lua {@code false} */ public static final LuaBoolean FALSE = LuaBoolean._FALSE; /** LuaValue constant corresponding to a {@link Varargs} list of no values */ public static final LuaValue NONE = None._NONE; /** LuaValue number constant equal to 0 */ public static final LuaNumber ZERO = LuaInteger.valueOf(0); /** LuaValue number constant equal to 1 */ public static final LuaNumber ONE = LuaInteger.valueOf(1); /** LuaValue number constant equal to -1 */ public static final LuaNumber MINUSONE = LuaInteger.valueOf(-1); /** LuaValue array constant with no values */ public static final LuaValue[] NOVALS = {}; /** The variable name of the environment. */ public static LuaString ENV = valueOf("_ENV"); /** LuaString constant with value "__index" for use as metatag */ public static final LuaString INDEX = valueOf("__index"); /**