X-Git-Url: http://git.nguyen.vg/gitweb/?a=blobdiff_plain;f=OCamlDriver.cpp;h=a5e47f807996faca481ca350413fbc020b378b8f;hb=0c2338bfcdae0df1c68112a10247dc4e68a483ff;hp=c10edf11fe3d7f03abc181110f3983a776e24381;hpb=cad5e2e2831477cba1f6211c57b9a4cc5b58bd55;p=SXSI%2Fxpathcomp.git

diff --git a/OCamlDriver.cpp b/OCamlDriver.cpp
index c10edf1..a5e47f8 100644
--- a/OCamlDriver.cpp
+++ b/OCamlDriver.cpp
@@ -117,7 +117,7 @@ extern "C"  value caml_call_shredder_string(value data,value sf, value iet, valu
   CAMLparam1(data);
   CAMLlocal1(doc);
   XMLDocShredder * shredder;
-  unsigned int ln = string_length(data);
+  unsigned int ln = caml_string_length(data);
   unsigned char *fn = (unsigned char*) String_val(data);
   try {
     shredder = new  XMLDocShredder (fn,ln,Int_val(sf),Bool_val(iet),Bool_val(dtc));  
@@ -130,18 +130,18 @@ extern "C"  value caml_call_shredder_string(value data,value sf, value iet, valu
   CAMLreturn(doc);
 }
 
-extern "C"  value caml_xml_tree_save(value tree,value fd){
-  CAMLparam2(tree,fd);
-  XMLTREE(tree)->Save(Int_val(fd));
+extern "C"  value caml_xml_tree_save(value tree,value fd, value str){
+  CAMLparam3(tree,fd,str);  
+  XMLTREE(tree)->Save(Int_val(fd), String_val(str));
   CAMLreturn (Val_unit);
 }
 
-extern "C"  value caml_xml_tree_load(value fd, value load_tc,value sf){
-  CAMLparam3(fd,load_tc,sf);
+extern "C"  value caml_xml_tree_load(value fd, value str, value load_tc,value sf){
+  CAMLparam4(fd,str,load_tc,sf);
   CAMLlocal1(doc);
   XMLTree * tree;
   try {
-    tree = XMLTree::Load(Int_val(fd),Bool_val(load_tc),Int_val(sf));
+    tree = XMLTree::Load(Int_val(fd),String_val(str),Bool_val(load_tc),Int_val(sf));
     printf("Pointer to tree is %p\n", (void*) tree);
     doc = caml_alloc_custom(&ops,sizeof(XMLTree*),1,2);
     memcpy(Data_custom_val(doc),&tree,sizeof(XMLTree*));
@@ -255,13 +255,14 @@ extern "C"  value caml_text_collection_count_lessthan(value tree,value str){
 }
 
 static value sort_alloc_array(std::vector<DocID> results, value resarray){
-    std::sort(results.begin(), results.end(), docId_comp);
+  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]));
     };
-    return resarray;
+    return resarray; 
+
 }
 
 /**
@@ -695,7 +696,7 @@ NoAlloc extern "C" value caml_result_set_count(value result){
 
 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));
+  XMLTREE(tree)->Print(Int_val(fd),TREENODEVAL(node), false);
   CAMLreturn(Val_unit);
 }
 
@@ -769,34 +770,163 @@ extern "C" value caml_bit_vector_node_array(value vect){
 }
 
 
-void iterjump(XMLTree* tree, treeNode node, TagType tag){
+int iterjump(XMLTree* tree, treeNode node, TagType tag, treeNode anc){
   if (node == NULLT)
-    return;
+    return 0;
   else {
-    iterjump(tree,tree->TaggedDescendant(node,tag),tag);
-    iterjump(tree,tree->TaggedFollowing(node,tag),tag);
-    return;
+    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){
-  iterjump(XMLTREE(tree),0, Int_val(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 iterfsns(XMLTree* tree, treeNode node){
+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 += iterfsns(tree,tree->FirstChild(node));
-    x += iterfsns(tree,tree->NextSibling(node));
+    x += iterlcps(tree,tree->LastChild(node));
+    x += iterlcps(tree,tree->PrevSibling(node));
     return x;
   };
 }
 
-extern "C" value caml_benchmark_fsns(value tree){
-  iterfsns(XMLTREE(tree),0);
+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);
+
+}
+
+extern "C" value caml_benchmark_iter(value tree){
+  return Val_int(fulliterative(XMLTREE(tree)));
+}
+
+extern "C" value caml_benchmark_lcps(value tree){  
+  iterlcps(XMLTREE(tree),0);
   return Val_unit;
 
 }
+
+extern "C" {
+
+  typedef struct dummy_node_ {
+    struct dummy_node_* first;
+    struct dummy_node_* next;
+  } dummy_node;
+  
+  
+  dummy_node * new_dummy_node () {
+    
+    dummy_node * node = (dummy_node*) malloc(sizeof(dummy_node));
+    if (!node)
+      printf("%s","Cannot allocate memory\n");
+    
+    return node;
+  }
+
+  void free_tree(dummy_node * node){
+    if (node){
+      free_tree(node->first);
+      free_tree(node->next);
+      free(node);
+    };
+    return;
+  }
+
+  dummy_node * create_tree(XMLTree* tree, treeNode i, int mode){
+    if (i == NULLT)
+       return NULL;
+    else {
+      dummy_node * f, *n, *r;
+      //mode = i % 3;
+      if (mode == 0) r = new_dummy_node();
+      f = create_tree(tree,tree->FirstChild(i), mode);
+      if (mode == 1) r = new_dummy_node();
+      n = create_tree(tree,tree->NextSibling(i), mode);
+      if (mode == 2) r = new_dummy_node();
+      r->first = f;
+      r->next = n;
+      return r;
+    };
+  }
+      
+  int iter_tree(dummy_node * n){
+    if (n == NULL)
+      return 0;
+    else
+      return 1 + iter_tree (n->first) + iter_tree (n->next);
+  }
+}
+extern "C" value caml_build_pointers(value tree, value mode){
+  return ((value) create_tree(XMLTREE(Field(tree,0)),0, Int_val(mode)));
+}
+
+extern "C" value caml_iter_pointers (value node){
+  return Val_int(iter_tree((dummy_node*) node));
+
+}
+
+extern "C" value caml_free_pointers(value node){
+  free_tree((dummy_node*) node);
+  return Val_unit;
+}