X-Git-Url: http://git.nguyen.vg/gitweb/?a=blobdiff_plain;f=OCamlDriver.cpp;h=35d03b87a9045a67a8de56330d716ed1ff8bab8a;hb=cf6d366b25132eea7b0f1966c11d034d748af0fa;hp=e20a7491da3c3540f5d3d88d03f54064dfeabdd2;hpb=5b4679e20761058f1e04c123da52631c0dd265cc;p=SXSI%2Fxpathcomp.git

diff --git a/OCamlDriver.cpp b/OCamlDriver.cpp
index e20a749..35d03b8 100644
--- a/OCamlDriver.cpp
+++ b/OCamlDriver.cpp
@@ -1,127 +1,147 @@
 /**************************************
  * OCamlDriver.cpp
  * -------------------
- * A Test Ocaml Driver which calls the C++ methods and
+ * An Ocaml Driver which calls the C++ methods and
  * adds a C wrapper interface with OCaml code.
  * 
  * Author: Kim Nguyen
  * Date: 04/11/08
  */
 
-/* OCaml memory managment */
+
+
+#include <unordered_set>
+#include <algorithm>
+#include "XMLDocShredder.h"
+#include "XMLTree.h"
+#include "Utils.h"
+
 extern "C" {
+/* OCaml memory managment */
 #include <caml/mlvalues.h>
 #include <caml/alloc.h>
 #include <caml/memory.h>
 #include <caml/callback.h>
 #include <caml/fail.h>
 #include <caml/custom.h>
-  
-
-} //extern C
-
-//#include "TextCollection/TextCollection.h"
-#include "XMLDocShredder.h"
-#include "XMLTree.h"
-#include "Utils.h"
+#include "results.h"
+#include <stdio.h>
 
-#define CAMLRAISECPP(e) (caml_failwith( ((e).what())))
+#define CAMLRAISEMSG(msg) (caml_raise_with_string(*cpp_exception,(msg) ))
 #define NOT_IMPLEMENTED(s)  (caml_failwith(s))
 #define XMLTREE(x) ((XMLTree *)(* (XMLTree**) Data_custom_val(x)))
+#define HSET(x) ((std::unordered_set<int>*)((* (std::unordered_set<int>**) Data_custom_val(x))))
 #define TEXTCOLLECTION(x)
 #define TREENODEVAL(i) ((treeNode) (Int_val(i)))
-
-extern "C" {
+#define XMLTREE_ROOT 0
+  
   static struct custom_operations ops;
-  static bool initialized = false;
+  static struct custom_operations set_ops;
+  static value * cpp_exception = NULL;
+  static bool ops_initialized = false;
+  
 }
+
 extern "C" void caml_xml_tree_finalize(value tree){
   delete XMLTREE(tree);
   return;
 }
 
