more serialization, fleshing out of test_ser_anno
[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 bool SerializerXML::start_xml_element(SerializerBase *sb, const char *tag)
329 {
330         SerializerXML *sxml = dynamic_cast<SerializerXML *>(sb);
331
332         if (!sxml)
333         {
334                 fprintf(stderr, "%s[%d]:  FIXME:  called xml function with non xml serializer\n",
335                                 FILE__, __LINE__);
336                 return false;
337         }
338
339         SerDesXML sdxml = sxml->getSD_xml();
340         start_xml_elem(sdxml, tag);
341         return true;
342
343 }
344 #if 0
345 bool SerializerXML::start_xml_element(SerializerBase *sb, const char *tag)
346 {
347         SerializerXML *sxml = dynamic_cast<SerializerXML *>(sb);
348
349         if (!sxml) 
350         {
351       fprintf(stderr, "%s[%d]:  FIXME:  called xml function with non xml serializer\n", 
352             FILE__, __LINE__);
353       return false;
354    }
355
356    SerDesXML sdxml = sxml->getSD_xml();
357    start_xml_elem(sdxml.writer, tag);
358
359 #if 0
360    sdxml.start_element(tag); 
361 #endif
362
363    return true;
364 }
365 #endif
366
367 SerDesXML &SerializerXML::getSD_xml()
368 {
369         SerializerBase *sb = this;
370         SerDes &sd = sb->getSD();
371         SerDesXML *sdxml = dynamic_cast<SerDesXML *> (&sd);
372         assert(sdxml);
373         return *sdxml;
374 }
375
376 bool SerializerXML::end_xml_element(SerializerBase * sb, const char  * /*tag*/)
377 {
378    SerializerXML *sxml = dynamic_cast<SerializerXML *>(sb);
379
380    if (!sxml) 
381    {
382       fprintf(stderr, "%s[%d]:  FIXME:  called xml function with non xml serializer\n", 
383             FILE__, __LINE__);
384       return false;
385    }
386
387    SerDesXML sdxml = sxml->getSD_xml();
388    end_xml_elem(sdxml);
389
390 #if 0
391    sdxml.end_element(); 
392 #endif
393    return true;
394 }
395
396 SerDesXML::~SerDesXML()
397 {
398 #if defined (cap_have_libxml)
399     my_xmlFreeTextWriter(writer);
400 #endif
401
402 }
403
404 void SerDesXML::vector_start(unsigned int &/*size*/, const char *tag) DECLTHROW(SerializerError)
405 {
406    bool rc = ::start_xml_elem(writer, tag);
407
408    if (!rc)
409    {
410         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
411    }
412
413 #if 0
414     int rc = my_xmlTextWriterStartElement(writer, XMLCHAR_CAST tag);
415     if (rc < 0) {
416         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
417     }
418 #endif
419 }
420
421 void SerDesXML::vector_end()
422 {
423    bool rc = ::end_xml_elem(writer);
424    if (!rc) 
425    {
426       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
427    }
428
429 #if 0
430     int rc = my_xmlTextWriterEndElement(writer);
431     if (rc < 0) {
432         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
433     }
434 #endif
435 }
436
437 void SerDesXML::multimap_start(unsigned int &/*size*/, const char *tag) DECLTHROW(SerializerError)
438 {
439    bool rc = ::start_xml_elem(writer, tag);
440
441    if (!rc)
442    {
443         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
444    }
445 #if 0
446     int rc = my_xmlTextWriterStartElement(writer, XMLCHAR_CAST tag);
447     if (rc < 0) {
448         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
449     }
450 #endif
451 }
452
453 void SerDesXML::multimap_end()
454 {
455    bool rc = ::end_xml_elem(writer);
456    if (!rc) 
457    {
458       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
459    }
460
461 #if 0
462     int rc = my_xmlTextWriterEndElement(writer);
463     if (rc < 0) {
464         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
465     }
466 #endif
467 }
468
469 void SerDesXML::hash_map_start(unsigned int &/*size*/, const char *tag) DECLTHROW(SerializerError)
470 {
471    bool rc = ::start_xml_elem(writer,  tag);
472
473    if (!rc)
474    {
475         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
476    }
477 #if 0
478     int rc = my_xmlTextWriterStartElement(writer, XMLCHAR_CAST tag);
479     if (rc < 0) {
480         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
481     }
482 #endif
483 }
484
485 void SerDesXML::hash_map_end()
486 {
487    bool rc = ::end_xml_elem(writer);
488    if (!rc) 
489    {
490       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
491    }
492
493 #if 0
494     int rc = my_xmlTextWriterEndElement(writer);
495     if (rc < 0) {
496         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
497     }
498 #endif
499 }
500
501 void SerDesXML::annotation_start(Dyninst::AnnotationClassID &a_id, const char * /*id*/, const char * tag) 
502 {
503    bool rc = ::start_xml_elem(writer, tag);
504
505    if (!rc)
506    {
507         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
508    }
509    translate(a_id, "annotationID");
510 }
511
512 void SerDesXML::annotation_end()
513 {
514    bool rc = ::end_xml_elem(writer);
515    if (!rc) 
516    {
517       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
518    }
519
520 }
521
522
523 void SerDesXML::annotation_list_start(Address &/*id*/, int &nelem, const char * tag) 
524 {
525    bool rc = ::start_xml_elem(writer, tag);
526
527    if (!rc)
528    {
529         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
530    }
531 }
532
533 void SerDesXML::annotation_list_end()
534 {
535    bool rc = ::end_xml_elem(writer);
536    if (!rc) 
537    {
538       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
539    }
540
541 }
542 void SerDesXML::translate(bool &param, const char *tag)
543 {       
544    bool rc = write_xml_elem(writer, tag,
545          "%s", param ? "true" : "false");
546
547    if (!rc) 
548    {
549       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
550    }
551
552 #if 0
553     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
554                                                 "%s", param ? "true" : "false");
555     if (rc < 0) {
556         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
557     }
558 #endif
559     
560 }     
561
562 void SerDesXML::translate(char &param, const char *tag)
563 {       
564    bool rc = write_xml_elem(writer, tag,
565          "%c", param);
566
567    if (!rc) 
568    {
569       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
570    }
571
572 #if 0
573     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
574                                                 "%c", param);
575     if (rc < 0) {
576         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
577     }
578 #endif
579     
580 }     
581
582 void SerDesXML::translate(int &param, const char *tag)
583 {   
584    bool rc = write_xml_elem(writer, tag,
585          "%d", param);
586
587    if (!rc) 
588    {
589       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
590    }
591     
592 #if 0
593     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
594                                                  "%d", param);
595     if (rc < 0) {
596         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
597     }
598 #endif
599 }
600
601 void SerDesXML::translate(long &param, const char *tag)
602 {   
603    bool rc = write_xml_elem(writer, tag,
604          "%l", param);
605
606    if (!rc) 
607    {
608       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
609    }
610     
611 #if 0
612     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
613                                                  "%l", param);
614     if (rc < 0) {
615         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
616     }
617 #endif
618 }
619
620 void SerDesXML::translate(short &param, const char *tag)
621 {   
622    bool rc = write_xml_elem(writer, tag,
623          "%h", param);
624
625    if (!rc) 
626    {
627       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
628    }
629     
630 #if 0
631     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
632                                                  "%h", param);
633     if (rc < 0) {
634         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
635     }
636 #endif
637 }
638
639 void SerDesXML::translate(unsigned short &param, const char *tag)
640 {   
641    bool rc = write_xml_elem(writer, tag,
642          "%h", param);
643
644    if (!rc) 
645    {
646       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
647    }
648     
649 #if 0
650     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
651                                                  "%h", param);
652     if (rc < 0) {
653         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
654     }
655 #endif
656 }
657 void SerDesXML::translate(unsigned int &param, const char *tag)
658 {   
659   translate( param, tag);
660 }
661
662 #if 0
663 void SerDesXML::translate(OFFSET &param, const char *tag)
664 {
665
666     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
667                                                  "%lx", param);
668     if (rc < 0) {
669         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
670     }
671 }
672 #endif
673
674 void SerDesXML::translate(float &param, const char *tag)
675 {
676    bool rc = write_xml_elem(writer, tag,
677          "%e", param);
678
679    if (!rc) 
680    {
681       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
682    }
683
684 #if 0
685     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
686                                                  "%e", param);
687     if (rc < 0) {
688         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
689     }
690 #endif
691 }
692
693 void SerDesXML::translate(double &param, const char *tag)
694 {
695    bool rc = write_xml_elem(writer, tag,
696          "%g", param);
697
698    if (!rc) 
699    {
700       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
701    }
702
703 #if 0
704     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
705                                                  "%g", param);
706     if (rc < 0) {
707         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
708     }
709 #endif
710 }
711
712 void SerDesXML::translate(Address &param, const char *tag)
713 {
714    bool rc = write_xml_elem(writer, tag,
715          "%p", param);
716
717    if (!rc) 
718    {
719       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
720    }
721
722 #if 0
723     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
724                                                  "%p", param);
725     if (rc < 0) {
726         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
727     }
728 #endif
729 }
730
731 void SerDesXML::translate(void * &param, const char *tag)
732 {
733    bool rc = write_xml_elem(writer, tag,
734          "%p", param);
735
736    if (!rc) 
737    {
738       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
739    }
740
741 #if 0
742     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
743                                                  "%p", param);
744     if (rc < 0) {
745         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
746     }
747 #endif
748 }
749 void SerDesXML::translate(const char * &param, int /*bufsize*/, const char *tag)
750 {
751    bool rc = write_xml_elem(writer, tag,
752          "%s", param);
753
754    if (!rc) 
755    {
756       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
757    }
758 #if 0
759     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
760                                                  "%s", param);
761     if (rc < 0) {
762         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
763     }
764 #endif
765 }
766
767 void SerDesXML::translate(char * &param, int /*bufsize*/, const char *tag)
768 {
769    bool rc = write_xml_elem(writer, tag,
770          "%s", param);
771
772    if (!rc) 
773    {
774       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
775    }
776
777 #if 0
778     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
779                                                  "%s", param);
780     if (rc < 0) {
781         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
782     }
783 #endif
784 }
785
786 void SerDesXML::translate(string &param, const char *tag)
787 {
788    assert(tag);
789    assert(param.c_str());
790
791    bool rc = write_xml_elem(writer, tag,
792          "%s", param.c_str());
793
794    if (!rc) 
795    {
796       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
797    }
798
799 #if 0
800     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
801                                                  "%s", param.c_str());
802     if (rc < 0) {
803         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
804     }
805 #endif
806 }
807
808 #if 0
809 void SerDesXML::translate(pdstring &param, const char *tag)
810 {
811     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
812                                                  "%s", param.c_str());
813     if (rc < 0) {
814         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
815     }
816 }
817 #endif
818
819 void SerDesXML::translate(std::vector<std::string> &param, const char *tag,
820                           const char *elem_tag)
821 {
822    bool rc = ::start_xml_elem(writer, tag);
823    if (!rc)
824    {
825       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
826    }
827
828 #if 0
829     int rc = my_xmlTextWriterStartElement(writer, XMLCHAR_CAST tag) ;
830     if (rc < 0) {
831         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
832     }
833 #endif
834
835     for (unsigned int i = 0; i < param.size(); ++i) 
836       translate(param[i], elem_tag);
837     
838
839    rc = ::end_xml_elem(writer);
840    if (!rc)
841    {
842       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterEndElement");
843    }
844
845 #if 0
846     rc = my_xmlTextWriterEndElement(writer);
847     if (rc < 0) {
848         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
849     }
850 #endif
851 }
852
853 #if 0
854 void SerDesXML::start_element(const char *tag)
855 {
856    int rc = my_xmlTextWriterStartElement(writer, XMLCHAR_CAST tag) ;
857    if (rc < 0) {
858       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
859    }
860 }
861
862 void SerDesXML::end_element()
863 {
864    int rc = my_xmlTextWriterEndElement(writer);
865    if (rc < 0) {
866       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
867    }
868 }
869
870 void SerDesXML::xml_value(const char *s, const char *tag)
871 {
872     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
873                                                  "%s", s);
874     if (rc < 0) {
875         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
876     }
877 }
878 #endif