commonMain.org.luaj.vm2.LuaInteger.kt Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of luak-iosx64 Show documentation
Show all versions of luak-iosx64 Show documentation
Multiplatform Kotlin LuaJ port (LUA interpreter)
/*******************************************************************************
* Copyright (c) 2009 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.lib.MathLib
import kotlin.jvm.*
/**
* Extension of [LuaNumber] which can hold a Java int as its value.
*
*
* These instance are not instantiated directly by clients, but indirectly
* via the static functions [LuaValue.valueOf] or [LuaValue.valueOf]
* functions. This ensures that policies regarding pooling of instances are
* encapsulated.
*
*
* There are no API's specific to LuaInteger that are useful beyond what is already
* exposed in [LuaValue].
*
* @see LuaValue
*
* @see LuaNumber
*
* @see LuaDouble
*
* @see LuaValue.valueOf
* @see LuaValue.valueOf
*/
class LuaInteger
/**
* Package protected constructor.
* @see LuaValue.valueOf
*/
internal constructor(
/** The value being held by this instance. */
val v: Int
) : LuaNumber() {
override fun isint(): Boolean = true
override fun isinttype(): Boolean = true
override fun islong(): Boolean = true
override fun tobyte(): Byte = v.toByte()
override fun tochar(): Char = v.toChar()
override fun todouble(): Double = v.toDouble()
override fun tofloat(): Float = v.toFloat()
override fun toint(): Int = v
override fun tolong(): Long = v.toLong()
override fun toshort(): Short = v.toShort()
override fun optdouble(defval: Double): Double = v.toDouble()
override fun optint(defval: Int): Int = v
override fun optinteger(defval: LuaInteger?): LuaInteger? = this
override fun optlong(defval: Long): Long = v.toLong()
override fun tojstring(): String = v.toString(10)
override fun strvalue(): LuaString? = LuaString.valueOf(v.toString(10))
override fun optstring(defval: LuaString?): LuaString? = LuaString.valueOf(v.toString(10))
override fun tostring(): LuaValue = LuaString.valueOf(v.toString(10))
override fun optjstring(defval: String?): String? = v.toString(10)
override fun checkinteger(): LuaInteger? = this
override fun isstring(): Boolean = true
override fun hashCode(): Int = v
// unary operators
override fun neg(): LuaValue = valueOf(-v.toLong())
// object equality, used for key comparison
override fun equals(o: Any?): Boolean = if (o is LuaInteger) o.v == v else false
// equality w/ metatable processing
override fun eq(`val`: LuaValue): LuaValue = if (`val`.raweq(v)) LuaValue.TRUE else LuaValue.FALSE
override fun eq_b(`val`: LuaValue): Boolean = `val`.raweq(v)
// equality w/o metatable processing
override fun raweq(`val`: LuaValue): Boolean = `val`.raweq(v)
override fun raweq(`val`: Double): Boolean = v.toDouble() == `val`
override fun raweq(`val`: Int): Boolean = v == `val`
// arithmetic operators
override fun add(rhs: LuaValue): LuaValue = rhs.add(v)
override fun add(lhs: Double): LuaValue = LuaDouble.valueOf(lhs + v)
override fun add(lhs: Int): LuaValue = LuaInteger.valueOf(lhs + v.toLong())
override fun sub(rhs: LuaValue): LuaValue = rhs.subFrom(v)
override fun sub(rhs: Double): LuaValue = LuaDouble.valueOf(v - rhs)
override fun sub(rhs: Int): LuaValue = LuaDouble.valueOf((v - rhs).toDouble())
override fun subFrom(lhs: Double): LuaValue = LuaDouble.valueOf(lhs - v)
override fun subFrom(lhs: Int): LuaValue = LuaInteger.valueOf(lhs - v.toLong())
override fun mul(rhs: LuaValue): LuaValue = rhs.mul(v)
override fun mul(lhs: Double): LuaValue = LuaDouble.valueOf(lhs * v)
override fun mul(lhs: Int): LuaValue = LuaInteger.valueOf(lhs * v.toLong())
override fun pow(rhs: LuaValue): LuaValue = rhs.powWith(v)
override fun pow(rhs: Double): LuaValue = MathLib.dpow(v.toDouble(), rhs)
override fun pow(rhs: Int): LuaValue = MathLib.dpow(v.toDouble(), rhs.toDouble())
override fun powWith(lhs: Double): LuaValue = MathLib.dpow(lhs, v.toDouble())
override fun powWith(lhs: Int): LuaValue = MathLib.dpow(lhs.toDouble(), v.toDouble())
override fun div(rhs: LuaValue): LuaValue = rhs.divInto(v.toDouble())
override fun div(rhs: Double): LuaValue = LuaDouble.ddiv(v.toDouble(), rhs)
override fun div(rhs: Int): LuaValue = LuaDouble.ddiv(v.toDouble(), rhs.toDouble())
override fun divInto(lhs: Double): LuaValue = LuaDouble.ddiv(lhs, v.toDouble())
override fun mod(rhs: LuaValue): LuaValue = rhs.modFrom(v.toDouble())
override fun mod(rhs: Double): LuaValue = LuaDouble.dmod(v.toDouble(), rhs)
override fun mod(rhs: Int): LuaValue = LuaDouble.dmod(v.toDouble(), rhs.toDouble())
override fun modFrom(lhs: Double): LuaValue = LuaDouble.dmod(lhs, v.toDouble())
// relational operators
override fun lt(rhs: LuaValue): LuaValue = if (rhs.gt_b(v)) LuaValue.TRUE else LuaValue.FALSE
override fun lt(rhs: Double): LuaValue = if (v < rhs) LuaValue.TRUE else LuaValue.FALSE
override fun lt(rhs: Int): LuaValue = if (v < rhs) LuaValue.TRUE else LuaValue.FALSE
override fun lt_b(rhs: LuaValue): Boolean = rhs.gt_b(v)
override fun lt_b(rhs: Int): Boolean = v < rhs
override fun lt_b(rhs: Double): Boolean = v < rhs
override fun lteq(rhs: LuaValue): LuaValue = if (rhs.gteq_b(v)) LuaValue.TRUE else LuaValue.FALSE
override fun lteq(rhs: Double): LuaValue = if (v <= rhs) LuaValue.TRUE else LuaValue.FALSE
override fun lteq(rhs: Int): LuaValue = if (v <= rhs) LuaValue.TRUE else LuaValue.FALSE
override fun lteq_b(rhs: LuaValue): Boolean = rhs.gteq_b(v)
override fun lteq_b(rhs: Int): Boolean = v <= rhs
override fun lteq_b(rhs: Double): Boolean = v <= rhs
override fun gt(rhs: LuaValue): LuaValue = if (rhs.lt_b(v)) LuaValue.TRUE else LuaValue.FALSE
override fun gt(rhs: Double): LuaValue = if (v > rhs) LuaValue.TRUE else LuaValue.FALSE
override fun gt(rhs: Int): LuaValue = if (v > rhs) LuaValue.TRUE else LuaValue.FALSE
override fun gt_b(rhs: LuaValue): Boolean = rhs.lt_b(v)
override fun gt_b(rhs: Int): Boolean = v > rhs
override fun gt_b(rhs: Double): Boolean = v > rhs
override fun gteq(rhs: LuaValue): LuaValue = if (rhs.lteq_b(v)) LuaValue.TRUE else LuaValue.FALSE
override fun gteq(rhs: Double): LuaValue = if (v >= rhs) LuaValue.TRUE else LuaValue.FALSE
override fun gteq(rhs: Int): LuaValue = if (v >= rhs) LuaValue.TRUE else LuaValue.FALSE
override fun gteq_b(rhs: LuaValue): Boolean = rhs.lteq_b(v)
override fun gteq_b(rhs: Int): Boolean = v >= rhs
override fun gteq_b(rhs: Double): Boolean = v >= rhs
// string comparison
override fun strcmp(rhs: LuaString): Int = typerror("attempt to compare number with string")
override fun checkint(): Int = v
override fun checklong(): Long = v.toLong()
override fun checkdouble(): Double = v.toDouble()
override fun checkjstring(): String? = v.toString()
override fun checkstring(): LuaString = LuaValue.valueOf(v.toString())
companion object {
private val intValues = Array(512) { LuaInteger(it - 256) }
@JvmName("valueOf2")
fun valueOf(i: Int): LuaInteger = if (i <= 255 && i >= -256) intValues[i + 256]!! else LuaInteger(i)
// TODO consider moving this to LuaValue
/** Return a LuaNumber that represents the value provided
* @param l long value to represent.
* @return LuaNumber that is eithe LuaInteger or LuaDouble representing l
* @see LuaValue.valueOf
* @see LuaValue.valueOf
*/
fun valueOf(l: Long): LuaNumber =
l.toInt().let { i -> if (l == i.toLong()) if (i <= 255 && i >= -256) intValues[i + 256] else LuaInteger(i) else LuaDouble.valueOf(l.toDouble()) }
fun hashCode(x: Int): Int = x
}
}