• Home
• com.jukusoft
• rembulan-stdlib
• 1.0.2
• source code
• DefaultStringLib.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

net.sandius.rembulan.lib.impl.DefaultStringLib Maven / Gradle / Ivy

/*
 * Copyright 2016 Miroslav Janíček
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package net.sandius.rembulan.lib.impl;

import net.sandius.rembulan.ByteString;
import net.sandius.rembulan.ByteStringBuilder;
import net.sandius.rembulan.Conversions;
import net.sandius.rembulan.LuaFormat;
import net.sandius.rembulan.LuaRuntimeException;
import net.sandius.rembulan.Metatables;
import net.sandius.rembulan.PlainValueTypeNamer;
import net.sandius.rembulan.Table;
import net.sandius.rembulan.impl.NonsuspendableFunctionException;
import net.sandius.rembulan.impl.UnimplementedFunction;
import net.sandius.rembulan.lib.BadArgumentException;
import net.sandius.rembulan.lib.BasicLib;
import net.sandius.rembulan.lib.StringLib;
import net.sandius.rembulan.runtime.AbstractFunction0;
import net.sandius.rembulan.runtime.Dispatch;
import net.sandius.rembulan.runtime.ExecutionContext;
import net.sandius.rembulan.runtime.IllegalOperationAttemptException;
import net.sandius.rembulan.runtime.LuaFunction;
import net.sandius.rembulan.runtime.ResolvedControlThrowable;
import net.sandius.rembulan.runtime.UnresolvedControlThrowable;
import net.sandius.rembulan.util.ByteIterator;
import net.sandius.rembulan.util.Check;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

public class DefaultStringLib extends StringLib {

	private final LuaFunction _pack;
	private final LuaFunction _packsize;
	private final LuaFunction _unpack;

	public DefaultStringLib() {
		this._pack = new UnimplementedFunction("string.pack");  // TODO
		this._packsize = new UnimplementedFunction("string.packsize");  // TODO
		this._unpack = new UnimplementedFunction("string.unpack");  // TODO
	}

	@Override
	public LuaFunction _byte() {
		return Byte.INSTANCE;
	}

	@Override
	public LuaFunction _char() {
		return Char.INSTANCE;
	}

	@Override
	public LuaFunction _dump() {
		return Dump.INSTANCE;
	}

	@Override
	public LuaFunction _find() {
		return Find.INSTANCE;
	}

	@Override
	public LuaFunction _format() {
		return Format.INSTANCE;
	}

	@Override
	public LuaFunction _gmatch() {
		return GMatch.INSTANCE;
	}

	@Override
	public LuaFunction _gsub() {
		return GSub.INSTANCE;
	}

	@Override
	public LuaFunction _len() {
		return Len.INSTANCE;
	}

	@Override
	public LuaFunction _lower() {
		return Lower.INSTANCE;
	}

	@Override
	public LuaFunction _match() {
		return Match.INSTANCE;
	}

	@Override
	public LuaFunction _pack() {
		return _pack;
	}

	@Override
	public LuaFunction _packsize() {
		return _packsize;
	}

	@Override
	public LuaFunction _rep() {
		return Rep.INSTANCE;
	}

	@Override
	public LuaFunction _reverse() {
		return Reverse.INSTANCE;
	}

	@Override
	public LuaFunction _sub() {
		return Sub.INSTANCE;
	}

	@Override
	public LuaFunction _unpack() {
		return _unpack;
	}

	@Override
	public LuaFunction _upper() {
		return Upper.INSTANCE;
	}

	private static int lowerBound(int i, int len) {
		int j = i < 0 ? len + i + 1 : i;
		return Math.max(1, j);
	}

	private static int upperBound(int i, int len) {
		int j = i < 0 ? len + i + 1 : i;
		return Math.max(0, Math.min(len, j));
	}

	private static byte toLower(byte b) {
		int c = b & 0xff;
		// FIXME: dealing with ASCII only
		return c >= 'A' && c <= 'Z' ? (byte) (c - (int) 'A' + (int) 'a') : b;
	}

	private static ByteString toLowerCase(ByteString s) {
		boolean changed = false;

		ByteStringBuilder bld = new ByteStringBuilder();
		ByteIterator it = s.byteIterator();
		while (it.hasNext()) {
			byte b = it.nextByte();
			byte c = toLower(b);
			changed |= b != c;
			bld.append(c);
		}

		return changed ? bld.toByteString() : s;
	}

	private static byte toUpper(byte b) {
		int c = b & 0xff;
		// FIXME: dealing with ASCII only
		return c >= 'a' && c <= 'z' ? (byte) (c - (int) 'a' + (int) 'A') : b;
	}

	private static ByteString toUpperCase(ByteString s) {
		boolean changed = false;

		ByteStringBuilder bld = new ByteStringBuilder();
		ByteIterator it = s.byteIterator();
		while (it.hasNext()) {
			byte b = it.nextByte();
			byte c = toUpper(b);
			changed |= b != c;
			bld.append(c);
		}

		return changed ? bld.toByteString() : s;
	}

	public static class Byte extends AbstractLibFunction {

		public static final Byte INSTANCE = new Byte();

		@Override
		protected String name() {
			return "byte";
		}

		@Override
		protected void invoke(ExecutionContext context, ArgumentIterator args) throws ResolvedControlThrowable {
			ByteString s = args.nextString();
			int i = args.optNextInt(1);
			int j = args.optNextInt(i);

			int len = s.length();

			i = lowerBound(i, len);
			j = upperBound(j, len);

			List