termPo sliceScan(specialClassPo cl, specialHelperFun helper, void *c, termPo o) {
listPo list = C_LIST(o);
helper(&list->base, c);
return o + ListCellCount;
}
retCode sliceDisp(ioPo out, termPo t, integer precision, integer depth, logical alt) {
listPo list = C_LIST(t);
basePo base = C_BASE(list->base);
retCode ret = outChar(out, '[');
if (depth > 0) {
integer ix = list->start;
integer lx = ix + list->length;
integer maxIx = (precision == 0 ? list->length + 1 : precision);
char *sep = "";
while (ret == Ok && ix < lx && maxIx-- > 0) {
ret = outStr(out, sep);
sep = ", ";
if (ret == Ok)
ret = dispTerm(out, base->els[ix], precision, depth - 1, alt);
ix++;
}
if (ret == Ok && maxIx <= 0) {
ret = outStr(out, "..");
}
} else if (ret == Ok)
ret = outStr(out, "..");
if (ret == Ok)
ret = outChar(out, ']');
return ret;
}
termPo sliceCopy(specialClassPo cl, termPo dst, termPo src) {
listPo si = C_LIST(src);
listPo di = (listPo) dst;
*di = *si;
return (termPo) di + ListCellCount;
}
integer sliceHash(specialClassPo cl, termPo o) {
listPo l = C_LIST(o);
integer sz = listSize(l);
integer hash = uniHash("array");
for (integer ix = 0; ix < sz; ix++)
hash = hash * 37 + termHash(nthEl(l, ix));
return hash;
}
comparison sliceCmp(specialClassPo cl, termPo o1, termPo o2) {
listPo l1 = C_LIST(o1);
listPo l2 = C_LIST(o2);
integer s1 = listSize(l1);
integer s2 = listSize(l2);
integer sz = minimum(s1, s2);
for (integer ix = 0; ix < sz; ix++) {
termPo e1 = nthEl(l1, ix);
termPo e2 = nthEl(l2, ix);
comparison cmp = compareTerm(e1, e2);
if (cmp != same)
return cmp;
}
if (s1 < s2)
return smaller;
else if (s1 > s2)
return bigger;
else
return same;
}
struct Cache_Block_Header *Strategy_Replace_Block(struct Cache *pcache)
{
struct Cache_Block_Header *buffer;
struct Cache_List *c_list = C_LIST(pcache);
/* S'il existe un cache invalide, on va utiliser celui la */
if ((buffer = Get_Free_Block(pcache)) != NULL) {
// Comme on va l'utiliser, on le met en fin de liste
Cache_List_Append(c_list, buffer);
} else {
// On prend le premier de la liste que l'on va retourner
buffer = Cache_List_Remove_First(c_list);
// Comme on va l'utiliser, on le met en fin de liste
Cache_List_Append(c_list, buffer);
}
return buffer;
}
listPo flattenList(heapPo H, listPo l) {
int root = gcAddRoot(H, (ptrPo) &l);
integer llen = 0;
processList(l, countEls, &llen);
listPo reslt = createList(H, llen);
for (integer ix = 0; ix < listSize(l); ix++) {
listPo ll = C_LIST(nthEl(l, ix));
for (integer jx = 0; jx < listSize(ll); jx++) {
reslt = addToList(H, reslt, nthEl(ll, jx));
}
}
assert(listSize(reslt) == llen);
gcReleaseRoot(H, root);
return reslt;
}
static retCode countEls(termPo el, integer ix, void *cl) {
integer *count = (integer *) cl;
listPo ll = C_LIST(el);
(*count) += listSize(ll);
return Ok;
}
void Strategy_Invalidate(struct Cache *pcache)
{
Cache_List_Clear(C_LIST(pcache));
}
void Strategy_Close(struct Cache *pcache)
{
Cache_List_Delete(C_LIST(pcache));
}
ReturnStatus g__list_nil(processPo p, ptrPo tos) {
integer cap = integerVal(tos[0]);
ReturnStatus ret = {.ret=Ok, .result=(termPo) createList(processHeap(p), cap)};
return ret;
}
ReturnStatus g__list_empty(processPo p, ptrPo tos) {
listPo l = C_LIST(tos[0]);
ReturnStatus ret = {.ret=Ok, .result=listSize(l) == 0 ? trueEnum : falseEnum};
return ret;
}
ReturnStatus g__list_size(processPo p, ptrPo tos) {
listPo l = C_LIST(tos[0]);
ReturnStatus ret = {.ret=Ok, .result=(termPo) allocateInteger(processHeap(p), listSize(l))};
return ret;
}
ReturnStatus g__list_nth(processPo p, ptrPo tos) {
termPo Lhs = tos[0];
integer ix = integerVal(tos[1]);
listPo l = C_LIST(Lhs);
assert(ix >= 0 && ix < listSize(l));
ReturnStatus ret = {.ret=Ok, .result=nthEl(l, ix)};
return ret;
}
ReturnStatus g__list_append(processPo p, ptrPo tos) {
termPo Lhs = tos[0];
termPo Rhs = tos[1];
listPo l = C_LIST(Lhs);
ReturnStatus ret = {.ret=Ok, .result=(termPo) appendToList(processHeap(p), l, Rhs)};
return ret;
}
ReturnStatus g__list_prepend(processPo p, ptrPo tos) {
termPo Lhs = tos[0];
termPo Rhs = tos[1];
listPo l = C_LIST(Lhs);
ReturnStatus ret = {.ret=Ok, .result=(termPo) prependToList(processHeap(p), l, Rhs)};
return ret;
}
ReturnStatus g__list_slice(processPo p, ptrPo tos) {
listPo l = C_LIST(tos[0]);
integer from = integerVal(tos[1]);
integer count = integerVal(tos[2]);
ReturnStatus ret = {.ret=Ok, .result=(termPo) sliceList(processHeap(p), l, from, count)};
return ret;
}
ReturnStatus g__list_front(processPo p, ptrPo tos) {
listPo l = C_LIST(tos[0]);
integer count = integerVal(tos[1]);
ReturnStatus ret = {.ret=Ok, .result=(termPo) sliceList(processHeap(p), l, 0, count)};
return ret;
}
ReturnStatus g__list_back(processPo p, ptrPo tos) {
listPo l = C_LIST(tos[0]);
integer from = integerVal(tos[1]);
ReturnStatus ret = {.ret=Ok, .result=(termPo) sliceList(processHeap(p), l, from, listSize(l) - from)};
return ret;
}
ReturnStatus g__list_concat(processPo p, ptrPo tos) {
termPo Lhs = tos[0];
termPo Rhs = tos[1];
listPo l = C_LIST(Lhs);
listPo r = C_LIST(Rhs);
ReturnStatus ret = {.ret=Ok, .result=(termPo) concatList(processHeap(p), l, r)};
return ret;
}
ReturnStatus g__list_reverse(processPo p, ptrPo tos) {
termPo Lhs = tos[0];
listPo l = C_LIST(Lhs);
ReturnStatus ret = {.ret=Ok, .result=(termPo) reverseList(processHeap(p), l)};
return ret;
}
ReturnStatus g__list_flatten(processPo p, ptrPo tos) {
listPo ll = C_LIST(tos[0]);
ReturnStatus ret = {.ret=Ok, .result=(termPo) flattenList(processHeap(p), ll)};
return ret;
}
ReturnStatus g__list_insert(processPo p, ptrPo tos) {
listPo l = C_LIST(tos[0]);
integer ix = integerVal(tos[1]);
termPo vl = tos[2];
ReturnStatus ret = {.ret=Ok, .result=(termPo) insertListEl(processHeap(p), l, ix, vl)};
return ret;
}
ReturnStatus g__list_replace(processPo p, ptrPo tos) {
listPo l = C_LIST(tos[0]);
integer ix = integerVal(tos[1]);
termPo vl = tos[2];
ReturnStatus ret = {.ret=Ok, .result=(termPo) replaceListEl(processHeap(p), l, ix, vl)};
return ret;
}
ReturnStatus g__list_remove(processPo p, ptrPo tos) {
listPo l = C_LIST(tos[0]);
integer ix = integerVal(tos[1]);
ReturnStatus ret = {.ret=Ok, .result=(termPo) removeListEl(processHeap(p), l, ix)};
return ret;
}
