add compiler flag cap_have_libxml, which can be disabled to build dyninst
[dyninst.git] / common / src / serialize-xml.C
1
2 /*
3  * Copyright (c) 1996-2007 Barton P. Miller
4  * 
5  * We provide the Paradyn Parallel Performance Tools (below
6  * described as "Paradyn") on an AS IS basis, and do not warrant its
7  * validity or performance.  We reserve the right to update, modify,
8  * or discontinue this software at any time.  We shall have no
9  * obligation to supply such updates or modifications or any other
10  * form of support to you.
11  * 
12  * By your use of Paradyn, you understand and agree that we (or any
13  * other person or entity with proprietary rights in Paradyn) are
14  * under no obligation to provide either maintenance services,
15  * update services, notices of latent defects, or correction of
16  * defects for Paradyn.
17  * 
18  * This library is free software; you can redistribute it and/or
19  * modify it under the terms of the GNU Lesser General Public
20  * License as published by the Free Software Foundation; either
21  * version 2.1 of the License, or (at your option) any later version.
22  * 
23  * This library is distributed in the hope that it will be useful,
24  * but WITHOUT ANY WARRANTY; without even the implied warranty of
25  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
26  * Lesser General Public License for more details.
27  * 
28  * You should have received a copy of the GNU Lesser General Public
29  * License along with this library; if not, write to the Free Software
30  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
31  */
32
33 #include "common/h/serialize.h"
34
35 #if !defined(os_windows)
36 #include "common/h/pathName.h"
37 #include <dlfcn.h>
38 #if defined (cap_have_libxml)
39 //libxml2 functions
40 void *hXML;
41 #endif
42 #else
43 #include "windows.h"
44 #if defined (cap_have_libxml)
45 #include <libxml/xmlversion.h>
46 #undef LIBXML_ICONV_ENABLED
47 HINSTANCE hXML;
48 #endif
49 #endif
50
51 #if defined (cap_have_libxml)
52 #if defined (os_linux) || defined (os_aix) || defined(os_solaris)
53 //  gcc is complaining about the constness of the library-provided
54 //  typecast (BAD_CAST) (which is defined in xmlstring.h), so we make our own
55 #define XMLCHAR_CAST (const xmlChar *)
56 #else
57 #define XMLCHAR_CAST BAD_CAST
58 #endif
59
60 #else
61 #define XMLCHAR_CAST (const char *)
62 #endif
63
64 SerDesXML &SerializerXML::getSD_xml()
65 {
66    SerDes &sd = getSD();
67    SerDesXML *sdxml = dynamic_cast<SerDesXML *> (&sd);
68    assert(sdxml);
69    return *sdxml;
70 }
71
72
73 #if 0
74 bool end_xml_element(SerializerBase *, const char *);
75 #endif
76
77
78
79 // DLLEXPORT SerDesXML(xmlTextWriterPtr w, iomode_t mode)  : SerDes(mode), writer(w) { }
80 // DLLEXPORT static xmlTextWriterPtr init(std::string fname, iomode_t mode, bool verbose);
81
82 #if defined (cap_have_libxml)
83 xmlTextWriterPtr(*my_xmlNewTextWriterFilename)(const char *,int) = NULL;
84
85 int (*my_xmlTextWriterStartDocument)(xmlTextWriterPtr, 
86       const char *, const char *, const char * ) = NULL;
87
88 int (*my_xmlTextWriterStartElement)(xmlTextWriterPtr, 
89       const xmlChar *) = NULL;
90
91 int (*my_xmlTextWriterWriteFormatElement)(xmlTextWriterPtr,
92       const xmlChar *,const char *,...) = NULL;
93
94 int (*my_xmlTextWriterEndDocument)(xmlTextWriterPtr) = NULL;
95
96 void (*my_xmlFreeTextWriter)(xmlTextWriterPtr) = NULL;
97
98 int (*my_xmlTextWriterWriteFormatAttribute)(xmlTextWriterPtr, 
99       const xmlChar *,const char *,...) = NULL;
100
101 int (*my_xmlTextWriterEndElement)(xmlTextWriterPtr) = NULL;
102
103 xmlTextWriterPtr SerDesXML::init(std::string fname, iomode_t /*mode*/, bool /*verbose*/) 
104 {
105 #if defined(_MSC_VER)
106    hXML = LoadLibrary(LPCSTR("../../../i386-unknown-nt4.0/lib/libxml2.dll"));
107    if (hXML == NULL)
108    {
109       char buf[1000];
110       DWORD result = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(),
111         MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
112         buf, 1000, NULL);
113       SER_ERR(buf);
114    }
115
116     my_xmlNewTextWriterFilename = 
117        (xmlTextWriterPtr (*)(const char *,int)) GetProcAddress(hXML,"xmlNewTextWriterFilename");
118     
119     my_xmlTextWriterStartDocument = 
120        (int (*)(xmlTextWriterPtr, const char *, const char *, const char * ))GetProcAddress(hXML,"xmlTextWriterStartDocument");
121     
122     my_xmlTextWriterStartElement = 
123        (int (*)(xmlTextWriterPtr, const xmlChar *))GetProcAddress(hXML,"xmlTextWriterStartElement");
124
125     my_xmlTextWriterWriteFormatElement = 
126        (int (*)(xmlTextWriterPtr,const xmlChar *,const char *,...))GetProcAddress(hXML,"xmlTextWriterWriteFormatElement");
127
128     my_xmlTextWriterEndDocument = 
129        (int (*)(xmlTextWriterPtr))GetProcAddress(hXML,"xmlTextWriterEndDocument");
130
131     my_xmlFreeTextWriter = 
132        (void (*)(xmlTextWriterPtr))GetProcAddress(hXML,"xmlFreeTextWriter");
133
134     my_xmlTextWriterWriteFormatAttribute = 
135        (int (*)(xmlTextWriterPtr, const xmlChar *,const char *,...))GetProcAddress(hXML,"xmlTextWriterWriteFormatAttribute");
136     
137     my_xmlTextWriterEndElement = 
138        (int (*)(xmlTextWriterPtr))GetProcAddress(hXML,"xmlTextWriterEndElement");
139
140 #else
141
142     hXML = dlopen("libxml2.so", RTLD_LAZY);
143
144     if (hXML == NULL)
145     {
146       SER_ERR("Unable to find libxml2");
147       return NULL;
148     }
149
150     my_xmlNewTextWriterFilename = (xmlTextWriterPtr(*)(const char *,int))dlsym(hXML,"xmlNewTextWriterFilename");
151     my_xmlTextWriterStartDocument = (int(*)(xmlTextWriterPtr, const char *, const char *, const char * ))dlsym(hXML,"xmlTextWriterStartDocument");
152     my_xmlTextWriterStartElement = (int(*)(xmlTextWriterPtr, const xmlChar *))dlsym(hXML,"xmlTextWriterStartElement");
153     my_xmlTextWriterWriteFormatElement = (int(*)(xmlTextWriterPtr,const xmlChar *,const char *,...))dlsym(hXML,"xmlTextWriterWriteFormatElement");
154     my_xmlTextWriterEndDocument = (int(*)(xmlTextWriterPtr))dlsym(hXML,"xmlTextWriterEndDocument");
155     my_xmlFreeTextWriter = (void(*)(xmlTextWriterPtr))dlsym(hXML,"xmlFreeTextWriter");
156     my_xmlTextWriterWriteFormatAttribute = (int(*)(xmlTextWriterPtr, const xmlChar *,const char *,...))dlsym(hXML,"xmlTextWriterWriteFormatAttribute");
157     my_xmlTextWriterEndElement = (int(*)(xmlTextWriterPtr))dlsym(hXML,"xmlTextWriterEndElement");
158
159 #endif
160
161     /* Create a new XmlWriter for DOM */
162
163     xmlTextWriterPtr writer = my_xmlNewTextWriterFilename(fname.c_str(), 0);
164
165     if (writer == NULL) 
166     {
167         SER_ERR("testXmlwriterDoc: Error creating the xml writer");
168       return NULL;
169     }
170
171     int rc = my_xmlTextWriterStartDocument(writer, NULL, "ISO-8859-1", NULL);
172
173     if (rc < 0) 
174     {
175         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartDocument");
176     return NULL;
177     }
178
179     return writer;
180 }
181
182 #endif // defined (cap_have_libxml)
183
184 #if defined (cap_have_libxml)
185 //int (*my_xmlTextWriterStartElement)(xmlTextWriterPtr, 
186 //      const xmlChar *) = NULL;
187 bool start_xml_elem(void *writer, const char *xmlChar)
188 {
189     int rc = my_xmlTextWriterStartElement((xmlTextWriterPtr) writer, XMLCHAR_CAST tag);
190     return (rc >= 0);
191 }
192 //    my_xmlTextWriterEndElement(writer);
193
194 bool end_xml_elem(void *writer)
195 {
196     int rc = my_xmlTextWriterEndElement((xmlTextWriterPtr) writer);
197     return (rc >= 0);
198 }
199
200 bool write_xml_elem(void *writer, const char *tag, const char *fmt, ...)
201 {
202    va_list ap;
203    va_start(ap, fmt);
204
205    int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag, fmt, ap);
206
207    if (rc < 0) 
208    {
209       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
210    }
211
212    va_end(ap);
213
214    return (rc >= 0);
215 }
216 #else
217
218 int start_xml_elem(void * /*writer*/, const char * /*xmlChar*/)
219 {
220    fprintf(stderr, "%s[%d]:  xml output is disabled\n", FILE__, __LINE__);
221    return false;
222 }
223
224 bool end_xml_elem(void * /*writer*/)
225 {
226    fprintf(stderr, "%s[%d]:  xml output is disabled\n", FILE__, __LINE__);
227    return false;
228 }
229
230 bool write_xml_elem(void * /*writer*/, const char * /*tag*/, const char * /*fmt*/, ...)
231 {
232    fprintf(stderr, "%s[%d]:  xml output is disabled\n", FILE__, __LINE__);
233    return false;
234 }
235 #endif
236
237 namespace Dyninst {
238 bool ifxml_start_element(SerializerBase *sb, const char *tag)
239 {
240    SerializerXML *sxml = dynamic_cast<SerializerXML *>(sb);
241    if (!sxml) 
242    {
243       return false;
244    }
245
246    if (sxml->iomode() == sd_deserialize) 
247    {
248       fprintf(stderr, "%s[%d]:  ERROR:  request to deserialize xml\n", FILE__, __LINE__);
249       return false;
250    }
251
252    start_xml_elem(sxml->getSD_xml().writer, tag);
253
254 #if 0
255    sxml->getSD_xml().start_element(tag);
256 #endif
257
258    return true;
259 }
260 }
261
262 namespace Dyninst {
263 bool ifxml_end_element(SerializerBase *sb, const char * /*tag*/)
264 {
265    SerializerXML *sxml = dynamic_cast<SerializerXML *>(sb);
266
267    if (!sxml) 
268    {
269       return false;
270    }
271
272    if (sxml->iomode() == sd_deserialize) 
273    {
274       fprintf(stderr, "%s[%d]:  ERROR:  request to deserialize xml\n", FILE__, __LINE__);
275       return false;
276    }
277
278    end_xml_elem(sxml->getSD_xml().writer);
279    
280 #if 0
281    sxml->getSD_xml().end_element();
282 #endif
283
284    return true;
285 }
286 }
287
288 bool SerializerXML::start_xml_element(SerializerBase *sb, const char *tag)
289 {
290    SerializerXML *sxml = dynamic_cast<SerializerXML *>(sb);
291
292    if (!sxml) 
293    {
294       fprintf(stderr, "%s[%d]:  FIXME:  called xml function with non xml serializer\n", 
295             FILE__, __LINE__);
296       return false;
297    }
298
299    SerDesXML sdxml = sxml->getSD_xml();
300    start_xml_elem(sdxml.writer, tag);
301
302 #if 0
303    sdxml.start_element(tag); 
304 #endif
305
306    return true;
307 }
308
309 bool SerializerXML::end_xml_element(SerializerBase * sb, const char  * /*tag*/)
310 {
311    SerializerXML *sxml = dynamic_cast<SerializerXML *>(sb);
312
313    if (!sxml) 
314    {
315       fprintf(stderr, "%s[%d]:  FIXME:  called xml function with non xml serializer\n", 
316             FILE__, __LINE__);
317       return false;
318    }
319
320    SerDesXML sdxml = sxml->getSD_xml();
321    end_xml_elem(sdxml.writer);
322
323 #if 0
324    sdxml.end_element(); 
325 #endif
326    return true;
327 }
328 SerDesXML::~SerDesXML()
329 {
330 #if defined (cap_have_libxml)
331     my_xmlFreeTextWriter(writer);
332 #endif
333
334 #if defined(_MSC_VER)
335     FreeLibrary(hXML);
336 #else
337     //  should we dlclose??
338 #endif
339
340 }
341
342 void SerDesXML::vector_start(unsigned int &/*size*/, const char *tag) DECLTHROW(SerializerError)
343 {
344    bool rc = start_xml_elem(writer, XMLCHAR_CAST tag);
345
346    if (!rc)
347    {
348         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
349    }
350
351 #if 0
352     int rc = my_xmlTextWriterStartElement(writer, XMLCHAR_CAST tag);
353     if (rc < 0) {
354         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
355     }
356 #endif
357 }
358
359 void SerDesXML::vector_end()
360 {
361    bool rc = end_xml_elem(writer);
362    if (!rc) 
363    {
364       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
365    }
366
367 #if 0
368     int rc = my_xmlTextWriterEndElement(writer);
369     if (rc < 0) {
370         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
371     }
372 #endif
373 }
374
375 void SerDesXML::multimap_start(unsigned int &/*size*/, const char *tag) DECLTHROW(SerializerError)
376 {
377    bool rc = start_xml_elem(writer, XMLCHAR_CAST tag);
378
379    if (!rc)
380    {
381         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
382    }
383 #if 0
384     int rc = my_xmlTextWriterStartElement(writer, XMLCHAR_CAST tag);
385     if (rc < 0) {
386         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
387     }
388 #endif
389 }
390
391 void SerDesXML::multimap_end()
392 {
393    bool rc = end_xml_elem(writer);
394    if (!rc) 
395    {
396       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
397    }
398
399 #if 0
400     int rc = my_xmlTextWriterEndElement(writer);
401     if (rc < 0) {
402         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
403     }
404 #endif
405 }
406
407 void SerDesXML::hash_map_start(unsigned int &/*size*/, const char *tag) DECLTHROW(SerializerError)
408 {
409    bool rc = start_xml_elem(writer, XMLCHAR_CAST tag);
410
411    if (!rc)
412    {
413         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
414    }
415 #if 0
416     int rc = my_xmlTextWriterStartElement(writer, XMLCHAR_CAST tag);
417     if (rc < 0) {
418         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
419     }
420 #endif
421 }
422
423 void SerDesXML::hash_map_end()
424 {
425    bool rc = end_xml_elem(writer);
426    if (!rc) 
427    {
428       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
429    }
430
431 #if 0
432     int rc = my_xmlTextWriterEndElement(writer);
433     if (rc < 0) {
434         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
435     }
436 #endif
437 }
438
439 void SerDesXML::annotation_start(const char * /*id*/, const char * tag) 
440 {
441    bool rc = start_xml_elem(writer, XMLCHAR_CAST tag);
442
443    if (!rc)
444    {
445         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
446    }
447 }
448
449 void SerDesXML::annotation_end()
450 {
451    bool rc = end_xml_elem(writer);
452    if (!rc) 
453    {
454       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
455    }
456
457 }
458
459
460 void SerDesXML::translate(bool &param, const char *tag)
461 {       
462    bool rc = write_xml_elem(writer, tag,
463          "%s", param ? "true" : "false");
464
465    if (!rc) 
466    {
467       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
468    }
469
470 #if 0
471     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
472                                                 "%s", param ? "true" : "false");
473     if (rc < 0) {
474         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
475     }
476 #endif
477     
478 }     
479
480 void SerDesXML::translate(char &param, const char *tag)
481 {       
482    bool rc = write_xml_elem(writer, tag,
483          "%c", param);
484
485    if (!rc) 
486    {
487       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
488    }
489
490 #if 0
491     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
492                                                 "%c", param);
493     if (rc < 0) {
494         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
495     }
496 #endif
497     
498 }     
499
500 void SerDesXML::translate(int &param, const char *tag)
501 {   
502    bool rc = write_xml_elem(writer, tag,
503          "%d", param);
504
505    if (!rc) 
506    {
507       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
508    }
509     
510 #if 0
511     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
512                                                  "%d", param);
513     if (rc < 0) {
514         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
515     }
516 #endif
517 }
518
519 void SerDesXML::translate(long &param, const char *tag)
520 {   
521    bool rc = write_xml_elem(writer, tag,
522          "%l", param);
523
524    if (!rc) 
525    {
526       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
527    }
528     
529 #if 0
530     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
531                                                  "%l", param);
532     if (rc < 0) {
533         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
534     }
535 #endif
536 }
537
538 void SerDesXML::translate(short &param, const char *tag)
539 {   
540    bool rc = write_xml_elem(writer, tag,
541          "%h", param);
542
543    if (!rc) 
544    {
545       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
546    }
547     
548 #if 0
549     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
550                                                  "%h", param);
551     if (rc < 0) {
552         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
553     }
554 #endif
555 }
556
557 void SerDesXML::translate(unsigned int &param, const char *tag)
558 {   
559   translate( param, tag);
560 }
561
562 #if 0
563 void SerDesXML::translate(OFFSET &param, const char *tag)
564 {
565
566     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
567                                                  "%lx", param);
568     if (rc < 0) {
569         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
570     }
571 }
572 #endif
573
574 void SerDesXML::translate(float &param, const char *tag)
575 {
576    bool rc = write_xml_elem(writer, tag,
577          "%e", param);
578
579    if (!rc) 
580    {
581       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
582    }
583
584 #if 0
585     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
586                                                  "%e", param);
587     if (rc < 0) {
588         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
589     }
590 #endif
591 }
592
593 void SerDesXML::translate(double &param, const char *tag)
594 {
595    bool rc = write_xml_elem(writer, tag,
596          "%g", param);
597
598    if (!rc) 
599    {
600       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
601    }
602
603 #if 0
604     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
605                                                  "%g", param);
606     if (rc < 0) {
607         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
608     }
609 #endif
610 }
611
612 void SerDesXML::translate(Address &param, const char *tag)
613 {
614    bool rc = write_xml_elem(writer, tag,
615          "%p", param);
616
617    if (!rc) 
618    {
619       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
620    }
621
622 #if 0
623     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
624                                                  "%p", param);
625     if (rc < 0) {
626         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
627     }
628 #endif
629 }
630
631 void SerDesXML::translate(const char * &param, int /*bufsize*/, const char *tag)
632 {
633    bool rc = write_xml_elem(writer, tag,
634          "%s", param);
635
636    if (!rc) 
637    {
638       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
639    }
640 #if 0
641     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
642                                                  "%s", param);
643     if (rc < 0) {
644         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
645     }
646 #endif
647 }
648
649 void SerDesXML::translate(char * &param, int /*bufsize*/, const char *tag)
650 {
651    bool rc = write_xml_elem(writer, tag,
652          "%s", param);
653
654    if (!rc) 
655    {
656       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
657    }
658
659 #if 0
660     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
661                                                  "%s", param);
662     if (rc < 0) {
663         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
664     }
665 #endif
666 }
667
668 void SerDesXML::translate(string &param, const char *tag)
669 {
670    assert(tag);
671    assert(param.c_str());
672
673    bool rc = write_xml_elem(writer, tag,
674          "%s", param.c_str());
675
676    if (!rc) 
677    {
678       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
679    }
680
681 #if 0
682     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
683                                                  "%s", param.c_str());
684     if (rc < 0) {
685         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
686     }
687 #endif
688 }
689
690 #if 0
691 void SerDesXML::translate(pdstring &param, const char *tag)
692 {
693     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
694                                                  "%s", param.c_str());
695     if (rc < 0) {
696         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
697     }
698 }
699 #endif
700
701 void SerDesXML::translate(std::vector<std::string> &param, const char *tag,
702                           const char *elem_tag)
703 {
704    bool rc = start_xml_elem(writer, tag);
705    if (!rc)
706    {
707       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
708    }
709
710 #if 0
711     int rc = my_xmlTextWriterStartElement(writer, XMLCHAR_CAST tag) ;
712     if (rc < 0) {
713         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
714     }
715 #endif
716
717     for (unsigned int i = 0; i < param.size(); ++i) 
718       translate(param[i], elem_tag);
719     
720
721    rc = end_xml_elem(writer);
722    if (!rc)
723    {
724       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterEndElement");
725    }
726
727 #if 0
728     rc = my_xmlTextWriterEndElement(writer);
729     if (rc < 0) {
730         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
731     }
732 #endif
733 }
734
735 #if 0
736 void SerDesXML::start_element(const char *tag)
737 {
738    int rc = my_xmlTextWriterStartElement(writer, XMLCHAR_CAST tag) ;
739    if (rc < 0) {
740       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
741    }
742 }
743
744 void SerDesXML::end_element()
745 {
746    int rc = my_xmlTextWriterEndElement(writer);
747    if (rc < 0) {
748       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
749    }
750 }
751
752 void SerDesXML::xml_value(const char *s, const char *tag)
753 {
754     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
755                                                  "%s", s);
756     if (rc < 0) {
757         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
758     }
759 }
760 #endif