3 // functions to convert tag positions to the corresponding tree node and viceversa.
\r
4 // These are implemented in order to be able to change the tree and Tags representations,
\r
5 // without affecting the code so much.
\r
6 // Current implementation corresponds to balanced-parentheses representation for
\r
7 // the tree, and storing 2 tags per tree node (opening and closing tags).
\r
9 // tag position -> tree node
\r
10 inline treeNode tagpos2node(int t) {
\r
14 // tree node -> tag position
\r
15 inline int node2tagpos(treeNode x) {
\r
19 // Save: saves XML tree data structure to file.
\r
20 void XMLTree::Save(unsigned char *filename)
\r
24 char filenameaux[1024];
\r
27 sprintf(filenameaux, "%s.srx", filename);
\r
28 fp = fopen(filenameaux, "w");
\r
30 printf("Error: cannot create file %s to store the tree structure of XML collection\n", filenameaux);
\r
34 // first stores the tree topology
\r
37 // stores the table with tag names
\r
38 fwrite(&ntagnames, sizeof(int), 1, fp);
\r
39 for (i=0; i<ntagnames;i++)
\r
40 fprintf(fp, "%s\n",TagName[i]);
\r
43 fwrite(&indexing_empty_texts, sizeof(bool), 1, fp);
\r
44 fwrite(&initialized, sizeof(bool), 1, fp);
\r
45 fwrite(&finished, sizeof(bool), 1, fp);
\r
47 if (!indexing_empty_texts) EBVector->save(fp);
\r
52 // stores the texts
\r
60 // Load: loads XML tree data structure from file. Returns
\r
61 // a pointer to the loaded data structure
\r
62 XMLTree *XMLTree::Load(unsigned char *filename, int sample_rate_text)
\r
66 char filenameaux[1024];
\r
70 // first load the tree topology
\r
71 sprintf(filenameaux, "%s.srx", filename);
\r
72 fp = fopen(filenameaux, "r");
\r
74 printf("Error: cannot open file %s to load the tree structure of XML collection\n", filenameaux);
\r
78 XML_Tree = new XMLTree();
\r
80 XML_Tree->Par = (bp *)malloc(sizeof(bp));
\r
82 loadTree(XML_Tree->Par, fp);
\r
84 // stores the table with tag names
\r
85 fread(&XML_Tree->ntagnames, sizeof(int), 1, fp);
\r
87 XML_Tree->TagName = (unsigned char **)malloc(XML_Tree->ntagnames*sizeof(unsigned char *));
\r
89 for (i=0; i<XML_Tree->ntagnames;i++) {
\r
91 fscanf(fp, "%s\n",filenameaux);
\r
92 XML_Tree->TagName[i] = (unsigned char *)malloc(sizeof(unsigned char)*(strlen((const char *)filenameaux)+1));
\r
93 strcpy((char *)XML_Tree->TagName[i], (const char *)filenameaux);
\r
97 fread(&(XML_Tree->indexing_empty_texts), sizeof(bool), 1, fp);
\r
98 fread(&(XML_Tree->initialized), sizeof(bool), 1, fp);
\r
99 fread(&(XML_Tree->finished), sizeof(bool), 1, fp);
\r
101 if (!(XML_Tree->indexing_empty_texts)) XML_Tree->EBVector = static_bitsequence_rrr02::load(fp);
\r
104 XML_Tree->Tags = static_sequence_wvtree::load(fp);
\r
106 // loads the texts
\r
107 XML_Tree->Text->Load(fp,sample_rate_text);
\r
115 // ~XMLTree: frees memory of XML tree.
\r
116 XMLTree::~XMLTree()
\r
121 free(Par); // frees the memory of struct Par
\r
123 for (i=0; i<ntagnames;i++)
\r
128 if (!indexing_empty_texts) {
\r
129 EBVector->~static_bitsequence_rrr02();
\r
134 Tags->~static_sequence_wvtree();
\r
138 Text->~TextCollection();
\r
142 initialized = false;
\r
146 // root(): returns the tree root.
\r
147 treeNode XMLTree::Root()
\r
150 fprintf(stderr, "Error: data structure has not been constructed properly\n");
\r
153 return root_node(Par);
\r
156 // SubtreeSize(x): the number of nodes (and attributes) in the subtree of node x.
\r
157 int XMLTree::SubtreeSize(treeNode x)
\r
160 fprintf(stderr, "Error: data structure has not been constructed properly\n");
\r
163 return subtree_size(Par, x);
\r
166 // SubtreeTags(x,tag): the number of occurrences of tag within the subtree of node x.
\r
167 int XMLTree::SubtreeTags(treeNode x, TagType tag)
\r
170 fprintf(stderr, "Error: data structure has not been constructed properly\n");
\r
174 int s = x + 2*subtree_size(Par, x) - 1;
\r
176 return Tags->rank(tag, s) - Tags->rank(tag, node2tagpos(x)-1);
\r
179 // IsLeaf(x): returns whether node x is leaf or not. In the succinct representation
\r
180 // this is just a bit inspection.
\r
181 bool XMLTree::IsLeaf(treeNode x)
\r
183 return isleaf(Par, x);
\r
186 // IsAncestor(x,y): returns whether node x is ancestor of node y.
\r
187 bool XMLTree::IsAncestor(treeNode x, treeNode y)
\r
190 fprintf(stderr, "Error: data structure has not been constructed properly\n");
\r
194 return is_ancestor(Par, x, y);
\r
197 // IsChild(x,y): returns whether node x is parent of node y.
\r
198 bool XMLTree::IsChild(treeNode x, treeNode y)
\r
201 fprintf(stderr, "Error: data structure has not been constructed properly\n");
\r
205 if (!is_ancestor(Par, x, y)) return false;
\r
206 return depth(Par, x) == (depth(Par, y) + 1);
\r
209 // NumChildren(x): number of children of node x. Constant time with the data structure
\r
211 int XMLTree::NumChildren(treeNode x)
\r
214 fprintf(stderr, "Error: data structure has not been constructed properly\n");
\r
218 return degree(Par, x);
\r
221 // ChildNumber(x): returns i if node x is the i-th children of its parent.
\r
222 int XMLTree::ChildNumber(treeNode x)
\r
225 fprintf(stderr, "Error: data structure has not been constructed properly\n");
\r
229 return child_rank(Par, x);
\r
232 // Depth(x): depth of node x, a simple binary rank on the parentheses sequence.
\r
233 int XMLTree::Depth(treeNode x)
\r
236 fprintf(stderr, "Error: data structure has not been constructed properly\n");
\r
240 return depth(Par, x);
\r
243 // Preorder(x): returns the preorder number of node x, just counting the tree
\r
244 // nodes (i.e., tags, it disregards the texts in the tree).
\r
245 int XMLTree::Preorder(treeNode x)
\r
248 fprintf(stderr, "Error: data structure has not been constructed properly\n");
\r
252 return preorder_rank(Par, x);
\r
255 // Postorder(x): returns the postorder number of node x, just counting the tree
\r
256 // nodes (i.e., tags, it disregards the texts in the tree).
\r
257 int XMLTree::Postorder(treeNode x)
\r
260 fprintf(stderr, "Error: data structure has not been constructed properly\n");
\r
264 return postorder_rank(Par, x);
\r
267 // Tag(x): returns the tag identifier of node x.
\r
268 TagType XMLTree::Tag(treeNode x)
\r
271 fprintf(stderr, "Error: data structure has not been constructed properly\n");
\r
275 return Tags->access(node2tagpos(x));
\r
278 // DocIds(x): returns the range of text identifiers that descend from node x.
\r
279 // returns {NULLT, NULLT} when there are no texts descending from x.
\r
280 range XMLTree::DocIds(treeNode x)
\r
283 fprintf(stderr, "Error: data structure has not been constructed properly\n");
\r
288 if (indexing_empty_texts) { // faster, no rank needed
\r
290 r.max = x+2*subtree_size(Par, x)-2;
\r
292 else { // we are not indexing empty texts, we need rank
\r
293 int min = EBVector->rank1(x-1);
\r
294 int max = EBVector->rank1(x+2*subtree_size(Par, x)-2);
\r
295 if (min==max) { // range is empty, no texts within the subtree of x
\r
299 else { // the range is non-empty, there are texts within the subtree of x
\r
307 // Parent(x): returns the parent node of node x.
\r
308 treeNode XMLTree::Parent(treeNode x)
\r
311 fprintf(stderr, "Error: data structure has not been constructed properly\n");
\r
315 return parent(Par, x);
\r
318 // Child(x,i): returns the i-th child of node x, assuming it exists.
\r
319 treeNode XMLTree::Child(treeNode x, int i)
\r
322 fprintf(stderr, "Error: data structure has not been constructed properly\n");
\r
326 if (i <= OPTD) return naive_child(Par, x, i);
\r
327 else return child(Par, x, i);
\r
330 // FirstChild(x): returns the first child of node x, assuming it exists. Very fast in BP.
\r
331 treeNode XMLTree::FirstChild(treeNode x)
\r
334 fprintf(stderr, "Error: data structure has not been constructed properly\n");
\r
338 return first_child(Par, x);
\r
341 // NextSibling(x): returns the next sibling of node x, assuming it exists.
\r
342 treeNode XMLTree::NextSibling(treeNode x)
\r
345 fprintf(stderr, "Error: data structure has not been constructed properly\n");
\r
349 return next_sibling(Par, x);
\r
352 // PrevSibling(x): returns the previous sibling of node x, assuming it exists.
\r
353 treeNode XMLTree::PrevSibling(treeNode x)
\r
356 fprintf(stderr, "Error: data structure has not been constructed properly\n");
\r
360 return prev_sibling(Par, x);
\r
363 // TaggedChild(x,i,tag): returns the i-th child of node x tagged tag, or NULLT if there is none.
\r
364 // Because of the balanced-parentheses representation of the tree, this operation is not supported
\r
365 // efficiently, just iterating among the children of node x until finding the desired child.
\r
366 treeNode XMLTree::TaggedChild(treeNode x, int i, TagType tag)
\r
369 fprintf(stderr, "Error: data structure has not been constructed properly\n");
\r
375 child = first_child(Par, x); // starts at first child of node x
\r
376 if (child==(treeNode)-1) return NULLT; // node x is a leaf, there is no such child
\r
377 while (child!=(treeNode)-1) {
\r
378 if (Tags->access(node2tagpos(child)) == tag) { // current child is labeled with tag of interest
\r
380 if (i==0) return child; // we have seen i children of x tagged tag, this is the one we are looking for
\r
382 child = next_sibling(Par, x); // OK, let's try with the next child
\r
384 return NULLT; // no such child was found
\r
387 // TaggedDesc(x,tag): returns the first node tagged tag with larger preorder than x and within
\r
388 // the subtree of x. Returns NULLT if there is none.
\r
389 treeNode XMLTree::TaggedDesc(treeNode x, TagType tag)
\r
392 fprintf(stderr, "Error: data structure has not been constructed properly\n");
\r
398 r = (int) Tags->rank(tag, node2tagpos(x));
\r
399 s = (int) Tags->select(tag, r+1);
\r
400 if (s == -1) return NULLT; // there is no such node
\r
401 y = tagpos2node(s); // transforms the tag position into a node position
\r
402 if (!is_ancestor(Par, x, y)) return NULLT; // the next node tagged tag (in preorder) is not within the subtree of x.
\r
406 // TaggedPrec(x,tag): returns the first node tagged tag with smaller preorder than x and not an
\r
407 // ancestor of x. Returns NULLT if there is none.
\r
408 treeNode XMLTree::TaggedPrec(treeNode x, TagType tag)
\r
411 fprintf(stderr, "Error: data structure has not been constructed properly\n");
\r
416 treeNode node_s, root;
\r
417 r = (int)Tags->rank(tag, node2tagpos(x)-1);
\r
418 if (r==0) return NULLT; // there is no such node.
\r
419 s = (int)Tags->select(tag, r);
\r
420 root = root_node(Par);
\r
421 node_s = tagpos2node(s);
\r
422 while (is_ancestor(Par, node_s, x) && (node_s!=root)) { // the one that we found is an ancestor of x
\r
424 if (r==0) return NULLT; // there is no such node
\r
425 s = (int)Tags->select(tag, r); // we should use select_prev instead when provided
\r
426 node_s = tagpos2node(s);
\r
428 return NULLT; // there is no such node
\r
431 // TaggedFoll(x,tag): returns the first node tagged tag with larger preorder than x and not in
\r
432 // the subtree of x. Returns NULLT if there is none.
\r
433 treeNode XMLTree::TaggedFoll(treeNode x, TagType tag)
\r
436 fprintf(stderr, "Error: data structure has not been constructed properly\n");
\r
441 r = (int) Tags->rank(tag, node2tagpos(next_sibling(Par, x))-1);
\r
442 s = (int) Tags->select(tag, r+1); // select returns -1 in case that there is no r+1-th tag.
\r
443 if (s==-1) return NULLT;
\r
444 else return tagpos2node(s);
\r
447 // PrevText(x): returns the document identifier of the text to the left
\r
448 // of node x, or NULLT if x is the root node or the text is empty.
\r
449 // Assumes Doc ids start from 0.
\r
450 DocID XMLTree::PrevText(treeNode x)
\r
453 fprintf(stderr, "Error: data structure has not been constructed properly\n");
\r
457 if (x == Root()) return NULLT;
\r
458 if (indexing_empty_texts) // faster, no rank needed
\r
460 else { // we are not indexing empty texts, rank is needed
\r
461 if (EBVector->access(x-1) == 0)
\r
462 return (DocID)NULLT; // there is no text to the left of node (text is empty)
\r
464 return (DocID)EBVector->rank1(x-1)-1; //-1 because document ids start from 0
\r
468 // NextText(x): returns the document identifier of the text to the right
\r
469 // of node x, or NULLT if x is the root node. Assumes Doc ids start from 0.
\r
470 DocID XMLTree::NextText(treeNode x)
\r
473 fprintf(stderr, "Error: data structure has not been constructed properly\n");
\r
477 if (x == Root()) return NULLT;
\r
478 if (indexing_empty_texts) // faster, no rank needed
\r
479 return (DocID)x+2*subtree_size(Par, x)-1;
\r
480 else { // we are not indexing empty texts, rank is needed
\r
481 int p = x+2*subtree_size(Par, x)-1;
\r
482 if (EBVector->access(p) == 0) // there is no text to the right of node
\r
483 return (DocID)NULLT;
\r
485 return (DocID)EBVector->rank1(p)-1; //-1 because document ids start from 0
\r
489 // MyText(x): returns the document identifier of the text below node x,
\r
490 // or NULLT if x is not a leaf node or the text is empty. Assumes Doc
\r
491 // ids start from 0.
\r
492 DocID XMLTree::MyText(treeNode x)
\r
495 fprintf(stderr, "Error: data structure has not been constructed properly\n");
\r
499 if (!IsLeaf(x)) return NULLT;
\r
500 if (indexing_empty_texts) // faster, no rank needed
\r
502 else { // we are not indexing empty texts, rank is needed
\r
503 if (EBVector->access(x) == 0) // there is no text below node x
\r
504 return (DocID)NULLT;
\r
506 return (DocID)EBVector->rank1(x)-1; //-1 because document ids start from 0
\r
510 // TextXMLId(d): returns the preorder of document with identifier d in the tree consisting of
\r
511 // all tree nodes and all text nodes. Assumes that the tree root has preorder 1.
\r
512 int XMLTree::TextXMLId(DocID d)
\r
515 fprintf(stderr, "Error: data structure has not been constructed properly\n");
\r
519 if (indexing_empty_texts)
\r
520 return d + rank_open(Par, d)+1; // +1 because root has preorder 1
\r
521 else { // slower, needs rank and select
\r
522 int s = EBVector->select1(d+1);
\r
523 return rank_open(Par, s) + d + 1; // +1 because root has preorder 1
\r
527 // NodeXMLId(x): returns the preorder of node x in the tree consisting
\r
528 // of all tree nodes and all text nodes. Assumes that the tree root has
\r
530 int XMLTree::NodeXMLId(treeNode x)
\r
533 fprintf(stderr, "Error: data structure has not been constructed properly\n");
\r
537 if (indexing_empty_texts)
\r
538 return x - 1 + rank_open(Par, x);
\r
540 if (x == Root()) return 1; // root node has preorder 1
\r
542 return rank_open(Par, x) + EBVector->rank1(x-1);
\r
546 // ParentNode(d): returns the parent node of document identifier d.
\r
547 treeNode XMLTree::ParentNode(DocID d)
\r
550 fprintf(stderr, "Error: data structure has not been constructed properly\n");
\r
555 if (indexing_empty_texts) s = d;
\r
556 else s = EBVector->select1(d);
\r
558 if (inspect(Par,s) == CP) // is a closing parenthesis
\r
559 return parent(Par, find_open(Par, s));
\r
560 else // is an opening parenthesis
\r
561 return (treeNode)s;
\r
566 // OpenDocument(empty_texts): it starts the construction of the data structure for
\r
567 // the XML document. Parameter empty_texts indicates whether we index empty texts
\r
568 // in document or not. Returns a non-zero value upon success, NULLT in case of error.
\r
569 int XMLTree::OpenDocument(bool empty_texts, int sample_rate_text)
\r
571 initialized = true;
\r
576 indexing_empty_texts = empty_texts;
\r
578 par_aux = (pb *)malloc(sizeof(pb));
\r
580 fprintf(stderr, "Error: not enough memory\n");
\r
584 tags_aux = (TagType *) malloc(sizeof(TagType));
\r
586 fprintf(stderr, "Error: not enough memory\n");
\r
592 if (!indexing_empty_texts) {
\r
593 empty_texts_aux = (unsigned int *)malloc(sizeof(unsigned int));
\r
594 if (!empty_texts_aux) {
\r
595 fprintf(stderr, "Error: not enough memory\n");
\r
600 Text = TextCollection::InitTextCollection((unsigned)sample_rate_text);
\r
602 return 1; // indicates success in the initialization of the data structure
\r
605 // CloseDocument(): it finishes the construction of the data structure for the XML
\r
606 // document. Tree and tags are represented in the final form, dynamic data
\r
607 // structures are made static, and the flag "finished" is set to true. After that,
\r
608 // the data structure can be queried.
\r
609 int XMLTree::CloseDocument()
\r
611 if (!initialized) { // data structure has not been initialized properly
\r
612 fprintf(stderr, "Error: data structure has not been initialized properly (by calling method OpenDocument)\n");
\r
616 // closing parenthesis for the tree root
\r
617 par_aux = (pb *)realloc(par_aux, sizeof(pb)*(1+npar/(8*sizeof(pb))));
\r
619 fprintf(stderr, "Error: not enough memory\n");
\r
623 // creates the data structure for the tree topology
\r
624 Par = (bp *)malloc(sizeof(bp));
\r
625 bp_construct(Par, npar, par_aux, OPT_DEGREE|0);
\r
626 // creates structure for tags
\r
627 alphabet_mapper * am = new alphabet_mapper_none();
\r
628 static_bitsequence_builder * bmb = new static_bitsequence_builder_rrr02(32);
\r
629 wt_coder * wtc = new wt_coder_huff((uint *)tags_aux,npar-1,am);
\r
630 Tags = new static_sequence_wvtree((uint *) tags_aux, (uint) npar-1, wtc, bmb, am);
\r
632 // makes the text collection static
\r
633 Text->MakeStatic();
\r
635 // creates the data structure marking the non-empty texts (just in the case it is necessary)
\r
636 if (!indexing_empty_texts)
\r
637 EBVector = new static_bitsequence_rrr02((uint *)empty_texts_aux,(ulong)npar,(uint)32);
\r
641 return 1; // indicates success in the inicialization
\r
645 // NewOpenTag(tagname): indicates the event of finding a new opening tag in the document.
\r
646 // Tag name is given. Returns a non-zero value upon success, and returns NULLT
\r
647 // in case of failing when trying to insert the new tag.
\r
648 int XMLTree::NewOpenTag(unsigned char *tagname)
\r
652 if (!initialized) { // data structure has not been initialized properly
\r
653 fprintf(stderr, "Error: you cannot insert a new opening tag without first calling method OpenDocument first\n");
\r
657 // inserts a new opening parentheses in the bit sequence
\r
658 par_aux = (pb *)realloc(par_aux, sizeof(pb)*(1+npar/(8*sizeof(pb))));
\r
660 fprintf(stderr, "Error: not enough memory\n");
\r
664 setbit(par_aux,npar,OP); // marks a new opening parenthesis
\r
666 // transforms the tagname into a tag identifier. If the tag is new, we insert
\r
667 // it in the table.
\r
668 for (i=0; i<ntagnames; i++)
\r
669 if (strcmp((const char *)tagname,(const char *)TagName[i])==0) break;
\r
671 if (i==ntagnames) { // the tag is a new one, then we insert it
\r
672 TagName = (unsigned char **)realloc(TagName, sizeof(char *)*(ntagnames+1));
\r
675 fprintf(stderr, "Error: not enough memory\n");
\r
680 TagName[i] = (unsigned char *)malloc(sizeof(unsigned char)*(strlen((const char *)tagname)+1));
\r
681 strcpy((char *)TagName[i], (const char *)tagname);
\r
683 tags_aux = (TagType *) realloc(tags_aux, sizeof(TagType)*(npar + 1));
\r
685 fprintf(stderr, "Error: not enough memory\n");
\r
689 tags_aux[npar] = i; // inserts the new tag id within the preorder sequence of tags
\r
698 // NewClosingTag(tagname): indicates the event of finding a new closing tag in the document.
\r
699 // Tag name is given. Returns a non-zero value upon success, and returns NULLT
\r
700 // in case of failing when trying to insert the new tag.
\r
701 int XMLTree::NewClosingTag(unsigned char *tagname)
\r
705 if (!initialized) { // data structure has not been initialized properly
\r
706 fprintf(stderr, "Error: you cannot insert a new closing tag without first calling method OpenDocument first\n");
\r
710 // inserts a new closing parentheses in the bit sequence
\r
711 par_aux = (pb *)realloc(par_aux, sizeof(pb)*(1+npar/(8*sizeof(pb))));
\r
713 fprintf(stderr, "Error: not enough memory\n");
\r
716 setbit(par_aux,npar,CP); // marks a new closing opening parenthesis
\r
718 // transforms the tagname into a tag identifier. If the tag is new, we insert
\r
719 // it in the table.
\r
720 for (i=0; i<ntagnames; i++)
\r
721 if (strcmp((const char *)tagname,(const char *)TagName[i])==0) break;
\r
723 if (i==ntagnames) { // the tag is a new one, then we insert it
\r
724 TagName = (unsigned char **)realloc(TagName, sizeof(char *)*(ntagnames+1));
\r
727 fprintf(stderr, "Error: not enough memory\n");
\r
732 TagName[i] = (unsigned char *)malloc(sizeof(char)*(strlen((const char *)tagname)+2));
\r
733 TagName[i][0] = '/';
\r
734 strcpy((char *)&(TagName[i][1]), (const char *)tagname);
\r
737 tags_aux = (TagType *)realloc(tags_aux, sizeof(TagType)*(npar + 1));
\r
740 fprintf(stderr, "Error: not enough memory\n");
\r
744 tags_aux[npar] = i; // inserts the new tag id within the preorder sequence of tags
\r
748 return 1; // success
\r
753 // NewText(s): indicates the event of finding a new (non-empty) text s in the document.
\r
754 // The new text is inserted within the text collection. Returns a non-zero value upon
\r
755 // success, NULLT in case of error.
\r
756 int XMLTree::NewText(unsigned char *s)
\r
758 if (!initialized) { // data structure has not been initialized properly
\r
759 fprintf(stderr, "Error: you cannot insert a new text without first calling method OpenDocument first\n");
\r
763 if (!indexing_empty_texts) {
\r
764 empty_texts_aux = (unsigned int *)realloc(empty_texts_aux, sizeof(pb)*(1+(npar-1)/(8*sizeof(pb))));
\r
765 if (!empty_texts_aux) {
\r
766 fprintf(stderr, "Error: not enough memory\n");
\r
770 bitset(empty_texts_aux, npar-1); // marks the non-empty text with a 1 in the bit vector
\r
773 Text->InsertText(s);
\r
775 return 1; // success
\r
778 // NewEmptyText(): indicates the event of finding a new empty text in the document.
\r
779 // In case of indexing empty and non-empty texts, we insert the empty texts into the
\r
780 // text collection. In case of indexing only non-empty texts, it just indicates an
\r
781 // empty text in the bit vector of empty texts. Returns a non-zero value upon
\r
782 // success, NULLT in case of error.
\r
783 int XMLTree::NewEmptyText()
\r
785 unsigned char c = 0;
\r
786 if (!initialized) { // data structure has not been initialized properly
\r
787 fprintf(stderr, "Error: you cannot insert a new empty text without first calling method OpenDocument first\n");
\r
791 if (!indexing_empty_texts) {
\r
792 empty_texts_aux = (unsigned int *)realloc(empty_texts_aux, sizeof(pb)*(1+(npar-1)/(8*sizeof(pb))));
\r
793 if (!empty_texts_aux) {
\r
794 fprintf(stderr, "Error: not enough memory\n");
\r
798 bitclean(empty_texts_aux, npar-1); // marks the empty text with a 0 in the bit vector
\r
800 else Text->InsertText(&c); // we insert the empty text just in case we index all the texts
\r
802 return 1; // success
\r
806 // GetTagId: returns the tag identifier corresponding to a given tag name.
\r
807 // Returns NULLT in case that the tag name does not exists.
\r
808 TagType XMLTree::GetTagId(unsigned char *tagname)
\r
811 // this should be changed for more efficient processing
\r
812 for (i=0; i<ntagnames; i++)
\r
813 if (strcmp((const char *)tagname,(const char *)TagName[i])==0) break;
\r
814 if (i==ntagnames) return (TagType)NULLT; // tagname does not exists in the table
\r
819 // GetTagName(tagid): returns the tag name of a given tag identifier.
\r
820 // Returns NULL in case that the tag identifier is not valid.
\r
821 unsigned char *XMLTree::GetTagName(TagType tagid)
\r
825 if (tagid >= ntagnames) return NULL; // invalid tag identifier
\r
826 s = (unsigned char *)malloc((strlen((const char *)TagName[tagid])+1)*sizeof(unsigned char));
\r
827 strcpy((char *)s, (const char *)TagName[tagid]);
\r