+ * The static methods provide a UNIX-style timestamp, a {@link Date}
+ * instance, or a {@link Calendar} instance. In the event the time
+ * expression provided is invalid, these methods return
+ * Boolean.FALSE.
+ *
+ *
+ * translateDayOfWeek = new HashMap<>();
+
+ static {
+ translateDayOfWeek.put("sunday", 1);
+ translateDayOfWeek.put("sun", 1);
+ translateDayOfWeek.put("monday", 2);
+ translateDayOfWeek.put("mon", 2);
+ translateDayOfWeek.put("tuesday", 3);
+ translateDayOfWeek.put("tue", 3);
+ translateDayOfWeek.put("wednesday", 4);
+ translateDayOfWeek.put("wed", 4);
+ translateDayOfWeek.put("thursday", 5);
+ translateDayOfWeek.put("thu", 5);
+ translateDayOfWeek.put("friday", 6);
+ translateDayOfWeek.put("fri", 6);
+ translateDayOfWeek.put("saturday", 7);
+ translateDayOfWeek.put("sat", 7);
+ }
+
+ private String sdf;
+
+ private FormatType type;
+
+ Format(FormatType type) {
+ this.type = type;
+ }
+
+ Format(String sdf) {
+ this.sdf = sdf;
+ }
+
+ @Override
+ public String toString() {
+ if (sdf != null)
+ return sdf;
+ else
+ return type.toString();
+ }
+
+ Date parse(String dateTimeString, Date now, Matcher m) throws ParseException {
+ if (sdf != null)
+ return new SimpleDateFormat(sdf, DEFAULT_LOCALE).parse(dateTimeString);
+ else {
+ dateTimeString = removeExtraSpaces.matcher(dateTimeString).replaceAll(" ").toLowerCase();
+
+ try {
+ Calendar cal = Calendar.getInstance();
+ cal.setTime(now);
+
+ // word expressions, e.g., "now" and "today" and "tonight"
+ if (type == FormatType.WORD) {
+ switch (dateTimeString) {
+ case "now":
+ return now;
+ case "today":
+ cal.set(Calendar.HOUR_OF_DAY, 0);
+ cal.set(Calendar.MINUTE, 0);
+ cal.set(Calendar.SECOND, 0);
+ cal.set(Calendar.MILLISECOND, 0);
+ return new Date(cal.getTimeInMillis());
+ case "morning":
+ case "this morning":
+ // by default, this morning begins at 07:00:00.000
+ int thisMorningBeginsAt = Integer.parseInt(System.getProperty(StringToTime.class + ".THIS_MORNING_BEGINS_AT", "7"));
+ cal.set(Calendar.HOUR_OF_DAY, thisMorningBeginsAt);
+ cal.set(Calendar.MINUTE, 0);
+ cal.set(Calendar.SECOND, 0);
+ cal.set(Calendar.MILLISECOND, 0);
+ return new Date(cal.getTimeInMillis());
+ case "noon":
+ // noon is 12:00:00.000
+ cal.set(Calendar.HOUR_OF_DAY, 12);
+ cal.set(Calendar.MINUTE, 0);
+ cal.set(Calendar.SECOND, 0);
+ cal.set(Calendar.MILLISECOND, 0);
+ return new Date(cal.getTimeInMillis());
+ case "afternoon":
+ case "this afternoon":
+ // by default, this afternoon begins at 13:00:00.000
+ int thisAfternoonBeginsAt = Integer.parseInt(System.getProperty(StringToTime.class + ".THIS_AFTERNOON_BEGINS_AT",
+ "13"));
+ cal.set(Calendar.HOUR_OF_DAY, thisAfternoonBeginsAt);
+ cal.set(Calendar.MINUTE, 0);
+ cal.set(Calendar.SECOND, 0);
+ cal.set(Calendar.MILLISECOND, 0);
+ return new Date(cal.getTimeInMillis());
+ case "evening":
+ case "this evening":
+ // by default, this evening begins at 17:00:00.000
+ int thisEveningBeginsAt = Integer.parseInt(System.getProperty(StringToTime.class + ".THIS_EVENING_BEGINS_AT", "17"));
+ cal.set(Calendar.HOUR_OF_DAY, thisEveningBeginsAt);
+ cal.set(Calendar.MINUTE, 0);
+ cal.set(Calendar.SECOND, 0);
+ cal.set(Calendar.MILLISECOND, 0);
+ return new Date(cal.getTimeInMillis());
+ case "tonight":
+ // by default, tonight begins at 20:00:00.000
+ int tonightBeginsAt = Integer.parseInt(System.getProperty(StringToTime.class + ".TONIGHT_BEGINS_AT", "20"));
+ cal.set(Calendar.HOUR_OF_DAY, tonightBeginsAt);
+ cal.set(Calendar.MINUTE, 0);
+ cal.set(Calendar.SECOND, 0);
+ cal.set(Calendar.MILLISECOND, 0);
+ return new Date(cal.getTimeInMillis());
+ case "midnight":
+ return new StringToTime("00:00:00 +24 hours", now);
+ case "tomorrow":
+ return new StringToTime("now +24 hours", now);
+ case "tomorrow morning":
+ return new StringToTime("morning +24 hours", now);
+ case "tomorrow noon":
+ case "noon tomorrow":
+ return new StringToTime("noon +24 hours", now);
+ case "tomorrow afternoon":
+ return new StringToTime("afternoon +24 hours", now);
+ case "tomorrow evening":
+ return new StringToTime("evening +24 hours", now);
+ case "tomorrow night":
+ return new StringToTime("tonight +24 hours", now);
+ case "yesterday":
+ return new StringToTime("now -24 hours", now);
+ case "yesterday morning":
+ return new StringToTime("morning -24 hours", now);
+ case "yesterday noon":
+ case "noon yesterday":
+ return new StringToTime("noon -24 hours", now);
+ case "yesterday afternoon":
+ return new StringToTime("afternoon -24 hours", now);
+ case "yesterday evening":
+ return new StringToTime("evening -24 hours", now);
+ case "yesterday night":
+ return new StringToTime("tonight -24 hours", now);
+ default:
+ throw new ParseException(String.format("Unrecognized date word: %s", dateTimeString), 0);
+ }
+ }
+
+ // time expressions, 24-hour and 12-hour
+ else if (type == FormatType.TIME) {
+ // An expression of time
+ // (hour)(:(minute))?((:(second))(.(millisecond))?)?(
+ // *(am?|pm?))?(RFC 822 time zone|general time zone)?
+ String hour = m.group(1);
+ String min = m.group(3);
+ String sec = m.group(5);
+ String ms = m.group(7);
+ String amOrPm = m.group(8);
+
+ if (hour != null) {
+ if (amOrPm != null)
+ cal.set(Calendar.HOUR, Integer.parseInt(hour));
+ else
+ cal.set(Calendar.HOUR_OF_DAY, Integer.parseInt(hour));
+ } else
+ cal.set(Calendar.HOUR, 0);
+
+ cal.set(Calendar.MINUTE, (min != null ? Integer.parseInt(min) : 0));
+ cal.set(Calendar.SECOND, (sec != null ? Integer.parseInt(sec) : 0));
+ cal.set(Calendar.MILLISECOND, (ms != null ? Integer.parseInt(ms) : 0));
+
+ if (amOrPm != null)
+ cal.set(Calendar.AM_PM, (amOrPm.equals("a") || amOrPm.equals("am") ? Calendar.AM : Calendar.PM));
+
+ return new Date(cal.getTimeInMillis());
+ }
+
+ // increments
+ else if (type == FormatType.INCREMENT || type == FormatType.DECREMENT) {
+ Matcher units = unit.matcher(dateTimeString);
+ while (units.find()) {
+ int val = Integer.parseInt(units.group(1)) * (type == FormatType.DECREMENT ? -1 : 1);
+ String u = units.group(2);
+
+ // second
+ if ("s".equals(u) || "sec".equals(u) || "second".equals(u))
+ cal.set(Calendar.SECOND, cal.get(Calendar.SECOND) + val);
+
+ // minute
+ else if ("m".equals(u) || "min".equals(u) || "minute".equals(u))
+ cal.set(Calendar.MINUTE, cal.get(Calendar.MINUTE) + val);
+
+ // hour
+ else if ("h".equals(u) || "hr".equals(u) || "hour".equals(u))
+ cal.set(Calendar.HOUR_OF_DAY, cal.get(Calendar.HOUR_OF_DAY) + val);
+
+ // day
+ else if ("d".equals(u) || "day".equals(u))
+ cal.set(Calendar.DATE, cal.get(Calendar.DATE) + val);
+
+ // week
+ else if ("w".equals(u) || "wk".equals(u) || "week".equals(u))
+ cal.set(Calendar.WEEK_OF_YEAR, cal.get(Calendar.WEEK_OF_YEAR) + val);
+
+ // month
+ else if ("mo".equals(u) || "mon".equals(u) || "month".equals(u))
+ cal.set(Calendar.MONTH, cal.get(Calendar.MONTH) + val);
+
+ // year
+ else if ("y".equals(u) || "yr".equals(u) || "year".equals(u))
+ cal.set(Calendar.YEAR, cal.get(Calendar.YEAR) + val);
+
+ else
+ throw new IllegalArgumentException(String.format("Unrecognized %s unit: [%s]", type, u));
+ }
+
+ return new Date(cal.getTimeInMillis());
+ }
+
+ // compound expressions
+ else if (type == FormatType.COMPOUND) {
+ Object date = StringToTime.date(m.group(1), now);
+ if (!Boolean.FALSE.equals(date))
+ return (Date) StringToTime.date(m.group(2), (Date) date);
+ else
+ throw new IllegalArgumentException(String.format("Couldn't parse %s, so couldn't compound with %s", m.group(1), m
+ .group(2)));
+ }
+
+ // month of the year
+ else if (type == FormatType.MONTH) {
+ Calendar ref = Calendar.getInstance();
+ ref.setTime(new SimpleDateFormat("MMM d, y", DEFAULT_LOCALE).parse(String.format("%s 1, 1970", m.group(1))));
+ cal.set(Calendar.MONTH, ref.get(Calendar.MONTH));
+
+ return new Date(cal.getTimeInMillis());
+ }
+
+ // day of week
+ else if (type == FormatType.DAY_OF_WEEK) {
+ Integer ref = translateDayOfWeek.get(dateTimeString);
+ if (cal.get(Calendar.DAY_OF_WEEK) >= ref)
+ cal.set(Calendar.WEEK_OF_YEAR, cal.get(Calendar.WEEK_OF_YEAR) + 1);
+ cal.set(Calendar.DAY_OF_WEEK, ref);
+
+ return new Date(cal.getTimeInMillis());
+ }
+
+ // month and day with slashes
+ else if (type == FormatType.MONTH_AND_DATE_WITH_SLASHES) {
+ Calendar ref = Calendar.getInstance();
+ ref.setTime(new SimpleDateFormat("M/d/y", DEFAULT_LOCALE).parse(String.format("%s/%s/1970", m.group(1), m.group(3))));
+ cal.set(Calendar.MONTH, ref.get(Calendar.MONTH));
+ cal.set(Calendar.DATE, ref.get(Calendar.DATE));
+
+ return new Date(cal.getTimeInMillis());
+ }
+
+ // month and day long-hand
+ else if (type == FormatType.MONTH_AND_DATE) {
+ Calendar ref = Calendar.getInstance();
+ ref.setTime(new SimpleDateFormat("MMM d, y", DEFAULT_LOCALE).parse(String.format("%s %s, 1970", m.group(1), m.group(2))));
+ cal.set(Calendar.MONTH, ref.get(Calendar.MONTH));
+ cal.set(Calendar.DATE, ref.get(Calendar.DATE));
+
+ return new Date(cal.getTimeInMillis());
+ }
+
+ // next X
+ else if (type == FormatType.NEXT) {
+ // Format types MONTH and DAY_OF_WEEK both return future dates, so
+ // no additional processing is needed
+ String expr = m.group(1);
+ ParserResult parsed = StringToTime.getParserResult(expr, now);
+
+ if (parsed != null
+ && (FormatType.MONTH.equals(parsed.type) || FormatType.DAY_OF_WEEK.equals(parsed.type) || FormatType.MONTH_AND_DATE
+ .equals(parsed.type)))
+ return new Date(parsed.timestamp);
+ else {
+ if ("week".equals(expr))
+ cal.set(Calendar.WEEK_OF_YEAR, cal.get(Calendar.WEEK_OF_YEAR) + 1);
+ else if ("month".equals(expr))
+ cal.set(Calendar.MONTH, cal.get(Calendar.MONTH) + 1);
+ else if ("year".equals(expr))
+ cal.set(Calendar.YEAR, cal.get(Calendar.YEAR) + 1);
+ else
+ throw new IllegalArgumentException(String.format("Invalid expression of time: %s", dateTimeString));
+
+ return new Date(cal.getTimeInMillis());
+ }
+ }
+
+ // last X
+ else if (type == FormatType.LAST) {
+ String expr = m.group(1);
+ ParserResult parsed = StringToTime.getParserResult(expr, now);
+
+ if (parsed != null && (FormatType.MONTH.equals(parsed.type) || FormatType.MONTH_AND_DATE.equals(parsed.type))) {
+ return new StringToTime("-1 year", new Date(parsed.timestamp));
+ }
+
+ else if (parsed != null && FormatType.DAY_OF_WEEK.equals(parsed.type)) {
+ return new StringToTime("-1 week", new Date(parsed.timestamp));
+ }
+
+ else {
+ if ("week".equals(expr))
+ cal.set(Calendar.WEEK_OF_YEAR, cal.get(Calendar.WEEK_OF_YEAR) - 1);
+ else if ("month".equals(expr))
+ cal.set(Calendar.MONTH, cal.get(Calendar.MONTH) - 1);
+ else if ("year".equals(expr))
+ cal.set(Calendar.YEAR, cal.get(Calendar.YEAR) - 1);
+ else
+ throw new IllegalArgumentException(String.format("Invalid expression of time: %s", dateTimeString));
+
+ return new Date(cal.getTimeInMillis());
+ }
+ }
+
+ // year
+ else if (type == FormatType.YEAR) {
+ cal.set(Calendar.YEAR, Integer.parseInt(m.group(0)));
+ return new Date(cal.getTimeInMillis());
+ }
+
+ // unimplemented format type
+ else
+ throw new IllegalStateException(String.format("Unimplemented FormatType: %s", type));
+ } catch (ParseException | IllegalStateException | IllegalArgumentException e) {
+ throw e;
+ } catch (Exception e) {
+ throw new RuntimeException(String.format("Unknown failure in string-to-time conversion: %s", e.getMessage()), e);
+ }
+ }
+ }
+ }
+
+ private enum FormatType {
+ COMPOUND, MONTH_AND_DATE_WITH_SLASHES, MONTH_AND_DATE, MONTH, DAY_OF_WEEK, NEXT, LAST, INCREMENT, DECREMENT, WORD, TIME, YEAR
+ }
+
+}
diff --git a/info/bliki/wiki/template/dates/StringToTimeException.java b/info/bliki/wiki/template/dates/StringToTimeException.java
new file mode 100644
index 0000000..ca6a53a
--- /dev/null
+++ b/info/bliki/wiki/template/dates/StringToTimeException.java
@@ -0,0 +1,17 @@
+package info.bliki.wiki.template.dates;
+/*
+code cloned from https://github.com/collegeman/stringtotime/blob/master/src/main/java/com/clutch/dates/StringToTimeException.java
+*/
+public final class StringToTimeException extends RuntimeException {
+
+ private static final long serialVersionUID = -3777846121104246071L;
+
+ public StringToTimeException(Object dateTimeString) {
+ super(String.format("Failed to parse [%s] into a java.util.Date", dateTimeString));
+ }
+
+ public StringToTimeException(Object dateTimeString, Throwable cause) {
+ super(String.format("Failed to parse [%s] into a java.util.Date", dateTimeString), cause);
+ }
+
+}
diff --git a/lib/StringLib.java b/lib/StringLib.java
new file mode 100644
index 0000000..15e3abd
--- /dev/null
+++ b/lib/StringLib.java
@@ -0,0 +1,1225 @@
+/*******************************************************************************
+* 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.lib;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+
+import org.luaj.vm2.Buffer;
+import org.luaj.vm2.LuaClosure;
+import org.luaj.vm2.LuaString;
+import org.luaj.vm2.LuaTable;
+import org.luaj.vm2.LuaValue;
+import org.luaj.vm2.Varargs;
+import org.luaj.vm2.compiler.DumpState;
+
+/**
+ * Subclass of {@link LibFunction} which implements the lua standard {@code string}
+ * library.
+ *
+ * Typically, this library is included as part of a call to either
+ * {@link org.luaj.vm2.lib.jse.JsePlatform#standardGlobals()} or {@link org.luaj.vm2.lib.jme.JmePlatform#standardGlobals()}
+ *
{@code
+ * Globals globals = JsePlatform.standardGlobals();
+ * System.out.println( globals.get("string").get("upper").call( LuaValue.valueOf("abcde") ) );
+ * }
+ *
+ * To instantiate and use it directly,
+ * link it into your globals table via {@link LuaValue#load(LuaValue)} using code such as:
+ *
{@code
+ * Globals globals = new Globals();
+ * globals.load(new JseBaseLib());
+ * globals.load(new PackageLib());
+ * globals.load(new JseStringLib());
+ * System.out.println( globals.get("string").get("upper").call( LuaValue.valueOf("abcde") ) );
+ * }
+ *
+ * This is a direct port of the corresponding library in C.
+ * @see LibFunction
+ * @see org.luaj.vm2.lib.jse.JsePlatform
+ * @see org.luaj.vm2.lib.jme.JmePlatform
+ * @see Lua 5.2 String Lib Reference
+ */
+public class StringLib extends TwoArgFunction {
+
+ /** Construct a StringLib, which can be initialized by calling it with a
+ * modname string, and a global environment table as arguments using
+ * {@link #call(LuaValue, LuaValue)}. */
+ public StringLib() {
+ }
+
+ /** Perform one-time initialization on the library by creating a table
+ * containing the library functions, adding that table to the supplied environment,
+ * adding the table to package.loaded, and returning table as the return value.
+ * Creates a metatable that uses __INDEX to fall back on itself to support string
+ * method operations.
+ * If the shared strings metatable instance is null, will set the metatable as
+ * the global shared metatable for strings.
+ *
+ * All tables and metatables are read-write by default so if this will be used in
+ * a server environment, sandboxing should be used. In particular, the
+ * {@link LuaString#s_metatable} table should probably be made read-only.
+ * @param modname the module name supplied if this is loaded via 'require'.
+ * @param env the environment to load into, typically a Globals instance.
+ */
+ public LuaValue call(LuaValue modname, LuaValue env) {
+ LuaTable string = new LuaTable();
+ string.set("byte", new _byte());
+ string.set("char", new _char());
+ string.set("dump", new dump());
+ string.set("find", new find());
+ string.set("format", new format());
+ string.set("gmatch", new gmatch());
+ string.set("gsub", new gsub());
+ string.set("len", new len());
+ string.set("lower", new lower());
+ string.set("match", new match());
+ string.set("rep", new rep());
+ string.set("reverse", new reverse());
+ string.set("sub", new sub());
+ string.set("upper", new upper());
+
+ env.set("string", string);
+ if (!env.get("package").isnil()) env.get("package").get("loaded").set("string", string);
+ if (LuaString.s_metatable == null) {
+ LuaString.s_metatable = LuaValue.tableOf(new LuaValue[] { INDEX, string });
+ }
+ return string;
+ }
+
+ /**
+ * string.byte (s [, i [, j]])
+ *
+ * Returns the internal numerical codes of the
+ * characters s[i], s[i+1], ..., s[j]. The default value for i is 1; the
+ * default value for j is i.
+ *
+ * Note that numerical codes are not necessarily portable across platforms.
+ *
+ * @param args the calling args
+ */
+ static final class _byte extends VarArgFunction {
+ public Varargs invoke(Varargs args) {
+ LuaString s = args.checkstring(1);
+ int l = s.m_length;
+ int posi = posrelat( args.optint(2,1), l );
+ int pose = posrelat( args.optint(3,posi), l );
+ int n,i;
+ if (posi <= 0) posi = 1;
+ if (pose > l) pose = l;
+ if (posi > pose) return NONE; /* empty interval; return no values */
+ n = (int)(pose - posi + 1);
+ if (posi + n <= pose) /* overflow? */
+ error("string slice too long");
+ LuaValue[] v = new LuaValue[n];
+ for (i=0; i=256) argerror(a, "invalid value for string.char [0; 255]: " + c);
+ bytes[i] = (byte) c;
+ }
+ return LuaString.valueUsing( bytes );
+ }
+ }
+
+ /**
+ * string.dump (function[, stripDebug])
+ *
+ * Returns a string containing a binary representation of the given function,
+ * so that a later loadstring on this string returns a copy of the function.
+ * function must be a Lua function without upvalues.
+ * Boolean param stripDebug - true to strip debugging info, false otherwise.
+ * The default value for stripDebug is true.
+ *
+ * TODO: port dumping code as optional add-on
+ */
+ static final class dump extends VarArgFunction {
+ public Varargs invoke(Varargs args) {
+ LuaValue f = args.checkfunction(1);
+ ByteArrayOutputStream baos = new ByteArrayOutputStream();
+ try {
+ DumpState.dump( ((LuaClosure)f).p, baos, args.optboolean(2, true) );
+ return LuaString.valueUsing(baos.toByteArray());
+ } catch (IOException e) {
+ return error( e.getMessage() );
+ }
+ }
+ }
+
+ /**
+ * string.find (s, pattern [, init [, plain]])
+ *
+ * Looks for the first match of pattern in the string s.
+ * If it finds a match, then find returns the indices of s
+ * where this occurrence starts and ends; otherwise, it returns nil.
+ * A third, optional numerical argument init specifies where to start the search;
+ * its default value is 1 and may be negative. A value of true as a fourth,
+ * optional argument plain turns off the pattern matching facilities,
+ * so the function does a plain "find substring" operation,
+ * with no characters in pattern being considered "magic".
+ * Note that if plain is given, then init must be given as well.
+ *
+ * If the pattern has captures, then in a successful match the captured values
+ * are also returned, after the two indices.
+ */
+ static final class find extends VarArgFunction {
+ public Varargs invoke(Varargs args) {
+ return str_find_aux( args, true );
+ }
+ }
+
+ /**
+ * string.format (formatstring, ...)
+ *
+ * Returns a formatted version of its variable number of arguments following
+ * the description given in its first argument (which must be a string).
+ * The format string follows the same rules as the printf family of standard C functions.
+ * The only differences are that the options/modifiers *, l, L, n, p, and h are not supported
+ * and that there is an extra option, q. The q option formats a string in a form suitable
+ * to be safely read back by the Lua interpreter: the string is written between double quotes,
+ * and all double quotes, newlines, embedded zeros, and backslashes in the string are correctly
+ * escaped when written. For instance, the call
+ * string.format('%q', 'a string with "quotes" and \n new line')
+ *
+ * will produce the string:
+ * "a string with \"quotes\" and \
+ * new line"
+ *
+ * The options c, d, E, e, f, g, G, i, o, u, X, and x all expect a number as argument,
+ * whereas q and s expect a string.
+ *
+ * This function does not accept string values containing embedded zeros,
+ * except as arguments to the q option.
+ */
+ final class format extends VarArgFunction {
+ public Varargs invoke(Varargs args) {
+ LuaString fmt = args.checkstring( 1 );
+ final int n = fmt.length();
+ Buffer result = new Buffer(n);
+ int arg = 1;
+ int c;
+
+ for ( int i = 0; i < n; ) {
+ switch ( c = fmt.luaByte( i++ ) ) {
+ case '\n':
+ result.append( "\n" );
+ break;
+ default:
+ result.append( (byte) c );
+ break;
+ case L_ESC:
+ if ( i < n ) {
+ if ( ( c = fmt.luaByte( i ) ) == L_ESC ) {
+ ++i;
+ result.append( (byte)L_ESC );
+ } else {
+ arg++;
+ FormatDesc fdsc = new FormatDesc(args, fmt, i );
+ i += fdsc.length;
+ switch ( fdsc.conversion ) {
+ case 'c':
+ fdsc.format( result, (byte)args.checkint( arg ) );
+ break;
+ case 'i':
+ case 'd':
+ fdsc.format( result, args.checklong( arg ) );
+ break;
+ case 'o':
+ case 'u':
+ case 'x':
+ case 'X':
+ fdsc.format( result, args.checklong( arg ) );
+ break;
+ case 'e':
+ case 'E':
+ case 'f':
+ case 'g':
+ case 'G':
+ fdsc.format( result, args.checkdouble( arg ) );
+ break;
+ case 'q':
+ addquoted( result, args.checkstring( arg ) );
+ break;
+ case 's': {
+ LuaString s = args.checkstring( arg );
+ if ( fdsc.precision == -1 && s.length() >= 100 ) {
+ result.append( s );
+ } else {
+ fdsc.format( result, s );
+ }
+ } break;
+ default:
+ error("invalid option '%"+(char)fdsc.conversion+"' to 'format'");
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ return result.tostring();
+ }
+ }
+
+ static void addquoted(Buffer buf, LuaString s) {
+ int c;
+ buf.append( (byte) '"' );
+ for ( int i = 0, n = s.length(); i < n; i++ ) {
+ switch ( c = s.luaByte( i ) ) {
+ case '"': case '\\': case '\n':
+ buf.append( (byte)'\\' );
+ buf.append( (byte)c );
+ break;
+ default:
+ if (c <= 0x1F || c == 0x7F) {
+ buf.append( (byte) '\\' );
+ if (i+1 == n || s.luaByte(i+1) < '0' || s.luaByte(i+1) > '9') {
+ buf.append(Integer.toString(c));
+ } else {
+ buf.append( (byte) '0' );
+ buf.append( (byte) (char) ('0' + c / 10) );
+ buf.append( (byte) (char) ('0' + c % 10) );
+ }
+ } else {
+ buf.append((byte) c);
+ }
+ break;
+ }
+ }
+ buf.append( (byte) '"' );
+ }
+
+ private static final String FLAGS = "-+ #0";
+
+ class FormatDesc {
+
+ private boolean leftAdjust;
+ private boolean zeroPad;
+ private boolean explicitPlus;
+ private boolean space;
+ private boolean alternateForm;
+ private static final int MAX_FLAGS = 5;
+
+ private int width;
+ int precision;
+
+ public final int conversion;
+ public final int length;
+
+ public final String src;
+
+ public FormatDesc(Varargs args, LuaString strfrmt, final int start) {
+ int p = start, n = strfrmt.length();
+ int c = 0;
+
+ boolean moreFlags = true;
+ while ( moreFlags ) {
+ switch ( c = ( (p < n) ? strfrmt.luaByte( p++ ) : 0 ) ) {
+ case '-': leftAdjust = true; break;
+ case '+': explicitPlus = true; break;
+ case ' ': space = true; break;
+ case '#': alternateForm = true; break;
+ case '0': zeroPad = true; break;
+ default: moreFlags = false; break;
+ }
+ }
+ if ( p - start > MAX_FLAGS )
+ error("invalid format (repeated flags)");
+
+ width = -1;
+ if ( Character.isDigit( (char)c ) ) {
+ width = c - '0';
+ c = ( (p < n) ? strfrmt.luaByte( p++ ) : 0 );
+ if ( Character.isDigit( (char) c ) ) {
+ width = width * 10 + (c - '0');
+ c = ( (p < n) ? strfrmt.luaByte( p++ ) : 0 );
+ }
+ }
+
+ precision = -1;
+ if ( c == '.' ) {
+ c = ( (p < n) ? strfrmt.luaByte( p++ ) : 0 );
+ if ( Character.isDigit( (char) c ) ) {
+ precision = c - '0';
+ c = ( (p < n) ? strfrmt.luaByte( p++ ) : 0 );
+ if ( Character.isDigit( (char) c ) ) {
+ precision = precision * 10 + (c - '0');
+ c = ( (p < n) ? strfrmt.luaByte( p++ ) : 0 );
+ }
+ }
+ }
+
+ if ( Character.isDigit( (char) c ) )
+ error("invalid format (width or precision too long)");
+
+ zeroPad &= !leftAdjust; // '-' overrides '0'
+ conversion = c;
+ length = p - start;
+ src = strfrmt.substring(start - 1, p).tojstring();
+ }
+
+ public void format(Buffer buf, byte c) {
+ // TODO: not clear that any of width, precision, or flags apply here.
+ buf.append(c);
+ }
+
+ public void format(Buffer buf, long number) {
+ String digits;
+
+ if ( number == 0 && precision == 0 ) {
+ digits = "";
+ } else {
+ int radix;
+ switch ( conversion ) {
+ case 'x':
+ case 'X':
+ radix = 16;
+ break;
+ case 'o':
+ radix = 8;
+ break;
+ default:
+ radix = 10;
+ break;
+ }
+ digits = Long.toString( number, radix );
+ if ( conversion == 'X' )
+ digits = digits.toUpperCase();
+ }
+
+ int minwidth = digits.length();
+ int ndigits = minwidth;
+ int nzeros;
+
+ if ( number < 0 ) {
+ ndigits--;
+ } else if ( explicitPlus || space ) {
+ minwidth++;
+ }
+
+ if ( precision > ndigits )
+ nzeros = precision - ndigits;
+ else if ( precision == -1 && zeroPad && width > minwidth )
+ nzeros = width - minwidth;
+ else
+ nzeros = 0;
+
+ minwidth += nzeros;
+ int nspaces = width > minwidth ? width - minwidth : 0;
+
+ if ( !leftAdjust )
+ pad( buf, ' ', nspaces );
+
+ if ( number < 0 ) {
+ if ( nzeros > 0 ) {
+ buf.append( (byte)'-' );
+ digits = digits.substring( 1 );
+ }
+ } else if ( explicitPlus ) {
+ buf.append( (byte)'+' );
+ } else if ( space ) {
+ buf.append( (byte)' ' );
+ }
+
+ if ( nzeros > 0 )
+ pad( buf, '0', nzeros );
+
+ buf.append( digits );
+
+ if ( leftAdjust )
+ pad( buf, ' ', nspaces );
+ }
+
+ public void format(Buffer buf, double x) {
+ buf.append( StringLib.this.format(src, x) );
+ }
+
+ public void format(Buffer buf, LuaString s) {
+ int nullindex = s.indexOf( (byte)'\0', 0 );
+ if ( nullindex != -1 )
+ s = s.substring( 0, nullindex );
+ buf.append(s);
+ }
+
+ public final void pad(Buffer buf, char c, int n) {
+ byte b = (byte)c;
+ while ( n-- > 0 )
+ buf.append(b);
+ }
+ }
+
+ protected String format(String src, double x) {
+ return String.valueOf(x);
+ }
+
+ /**
+ * string.gmatch (s, pattern)
+ *
+ * Returns an iterator function that, each time it is called, returns the next captures
+ * from pattern over string s. If pattern specifies no captures, then the
+ * whole match is produced in each call.
+ *
+ * As an example, the following loop
+ * s = "hello world from Lua"
+ * for w in string.gmatch(s, "%a+") do
+ * print(w)
+ * end
+ *
+ * will iterate over all the words from string s, printing one per line.
+ * The next example collects all pairs key=value from the given string into a table:
+ * t = {}
+ * s = "from=world, to=Lua"
+ * for k, v in string.gmatch(s, "(%w+)=(%w+)") do
+ * t[k] = v
+ * end
+ *
+ * For this function, a '^' at the start of a pattern does not work as an anchor,
+ * as this would prevent the iteration.
+ */
+ static final class gmatch extends VarArgFunction {
+ public Varargs invoke(Varargs args) {
+ LuaString src = args.checkstring( 1 );
+ LuaString pat = args.checkstring( 2 );
+ return new GMatchAux(args, src, pat);
+ }
+ }
+
+ static class GMatchAux extends VarArgFunction {
+ private final int srclen;
+ private final MatchState ms;
+ private int soffset;
+ private int lastmatch;
+ public GMatchAux(Varargs args, LuaString src, LuaString pat) {
+ this.srclen = src.length();
+ this.ms = new MatchState(args, src, pat);
+ this.soffset = 0;
+ this.lastmatch = -1;
+ }
+ public Varargs invoke(Varargs args) {
+ for ( ; soffset<=srclen; soffset++ ) {
+ ms.reset();
+ int res = ms.match(soffset, 0);
+ if ( res >=0 && res != lastmatch ) {
+ int soff = soffset;
+ lastmatch = soffset = res;
+ return ms.push_captures( true, soff, res );
+ }
+ }
+ return NIL;
+ }
+ }
+
+
+ /**
+ * string.gsub (s, pattern, repl [, n])
+ * Returns a copy of s in which all (or the first n, if given) occurrences of the
+ * pattern have been replaced by a replacement string specified by repl, which
+ * may be a string, a table, or a function. gsub also returns, as its second value,
+ * the total number of matches that occurred.
+ *
+ * If repl is a string, then its value is used for replacement.
+ * The character % works as an escape character: any sequence in repl of the form %n,
+ * with n between 1 and 9, stands for the value of the n-th captured substring (see below).
+ * The sequence %0 stands for the whole match. The sequence %% stands for a single %.
+ *
+ * If repl is a table, then the table is queried for every match, using the first capture
+ * as the key; if the pattern specifies no captures, then the whole match is used as the key.
+ *
+ * If repl is a function, then this function is called every time a match occurs,
+ * with all captured substrings passed as arguments, in order; if the pattern specifies
+ * no captures, then the whole match is passed as a sole argument.
+ *
+ * If the value returned by the table query or by the function call is a string or a number,
+ * then it is used as the replacement string; otherwise, if it is false or nil,
+ * then there is no replacement (that is, the original match is kept in the string).
+ *
+ * Here are some examples:
+ * x = string.gsub("hello world", "(%w+)", "%1 %1")
+ * --> x="hello hello world world"
+ *
+ * x = string.gsub("hello world", "%w+", "%0 %0", 1)
+ * --> x="hello hello world"
+ *
+ * x = string.gsub("hello world from Lua", "(%w+)%s*(%w+)", "%2 %1")
+ * --> x="world hello Lua from"
+ *
+ * x = string.gsub("home = $HOME, user = $USER", "%$(%w+)", os.getenv)
+ * --> x="home = /home/roberto, user = roberto"
+ *
+ * x = string.gsub("4+5 = $return 4+5$", "%$(.-)%$", function (s)
+ * return loadstring(s)()
+ * end)
+ * --> x="4+5 = 9"
+ *
+ * local t = {name="lua", version="5.1"}
+ * x = string.gsub("$name-$version.tar.gz", "%$(%w+)", t)
+ * --> x="lua-5.1.tar.gz"
+ */
+ static final class gsub extends VarArgFunction {
+ public Varargs invoke(Varargs args) {
+ LuaString src = args.checkstring( 1 );
+ final int srclen = src.length();
+ LuaString p = args.checkstring( 2 );
+ int lastmatch = -1; /* end of last match */
+ LuaValue repl = args.arg( 3 );
+ int max_s = args.optint( 4, srclen + 1 );
+ final boolean anchor = p.length() > 0 && p.charAt( 0 ) == '^';
+
+ Buffer lbuf = new Buffer( srclen );
+ MatchState ms = new MatchState( args, src, p );
+
+ int soffset = 0;
+ int n = 0;
+ while ( n < max_s ) {
+ ms.reset();
+ int res = ms.match( soffset, anchor ? 1 : 0 );
+ if ( res != -1 && res != lastmatch ) { /* match? */
+ n++;
+ ms.add_value( lbuf, soffset, res, repl ); /* add replacement to buffer */
+ soffset = lastmatch = res;
+ }
+ else if ( soffset < srclen ) /* otherwise, skip one character */
+ lbuf.append( (byte) src.luaByte( soffset++ ) );
+ else break; /* end of subject */
+ if ( anchor ) break;
+ }
+ lbuf.append( src.substring( soffset, srclen ) );
+ return varargsOf(lbuf.tostring(), valueOf(n));
+ }
+ }
+
+ /**
+ * string.len (s)
+ *
+ * Receives a string and returns its length. The empty string "" has length 0.
+ * Embedded zeros are counted, so "a\000bc\000" has length 5.
+ */
+ static final class len extends OneArgFunction {
+ public LuaValue call(LuaValue arg) {
+ return arg.checkstring().len();
+ }
+ }
+
+ /**
+ * string.lower (s)
+ *
+ * Receives a string and returns a copy of this string with all uppercase letters
+ * changed to lowercase. All other characters are left unchanged.
+ * The definition of what an uppercase letter is depends on the current locale.
+ */
+ static final class lower extends OneArgFunction {
+ public LuaValue call(LuaValue arg) {
+ return valueOf( arg.checkjstring().toLowerCase() );
+ }
+ }
+
+ /**
+ * string.match (s, pattern [, init])
+ *
+ * Looks for the first match of pattern in the string s. If it finds one,
+ * then match returns the captures from the pattern; otherwise it returns
+ * nil. If pattern specifies no captures, then the whole match is returned.
+ * A third, optional numerical argument init specifies where to start the
+ * search; its default value is 1 and may be negative.
+ */
+ static final class match extends VarArgFunction {
+ public Varargs invoke(Varargs args) {
+ return str_find_aux( args, false );
+ }
+ }
+
+ /**
+ * string.rep (s, n)
+ *
+ * Returns a string that is the concatenation of n copies of the string s.
+ */
+ static final class rep extends VarArgFunction {
+ public Varargs invoke(Varargs args) {
+ LuaString s = args.checkstring( 1 );
+ int n = args.checkint( 2 );
+ final byte[] bytes = new byte[ s.length() * n ];
+ int len = s.length();
+ for ( int offset = 0; offset < bytes.length; offset += len ) {
+ s.copyInto( 0, bytes, offset, len );
+ }
+ return LuaString.valueUsing( bytes );
+ }
+ }
+
+ /**
+ * string.reverse (s)
+ *
+ * Returns a string that is the string s reversed.
+ */
+ static final class reverse extends OneArgFunction {
+ public LuaValue call(LuaValue arg) {
+ LuaString s = arg.checkstring();
+ int n = s.length();
+ byte[] b = new byte[n];
+ for ( int i=0, j=n-1; i l )
+ end = l;
+
+ if ( start <= end ) {
+ return s.substring( start-1 , end );
+ } else {
+ return EMPTYSTRING;
+ }
+ }
+ }
+
+ /**
+ * string.upper (s)
+ *
+ * Receives a string and returns a copy of this string with all lowercase letters
+ * changed to uppercase. All other characters are left unchanged.
+ * The definition of what a lowercase letter is depends on the current locale.
+ */
+ static final class upper extends OneArgFunction {
+ public LuaValue call(LuaValue arg) {
+ return valueOf(arg.checkjstring().toUpperCase());
+ }
+ }
+
+ /**
+ * This utility method implements both string.find and string.match.
+ */
+ static Varargs str_find_aux( Varargs args, boolean find ) {
+ LuaString s = args.checkstring( 1 );
+ LuaString pat = args.checkstring( 2 );
+ int init = args.optint( 3, 1 );
+
+ if ( init > 0 ) {
+ init = Math.min( init - 1, s.length() );
+ } else if ( init < 0 ) {
+ init = Math.max( 0, s.length() + init );
+ }
+
+ boolean fastMatch = find && ( args.arg(4).toboolean() || pat.indexOfAny( SPECIALS ) == -1 );
+
+ if ( fastMatch ) {
+ int result = s.indexOf( pat, init );
+ if ( result != -1 ) {
+ return varargsOf( valueOf(result+1), valueOf(result+pat.length()) );
+ }
+ } else {
+ MatchState ms = new MatchState( args, s, pat );
+
+ boolean anchor = false;
+ int poff = 0;
+ if ( pat.length() > 0 && pat.luaByte( 0 ) == '^' ) {
+ anchor = true;
+ poff = 1;
+ }
+
+ int soff = init;
+ do {
+ int res;
+ ms.reset();
+ if ( ( res = ms.match( soff, poff ) ) != -1 ) {
+ if ( find ) {
+ return varargsOf( valueOf(soff+1), valueOf(res), ms.push_captures( false, soff, res ));
+ } else {
+ return ms.push_captures( true, soff, res );
+ }
+ }
+ } while ( soff++ < s.length() && !anchor );
+ }
+ return NIL;
+ }
+
+ static int posrelat( int pos, int len ) {
+ return ( pos >= 0 ) ? pos : len + pos + 1;
+ }
+
+ // Pattern matching implementation
+
+ private static final int L_ESC = '%';
+ private static final LuaString SPECIALS = valueOf("^$*+?.([%-");
+ private static final int MAX_CAPTURES = 32;
+
+ private static final int MAXCCALLS = 200;
+
+ private static final int CAP_UNFINISHED = -1;
+ private static final int CAP_POSITION = -2;
+
+ private static final byte MASK_ALPHA = 0x01;
+ private static final byte MASK_LOWERCASE = 0x02;
+ private static final byte MASK_UPPERCASE = 0x04;
+ private static final byte MASK_DIGIT = 0x08;
+ private static final byte MASK_PUNCT = 0x10;
+ private static final byte MASK_SPACE = 0x20;
+ private static final byte MASK_CONTROL = 0x40;
+ private static final byte MASK_HEXDIGIT = (byte)0x80;
+
+ static final byte[] CHAR_TABLE;
+
+ static {
+ CHAR_TABLE = new byte[256];
+
+ for ( int i = 0; i < 128; ++i ) {
+ final char c = (char) i;
+ CHAR_TABLE[i] = (byte)( ( Character.isDigit( c ) ? MASK_DIGIT : 0 ) |
+ ( Character.isLowerCase( c ) ? MASK_LOWERCASE : 0 ) |
+ ( Character.isUpperCase( c ) ? MASK_UPPERCASE : 0 ) |
+ ( ( c < ' ' || c == 0x7F ) ? MASK_CONTROL : 0 ) );
+ if ( ( c >= 'a' && c <= 'f' ) || ( c >= 'A' && c <= 'F' ) || ( c >= '0' && c <= '9' ) ) {
+ CHAR_TABLE[i] |= MASK_HEXDIGIT;
+ }
+ if ( ( c >= '!' && c <= '/' ) || ( c >= ':' && c <= '@' ) || ( c >= '[' && c <= '`' ) || ( c >= '{' && c <= '~' ) ) {
+ CHAR_TABLE[i] |= MASK_PUNCT;
+ }
+ if ( ( CHAR_TABLE[i] & ( MASK_LOWERCASE | MASK_UPPERCASE ) ) != 0 ) {
+ CHAR_TABLE[i] |= MASK_ALPHA;
+ }
+ }
+
+ CHAR_TABLE[' '] = MASK_SPACE;
+ CHAR_TABLE['\r'] |= MASK_SPACE;
+ CHAR_TABLE['\n'] |= MASK_SPACE;
+ CHAR_TABLE['\t'] |= MASK_SPACE;
+ CHAR_TABLE[0x0B /* '\v' */ ] |= MASK_SPACE;
+ CHAR_TABLE['\f'] |= MASK_SPACE;
+ };
+
+ static class MatchState {
+ int matchdepth; /* control for recursive depth (to avoid C stack overflow) */
+ final LuaString s;
+ final LuaString p;
+ final Varargs args;
+ int level;
+ int[] cinit;
+ int[] clen;
+
+ MatchState( Varargs args, LuaString s, LuaString pattern ) {
+ this.s = s;
+ this.p = pattern;
+ this.args = args;
+ this.level = 0;
+ this.cinit = new int[ MAX_CAPTURES ];
+ this.clen = new int[ MAX_CAPTURES ];
+ this.matchdepth = MAXCCALLS;
+ }
+
+ void reset() {
+ level = 0;
+ this.matchdepth = MAXCCALLS;
+ }
+
+ private void add_s( Buffer lbuf, LuaString news, int soff, int e ) {
+ int l = news.length();
+ for ( int i = 0; i < l; ++i ) {
+ byte b = (byte) news.luaByte( i );
+ if ( b != L_ESC ) {
+ lbuf.append( (byte) b );
+ } else {
+ ++i; // skip ESC
+ b = (byte)(i < l ? news.luaByte( i ) : 0);
+ if ( !Character.isDigit( (char) b ) ) {
+/* disabled: incompatible with wiki, it may raise error "invalid use of '%' in replacement string: after '%' must be '0'-'9' or '%'"
+ if (b != L_ESC) error( "invalid use of '" + (char)L_ESC +
+ "' in replacement string: after '" + (char)L_ESC +
+ "' must be '0'-'9' or '" + (char)L_ESC +
+ "', but found " + (i < l ? "symbol '" + (char)b + "' with code " + b +
+ " at pos " + (i + 1) :
+ "end of string"));
+*/
+ lbuf.append( b );
+ } else if ( b == '0' ) {
+ lbuf.append( s.substring( soff, e ) );
+ } else {
+ lbuf.append( push_onecapture( b - '1', soff, e ).strvalue() );
+ }
+ }
+ }
+ }
+
+ public void add_value( Buffer lbuf, int soffset, int end, LuaValue repl ) {
+ switch ( repl.type() ) {
+ case LuaValue.TSTRING:
+ case LuaValue.TNUMBER:
+ add_s( lbuf, repl.strvalue(), soffset, end );
+ return;
+
+ case LuaValue.TFUNCTION:
+ repl = repl.invoke( push_captures( true, soffset, end ) ).arg1();
+ break;
+
+ case LuaValue.TTABLE:
+ // Need to call push_onecapture here for the error checking
+ repl = repl.get( push_onecapture( 0, soffset, end ) );
+ break;
+
+ default:
+ error( "bad argument: string/function/table expected" );
+ return;
+ }
+
+ if ( !repl.toboolean() ) {
+ repl = s.substring( soffset, end );
+ } else if ( ! repl.isstring() ) {
+ error( "invalid replacement value (a "+repl.typename()+")" );
+ }
+ lbuf.append( repl.strvalue() );
+ }
+
+ Varargs push_captures( boolean wholeMatch, int soff, int end ) {
+ int nlevels = ( this.level == 0 && wholeMatch ) ? 1 : this.level;
+ switch ( nlevels ) {
+ case 0: return NONE;
+ case 1: return push_onecapture( 0, soff, end );
+ }
+ LuaValue[] v = new LuaValue[nlevels];
+ for ( int i = 0; i < nlevels; ++i )
+ v[i] = push_onecapture( i, soff, end );
+ return varargsOf(v);
+ }
+
+ private LuaValue push_onecapture( int i, int soff, int end ) {
+ if ( i >= this.level ) {
+ if ( i == 0 ) {
+ return s.substring( soff, end );
+ } else {
+ return error( "invalid capture index %" + (i + 1) );
+ }
+ } else {
+ int l = clen[i];
+ if ( l == CAP_UNFINISHED ) {
+ return error( "unfinished capture" );
+ }
+ if ( l == CAP_POSITION ) {
+ return valueOf( cinit[i] + 1 );
+ } else {
+ int begin = cinit[i];
+ return s.substring( begin, begin + l );
+ }
+ }
+ }
+
+ private int check_capture( int l ) {
+ l -= '1';
+ if ( l < 0 || l >= level || this.clen[l] == CAP_UNFINISHED ) {
+ error("invalid capture index %" + (l + 1));
+ }
+ return l;
+ }
+
+ private int capture_to_close() {
+ int level = this.level;
+ for ( level--; level >= 0; level-- )
+ if ( clen[level] == CAP_UNFINISHED )
+ return level;
+ error("invalid pattern capture");
+ return 0;
+ }
+
+ int classend( int poffset ) {
+ switch ( p.luaByte( poffset++ ) ) {
+ case L_ESC:
+ if ( poffset == p.length() ) {
+ error( "malformed pattern (ends with '%')" );
+ }
+ return poffset + 1;
+
+ case '[':
+ if ( poffset != p.length() && p.luaByte( poffset ) == '^' ) poffset++;
+ do {
+ if ( poffset == p.length() ) {
+ error( "malformed pattern (missing ']')" );
+ }
+ if ( p.luaByte( poffset++ ) == L_ESC && poffset < p.length() )
+ poffset++; /* skip escapes (e.g. '%]') */
+ } while ( poffset == p.length() || p.luaByte( poffset ) != ']' );
+ return poffset + 1;
+ default:
+ return poffset;
+ }
+ }
+
+ static boolean match_class( int c, int cl ) {
+ final char lcl = Character.toLowerCase( (char) cl );
+ int cdata = CHAR_TABLE[c];
+
+ boolean res;
+ switch ( lcl ) {
+ case 'a': res = ( cdata & MASK_ALPHA ) != 0; break;
+ case 'd': res = ( cdata & MASK_DIGIT ) != 0; break;
+ case 'l': res = ( cdata & MASK_LOWERCASE ) != 0; break;
+ case 'u': res = ( cdata & MASK_UPPERCASE ) != 0; break;
+ case 'c': res = ( cdata & MASK_CONTROL ) != 0; break;
+ case 'p': res = ( cdata & MASK_PUNCT ) != 0; break;
+ case 's': res = ( cdata & MASK_SPACE ) != 0; break;
+ case 'g': res = ( cdata & ( MASK_ALPHA | MASK_DIGIT | MASK_PUNCT ) ) != 0; break;
+ case 'w': res = ( cdata & ( MASK_ALPHA | MASK_DIGIT ) ) != 0; break;
+ case 'x': res = ( cdata & MASK_HEXDIGIT ) != 0; break;
+ case 'z': res = ( c == 0 ); break; /* deprecated option */
+ default: return cl == c;
+ }
+ return ( lcl == cl ) ? res : !res;
+ }
+
+ boolean matchbracketclass( int c, int poff, int ec ) {
+ boolean sig = true;
+ if ( p.luaByte( poff + 1 ) == '^' ) {
+ sig = false;
+ poff++;
+ }
+ while ( ++poff < ec ) {
+ if ( p.luaByte( poff ) == L_ESC ) {
+ poff++;
+ if ( match_class( c, p.luaByte( poff ) ) )
+ return sig;
+ }
+ else if ( ( p.luaByte( poff + 1 ) == '-' ) && ( poff + 2 < ec ) ) {
+ poff += 2;
+ if ( p.luaByte( poff - 2 ) <= c && c <= p.luaByte( poff ) )
+ return sig;
+ }
+ else if ( p.luaByte( poff ) == c ) return sig;
+ }
+ return !sig;
+ }
+
+ boolean singlematch( int c, int poff, int ep ) {
+ switch ( p.luaByte( poff ) ) {
+ case '.': return true;
+ case L_ESC: return match_class( c, p.luaByte( poff + 1 ) );
+ case '[': return matchbracketclass( c, poff, ep - 1 );
+ default: return p.luaByte( poff ) == c;
+ }
+ }
+
+ /**
+ * Perform pattern matching. If there is a match, returns offset into s
+ * where match ends, otherwise returns -1.
+ */
+ int match( int soffset, int poffset ) {
+ if (matchdepth-- == 0) error("pattern too complex");
+ try {
+ while ( true ) {
+ // Check if we are at the end of the pattern -
+ // equivalent to the '\0' case in the C version, but our pattern
+ // string is not NUL-terminated.
+ if ( poffset == p.length() )
+ return soffset;
+ switch ( p.luaByte( poffset ) ) {
+ case '(':
+ if ( ++poffset < p.length() && p.luaByte( poffset ) == ')' )
+ return start_capture( soffset, poffset + 1, CAP_POSITION );
+ else
+ return start_capture( soffset, poffset, CAP_UNFINISHED );
+ case ')':
+ return end_capture( soffset, poffset + 1 );
+ case L_ESC:
+ if ( poffset + 1 == p.length() )
+ error("malformed pattern (ends with '%')");
+ switch ( p.luaByte( poffset + 1 ) ) {
+ case 'b':
+ soffset = matchbalance( soffset, poffset + 2 );
+ if ( soffset == -1 ) return -1;
+ poffset += 4;
+ continue;
+ case 'f': {
+ poffset += 2;
+ if ( poffset == p.length() || p.luaByte( poffset ) != '[' ) {
+ error("missing '[' after '%f' in pattern");
+ }
+ int ep = classend( poffset );
+ int previous = ( soffset == 0 ) ? '\0' : s.luaByte( soffset - 1 );
+ int next = ( soffset == s.length() ) ? '\0' : s.luaByte( soffset );
+ if ( matchbracketclass( previous, poffset, ep - 1 ) ||
+ !matchbracketclass( next, poffset, ep - 1 ) )
+ return -1;
+ poffset = ep;
+ continue;
+ }
+ default: {
+ int c = p.luaByte( poffset + 1 );
+ if ( Character.isDigit( (char) c ) ) {
+ soffset = match_capture( soffset, c );
+ if ( soffset == -1 )
+ return -1;
+ return match( soffset, poffset + 2 );
+ }
+ }
+ }
+ case '$':
+ if ( poffset + 1 == p.length() )
+ return ( soffset == s.length() ) ? soffset : -1;
+ }
+ int ep = classend( poffset );
+ boolean m = soffset < s.length() && singlematch( s.luaByte( soffset ), poffset, ep );
+ int pc = ( ep < p.length() ) ? p.luaByte( ep ) : '\0';
+
+ switch ( pc ) {
+ case '?':
+ int res;
+ if ( m && ( ( res = match( soffset + 1, ep + 1 ) ) != -1 ) )
+ return res;
+ poffset = ep + 1;
+ continue;
+ case '*':
+ return max_expand( soffset, poffset, ep );
+ case '+':
+ return ( m ? max_expand( soffset + 1, poffset, ep ) : -1 );
+ case '-':
+ return min_expand( soffset, poffset, ep );
+ default:
+ if ( !m )
+ return -1;
+ soffset++;
+ poffset = ep;
+ continue;
+ }
+ }
+ } finally {
+ matchdepth++;
+ }
+ }
+
+ int max_expand( int soff, int poff, int ep ) {
+ int i = 0;
+ while ( soff + i < s.length() &&
+ singlematch( s.luaByte( soff + i ), poff, ep ) )
+ i++;
+ while ( i >= 0 ) {
+ int res = match( soff + i, ep + 1 );
+ if ( res != -1 )
+ return res;
+ i--;
+ }
+ return -1;
+ }
+
+ int min_expand( int soff, int poff, int ep ) {
+ for ( ;; ) {
+ int res = match( soff, ep + 1 );
+ if ( res != -1 )
+ return res;
+ else if ( soff < s.length() && singlematch( s.luaByte( soff ), poff, ep ) )
+ soff++;
+ else return -1;
+ }
+ }
+
+ int start_capture( int soff, int poff, int what ) {
+ int res;
+ int level = this.level;
+ if ( level >= MAX_CAPTURES ) {
+ error( "too many captures" );
+ }
+ cinit[ level ] = soff;
+ clen[ level ] = what;
+ this.level = level + 1;
+ if ( ( res = match( soff, poff ) ) == -1 )
+ this.level--;
+ return res;
+ }
+
+ int end_capture( int soff, int poff ) {
+ int l = capture_to_close();
+ int res;
+ clen[l] = soff - cinit[l];
+ if ( ( res = match( soff, poff ) ) == -1 )
+ clen[l] = CAP_UNFINISHED;
+ return res;
+ }
+
+ int match_capture( int soff, int l ) {
+ l = check_capture( l );
+ int len = clen[ l ];
+ if ( ( s.length() - soff ) >= len &&
+ LuaString.equals( s, cinit[l], s, soff, len ) )
+ return soff + len;
+ else
+ return -1;
+ }
+
+ int matchbalance( int soff, int poff ) {
+ final int plen = p.length();
+ if ( poff == plen || poff + 1 == plen ) {
+ error( "malformed pattern (missing arguments to '%b')" );
+ }
+ final int slen = s.length();
+ if ( soff >= slen )
+ return -1;
+ final int b = p.luaByte( poff );
+ if ( s.luaByte( soff ) != b )
+ return -1;
+ final int e = p.luaByte( poff + 1 );
+ int cont = 1;
+ while ( ++soff < slen ) {
+ if ( s.luaByte( soff ) == e ) {
+ if ( --cont == 0 ) return soff + 1;
+ }
+ else if ( s.luaByte( soff ) == b ) cont++;
+ }
+ return -1;
+ }
+ }
+}
diff --git a/lib/luaj-jse-3.0.2p.jar b/lib/luaj-jse-3.0.2p.jar
new file mode 100644
index 0000000000000000000000000000000000000000..ce5746cf49d66ed12bebbeedd19fb6164d9b0d92
GIT binary patch
literal 472927
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