/**
* This file is part of Erjang - A JVM-based Erlang VM
*
* Copyright (c) 2009 by Trifork
*
* 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 erjang;
import java.nio.ByteBuffer;
import java.io.IOException;
import java.util.List;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.Type;
/**
* Special cons cell optimizing for [byte, byte, byte | Tail].
* An <code>EBinList</code> has a tail, and an array of bytes for the
* values it contains. It is optimized for the case of cons'ing a
* byte onto it; it works like a java StringBuilder, but its contents
* array grows backwards; so the bytes contained in it are stored in
* the last bytes of the <code>data</code> array variable.
*/
public class EBinList extends ECons {
/**
*
*/
private static final int INITIAL_BUFFER_SIZE = 10;
final byte[] data;
final int off;
final int len;
final EObject tail;
// synchronized access
/** True if <code>data</code> is shared by other instances of EBinList.
* In that case, we need to copy the data array if we need to grow. */
private boolean shared;
/** create list as sublist of data given */
private EBinList(byte[] data, int off, int len, EObject tail, boolean shared) {
assert len != 0;
this.data = data;
this.off = off;
this.len = len;
this.tail = tail;
this.shared = shared;
assert(tail!=null);
if (len < 1 || off + len > data.length)
throw ERT.badarg();
}
@Override
public int hashCode() {
ESeq seq;
if ((seq=testSeq()) != null) return seq.hashCode();
//TODO: use phash() rather than this brittle nonsense:
int h = 0;
for (int i=off; i<off+len; i++) {
h = 31*h + data[i];
}
return h + tail.hashCode();
}
/** create a list with [value|tail], where value is a smallint 0..255 */
public EBinList(byte value, EObject tail) {
this.data = new byte[INITIAL_BUFFER_SIZE];
this.off = INITIAL_BUFFER_SIZE-1;
this.len = 1;
this.tail = tail;
this.shared = false;
data[off] = value;
}
public ECons testNonEmptyList() {
if (len == 0)
return tail.testNonEmptyList();
return this;
}
public ESeq testSeq() {
if (tail.testSeq() != null) {
return this.seq();
} else {
return null;
}
}
/**
* @param header
* @param tail
*/
public EBinList(byte[] header, EObject tail) {
this(header, 0, header.length, tail, true);
}
/**
* @param header
* @param tail2
*/
public EBinList(ByteBuffer buf, EObject tail) {
this(buf.array(), buf.arrayOffset()+buf.position(), buf.remaining(), tail, true);
}
@Override
public ECons cons(EObject h) {
ESmall sm;
ESeq seqTail;
if ((sm = h.testSmall()) != null && sm.value >= 0 && sm.value < 256) {
byte[] res_data = data;
int res_off = off;
int res_len = len + 1;
synchronized (this) {
if (shared || off == 0) {
res_data = new byte[len * 2 + 1];
System.arraycopy(data, off, res_data, len + 1, len);
res_off = len + 1;
} else {
shared = true;
}
}
res_data[--res_off] = (byte) sm.value;
return new EBinList(res_data, res_off, res_len, tail, res_data==data);
} else if ((seqTail=this.testSeq()) != null) {
return new EList(h, seqTail);
} else {
return new EPair(h, this);
}
}
public EObject drop(int n) {
if (n > len) throw new IllegalArgumentException();
if (n == len) return tail;
synchronized (this) {
shared = true;
}
return new EBinList(data, off+n, len-n, tail, true);
}
@Override
public ESmall head() {
return ESmall.little[(data[off] & 0xff)];
}
@Override
public EObject tail() {
if (len == 1)
return tail;
return new EBinList(data, off + 1, len - 1, tail, true);
}
// TODO: Remote this method all together
@Override
public boolean isNil() {
assert len != 0;
return false;
}
@Override
public ENil testNil() {
if (isNil())
return ERT.NIL;
return null;
}
public EString testString() {
EString st = tail.testString();
if (st == null) {
return null;
}
byte[] out_bin = new byte[len + st.length()];
System.arraycopy(this.data, this.off, out_bin, 0, this.len);
System.arraycopy(st.data, st.off, out_bin, len, st.length());
return new EString(out_bin, 0);
}
private ESeq seq() { return new Seq(); }
/**
* Helper class that looks at this EBinList as a Seq.
*/
private class Seq extends ESeq {
@Override
public ECons testNonEmptyList() {
return EBinList.this.testNonEmptyList();
}
@Override
public ESeq cons(EObject h) {
return EBinList.this.cons(h).testSeq();
}
@Override
public ESeq tail() {
return EBinList.this.tail().testSeq();
}
@Override
public EObject head() {
return EBinList.this.head();
}
@Override
public void encode(EOutputStream eos) {
EBinList.this.encode(eos);
}
}
private boolean all_printable() {
byte val;
for (int i = 0; i < len; i++) {
val = data[off+i];
if (val < ' ' || val >= 127) {
return false;
}
}
return true;
}
@Override
public String toString() {
//
// Can this be printed as "..."
//
if (tail.isNil() && all_printable()) {
StringBuilder sb = new StringBuilder("\"");
for (int i = 0; i < len; i++) {
byte val = data[off+i];
sb.append((char)val);
}
sb.append('"');
return sb.toString();
}
//
// Otherwise, print it as [.., .., |..]
//
StringBuilder sb = new StringBuilder("[");
int max = Math.min(len, 40);
for (int i = 0; i < max; i++) {
if (i != 0) { sb.append(","); }
byte val = data[off+i];
if (val > ' ' && val < 127) {
sb.append('$');
sb.append((char)val);
} else {
sb.append(val & 0xFF);
}
}
if (max!=len) {
sb.append("...");
}
if (!tail.isNil()) {
sb.append('|');
sb.append(tail);
}
sb.append("]");
return sb.toString();
}
@Override
public void visitIOList(EIOListVisitor out) throws ErlangError {
out.visit(data, off, len);
tail.visitIOList(out);
}
@Override
public boolean collectIOList(List<ByteBuffer> out) {
out.add(ByteBuffer.wrap(data, off, len));
return tail.collectIOList(out);
}
@Override
public ESeq collectCharList(CharCollector out, ESeq rest)
throws CharCollector.CollectingException,
CharCollector.InvalidElementException,
IOException
{
if (rest != ERT.NIL) {
return rest.cons(this);
}
try {
rest = out.addBinary(data, off, len, rest);
} catch (CharCollector.PartialDecodingException e) {
throw new CharCollector.CollectingException(drop(e.inputPos - off));
}
if (tail.testNumber() != null) {
// Only nil and binaries are allowed as tail
// TODO: Fail sooner?
throw new CharCollector.InvalidElementException();
} else {
return tail.collectCharList(out, rest);
}
}
@Override
public void encode(EOutputStream eos) {
eos.write_list_head(len);
for (int i = 0; i < len; i++) {
eos.write_int(data[off+i]);
}
eos.write_any(tail);
}
public static EBinList fromString(String c, EObject tail) {
byte[] data = new byte[c.length()];
for (int i = 0; i < data.length; i++) {
data[i] = (byte) c.charAt(i);
}
return new EBinList(data, tail);
}
private static final Type EBINLIST_TYPE = Type.getType(EBinList.class);
private static final Type STRING_TYPE = Type.getType(String.class);
private static final String EOBJECT_DESC = Type.getDescriptor(EObject.class);
@Override
public Type emit_const(MethodVisitor fa) {
Type type = EBINLIST_TYPE;
char[] ch = new char[len];
for (int i = 0; i < len; i++) {
ch[i] = (char)(0xff & (int)data[off+i]);
}
fa.visitLdcInsn(new String(ch));
tail.emit_const(fa);
fa.visitMethodInsn(Opcodes.INVOKESTATIC, type.getInternalName(),
"fromString", "(" + STRING_TYPE.getDescriptor() + EOBJECT_DESC + ")"
+ type.getDescriptor());
return type;
}
}