Merge remote-tracking branch 'origin/master' into java-6

Author: SquidDev

README.md

@@ -1,15 +1,17 @@
 # Cobalt
-Cobalt is an Lua implementation for Java, designed for use in the Minecraft mod
-[CC: Tweaked]. Is is based on [LuaJ 2.0][LuaJ], though has diverged
+Cobalt is a Lua implementation for Java, designed for use in the Minecraft mod
+[CC: Tweaked]. It is based on [LuaJ 2.0][LuaJ], though has diverged
 significantly over the years.
 
 ## Features
-Cobalt implements a (mostly) compliant Lua 5.1 implementation, with several
+Cobalt is a (mostly) compliant implementation of Lua 5.2, with several
 interesting additional features:
 
- - Backports much of the Lua 5.2-5.4 standard library.
+ - Backwards compatibility with Lua 5.1 (`getfenv`/`setfenv`, `goto` as an
+   identifier).
+ - Backports much of the Lua 5.3 and 5.4 standard library.
  - Allows yielding _anywhere_ within a Lua program, including debug hooks and
-   any inside any native function.
+   inside any native function.
  - Support for interrupting and resuming the VM at arbitrary points.
  - Efficient concatenation of strings using ropes.
 

build-tools/src/main/kotlin/cc/tweaked/cobalt/build/ClassEmitter.kt

@@ -68,6 +68,8 @@ private val subclassRelations = mapOf(
 	UnorderedPair("org/squiddev/cobalt/LuaValue", "org/squiddev/cobalt/LuaString") to "org/squiddev/cobalt/LuaValue",
 	UnorderedPair("org/squiddev/cobalt/Varargs", "org/squiddev/cobalt/LuaValue") to "org/squiddev/cobalt/Varargs",
 	UnorderedPair("org/squiddev/cobalt/LuaError", "org/squiddev/cobalt/compiler/CompileException") to "java/lang/Exception",
+	UnorderedPair("org/squiddev/cobalt/LuaError", "java/lang/Exception") to "java/lang/Exception",
+	UnorderedPair("org/squiddev/cobalt/compiler/CompileException", "java/lang/Exception") to "java/lang/Exception"
 )
 
 fun getCommonSuperclass(type1: String, type2: String): String? = subclassRelations[UnorderedPair(type1, type2)]

build-tools/src/main/kotlin/cc/tweaked/cobalt/build/coroutine/DefinitionData.kt

