+ return (Val_unit);
+}
+
+NoAlloc extern "C" value caml_result_set_next(value result,value p){
+ results r;
+ r = *( (results *) result);
+ return (Val_int(nextResult(r, Int_val(p))));
+}
+
+NoAlloc extern "C" value caml_result_set_count(value result){
+ results r;
+ r = *( (results *) result);
+ return (Val_int(countResult(r)));
+}
+
+NoAlloc extern "C" value caml_xml_tree_print(value tree,value node,value fd){
+ CAMLparam3(tree,node,fd);
+ XMLTREE(tree)->Print(Int_val(fd),TREENODEVAL(node), false);
+ CAMLreturn(Val_unit);
+}
+
+NoAlloc extern "C" value caml_set_tag_bits(value result, value tag, value tree, value node)
+{
+ results r;
+ XMLTree *t = XMLTREE(Field(tree,0));
+ treeNode opening = TREENODEVAL(node);
+ treeNode closing = t->Closing(opening);
+ TagType target_tag = Int_val(tag);
+ treeNode first = t->TaggedDescendant(opening,target_tag);
+ r = *( (results *) result);
+ opening = first;
+ while (opening != NULLT){
+ setResult(r,opening);
+ opening = t->TaggedFollowingBefore(opening,target_tag,closing);
+ };
+ return(Val_int(first));
+}
+
+
+NoAlloc extern "C" value caml_bit_vector_create(value size){
+ return (value) (new vector<bool>(Int_val(size),false));
+}
+
+NoAlloc extern "C" value caml_bit_vector_free(value vect){
+ delete ((vector<bool>*) vect);
+ return Val_unit;
+}
+
+NoAlloc extern "C" value caml_bit_vector_get(value vect,value idx){
+ return Val_bool (((vector<bool>*)vect)->at(Int_val(idx)));
+}
+
+NoAlloc extern "C" value caml_bit_vector_set(value vect,value idx,value b){
+ (((vector<bool>*)vect)->at(Int_val(idx))) = (bool) Bool_val(b);
+ return Val_unit;
+}
+
+NoAlloc extern "C" value caml_bit_vector_next(value vect,value idx){
+ vector<bool>* bv = (vector<bool>*) vect;
+ int i = Int_val(idx);
+ int l = bv->size();
+ while (i < l && !((*bv)[i]))
+ i++;
+ return Val_int(i);
+}
+NoAlloc extern "C" value caml_bit_vector_prev(value vect,value idx){
+ int i = Int_val(idx);
+ while (i >= 0 && !((*((vector<bool>*) vect))[i]))
+ i--;
+ return Val_int(i);
+}
+
+extern "C" value caml_bit_vector_node_array(value vect){
+ CAMLparam0();
+ CAMLlocal1(res);
+ vector<bool>* bv = (vector<bool>*) vect;
+ vector<treeNode> vr;
+ int l = bv->size();
+ int i = 0;
+ while (i < l){
+ if ((*bv)[i]) vr.push_back(i);
+ i++;
+ };
+ l = vr.size();
+ res = caml_alloc_tuple(l);
+ for(i=0;i<l;i++)
+ caml_initialize(&Field(res,i),Val_int(vr[i]));
+ CAMLreturn (res);
+}
+
+
+int iterjump(XMLTree* tree, treeNode node, TagType tag, treeNode anc){
+ if (node == NULLT)
+ return 0;
+ else {
+ return
+ 1
+ + iterjump(tree,tree->TaggedDescendant(node,tag),tag,node)
+ + iterjump(tree,tree->TaggedFollowingBelow(node,tag,anc),tag,anc);
+ };
+}
+
+extern "C" value caml_benchmark_jump(value tree,value tag){
+ int count;
+ treeNode root = XMLTREE(tree)->FirstChild(0);
+ root = XMLTREE(tree)->FirstChild(root);
+ count = iterjump(XMLTREE(tree), root , Int_val(tag),0);
+ return Val_unit;
+}
+
+int iterfcns(XMLTree* tree, treeNode node){
+ if (node == NULLT)
+ return 0;
+ else {
+ int tmp = 1;
+ tmp += iterfcns(tree,tree->FirstChild(node));
+ tmp += iterfcns(tree,tree->NextSibling(node));
+ return tmp;
+ };
+}
+
+int iterfene(XMLTree* tree, treeNode node){
+ if (node == NULLT)
+ return 0;
+ else {
+ int tmp = 1;
+ tmp += iterfene(tree,tree->FirstElement(node));
+ tmp += iterfene(tree,tree->NextElement(node));
+ return tmp;
+ };
+}
+
+extern "C" value caml_benchmark_fcns(value tree){
+ int i = iterfcns(XMLTREE(tree),0);
+ return Val_int(i);
+
+}
+
+extern "C" value caml_benchmark_fene(value tree){
+ int i = iterfene(XMLTREE(tree),0);
+ return Val_int(i);
+
+}
+
+int iterlcps(XMLTree* tree, treeNode node){
+ if (node == NULLT)
+ return 0;
+ else {
+ int x = tree->Tag(node);
+ x += iterlcps(tree,tree->LastChild(node));
+ x += iterlcps(tree,tree->PrevSibling(node));
+ return x;
+ };
+}
+
+int fulliterative(XMLTree* tree){
+ treeNode current = tree->Root();
+ treeNode next = NULLT;
+ int count = 1; //the root
+
+ do {
+
+
+ while ((next = tree->FirstChild(current)) != NULLT) {
+ current = next;
+ count++;
+ };
+
+ while ( (next = tree->NextSibling(current)) == NULLT){
+ current = tree->Parent(current);
+ if (current == NULLT) return count;
+ }
+ current = next;
+ count++;
+ } while (true);
+