checkpoint for merge
[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 *tag)
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((xmlTextWriterPtr) 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 COMMON_EXPORT 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 }
335
336 void SerDesXML::vector_start(unsigned int &/*size*/, const char *tag) DECLTHROW(SerializerError)
337 {
338    bool rc = start_xml_elem(writer, tag);
339
340    if (!rc)
341    {
342         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
343    }
344
345 #if 0
346     int rc = my_xmlTextWriterStartElement(writer, XMLCHAR_CAST tag);
347     if (rc < 0) {
348         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
349     }
350 #endif
351 }
352
353 void SerDesXML::vector_end()
354 {
355    bool rc = end_xml_elem(writer);
356    if (!rc) 
357    {
358       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
359    }
360
361 #if 0
362     int rc = my_xmlTextWriterEndElement(writer);
363     if (rc < 0) {
364         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
365     }
366 #endif
367 }
368
369 void SerDesXML::multimap_start(unsigned int &/*size*/, const char *tag) DECLTHROW(SerializerError)
370 {
371    bool rc = start_xml_elem(writer, tag);
372
373    if (!rc)
374    {
375         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
376    }
377 #if 0
378     int rc = my_xmlTextWriterStartElement(writer, XMLCHAR_CAST tag);
379     if (rc < 0) {
380         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
381     }
382 #endif
383 }
384
385 void SerDesXML::multimap_end()
386 {
387    bool rc = end_xml_elem(writer);
388    if (!rc) 
389    {
390       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
391    }
392
393 #if 0
394     int rc = my_xmlTextWriterEndElement(writer);
395     if (rc < 0) {
396         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
397     }
398 #endif
399 }
400
401 void SerDesXML::hash_map_start(unsigned int &/*size*/, const char *tag) DECLTHROW(SerializerError)
402 {
403    bool rc = start_xml_elem(writer,  tag);
404
405    if (!rc)
406    {
407         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
408    }
409 #if 0
410     int rc = my_xmlTextWriterStartElement(writer, XMLCHAR_CAST tag);
411     if (rc < 0) {
412         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
413     }
414 #endif
415 }
416
417 void SerDesXML::hash_map_end()
418 {
419    bool rc = end_xml_elem(writer);
420    if (!rc) 
421    {
422       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
423    }
424
425 #if 0
426     int rc = my_xmlTextWriterEndElement(writer);
427     if (rc < 0) {
428         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
429     }
430 #endif
431 }
432
433 void SerDesXML::annotation_start(const char * /*id*/, const char * tag) 
434 {
435    bool rc = start_xml_elem(writer, tag);
436
437    if (!rc)
438    {
439         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
440    }
441 }
442
443 void SerDesXML::annotation_end()
444 {
445    bool rc = end_xml_elem(writer);
446    if (!rc) 
447    {
448       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
449    }
450
451 }
452
453
454 void SerDesXML::translate(bool &param, const char *tag)
455 {       
456    bool rc = write_xml_elem(writer, tag,
457          "%s", param ? "true" : "false");
458
459    if (!rc) 
460    {
461       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
462    }
463
464 #if 0
465     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
466                                                 "%s", param ? "true" : "false");
467     if (rc < 0) {
468         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
469     }
470 #endif
471     
472 }     
473
474 void SerDesXML::translate(char &param, const char *tag)
475 {       
476    bool rc = write_xml_elem(writer, tag,
477          "%c", param);
478
479    if (!rc) 
480    {
481       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
482    }
483
484 #if 0
485     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
486                                                 "%c", param);
487     if (rc < 0) {
488         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
489     }
490 #endif
491     
492 }     
493
494 void SerDesXML::translate(int &param, const char *tag)
495 {   
496    bool rc = write_xml_elem(writer, tag,
497          "%d", param);
498
499    if (!rc) 
500    {
501       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
502    }
503     
504 #if 0
505     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
506                                                  "%d", param);
507     if (rc < 0) {
508         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
509     }
510 #endif
511 }
512
513 void SerDesXML::translate(long &param, const char *tag)
514 {   
515    bool rc = write_xml_elem(writer, tag,
516          "%l", param);
517
518    if (!rc) 
519    {
520       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
521    }
522     
523 #if 0
524     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
525                                                  "%l", param);
526     if (rc < 0) {
527         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
528     }
529 #endif
530 }
531
532 void SerDesXML::translate(short &param, const char *tag)
533 {   
534    bool rc = write_xml_elem(writer, tag,
535          "%h", param);
536
537    if (!rc) 
538    {
539       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
540    }
541     
542 #if 0
543     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
544                                                  "%h", param);
545     if (rc < 0) {
546         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
547     }
548 #endif
549 }
550
551 void SerDesXML::translate(unsigned int &param, const char *tag)
552 {   
553   translate( param, tag);
554 }
555
556 #if 0
557 void SerDesXML::translate(OFFSET &param, const char *tag)
558 {
559
560     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
561                                                  "%lx", param);
562     if (rc < 0) {
563         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
564     }
565 }
566 #endif
567
568 void SerDesXML::translate(float &param, const char *tag)
569 {
570    bool rc = write_xml_elem(writer, tag,
571          "%e", param);
572
573    if (!rc) 
574    {
575       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
576    }
577
578 #if 0
579     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
580                                                  "%e", param);
581     if (rc < 0) {
582         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
583     }
584 #endif
585 }
586
587 void SerDesXML::translate(double &param, const char *tag)
588 {
589    bool rc = write_xml_elem(writer, tag,
590          "%g", param);
591
592    if (!rc) 
593    {
594       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
595    }
596
597 #if 0
598     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
599                                                  "%g", param);
600     if (rc < 0) {
601         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
602     }
603 #endif
604 }
605
606 void SerDesXML::translate(Address &param, const char *tag)
607 {
608    bool rc = write_xml_elem(writer, tag,
609          "%p", param);
610
611    if (!rc) 
612    {
613       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
614    }
615
616 #if 0
617     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
618                                                  "%p", param);
619     if (rc < 0) {
620         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
621     }
622 #endif
623 }
624
625 void SerDesXML::translate(const char * &param, int /*bufsize*/, const char *tag)
626 {
627    bool rc = write_xml_elem(writer, tag,
628          "%s", param);
629
630    if (!rc) 
631    {
632       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
633    }
634 #if 0
635     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
636                                                  "%s", param);
637     if (rc < 0) {
638         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
639     }
640 #endif
641 }
642
643 void SerDesXML::translate(char * &param, int /*bufsize*/, const char *tag)
644 {
645    bool rc = write_xml_elem(writer, tag,
646          "%s", param);
647
648    if (!rc) 
649    {
650       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
651    }
652
653 #if 0
654     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
655                                                  "%s", param);
656     if (rc < 0) {
657         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
658     }
659 #endif
660 }
661
662 void SerDesXML::translate(string &param, const char *tag)
663 {
664    assert(tag);
665    assert(param.c_str());
666
667    bool rc = write_xml_elem(writer, tag,
668          "%s", param.c_str());
669
670    if (!rc) 
671    {
672       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
673    }
674
675 #if 0
676     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
677                                                  "%s", param.c_str());
678     if (rc < 0) {
679         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
680     }
681 #endif
682 }
683
684 #if 0
685 void SerDesXML::translate(pdstring &param, const char *tag)
686 {
687     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
688                                                  "%s", param.c_str());
689     if (rc < 0) {
690         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
691     }
692 }
693 #endif
694
695 void SerDesXML::translate(std::vector<std::string> &param, const char *tag,
696                           const char *elem_tag)
697 {
698    bool rc = start_xml_elem(writer, tag);
699    if (!rc)
700    {
701       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
702    }
703
704 #if 0
705     int rc = my_xmlTextWriterStartElement(writer, XMLCHAR_CAST tag) ;
706     if (rc < 0) {
707         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
708     }
709 #endif
710
711     for (unsigned int i = 0; i < param.size(); ++i) 
712       translate(param[i], elem_tag);
713     
714
715    rc = end_xml_elem(writer);
716    if (!rc)
717    {
718       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterEndElement");
719    }
720
721 #if 0
722     rc = my_xmlTextWriterEndElement(writer);
723     if (rc < 0) {
724         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
725     }
726 #endif
727 }
728
729 #if 0
730 void SerDesXML::start_element(const char *tag)
731 {
732    int rc = my_xmlTextWriterStartElement(writer, XMLCHAR_CAST tag) ;
733    if (rc < 0) {
734       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
735    }
736 }
737
738 void SerDesXML::end_element()
739 {
740    int rc = my_xmlTextWriterEndElement(writer);
741    if (rc < 0) {
742       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
743    }
744 }
745
746 void SerDesXML::xml_value(const char *s, const char *tag)
747 {
748     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
749                                                  "%s", s);
750     if (rc < 0) {
751         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
752     }
753 }
754 #endif