@@ -63,6 +63,7 @@ interface DefinitionData {
 private val builtinMethods = run {
 	val opHelper = "org/squiddev/cobalt/OperationHelper"
 	val dispatch = "org/squiddev/cobalt/function/Dispatch"
+	val nop = YieldType.Direct { }
 	val first = YieldType.Direct { mw ->
 		mw.visitMethodInsn(INVOKEVIRTUAL, VARARGS.internalName, "first", "()${LUA_VALUE.descriptor}", false)
 	}
@@ -75,11 +76,14 @@ private val builtinMethods = run {
 	mapOf(
 		Desc("org/squiddev/cobalt/compiler/InputReader", "read", "()I") to YieldType.Resume,
 		Desc("org/squiddev/cobalt/unwind/SuspendedFunction", "call", "(Lorg/squiddev/cobalt/LuaState;)Ljava/lang/Object;") to YieldType.Resume,
+		Desc(dispatch, "call", Type.getMethodDescriptor(LUA_VALUE, LUA_STATE, LUA_VALUE)) to first,
 		Desc(dispatch, "call", Type.getMethodDescriptor(LUA_VALUE, LUA_STATE, LUA_VALUE, LUA_VALUE)) to first,
 		Desc(dispatch, "call", Type.getMethodDescriptor(LUA_VALUE, LUA_STATE, LUA_VALUE, LUA_VALUE, LUA_VALUE)) to first,
+		Desc(dispatch, "invoke", Type.getMethodDescriptor(VARARGS, LUA_STATE, LUA_VALUE, VARARGS)) to nop,
 		Desc(opHelper, "eq", Type.getMethodDescriptor(Type.BOOLEAN_TYPE, LUA_STATE, LUA_VALUE, LUA_VALUE)) to firstBool,
 		Desc(opHelper, "lt", Type.getMethodDescriptor(Type.BOOLEAN_TYPE, LUA_STATE, LUA_VALUE, LUA_VALUE)) to firstBool,
 		Desc(opHelper, "length", Type.getMethodDescriptor(LUA_VALUE, LUA_STATE, LUA_VALUE)) to first,
+		Desc(opHelper, "toString", Type.getMethodDescriptor(LUA_VALUE, LUA_STATE, LUA_VALUE)) to first,
 		Desc(opHelper, "getTable", Type.getMethodDescriptor(LUA_VALUE, LUA_STATE, LUA_VALUE, Type.INT_TYPE)) to first,
 		Desc(opHelper, "getTable", Type.getMethodDescriptor(LUA_VALUE, LUA_STATE, LUA_VALUE, LUA_VALUE)) to first,
 		Desc(opHelper, "setTable", Type.getMethodDescriptor(Type.VOID_TYPE, LUA_STATE, LUA_VALUE, Type.INT_TYPE, LUA_VALUE)) to drop,

build.gradle.kts

@@ -6,7 +6,7 @@ plugins {
 }
 
 group = "cc.tweaked"
-version = "0.9.1"
+version = "0.9.5"
 
 java {
 	toolchain {
@@ -149,29 +149,29 @@ publishing {
 			pom {
 				name = "Cobalt"
 				description = "A reentrant fork of LuaJ for Lua 5.2"
-				url = "https://github.com/SquidDev/Cobalt"
+				url = "https://github.com/cc-tweaked/Cobalt"
 
 				scm {
-					url = "https://github.com/SquidDev/Cobalt.git"
+					url = "https://github.com/cc-tweaked/Cobalt.git"
 				}
 
 				issueManagement {
 					system = "github"
-					url = "https://github.com/SquidDev/Cobalt/issues"
+					url = "https://github.com/cc-tweaked/Cobalt/issues"
 				}
 
 				licenses {
 					license {
 						name = "MIT"
-						url = "https://github.com/SquidDev/Cobalt/blob/master/LICENSE"
+						url = "https://github.com/cc-tweaked/Cobalt/blob/master/LICENSE"
 					}
 				}
 			}
 		}
 	}
 
 	repositories {
-		maven("https://squiddev.cc/maven") {
+		maven("https://maven.squiddev.cc") {
 			name = "SquidDev"
 			credentials(PasswordCredentials::class)
 		}

src/main/java/cc/tweaked/cobalt/internal/doubles/CharBuffer.java

@@ -32,6 +32,7 @@
 package cc.tweaked.cobalt.internal.doubles;
 
 import org.checkerframework.checker.signedness.qual.Unsigned;
+import org.squiddev.cobalt.Buffer;
 
 import static cc.tweaked.cobalt.internal.doubles.Assert.requireArg;
 
@@ -120,7 +121,7 @@ private DoubleToStringConverter() {
 	 * If either of them is NULL or the value is not special then the
 	 * function returns false.
 	 */
-	private static void handleSpecialValues(double value, FormatOptions fo, CharBuffer resultBuilder) {
+	private static void handleSpecialValues(double value, FormatOptions fo, Buffer resultBuilder) {
 		boolean sign = value < 0.0;
 
 		int effectiveWidth = fo.width();
@@ -164,7 +165,7 @@ private static void createExponentialRepresentation(
 		int length,
 		int exponent,
 		FormatOptions fo,
-		CharBuffer resultBuilder
+		Buffer resultBuilder
 	) {
 		requireArg(decimalDigits.length() != 0, "decimalDigits must not be empty");
 		requireArg(length <= decimalDigits.length(), "length must be smaller than decimalDigits");
@@ -246,7 +247,7 @@ private static void createDecimalRepresentation(
 		double value,
 		int digitsAfterPoint,
 		FormatOptions fo,
-		CharBuffer resultBuilder
+		Buffer resultBuilder
 	) {
 		int decimalPoint = decimalDigits.getPointPosition();
 		int digitsLength = decimalDigits.length();
@@ -395,7 +396,7 @@ private static int calculateExpWidth(
 	 *                                  MAX_FIXED_DIGITS_AFTER_POINT</code><br/>
 	 *                                  characters (one additional character for the sign, and one for the decimal point).
 	 */
-	public static void toFixed(double value, int requestedDigits, FormatOptions formatOptions, CharBuffer resultBuilder) {
+	public static void toFixed(double value, int requestedDigits, FormatOptions formatOptions, Buffer resultBuilder) {
 		// DOUBLE_CONVERSION_ASSERT(MAX_FIXED_DIGITS_BEFORE_POINT == 60);
 
 		if (Doubles.isSpecial(value)) {
@@ -442,7 +443,7 @@ public static void toFixed(double value, int requestedDigits, FormatOptions form
 	 * @param formatOptions
 	 * @throws IllegalArgumentException if <code>requestedDigits > MAX_EXPONENTIAL_DIGITS</code>
 	 */
-	public static void toExponential(double value, int requestedDigits, FormatOptions formatOptions, CharBuffer resultBuilder) {
+	public static void toExponential(double value, int requestedDigits, FormatOptions formatOptions, Buffer resultBuilder) {
 		if (Doubles.isSpecial(value)) {
 			handleSpecialValues(value, formatOptions, resultBuilder);
 			return;
@@ -512,7 +513,7 @@ public static void toExponential(double value, int requestedDigits, FormatOption
 	 * @throws IllegalArgumentException when <code>precision < MIN_PRECISION_DIGITS</code> or
 	 *                                  <code>precision > MAX_PRECISION_DIGITS</code>
 	 */
-	public static void toPrecision(double value, int precision, FormatOptions formatOptions, CharBuffer resultBuilder) {
+	public static void toPrecision(double value, int precision, FormatOptions formatOptions, Buffer resultBuilder) {
 		if (Doubles.isSpecial(value)) {
 			handleSpecialValues(value, formatOptions, resultBuilder);
 			return;
@@ -562,7 +563,7 @@ public static void toPrecision(double value, int precision, FormatOptions format
 	 * @param formatOptions   Additional options for this number's formatting.
 	 * @param resultBuilder   The buffer to output to.
 	 */
-	public static void toHex(double value, int requestedDigits, FormatOptions formatOptions, CharBuffer resultBuilder) {
+	public static void toHex(double value, int requestedDigits, FormatOptions formatOptions, Buffer resultBuilder) {
 		if (Doubles.isSpecial(value)) {
 			handleSpecialValues(value, formatOptions, resultBuilder);
 			return;
@@ -651,7 +652,7 @@ private static boolean shouldEmitMinus(double value) {
 		return (Double.doubleToRawLongBits(value) & Doubles.SIGN_MASK) != 0 && value != 0.0;
 	}
 
-	private static void appendSign(double value, FormatOptions formatOptions, CharBuffer resultBuilder) {
+	private static void appendSign(double value, FormatOptions formatOptions, Buffer resultBuilder) {
 		if (shouldEmitMinus(value)) {
 			resultBuilder.append('-');
 		} else if (formatOptions.spaceWhenPositive()) {
@@ -771,7 +772,7 @@ static void doubleToAscii(double v, DtoaMode mode, int requestedDigits, DecimalR
 	 * Add character padding to the builder. If count is non-positive,
 	 * nothing is added to the builder.
 	 */
-	private static void addPadding(CharBuffer sb, char character, int count) {
+	private static void addPadding(Buffer sb, char character, int count) {
 		for (int i = count; i > 0; i--) sb.append(character);
 	}
 

src/main/java/cc/tweaked/cobalt/internal/doubles/DoubleToStringConverter.java

@@ -11,41 +11,37 @@ public final class NumberParser {
 	private NumberParser() {
 	}
 
-	public static double parse(byte[] bytes, int offset, int length, int base) {
-		int index = offset, end = offset + length;
-		while (index < end && StringLib.isWhitespace(bytes[index])) index++;
-		while (index < end && StringLib.isWhitespace(bytes[end - 1])) end--;
+	public static double parse(byte[] bytes, int start, int length, int base) {
+		int end = start + length;
+		while (start < end && StringLib.isWhitespace(bytes[start])) start++;
+		while (start < end && StringLib.isWhitespace(bytes[end - 1])) end--;
 
+		var originalStart = start;
 		boolean isNeg = false;
-		if (index < end) {
-			switch (bytes[index]) {
-				case '+' -> index++;
+		if (start < end) {
+			switch (bytes[start]) {
+				case '+' -> start++;
 				case '-' -> {
-					index++;
+					start++;
 					isNeg = true;
 				}
 			}
 		}
 
-		if (index >= end) return Double.NaN;
+		if (start >= end) return Double.NaN;
 
-		if ((base == 10 || base == 16) && (bytes[index] == '0' && index + 1 < end && (bytes[index + 1] == 'x' || bytes[index + 1] == 'X'))) {
+		if ((base == 10 || base == 16) && (bytes[start] == '0' && start + 1 < end && (bytes[start + 1] == 'x' || bytes[start + 1] == 'X'))) {
 			base = 16;
-			index += 2;
-
-			if (index >= end) return Double.NaN;
-		}
+			start += 2;
 
-		double value = scanLong(base, bytes, index, end);
-		if (Double.isNaN(value)) {
-			value = switch (base) {
-				case 10 -> scanDouble(bytes, index, end);
-				case 16 -> scanHexDouble(bytes, index, end);
-				default -> Double.NaN;
-			};
+			if (start >= end) return Double.NaN;
 		}
 
-		return isNeg ? -value : value;
+		return switch (base) {
+			case 10 -> scanDouble(bytes, originalStart, end);
+			case 16 -> scanHexDouble(bytes, start, end, isNeg);
+			default -> scanLong(base, bytes, start, end, isNeg);
+		};
 	}
 
 	/**
@@ -54,11 +50,12 @@ public static double parse(byte[] bytes, int offset, int length, int base) {
 	 * @param base  the base to use, such as 10
 	 * @param start the index to start searching from
 	 * @param end   the first index beyond the search range
+	 * @param isNeg Whether this is a negative value.
 	 * @return double value if conversion is valid,
 	 * or Double.NaN if not
 	 */
-	private static double scanLong(int base, byte[] bytes, int start, int end) {
-		long x = 0;
+	private static double scanLong(int base, byte[] bytes, int start, int end, boolean isNeg) {
+		double x = 0;
 		for (int i = start; i < end; i++) {
 			var chr = bytes[i];
 			int digit;
@@ -73,7 +70,7 @@ private static double scanLong(int base, byte[] bytes, int start, int end) {
 			if (digit >= base) return Double.NaN;
 			x = x * base + digit;
 		}
-		return x;
+		return isNeg ? -x : x;
 	}
 
 	/**
@@ -85,31 +82,11 @@ private static double scanLong(int base, byte[] bytes, int start, int end) {
 	 * or Double.NaN if not
 	 */
 	private static double scanDouble(byte[] bytes, int start, int end) {
-		for (int i = start; i < end; i++) {
-			switch (bytes[i]) {
-				case '-':
-				case '+':
-				case '.':
-				case 'e':
-				case 'E':
-				case '0':
-				case '1':
-				case '2':
-				case '3':
-				case '4':
-				case '5':
-				case '6':
-				case '7':
-				case '8':
-				case '9':
-					break;
-				default:
-					return Double.NaN;
-			}
-		}
 		char[] c = new char[end - start];
 		for (int i = start; i < end; i++) {
-			c[i - start] = (char) bytes[i];
+			var b = bytes[i];
+			if (!isValidDoubleCharacter(b)) return Double.NaN;
+			c[i - start] = (char) b;
 		}
 		try {
 			return Double.parseDouble(String.valueOf(c));
@@ -118,8 +95,12 @@ private static double scanDouble(byte[] bytes, int start, int end) {
 		}
 	}
 
-	private static double scanHexDouble(byte[] bytes, int index, int end) {
-		long result = 0; // The mantissa
+	private static boolean isValidDoubleCharacter(byte b) {
+		return (b >= '0' && b <= '9') || b == '+' || b == '-' || b == '.' || b == 'E' || b == 'e';
+	}
+
+	private static double scanHexDouble(byte[] bytes, int index, int end, boolean isNeg) {
+		double result = 0; // The mantissa
 		int exponent = 0;
 
 		int sigDigits = 0, nonSigDigits = 0; // Number of significant digits and non-significant digits (leading 0s).
@@ -187,6 +168,7 @@ private static double scanHexDouble(byte[] bytes, int index, int end) {
 			exponent += givenExponent;
 		}
 
-		return Math.scalb((double) result, exponent);
+		if (isNeg) result = -result;
+		return Math.scalb(result, exponent);
 	}
 }

src/main/java/cc/tweaked/cobalt/internal/string/NumberParser.java

@@ -24,15 +24,13 @@
  */
 package org.squiddev.cobalt;
 
-import cc.tweaked.cobalt.internal.doubles.CharBuffer;
-
 /**
  * String buffer for use in string library methods, optimized for producing {@link LuaString} instances.
  *
  * @see LuaValue
  * @see LuaString
  */
-public final class Buffer implements CharBuffer {
+public final class Buffer {
 	/**
 	 * Default capacity for a buffer: 64
 	 */
@@ -181,7 +179,6 @@ public Buffer append(LuaString str, int start, int srcLength) {
 	 * @return {@code this}, for chaining.
 	 * @see LuaString#encode(String, byte[], int)
 	 */
-	@Override
 	public Buffer append(String str) {
 		final int n = str.length();
 		ensure(n);