+extern "C" value caml_xml_tree_get_tag_id(value tree, value tagname){
+ CAMLparam2(tree,tagname);
+ CAMLlocal1(res);
+ unsigned char* ctagname = (unsigned char*) strdup(String_val(tagname));
+ res = Val_int(XMLTREE(tree)->GetTagId(ctagname));
+ free(ctagname);
+ CAMLreturn(res);
+}
+
+extern "C" value caml_xml_tree_get_tag_name(value tree, value tag){
+ CAMLparam2(tree,tag);
+ CAMLlocal1(res);
+ res = caml_copy_string((const char*) XMLTREE(tree)->GetTagNameByRef(TAGVAL(tag)));
+ CAMLreturn(res);
+}
+
+extern "C" value caml_xml_tree_register_tag(value tree, value tagname){
+ CAMLparam2(tree,tagname);
+ CAMLlocal1(res);
+ unsigned char* ctagname = (unsigned char*) strdup(String_val(tagname));
+ res = Val_int(XMLTREE(tree)->RegisterTag(ctagname));
+ free(ctagname);
+ CAMLreturn(res);
+}
+
+
+NoAlloc extern "C" value caml_xml_tree_get_text_collection(value tree){
+ return((value) XMLTREE(tree)->getTextCollection());
+}
+
+NoAlloc extern "C" value caml_xml_tree_closing(value tree, value node){
+ return (Val_int(XMLTREE(tree)->Closing(TREENODEVAL(node))));
+}
+
+NoAlloc extern "C" value caml_xml_tree_is_open(value tree, value node){
+ return (Val_bool(XMLTREE(tree)->IsOpen(TREENODEVAL(node))));
+}
+
+
+
+NoAlloc extern "C" value caml_xml_tree_nullt(value unit){
+ return (NULLT);
+}
+
+NoAlloc extern "C" value caml_unordered_set_length(value hset){
+ return (Val_int((HSET(hset))->size()));
+}
+
+extern "C" value caml_unordered_set_alloc(value unit){
+ CAMLparam1(unit);
+ CAMLlocal1(hset);
+ hset = caml_alloc_custom(&set_ops,sizeof(TagIdSet*),1,2);
+ TagIdSet* ht = new TagIdSet();
+ memcpy(Data_custom_val(hset),&ht,sizeof(TagIdSet*));
+ CAMLreturn (hset);
+}
+
+NoAlloc extern "C" value caml_unordered_set_set(value set, value v){
+ HSET(set)->insert((int) Int_val(v));
+ return (Val_unit);
+}
+
+NoAlloc extern "C" value caml_result_set_create(value size){
+ results* res = (results*) malloc(sizeof(results));
+ results r = createResults (Int_val(size));
+ res->n = r.n;
+ res->lgn = r.lgn;
+ res->tree = r.tree;
+ return ((value) (res));
+}
+
+NoAlloc extern "C" value caml_result_set_set(value result,value p){
+ setResult ( *((results*) result), Int_val(p));
+ return (Val_unit);
+}
+
+NoAlloc extern "C" value caml_result_set_clear(value result,value p1,value p2){
+ clearRange ( *((results*) result), Int_val(p1), Int_val(p2));
+ 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));
+ 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);
+}
+
+
+void iterjump(XMLTree* tree, treeNode node, TagType tag){
+ if (node == NULLT)
+ return;
+ else {
+ iterjump(tree,tree->TaggedDescendant(node,tag),tag);
+ iterjump(tree,tree->TaggedFollowing(node,tag),tag);
+ return;
+ };
+}
+
+extern "C" value caml_benchmark_jump(value tree,value tag){
+ iterjump(XMLTREE(tree),0, Int_val(tag));
+ return Val_unit;
+}
+
+int iterfsns(XMLTree* tree, treeNode node){
+ if (node == NULLT)
+ return 0;
+ else {
+ int x = tree->Tag(node);
+ x += iterfsns(tree,tree->FirstChild(node));
+ x += iterfsns(tree,tree->NextSibling(node));
+ return x;
+ };
+}
+
+extern "C" value caml_benchmark_fsns(value tree){
+ iterfsns(XMLTREE(tree),0);
+ return Val_unit;
+