@BIF
public static EObject keysearch(EObject k, EObject n, EObject list) {
ESmall idx = n.testSmall();
ESeq src = list.testSeq();
if (k == null || idx == null || src == null || idx.value < 1) throw ERT.badarg(k, n, list);
int index = idx.value;
while (!src.isNil()) {
EObject elm = src.head();
ETuple tup;
if ((tup = elm.testTuple()) != null) {
if (tup.arity() >= index) {
if (tup.elm(index).equals(k)) {
return new ETuple2(ERT.am_value, tup);
}
}
}
src = src.tail();
}
return ERT.FALSE;
}
@BIF
public static ESeq reverse(ESeq front, ESeq res) {
while (!front.isNil()) {
res = res.cons(front.head());
front = front.tail();
}
return res;
}
@BIF
public static EAtom member(EObject e, EObject l) {
ESeq list = l.testSeq();
if (list == null) throw ERT.badarg(e, l);
while (!list.isNil()) {
if (e.equals(list.head())) return ERT.TRUE;
list = list.tail();
}
return ERT.FALSE;
}
@BIF
public static ESeq map(EProc proc, EObject f, EObject s) throws Pausable {
EFun fun = f.testFunction2(1);
ESeq seq = s.testSeq();
if (fun == null || seq == null) throw ERT.badarg(f, s);
EObject[] arg = new EObject[1];
ESeq rev = ERT.NIL;
for (; !seq.isNil(); seq = seq.tail()) {
arg[0] = seq.head();
rev = rev.cons(fun.invoke(proc, arg));
}
return reverse(rev, ERT.NIL);
}
@BIF
public static EObject hibernate(EProc self, EObject a1, EObject a2, EObject a3) {
EAtom m = a1.testAtom();
EAtom f = a2.testAtom();
ESeq a = a3.testSeq();
if (m == null || f == null || a == null) {
throw ERT.badarg(a1, a2, a3);
}
int arity = a.length();
EFun target = EModuleManager.resolve(new FunID(m, f, arity));
if (target == null) {
throw new ErlangUndefined(m, f, new ESmall(arity));
}
self.tail = target;
a = a.reverse();
switch (arity) {
default:
throw new NotImplemented("hibernate w/" + arity + " args");
case 7:
self.arg6 = a.head();
a = a.tail();
case 6:
self.arg5 = a.head();
a = a.tail();
case 5:
self.arg4 = a.head();
a = a.tail();
case 4:
self.arg3 = a.head();
a = a.tail();
case 3:
self.arg2 = a.head();
a = a.tail();
case 2:
self.arg1 = a.head();
a = a.tail();
case 1:
self.arg0 = a.head(); // a = a.tail();
case 0:
}
throw ErjangHibernateException.INSTANCE;
}
@BIF
public static EObject keyfind(EObject key, EObject nth_arg, EObject list_arg) {
ESmall nth = nth_arg.testSmall();
ESeq list = list_arg.testSeq();
if (key == null || nth == null | list == null) throw ERT.badarg(key, nth_arg, list_arg);
while (!list.isNil()) {
EObject elm = list.head();
ETuple tup = elm.testTuple();
// test that it is a tuple of the right size
if (tup != null && tup.arity() >= nth.value) {
EObject val = tup.elm(nth.value);
if (val.equals(key)) {
return tup;
}
}
list = list.tail();
}
return ERT.FALSE;
}
@BIF
public static EObject spawn_opt(EProc self, EObject tup) throws Pausable {
ETuple t;
EAtom m;
EAtom f;
ESeq a;
ESeq o;
if ((t = tup.testTuple()) == null
|| t.arity() != 4
|| (m = t.elm(1).testAtom()) == null
|| (f = t.elm(2).testAtom()) == null
|| (a = t.elm(3).testSeq()) == null
|| (o = t.elm(4).testSeq()) == null) throw ERT.badarg(tup);
boolean link = false;
boolean monitor = false;
EAtom priority = null;
for (; !o.isNil(); o = o.tail()) {
EObject val = o.head();
ETuple2 t2;
if (val == am_link) {
link = true;
} else if (val == am_monitor) {
monitor = true;
} else if ((t2 = ETuple2.cast(val)) != null) {
if (t2.elm(1) == am_priority) {
EAtom am = t2.elm(2).testAtom();
if (am != null) priority = am;
}
// ignore full_sweep_after and min_heap_size
}
}
EProc p2 = new EProc(self.group_leader(), m, f, a);
if (link) {
self.link_to(p2);
}
if (priority != null) {
// may throw badarg!
p2.process_flag(am_priority, priority);
}
ERef ref = null;
if (monitor) {
ref = ERT.getLocalNode().createRef();
if (!self.monitor(p2.self_handle(), p2.self_handle(), ref)) {
throw new InternalError("cannot monitor new process?");
// self.mbox_send(ETuple.make(ERT.am_DOWN, ref, p2.self_handle(), ERT.am_noproc));
}
}
ERT.run(p2);
if (monitor) {
return new ETuple2(p2.self_handle(), ref);
} else {
return p2.self_handle();
}
}