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));
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*));
}
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;
+
}
/**
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);
}
}
-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));
- return Val_unit;
+ int count;
+ treeNode root = XMLTREE(tree)->FirstChild(0);
+ root = XMLTREE(tree)->FirstChild(root);
+ count = iterjump(XMLTREE(tree), root , Int_val(tag),0);
+ return Val_int(count);
}
-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;
+}
projects / SXSI / xpathcomp.git / blobdiff