VideoOS 安卓端 SDK.zip

/******************************************************************************* * 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; /** * 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 JsePlatform} and {@link 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 JsePlatform * @see 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 */ 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"); /**