export more serializer interface to allow for finer grain testing
[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 #if 0
65 SerDesXML &SerializerXML::getSD_xml()
66 {
67    SerDes &sd = getSD();
68    SerDesXML *sdxml = dynamic_cast<SerDesXML *> (&sd);
69    assert(sdxml);
70    return *sdxml;
71 }
72 #endif
73
74
75 #if 0
76 bool end_xml_element(SerializerBase *, const char *);
77 #endif
78
79
80
81 // DLLEXPORT SerDesXML(xmlTextWriterPtr w, iomode_t mode)  : SerDes(mode), writer(w) { }
82 // DLLEXPORT static xmlTextWriterPtr init(std::string fname, iomode_t mode, bool verbose);
83
84 #if defined (cap_have_libxml)
85 xmlTextWriterPtr(*my_xmlNewTextWriterFilename)(const char *,int) = NULL;
86
87 int (*my_xmlTextWriterStartDocument)(xmlTextWriterPtr, 
88       const char *, const char *, const char * ) = NULL;
89
90 int (*my_xmlTextWriterStartElement)(xmlTextWriterPtr, 
91       const xmlChar *) = NULL;
92
93 int (*my_xmlTextWriterWriteFormatElement)(xmlTextWriterPtr,
94       const xmlChar *,const char *,...) = NULL;
95
96 int (*my_xmlTextWriterEndDocument)(xmlTextWriterPtr) = NULL;
97
98 void (*my_xmlFreeTextWriter)(xmlTextWriterPtr) = NULL;
99
100 int (*my_xmlTextWriterWriteFormatAttribute)(xmlTextWriterPtr, 
101       const xmlChar *,const char *,...) = NULL;
102
103 int (*my_xmlTextWriterEndElement)(xmlTextWriterPtr) = NULL;
104
105 xmlTextWriterPtr SerDesXML::init(std::string fname, iomode_t /*mode*/, bool /*verbose*/) 
106 {
107 #if defined(_MSC_VER)
108    hXML = LoadLibrary(LPCSTR("../../../i386-unknown-nt4.0/lib/libxml2.dll"));
109    if (hXML == NULL)
110    {
111       char buf[1000];
112       DWORD result = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(),
113         MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
114         buf, 1000, NULL);
115       SER_ERR(buf);
116    }
117
118     my_xmlNewTextWriterFilename = 
119        (xmlTextWriterPtr (*)(const char *,int)) GetProcAddress(hXML,"xmlNewTextWriterFilename");
120     
121     my_xmlTextWriterStartDocument = 
122        (int (*)(xmlTextWriterPtr, const char *, const char *, const char * ))GetProcAddress(hXML,"xmlTextWriterStartDocument");
123     
124     my_xmlTextWriterStartElement = 
125        (int (*)(xmlTextWriterPtr, const xmlChar *))GetProcAddress(hXML,"xmlTextWriterStartElement");
126
127     my_xmlTextWriterWriteFormatElement = 
128        (int (*)(xmlTextWriterPtr,const xmlChar *,const char *,...))GetProcAddress(hXML,"xmlTextWriterWriteFormatElement");
129
130     my_xmlTextWriterEndDocument = 
131        (int (*)(xmlTextWriterPtr))GetProcAddress(hXML,"xmlTextWriterEndDocument");
132
133     my_xmlFreeTextWriter = 
134        (void (*)(xmlTextWriterPtr))GetProcAddress(hXML,"xmlFreeTextWriter");
135
136     my_xmlTextWriterWriteFormatAttribute = 
137        (int (*)(xmlTextWriterPtr, const xmlChar *,const char *,...))GetProcAddress(hXML,"xmlTextWriterWriteFormatAttribute");
138     
139     my_xmlTextWriterEndElement = 
140        (int (*)(xmlTextWriterPtr))GetProcAddress(hXML,"xmlTextWriterEndElement");
141
142 #else
143
144     hXML = dlopen("libxml2.so", RTLD_LAZY);
145
146     if (hXML == NULL)
147     {
148       SER_ERR("Unable to find libxml2");
149       return NULL;
150     }
151
152     my_xmlNewTextWriterFilename = (xmlTextWriterPtr(*)(const char *,int))dlsym(hXML,"xmlNewTextWriterFilename");
153     my_xmlTextWriterStartDocument = (int(*)(xmlTextWriterPtr, const char *, const char *, const char * ))dlsym(hXML,"xmlTextWriterStartDocument");
154     my_xmlTextWriterStartElement = (int(*)(xmlTextWriterPtr, const xmlChar *))dlsym(hXML,"xmlTextWriterStartElement");
155     my_xmlTextWriterWriteFormatElement = (int(*)(xmlTextWriterPtr,const xmlChar *,const char *,...))dlsym(hXML,"xmlTextWriterWriteFormatElement");
156     my_xmlTextWriterEndDocument = (int(*)(xmlTextWriterPtr))dlsym(hXML,"xmlTextWriterEndDocument");
157     my_xmlFreeTextWriter = (void(*)(xmlTextWriterPtr))dlsym(hXML,"xmlFreeTextWriter");
158     my_xmlTextWriterWriteFormatAttribute = (int(*)(xmlTextWriterPtr, const xmlChar *,const char *,...))dlsym(hXML,"xmlTextWriterWriteFormatAttribute");
159     my_xmlTextWriterEndElement = (int(*)(xmlTextWriterPtr))dlsym(hXML,"xmlTextWriterEndElement");
160
161 #endif
162
163     /* Create a new XmlWriter for DOM */
164
165     xmlTextWriterPtr writer = my_xmlNewTextWriterFilename(fname.c_str(), 0);
166
167     if (writer == NULL) 
168     {
169         SER_ERR("testXmlwriterDoc: Error creating the xml writer");
170       return NULL;
171     }
172
173     int rc = my_xmlTextWriterStartDocument(writer, NULL, "ISO-8859-1", NULL);
174
175     if (rc < 0) 
176     {
177         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartDocument");
178     return NULL;
179     }
180
181     return writer;
182 }
183
184 #endif // defined (cap_have_libxml)
185
186
187 namespace Dyninst {
188 #if defined (cap_have_libxml)
189 //int (*my_xmlTextWriterStartElement)(xmlTextWriterPtr, 
190 //      const xmlChar *) = NULL;
191 bool start_xml_elem(void *writer, const char *tag)
192 {
193     int rc = my_xmlTextWriterStartElement((xmlTextWriterPtr) writer, XMLCHAR_CAST tag);
194     return (rc >= 0);
195 }
196 //    my_xmlTextWriterEndElement(writer);
197
198 bool end_xml_elem(void *writer)
199 {
200     int rc = my_xmlTextWriterEndElement((xmlTextWriterPtr) writer);
201     return (rc >= 0);
202 }
203
204 bool write_xml_elem(void *writer, const char *tag, const char *fmt, ...)
205 {
206    va_list ap;
207    va_start(ap, fmt);
208
209    int rc = my_xmlTextWriterWriteFormatElement((xmlTextWriterPtr) writer, XMLCHAR_CAST tag, fmt, ap);
210
211    if (rc < 0) 
212    {
213       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
214    }
215
216    va_end(ap);
217
218    return (rc >= 0);
219 }
220 #else
221
222 bool start_xml_elem(void * /*writer*/, const char * /*xmlChar*/)
223 {
224    fprintf(stderr, "%s[%d]:  xml output is disabled\n", FILE__, __LINE__);
225    return false;
226 }
227
228 bool end_xml_elem(void * /*writer*/)
229 {
230    fprintf(stderr, "%s[%d]:  xml output is disabled\n", FILE__, __LINE__);
231    return false;
232 }
233
234 bool write_xml_elem(void * /*writer*/, const char * /*tag*/, const char * /*fmt*/, ...)
235 {
236    fprintf(stderr, "%s[%d]:  xml output is disabled\n", FILE__, __LINE__);
237    return false;
238 }
239 #endif
240 }
241
242 namespace Dyninst {
243 bool start_xml_elem(SerDesXML &s, const char *tag)
244 {
245         return start_xml_elem(s.writer, tag);
246 }
247 bool end_xml_elem(SerDesXML &s)
248 {
249         return end_xml_elem(s.writer);
250 }
251 }
252
253 namespace Dyninst {
254 bool ifxml_start_element(SerializerBase *sb, const char *tag)
255 {
256 #if 0
257    SerializerXML *sxml = dynamic_cast<SerializerXML *>(sb);
258    if (!sxml) 
259    {
260       return false;
261    }
262
263    if (sxml->iomode() == sd_deserialize) 
264    {
265       fprintf(stderr, "%s[%d]:  ERROR:  request to deserialize xml\n", FILE__, __LINE__);
266       return false;
267    }
268 #endif
269    if (!sb->isXML())
270            return false;
271    if (!sb->isOutput())
272    {
273       fprintf(stderr, "%s[%d]:  ERROR:  request to deserialize xml\n", FILE__, __LINE__);
274       return false;
275    }
276
277    SerDes &sd = sb->getSD();
278    SerDesXML *sdxml = dynamic_cast<SerDesXML *>(&sd);
279    assert(sdxml);
280    ::start_xml_elem(sdxml->writer, tag);
281
282 #if 0
283    sxml->getSD_xml().start_element(tag);
284 #endif
285
286    return true;
287 }
288 }
289
290 namespace Dyninst {
291 COMMON_EXPORT bool ifxml_end_element(SerializerBase *sb, const char * /*tag*/)
292 {
293 #if 0
294    SerializerXML *sxml = dynamic_cast<SerializerXML *>(sb);
295
296    if (!sxml) 
297    {
298       return false;
299    }
300
301    if (sxml->iomode() == sd_deserialize) 
302    {
303       fprintf(stderr, "%s[%d]:  ERROR:  request to deserialize xml\n", FILE__, __LINE__);
304       return false;
305    }
306 #endif
307    if (!sb->isXML())
308            return false;
309    if (!sb->isOutput())
310    {
311       fprintf(stderr, "%s[%d]:  ERROR:  request to deserialize xml\n", FILE__, __LINE__);
312       return false;
313    }
314
315    SerDes &sd = sb->getSD();
316    SerDesXML *sdxml = dynamic_cast<SerDesXML *>(&sd);
317    assert(sdxml);
318    ::end_xml_elem(sdxml->writer);
319    
320 #if 0
321    sxml->getSD_xml().end_element();
322 #endif
323
324    return true;
325 }
326 }
327
328 #if 0
329 bool SerializerXML::start_xml_element(SerializerBase *sb, const char *tag)
330 {
331    SerializerXML *sxml = dynamic_cast<SerializerXML *>(sb);
332
333    if (!sxml) 
334    {
335       fprintf(stderr, "%s[%d]:  FIXME:  called xml function with non xml serializer\n", 
336             FILE__, __LINE__);
337       return false;
338    }
339
340    SerDesXML sdxml = sxml->getSD_xml();
341    start_xml_elem(sdxml.writer, tag);
342
343 #if 0
344    sdxml.start_element(tag); 
345 #endif
346
347    return true;
348 }
349 #endif
350
351 #if 0
352 bool SerializerXML::end_xml_element(SerializerBase * sb, const char  * /*tag*/)
353 {
354    SerializerXML *sxml = dynamic_cast<SerializerXML *>(sb);
355
356    if (!sxml) 
357    {
358       fprintf(stderr, "%s[%d]:  FIXME:  called xml function with non xml serializer\n", 
359             FILE__, __LINE__);
360       return false;
361    }
362
363    SerDesXML sdxml = sxml->getSD_xml();
364    end_xml_elem(sdxml.writer);
365
366 #if 0
367    sdxml.end_element(); 
368 #endif
369    return true;
370 }
371 #endif
372 SerDesXML::~SerDesXML()
373 {
374 #if defined (cap_have_libxml)
375     my_xmlFreeTextWriter(writer);
376 #endif
377
378 }
379
380 void SerDesXML::vector_start(unsigned int &/*size*/, const char *tag) DECLTHROW(SerializerError)
381 {
382    bool rc = ::start_xml_elem(writer, tag);
383
384    if (!rc)
385    {
386         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
387    }
388
389 #if 0
390     int rc = my_xmlTextWriterStartElement(writer, XMLCHAR_CAST tag);
391     if (rc < 0) {
392         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
393     }
394 #endif
395 }
396
397 void SerDesXML::vector_end()
398 {
399    bool rc = ::end_xml_elem(writer);
400    if (!rc) 
401    {
402       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
403    }
404
405 #if 0
406     int rc = my_xmlTextWriterEndElement(writer);
407     if (rc < 0) {
408         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
409     }
410 #endif
411 }
412
413 void SerDesXML::multimap_start(unsigned int &/*size*/, const char *tag) DECLTHROW(SerializerError)
414 {
415    bool rc = ::start_xml_elem(writer, tag);
416
417    if (!rc)
418    {
419         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
420    }
421 #if 0
422     int rc = my_xmlTextWriterStartElement(writer, XMLCHAR_CAST tag);
423     if (rc < 0) {
424         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
425     }
426 #endif
427 }
428
429 void SerDesXML::multimap_end()
430 {
431    bool rc = ::end_xml_elem(writer);
432    if (!rc) 
433    {
434       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
435    }
436
437 #if 0
438     int rc = my_xmlTextWriterEndElement(writer);
439     if (rc < 0) {
440         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
441     }
442 #endif
443 }
444
445 void SerDesXML::hash_map_start(unsigned int &/*size*/, const char *tag) DECLTHROW(SerializerError)
446 {
447    bool rc = ::start_xml_elem(writer,  tag);
448
449    if (!rc)
450    {
451         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
452    }
453 #if 0
454     int rc = my_xmlTextWriterStartElement(writer, XMLCHAR_CAST tag);
455     if (rc < 0) {
456         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
457     }
458 #endif
459 }
460
461 void SerDesXML::hash_map_end()
462 {
463    bool rc = ::end_xml_elem(writer);
464    if (!rc) 
465    {
466       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
467    }
468
469 #if 0
470     int rc = my_xmlTextWriterEndElement(writer);
471     if (rc < 0) {
472         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
473     }
474 #endif
475 }
476
477 void SerDesXML::annotation_start(const char * /*id*/, const char * tag) 
478 {
479    bool rc = ::start_xml_elem(writer, tag);
480
481    if (!rc)
482    {
483         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
484    }
485 }
486
487 void SerDesXML::annotation_end()
488 {
489    bool rc = ::end_xml_elem(writer);
490    if (!rc) 
491    {
492       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
493    }
494
495 }
496
497
498 void SerDesXML::translate(bool &param, const char *tag)
499 {       
500    bool rc = write_xml_elem(writer, tag,
501          "%s", param ? "true" : "false");
502
503    if (!rc) 
504    {
505       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
506    }
507
508 #if 0
509     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
510                                                 "%s", param ? "true" : "false");
511     if (rc < 0) {
512         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
513     }
514 #endif
515     
516 }     
517
518 void SerDesXML::translate(char &param, const char *tag)
519 {       
520    bool rc = write_xml_elem(writer, tag,
521          "%c", param);
522
523    if (!rc) 
524    {
525       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
526    }
527
528 #if 0
529     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
530                                                 "%c", param);
531     if (rc < 0) {
532         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
533     }
534 #endif
535     
536 }     
537
538 void SerDesXML::translate(int &param, const char *tag)
539 {   
540    bool rc = write_xml_elem(writer, tag,
541          "%d", 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                                                  "%d", param);
551     if (rc < 0) {
552         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
553     }
554 #endif
555 }
556
557 void SerDesXML::translate(long &param, const char *tag)
558 {   
559    bool rc = write_xml_elem(writer, tag,
560          "%l", param);
561
562    if (!rc) 
563    {
564       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
565    }
566     
567 #if 0
568     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
569                                                  "%l", param);
570     if (rc < 0) {
571         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
572     }
573 #endif
574 }
575
576 void SerDesXML::translate(short &param, const char *tag)
577 {   
578    bool rc = write_xml_elem(writer, tag,
579          "%h", param);
580
581    if (!rc) 
582    {
583       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
584    }
585     
586 #if 0
587     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
588                                                  "%h", param);
589     if (rc < 0) {
590         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
591     }
592 #endif
593 }
594
595 void SerDesXML::translate(unsigned int &param, const char *tag)
596 {   
597   translate( param, tag);
598 }
599
600 #if 0
601 void SerDesXML::translate(OFFSET &param, const char *tag)
602 {
603
604     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
605                                                  "%lx", param);
606     if (rc < 0) {
607         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
608     }
609 }
610 #endif
611
612 void SerDesXML::translate(float &param, const char *tag)
613 {
614    bool rc = write_xml_elem(writer, tag,
615          "%e", 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                                                  "%e", param);
625     if (rc < 0) {
626         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
627     }
628 #endif
629 }
630
631 void SerDesXML::translate(double &param, const char *tag)
632 {
633    bool rc = write_xml_elem(writer, tag,
634          "%g", param);
635
636    if (!rc) 
637    {
638       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
639    }
640
641 #if 0
642     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
643                                                  "%g", param);
644     if (rc < 0) {
645         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
646     }
647 #endif
648 }
649
650 void SerDesXML::translate(Address &param, const char *tag)
651 {
652    bool rc = write_xml_elem(writer, tag,
653          "%p", param);
654
655    if (!rc) 
656    {
657       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
658    }
659
660 #if 0
661     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
662                                                  "%p", param);
663     if (rc < 0) {
664         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
665     }
666 #endif
667 }
668
669 void SerDesXML::translate(const char * &param, int /*bufsize*/, const char *tag)
670 {
671    bool rc = write_xml_elem(writer, tag,
672          "%s", param);
673
674    if (!rc) 
675    {
676       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
677    }
678 #if 0
679     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
680                                                  "%s", param);
681     if (rc < 0) {
682         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
683     }
684 #endif
685 }
686
687 void SerDesXML::translate(char * &param, int /*bufsize*/, const char *tag)
688 {
689    bool rc = write_xml_elem(writer, tag,
690          "%s", param);
691
692    if (!rc) 
693    {
694       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
695    }
696
697 #if 0
698     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
699                                                  "%s", param);
700     if (rc < 0) {
701         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
702     }
703 #endif
704 }
705
706 void SerDesXML::translate(string &param, const char *tag)
707 {
708    assert(tag);
709    assert(param.c_str());
710
711    bool rc = write_xml_elem(writer, tag,
712          "%s", param.c_str());
713
714    if (!rc) 
715    {
716       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
717    }
718
719 #if 0
720     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
721                                                  "%s", param.c_str());
722     if (rc < 0) {
723         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
724     }
725 #endif
726 }
727
728 #if 0
729 void SerDesXML::translate(pdstring &param, const char *tag)
730 {
731     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
732                                                  "%s", param.c_str());
733     if (rc < 0) {
734         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
735     }
736 }
737 #endif
738
739 void SerDesXML::translate(std::vector<std::string> &param, const char *tag,
740                           const char *elem_tag)
741 {
742    bool rc = ::start_xml_elem(writer, tag);
743    if (!rc)
744    {
745       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
746    }
747
748 #if 0
749     int rc = my_xmlTextWriterStartElement(writer, XMLCHAR_CAST tag) ;
750     if (rc < 0) {
751         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
752     }
753 #endif
754
755     for (unsigned int i = 0; i < param.size(); ++i) 
756       translate(param[i], elem_tag);
757     
758
759    rc = ::end_xml_elem(writer);
760    if (!rc)
761    {
762       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterEndElement");
763    }
764
765 #if 0
766     rc = my_xmlTextWriterEndElement(writer);
767     if (rc < 0) {
768         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
769     }
770 #endif
771 }
772
773 #if 0
774 void SerDesXML::start_element(const char *tag)
775 {
776    int rc = my_xmlTextWriterStartElement(writer, XMLCHAR_CAST tag) ;
777    if (rc < 0) {
778       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
779    }
780 }
781
782 void SerDesXML::end_element()
783 {
784    int rc = my_xmlTextWriterEndElement(writer);
785    if (rc < 0) {
786       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
787    }
788 }
789
790 void SerDesXML::xml_value(const char *s, const char *tag)
791 {
792     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
793                                                  "%s", s);
794     if (rc < 0) {
795         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
796     }
797 }
798 #endif