-extern "C" void caml_init_ops () {
+extern "C" void caml_hset_finalize(value hblock){
+  delete HSET(hblock);
+  return;
+}
 
-  if (initialized)
-    return; 
+extern "C" CAMLprim value caml_init_lib (value unit) {
+  CAMLparam1(unit);
+  if (!ops_initialized){
+    
+  
   ops.identifier = (char*) "XMLTree";
   ops.finalize = caml_xml_tree_finalize;
-  return;
+  set_ops.identifier = (char*) "unordered_set";
+  set_ops.finalize = caml_hset_finalize;
+  
+  cpp_exception = caml_named_value("CPlusPlusError");
+  if (cpp_exception == NULL){
+    string s = "FATAL: Unregistered exception ";
+    s += "CPlusPlusError";
+    caml_failwith(s.c_str());
+  };
+  
+  ops_initialized = true;
+  
+  };
+  CAMLreturn(Val_unit);
+  
+}
+extern "C" CAMLprim value caml_shredder_parse(XMLDocShredder *shredder){
+  CAMLparam0();
+  CAMLlocal1(doc);
+  XMLTree * tree;
+  shredder->processStartDocument("");  
+  shredder->parse();  
+  shredder->processEndDocument();
+  doc = caml_alloc_custom(&ops,sizeof(XMLTree*),1,2);
+  tree = (XMLTree *) shredder->getXMLTree();
+  memcpy(Data_custom_val(doc),&tree,sizeof(XMLTree*));
+  CAMLreturn(doc);
+  
 }
 
 extern "C" CAMLprim value caml_call_shredder_uri(value uri,value sf, value iet, value dtc){
   CAMLparam1(uri);
   CAMLlocal1(doc);
   char *fn = String_val(uri);
+  XMLDocShredder * shredder;
   try {
-    XMLDocShredder shredder(fn,Int_val(sf),Bool_val(iet),Bool_val(dtc));
-  XMLTree * tree;
-  shredder.processStartDocument(fn);  
-  shredder.parse();  
-  shredder.processEndDocument();
-  caml_init_ops();
-  doc = caml_alloc_custom(&ops,sizeof(XMLTree*),1,2);
-  tree = (XMLTree *) shredder.storageIfc_->returnDocument();
-  memcpy(Data_custom_val(doc),&tree,sizeof(XMLTree*));
-  CAMLreturn(doc);
+    shredder = new XMLDocShredder(fn,Int_val(sf),Bool_val(iet),Bool_val(dtc));
+    doc = caml_shredder_parse(shredder);
+    delete shredder;
   }
-  catch (const std::exception& e){
-    CAMLRAISECPP(e);
-  };
+  catch (const std::exception& e){ CAMLRAISEMSG(e.what()); }
+  catch (string  msg){  CAMLRAISEMSG(msg.c_str()); }
+  catch (char const * msg){ CAMLRAISEMSG(msg);  };
+  CAMLreturn (doc);
   
 }
-
 extern "C" CAMLprim value caml_call_shredder_string(value data,value sf, value iet, value dtc){
   CAMLparam1(data);
   CAMLlocal1(doc);
+  XMLDocShredder * shredder;
   unsigned int ln = string_length(data);
   unsigned char *fn = (unsigned char*) String_val(data);
-  
   try {
-    XMLDocShredder shredder(fn,ln,Int_val(sf),Bool_val(iet),Bool_val(dtc));  
-    XMLTree* tree;
-    shredder.processStartDocument("");  
-    shredder.parse();  
-    shredder.processEndDocument();
-    caml_init_ops();
-    doc = caml_alloc_custom(&ops,sizeof(XMLTree*),1,2);
-    tree = (XMLTree *) shredder.storageIfc_->returnDocument();
-    memcpy(Data_custom_val(doc),&tree,sizeof(XMLTree*));
-    CAMLreturn(doc);
+    shredder = new  XMLDocShredder (fn,ln,Int_val(sf),Bool_val(iet),Bool_val(dtc));  
+    doc = caml_shredder_parse(shredder);
+    delete shredder;
   }
-  catch (const std::exception& e) {
-    CAMLRAISECPP(e);
-  };
+  catch (const std::exception& e){ CAMLRAISEMSG(e.what()); }
+  catch (string  msg){  CAMLRAISEMSG(msg.c_str()); }
+  catch (char const * msg){ CAMLRAISEMSG(msg);  };
+  CAMLreturn(doc);
 }
 
-void traversal_rec(XMLTree* tree, treeNode id){
- DocID tid; 
-  if (id == NULLT)
-    return;
-  //  int tag = tree->Tag(id);
-   if (id) {
-        tid = tree->PrevText(id);
-	char * data = (char *) (tree->getTextCollection())->GetText(tid);
-	if (tree->IsLeaf(id)){
-	  tid = tree->MyText(id);
-
-	  data = (char*) (tree->getTextCollection())->GetText(tid);
-	};
-  
-	if (tree->NextSibling(id) == NULLT){
-	  tid = tree->NextText(id);
-	  data = (char*) (tree->getTextCollection())->GetText(tid);
-	}; 
-   };
-   traversal_rec(tree,tree->FirstChild(id));
-   traversal_rec(tree,tree->NextSibling(id));
-   return;
+extern "C" CAMLprim value caml_xml_tree_save(value tree,value fd){
+  CAMLparam2(tree,fd);
+  XMLTREE(tree)->Save(Int_val(fd));
+  CAMLreturn (Val_unit);
 }
 
-extern "C" CAMLprim value caml_cpp_traversal(value tree){
-  CAMLparam1(tree);
-  traversal_rec(XMLTREE(tree),XMLTREE(tree)->Root());
-  CAMLreturn(Val_unit);
+extern "C" CAMLprim value caml_xml_tree_load(value fd, value load_tc,value sf){
+  CAMLparam3(fd,load_tc,sf);
+  CAMLlocal1(doc);
+  XMLTree * tree;
+  try {
+    tree = XMLTree::Load(Int_val(fd),Bool_val(load_tc),Int_val(sf));
+    doc = caml_alloc_custom(&ops,sizeof(XMLTree*),1,2);
+    memcpy(Data_custom_val(doc),&tree,sizeof(XMLTree*));
+    CAMLreturn(doc);
+  }
+  catch (const xmlpp::internal_error& e){ CAMLRAISEMSG(e.what()); }
+  catch (const std::exception& e){ CAMLRAISEMSG(e.what()); }
+  catch (string  msg){  CAMLRAISEMSG(msg.c_str()); }
+  catch (char const * msg){ CAMLRAISEMSG(msg);  };
 }
 
 extern "C" CAMLprim value caml_text_collection_get_text(value tree, value id){
@@ -129,9 +149,18 @@ extern "C" CAMLprim value caml_text_collection_get_text(value tree, value id){
   CAMLlocal1(str);
   uchar* txt = XMLTREE(tree)->GetText((DocID) Int_val(id));
   str = caml_copy_string((const char*)txt);
-  delete (txt);
   CAMLreturn (str);
 }
+
+extern "C" CAMLprim value caml_text_collection_get_cached_text(value tree, value id){
+  CAMLparam2(tree,id);
+  CAMLlocal1(str);
+  char* txt = (char*) XMLTREE(tree)->GetText((DocID) Int_val(id));
+  str = caml_copy_string(txt);
+  CAMLreturn (str);
+}
+
+
 extern "C" CAMLprim value caml_text_collection_empty_text(value tree,value id){
   CAMLparam2(tree,id);
   CAMLreturn ( Val_int((XMLTREE(tree))->EmptyText((DocID) Int_val(id))));
@@ -149,6 +178,15 @@ extern "C" CAMLprim value caml_text_collection_count_contains(value tree,value s
   CAMLreturn (Val_int((XMLTREE(tree)->CountContains(cstr))));
   
 }
+extern "C" CAMLprim value caml_text_collection_count(value tree,value str){
+  CAMLparam2(tree,str);
+  uchar * cstr = (uchar *) String_val(str);
+  CAMLreturn (Val_int((XMLTREE(tree)->Count(cstr))));
+  CAMLreturn (Val_unit);
+  
+}
+bool docId_comp(DocID x, DocID y) { return x < y; };
+
 
 extern "C" CAMLprim value caml_text_collection_contains(value tree,value str){
   CAMLparam2(tree,str);
@@ -156,10 +194,72 @@ extern "C" CAMLprim value caml_text_collection_contains(value tree,value str){
   uchar * cstr = (uchar *) String_val(str);  
   std::vector<DocID> results;
   results = XMLTREE(tree)->Contains(cstr);
-  //free(cstr);
-  resarray = caml_alloc_tuple(results.size());
+  std::sort(results.begin(), results.end(), docId_comp);
+  size_t s = results.size();
+  resarray = caml_alloc_tuple(s);
+
+  for (size_t i = 0; i < s ;i++){
+    caml_initialize(&Field(resarray,i),Val_int(results[i]));
+  };
+  CAMLreturn (resarray);  
+}
+
+extern "C" CAMLprim value caml_text_collection_equals(value tree,value str){
+  CAMLparam2(tree,str);
+  CAMLlocal1(resarray);
+  uchar * cstr = (uchar *) String_val(str);  
+  std::vector<DocID> results;
+  results = XMLTREE(tree)->Equal(cstr);
+  std::sort(results.begin(), results.end(), docId_comp);
+  size_t s = results.size();
+  resarray = caml_alloc_tuple(s);
+
+  for (size_t i = 0; i < s ;i++){
+    caml_initialize(&Field(resarray,i),Val_int(results[i]));
+  };
+  CAMLreturn (resarray);  
+}
+extern "C" CAMLprim value caml_text_collection_startswith(value tree,value str){
+  CAMLparam2(tree,str);
+  CAMLlocal1(resarray);
+  uchar * cstr = (uchar *) String_val(str);  
+  std::vector<DocID> results;
+  results = XMLTREE(tree)->Prefix(cstr);
+  std::sort(results.begin(), results.end(), docId_comp);
+  size_t s = results.size();
+  resarray = caml_alloc_tuple(s);
 
-  for (unsigned int i=0; i<results.size();i++){
+  for (size_t i = 0; i < s ;i++){
+    caml_initialize(&Field(resarray,i),Val_int(results[i]));
+  };
+  CAMLreturn (resarray);  
+}
+extern "C" CAMLprim value caml_text_collection_endswith(value tree,value str){
+  CAMLparam2(tree,str);
+  CAMLlocal1(resarray);
+  uchar * cstr = (uchar *) String_val(str);  
+  std::vector<DocID> results;
+  results = XMLTREE(tree)->Suffix(cstr);
+  std::sort(results.begin(), results.end(), docId_comp);
+  size_t s = results.size();
+  resarray = caml_alloc_tuple(s);
+
+  for (size_t i = 0; i < s ;i++){
+    caml_initialize(&Field(resarray,i),Val_int(results[i]));
+  };
+  CAMLreturn (resarray);  
+}
+
+
+
+extern "C" CAMLprim value caml_text_collection_unsorted_contains(value tree,value str){
+  CAMLparam2(tree,str);
+  CAMLlocal1(resarray);
+  uchar * cstr = (uchar *) String_val(str);  
+  std::vector<DocID> results;
+  results = XMLTREE(tree)->Contains(cstr);
+  resarray = caml_alloc_tuple(results.size());
+  for (size_t i = 0; i < results.size() ;i++){
     caml_initialize(&Field(resarray,i),Val_int(results[i]));
   };
   CAMLreturn (resarray);  
@@ -168,19 +268,21 @@ extern "C" CAMLprim value caml_text_collection_contains(value tree,value str){
 
 extern "C" CAMLprim value caml_xml_tree_root(value tree){
   CAMLparam1(tree);
-  CAMLreturn (TREENODEVAL(XMLTREE(tree)->Root()));
+  CAMLreturn (Val_int(TREENODEVAL(XMLTREE_ROOT)));
 }
 extern "C" CAMLprim value caml_xml_tree_text_collection(value tree){
   CAMLparam1(tree);
   CAMLreturn((value) XMLTREE(tree)->getTextCollection());
 }
 extern "C" CAMLprim value caml_xml_tree_parent(value tree, value id){
-  CAMLparam2(tree,id);
-  CAMLreturn(Val_int (XMLTREE(tree)->Parent(TREENODEVAL(id))));
+  return(Val_int (XMLTREE(tree)->Parent(TREENODEVAL(id))));
+}
+extern "C" CAMLprim value caml_xml_tree_prev_sibling(value tree, value id){
+  return(Val_int (XMLTREE(tree)->PrevSibling(TREENODEVAL(id))));
 }
+
 extern "C" CAMLprim value caml_xml_tree_parent_doc(value tree, value id){
-  CAMLparam2(tree,id);
-  CAMLreturn(Val_int (XMLTREE(tree)->ParentNode((DocID) Int_val(id))));
+  return (Val_int (XMLTREE(tree)->ParentNode((DocID) Int_val(id))));
 }
 
 extern "C" CAMLprim value caml_xml_tree_is_ancestor(value tree,value id1, value id2) {
@@ -188,75 +290,76 @@ extern "C" CAMLprim value caml_xml_tree_is_ancestor(value tree,value id1, value
   CAMLreturn(Val_bool (XMLTREE(tree)->IsAncestor(TREENODEVAL(id1),TREENODEVAL(id2))));
 }
 
-extern "C" CAMLprim value caml_xml_tree_serialize(value tree, value filename){
-  CAMLparam2(tree,filename);
-  NOT_IMPLEMENTED("caml_xml_tree_serialize");
-  CAMLreturn(Val_unit);
+extern "C" CAMLprim value caml_xml_tree_last_child(value tree, value id){
+  return(Val_int (XMLTREE(tree)->LastChild(TREENODEVAL(id))));
 }
 
-extern "C" CAMLprim value caml_xml_tree_unserialize(value filename){
-  CAMLparam1(filename);
-  NOT_IMPLEMENTED("caml_xml_tree_unserialize");
-  CAMLreturn(Val_unit);
+extern "C" CAMLprim value caml_xml_tree_is_first_child(value tree, value id){
+  return Val_bool (XMLTREE(tree)->IsFirstChild(TREENODEVAL(id)));
 }
-
-
 extern "C" CAMLprim value caml_xml_tree_first_child(value tree, value id){
-  CAMLparam2(tree,id);
-  CAMLreturn(Val_int (XMLTREE(tree)->FirstChild(TREENODEVAL(id))));
+  return(Val_int (XMLTREE(tree)->FirstChild(TREENODEVAL(id))));
+}
+extern "C" CAMLprim value caml_xml_tree_closing(value tree, value id){
+  return(Val_int (XMLTREE(tree)->Closing(TREENODEVAL(id))));
+}
+extern "C" CAMLprim value caml_xml_tree_is_open(value tree, value id){
+  return(Val_bool (XMLTREE(tree)->IsOpen(TREENODEVAL(id))));
 }
 
-extern "C" CAMLprim value caml_xml_tree_is_leaf(value tree, value id){
-  CAMLparam2(tree,id);
-  CAMLreturn(Val_bool (XMLTREE(tree)->IsLeaf(TREENODEVAL(id))));
+extern "C" CAMLprim value caml_xml_tree_first_element(value tree, value id){
+  return(Val_int (XMLTREE(Field(tree,0))->FirstElement(TREENODEVAL(id))));
 }
 
-extern "C" CAMLprim value caml_xml_tree_tagged_desc(value tree, value id, value tag){
-  CAMLparam3(tree,id,tag);
-  CAMLreturn(Val_int (XMLTREE(tree)->TaggedDesc(TREENODEVAL(id),(TagType) Int_val(tag))));
+extern "C" CAMLprim value caml_xml_tree_tagged_child(value tree, value id, value tag){
+  return(Val_int (XMLTREE(tree)->TaggedChild(TREENODEVAL(id),Int_val(tag))));
 }
 
-extern "C" CAMLprim value caml_xml_tree_tagged_next(value tree, value id, value tag){
-  CAMLparam3(tree,id,tag);
-  CAMLreturn(Val_int (XMLTREE(tree)->TaggedNext(TREENODEVAL(id),(TagType) Int_val(tag))));
+extern "C" CAMLprim value caml_xml_tree_next_sibling(value tree, value id){
+  return(Val_int (XMLTREE(tree)->NextSibling(TREENODEVAL(id))));
 }
 
+extern "C" CAMLprim value caml_xml_tree_next_element(value tree, value id){
+  return(Val_int (XMLTREE(Field(tree,0))->NextElement(TREENODEVAL(id))));
+}
 
+extern "C" CAMLprim value caml_xml_tree_tagged_sibling(value tree, value id, value tag){
+  return(Val_int (XMLTREE(tree)->TaggedFollSibling(TREENODEVAL(id),Int_val(tag))));
+}
 
 
-extern "C" CAMLprim value caml_xml_tree_tagged_foll(value tree, value id, value tag){
-  CAMLparam3(tree,id,tag);
-  CAMLreturn(Val_int (XMLTREE(tree)->TaggedFoll(TREENODEVAL(id),(TagType) Int_val(tag))));
+extern "C" CAMLprim value caml_xml_tree_is_leaf(value tree, value id){
+  return(Val_bool (XMLTREE(tree)->IsLeaf(TREENODEVAL(id))));
 }
 
-
-extern "C" CAMLprim value caml_xml_tree_next_sibling(value tree, value id){
-  CAMLparam2(tree,id);
-  CAMLreturn(Val_int (XMLTREE(tree)->NextSibling(TREENODEVAL(id))));
+extern "C" CAMLprim value caml_xml_tree_tagged_desc(value tree, value id, value tag){
+  return(Val_int (XMLTREE(tree)->TaggedDesc(TREENODEVAL(id),(TagType) Int_val(tag))));
 }
 
-extern "C" CAMLprim value caml_xml_tree_prev_text(value tree, value id){
-  CAMLparam2(tree,id);
-  CAMLlocal1(res);
-  CAMLreturn(Val_int((XMLTREE(tree)->PrevText(TREENODEVAL(id)))));
-  CAMLreturn(res);
+
+extern "C" CAMLprim value caml_xml_tree_tagged_foll(value tree, value id, value tag){
+  return(Val_int (XMLTREE(tree)->TaggedFoll(TREENODEVAL(id),(TagType) Int_val(tag))));
 }
-extern "C" CAMLprim value caml_xml_tree_next_text(value tree, value id){
-  CAMLparam2(tree,id);
-  CAMLreturn(Val_int((XMLTREE(tree)->NextText(TREENODEVAL(id)))));
+extern "C" CAMLprim value caml_xml_tree_tagged_foll_below(value tree, value id, value tag,value root){
+  return(Val_int (XMLTREE(tree)->TaggedFollBelow(TREENODEVAL(id),(TagType) Int_val(tag),TREENODEVAL(root))));
+}
+extern "C" CAMLprim value caml_xml_tree_tagged_foll_before(value tree, value id, value tag,value root){
+  return(Val_int (XMLTREE(tree)->TaggedFollBefore(TREENODEVAL(id),(TagType) Int_val(tag),TREENODEVAL(root))));
 }
+
 extern "C" CAMLprim value caml_xml_tree_my_text(value tree, value id){
-  CAMLparam2(tree,id);
-  CAMLreturn(Val_int((XMLTREE(tree)->MyText(TREENODEVAL(id)))));
+  return(Val_int((XMLTREE(tree)->MyText(TREENODEVAL(id)))));
+}
+
+extern "C" CAMLprim value caml_xml_tree_my_text_unsafe(value tree, value id){
+  return(Val_int((XMLTREE(tree)->MyTextUnsafe(TREENODEVAL(id)))));
 }
 
 extern "C" CAMLprim value caml_xml_tree_text_xml_id(value tree, value id){
-  CAMLparam2(tree,id);
-  CAMLreturn(Val_int((XMLTREE(tree)->TextXMLId(TREENODEVAL(id)))));
+  return(Val_int((XMLTREE(tree)->TextXMLId(TREENODEVAL(id)))));
 }
 extern "C" CAMLprim value caml_xml_tree_node_xml_id(value tree, value id){
-  CAMLparam2(tree,id);
-  CAMLreturn(Val_int((XMLTREE(tree)->NodeXMLId(TREENODEVAL(id)))));
+  return(Val_int((XMLTREE(tree)->NodeXMLId(TREENODEVAL(id)))));
 }
 
 extern "C" CAMLprim value caml_xml_tree_tag_name(value tree, value tagid){
@@ -270,13 +373,19 @@ extern "C" CAMLprim value caml_xml_tree_tag_name(value tree, value tagid){
 
 
 extern "C" CAMLprim value caml_xml_tree_tag_id(value tree,value id){
-  CAMLparam2(tree,id);  
-  CAMLreturn (Val_int(XMLTREE(tree)->Tag(TREENODEVAL(id))));
+  return (Val_int(XMLTREE(tree)->Tag(TREENODEVAL(id))));
 }
 
 extern "C" CAMLprim value caml_xml_tree_subtree_tags(value tree,value id,value tag){
-  CAMLparam3(tree,id,tag);  
-  CAMLreturn (Val_int(XMLTREE(tree)->SubtreeTags(TREENODEVAL(id),Int_val(tag))));
+  return (Val_int(XMLTREE(tree)->SubtreeTags(TREENODEVAL(id),Int_val(tag))));
+}
+
+extern "C" CAMLprim value caml_xml_tree_subtree_size(value tree,value id){
+  return (Val_int(XMLTREE(tree)->SubtreeSize(TREENODEVAL(id))));
+}
+
+extern "C" CAMLprim value caml_xml_tree_subtree_elements(value tree,value id){
+  return (Val_int(XMLTREE(tree)->SubtreeElements(TREENODEVAL(id))));
 }
 
 
@@ -290,23 +399,118 @@ extern "C" CAMLprim value caml_xml_tree_register_tag(value tree,value str){
 }
 
 extern "C" CAMLprim value caml_xml_tree_nullt(value unit){
-  CAMLparam1(unit);
-  CAMLreturn (NULLT);
+  return (NULLT);
+}
+
+extern "C" CAMLprim value caml_unordered_set_length(value hset){
+  CAMLparam1(hset);
+  CAMLreturn (Val_int((HSET(hset))->size()));
+}
+
+extern "C" CAMLprim value caml_unordered_set_alloc(value len){
+  CAMLparam1(len);
+  CAMLlocal1(hset);
+  hset = caml_alloc_custom(&set_ops,sizeof(std::unordered_set<int>*),1,2);
+  std::unordered_set<int>* ht = new std::unordered_set<int>();
+  memcpy(Data_custom_val(hset),&ht,sizeof(std::unordered_set<int>*));
+  CAMLreturn (hset);
 }
 
-extern "C" CAMLprim value caml_xml_tree_save(value tree,value filename){
-  CAMLparam2(tree,filename);
-  XMLTREE(tree)->Save((unsigned char *) String_val(filename));
+extern "C" CAMLprim value caml_unordered_set_set(value vec, value v){  
+  HSET(vec)->insert((int) Int_val(v));
+  return (Val_unit);
+}
+
+extern "C" CAMLprim value caml_xml_tree_select_desc(value tree, value node, value tags){
+  return (Val_int (XMLTREE(tree)->SelectDesc(TREENODEVAL(node),
+					     HSET(tags))));
+}
+extern "C" CAMLprim value caml_xml_tree_select_child(value tree, value node, value tags){
+  return (Val_int (XMLTREE(tree)->SelectChild(TREENODEVAL(node),
+					      HSET(tags))));
+}
+extern "C" CAMLprim value caml_xml_tree_select_foll_sibling(value tree, value node, value tags){
+  return (Val_int (XMLTREE(tree)->SelectFollSibling(TREENODEVAL(node),
+						    HSET(tags))));
+}
+extern "C" CAMLprim value caml_xml_tree_select_foll_below(value tree, value node, value tags,value ctx){
+  return (Val_int (XMLTREE(tree)->SelectFollBelow(TREENODEVAL(node),
+						  HSET(tags),
+						  TREENODEVAL(ctx))));
+}
+extern "C" CAMLprim value caml_xml_tree_select_foll_before(value tree, value node, value tags,value ctx){
+  return (Val_int (XMLTREE(tree)->SelectFollBelow(TREENODEVAL(node),
+						  HSET(tags),
+						  TREENODEVAL(ctx))));
+}
+
+
+extern "C" CAMLprim value caml_xml_tree_doc_ids(value tree, value node){
+  CAMLparam2(tree,node);
+  CAMLlocal1(tuple);
+  tuple = caml_alloc_tuple(2);
+  range r = (XMLTREE(tree)->DocIds(TREENODEVAL(node)));
+  caml_initialize(&Field(tuple,0),Val_int(r.min));
+  caml_initialize(&Field(tuple,1),Val_int(r.max));
+  CAMLreturn (tuple);
+}
+
+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));
+}
+
+extern "C" CAMLprim value caml_result_set_set(value result,value p){
+  CAMLparam1(p);
+  setResult (  *((results*) result), Int_val(p));
   CAMLreturn (Val_unit);
 }
 
-extern "C" CAMLprim value caml_xml_tree_load(value filename,value samplerate){
-  CAMLparam2(filename,samplerate);
-  CAMLlocal1(doc);
-  XMLTree * tree;
-  tree = XMLTree::Load((unsigned char *) String_val(filename),Int_val(samplerate));
-  caml_init_ops();
-  doc = caml_alloc_custom(&ops,sizeof(XMLTree*),1,2);
-  memcpy(Data_custom_val(doc),&tree,sizeof(XMLTree*));
-  CAMLreturn(doc);
+extern "C" CAMLprim value caml_result_set_clear(value result,value p1,value p2){
+  CAMLparam2(p1,p2);
+  clearRange ( *((results*) result), Int_val(p1), Int_val(p2));
+  CAMLreturn (Val_unit);
+}
+
+extern "C" CAMLprim value caml_result_set_next(value result,value p){
+  CAMLparam1(p);
+  results r;
+  r = *( (results *) result);
+  CAMLreturn (Val_int(nextResult(r, Int_val(p))));
+}
+
+extern "C" CAMLprim value caml_result_set_count(value result){
+  CAMLparam0();
+  results r;
+  r = *( (results *) result);
+  CAMLreturn (Val_int(countResult(r)));
+}
+
+extern "C" CAMLprim 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);
+}
+
+extern "C" CAMLprim value caml_set_tag_bits(value result, value tag, value tree, value node)
+{
+  CAMLparam3(tag,tree,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->TaggedDesc(opening,target_tag);
+  r = *( (results *) result);
+  opening = first;
+  while (opening != NULLT){
+    setResult(r,opening);
+    opening = t->TaggedFollBefore(opening,target_tag,closing);
+  };
+  CAMLreturn(Val_int(first));
 }
+