merge commit
[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 long &/*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 long &/*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::pair_start(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::pair_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 void SerDesXML::hash_map_start(unsigned long &/*size*/, const char *tag) DECLTHROW(SerializerError)
501 {
502    bool rc = ::start_xml_elem(writer,  tag);
503
504    if (!rc)
505    {
506         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
507    }
508 #if 0
509     int rc = my_xmlTextWriterStartElement(writer, XMLCHAR_CAST tag);
510     if (rc < 0) {
511         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
512     }
513 #endif
514 }
515
516 void SerDesXML::hash_map_end()
517 {
518    bool rc = ::end_xml_elem(writer);
519    if (!rc) 
520    {
521       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
522    }
523
524 #if 0
525     int rc = my_xmlTextWriterEndElement(writer);
526     if (rc < 0) {
527         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
528     }
529 #endif
530 }
531
532 void SerDesXML::annotation_start(Dyninst::AnnotationClassID &a_id, void *& parent_id, sparse_or_dense_anno_t &sod, const char * /*id*/, const char * tag) 
533 {
534    bool rc = ::start_xml_elem(writer, tag);
535
536    if (!rc)
537    {
538         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
539    }
540    translate(a_id, "annotationID");
541    translate((Address &)parent_id, "annotatableID");
542    translate((int &) sod, "SparseOrDense");
543    //char sodstr[12];
544    //sprintf(sodstr, "%s", sod == sparse ? "sparse" : "dense");
545    //const char *sodstr = (sod == sparse) ? "sparse" : "dense";
546    //translate((const char *&)const_cast<const char *>(sodstr), 12, "SparseOrDense");
547 }
548
549 void SerDesXML::annotation_end()
550 {
551    bool rc = ::end_xml_elem(writer);
552    if (!rc) 
553    {
554       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
555    }
556
557 }
558
559 void SerDesXML::annotation_container_start(void *& id) 
560 {
561    bool rc = ::start_xml_elem(writer, "AnnotationContainer");
562
563    if (!rc)
564    {
565         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
566    }
567    translate((Address &)id, "containerID");
568 }
569
570 void SerDesXML::annotation_container_end()
571 {
572    bool rc = ::end_xml_elem(writer);
573    if (!rc) 
574    {
575       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
576    }
577
578 }
579
580 void SerDesXML::annotation_container_item_start(void *& id) 
581 {
582    bool rc = ::start_xml_elem(writer, "AnnotationContainerItem");
583
584    if (!rc)
585    {
586         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
587    }
588    translate((Address &)id, "containerID");
589 }
590
591 void SerDesXML::annotation_container_item_end()
592 {
593    bool rc = ::end_xml_elem(writer);
594    if (!rc) 
595    {
596       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
597    }
598
599 }
600 void SerDesXML::annotation_list_start(Address &/*id*/, unsigned long &/*nelem*/, const char * tag) 
601 {
602    bool rc = ::start_xml_elem(writer, tag);
603
604    if (!rc)
605    {
606         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
607    }
608 }
609
610 void SerDesXML::annotation_list_end()
611 {
612    bool rc = ::end_xml_elem(writer);
613    if (!rc) 
614    {
615       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
616    }
617
618 }
619 void SerDesXML::translate(bool &param, const char *tag)
620 {       
621    bool rc = write_xml_elem(writer, tag,
622          "%s", param ? "true" : "false");
623
624    if (!rc) 
625    {
626       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
627    }
628
629 #if 0
630     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
631                                                 "%s", param ? "true" : "false");
632     if (rc < 0) {
633         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
634     }
635 #endif
636     
637 }     
638
639 void SerDesXML::translate(char &param, const char *tag)
640 {       
641    bool rc = write_xml_elem(writer, tag,
642          "%c", 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                                                 "%c", param);
652     if (rc < 0) {
653         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
654     }
655 #endif
656     
657 }     
658
659 void SerDesXML::translate(int &param, const char *tag)
660 {   
661    bool rc = write_xml_elem(writer, tag,
662          "%d", param);
663
664    if (!rc) 
665    {
666       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
667    }
668     
669 #if 0
670     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
671                                                  "%d", param);
672     if (rc < 0) {
673         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
674     }
675 #endif
676 }
677
678 void SerDesXML::translate(long &param, const char *tag)
679 {   
680    bool rc = write_xml_elem(writer, tag,
681          "%l", param);
682
683    if (!rc) 
684    {
685       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
686    }
687     
688 #if 0
689     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
690                                                  "%l", param);
691     if (rc < 0) {
692         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
693     }
694 #endif
695 }
696
697 void SerDesXML::translate(short &param, const char *tag)
698 {   
699    bool rc = write_xml_elem(writer, tag,
700          "%h", param);
701
702    if (!rc) 
703    {
704       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
705    }
706     
707 #if 0
708     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
709                                                  "%h", param);
710     if (rc < 0) {
711         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
712     }
713 #endif
714 }
715
716 void SerDesXML::translate(unsigned short &param, const char *tag)
717 {   
718    bool rc = write_xml_elem(writer, tag,
719          "%h", param);
720
721    if (!rc) 
722    {
723       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
724    }
725     
726 #if 0
727     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
728                                                  "%h", param);
729     if (rc < 0) {
730         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
731     }
732 #endif
733 }
734 void SerDesXML::translate(unsigned int &param, const char *tag)
735 {   
736   translate( param, tag);
737 }
738
739 #if 0
740 void SerDesXML::translate(OFFSET &param, const char *tag)
741 {
742
743     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
744                                                  "%lx", param);
745     if (rc < 0) {
746         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
747     }
748 }
749 #endif
750
751 void SerDesXML::translate(float &param, const char *tag)
752 {
753    bool rc = write_xml_elem(writer, tag,
754          "%e", param);
755
756    if (!rc) 
757    {
758       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
759    }
760
761 #if 0
762     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
763                                                  "%e", param);
764     if (rc < 0) {
765         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
766     }
767 #endif
768 }
769
770 void SerDesXML::translate(double &param, const char *tag)
771 {
772    bool rc = write_xml_elem(writer, tag,
773          "%g", param);
774
775    if (!rc) 
776    {
777       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
778    }
779
780 #if 0
781     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
782                                                  "%g", param);
783     if (rc < 0) {
784         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
785     }
786 #endif
787 }
788
789 void SerDesXML::translate(Address &param, const char *tag)
790 {
791    bool rc = write_xml_elem(writer, tag,
792          "%p", param);
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                                                  "%p", param);
802     if (rc < 0) {
803         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
804     }
805 #endif
806 }
807
808 void SerDesXML::translate(void * &param, const char *tag)
809 {
810    bool rc = write_xml_elem(writer, tag,
811          "%p", param);
812
813    if (!rc) 
814    {
815       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
816    }
817
818 #if 0
819     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
820                                                  "%p", param);
821     if (rc < 0) {
822         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
823     }
824 #endif
825 }
826 void SerDesXML::translate(const char * &param, int /*bufsize*/, const char *tag)
827 {
828    bool rc = write_xml_elem(writer, tag,
829          "%s", param);
830
831    if (!rc) 
832    {
833       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
834    }
835 #if 0
836     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
837                                                  "%s", param);
838     if (rc < 0) {
839         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
840     }
841 #endif
842 }
843
844 void SerDesXML::translate(char * &param, int /*bufsize*/, const char *tag)
845 {
846    bool rc = write_xml_elem(writer, tag,
847          "%s", param);
848
849    if (!rc) 
850    {
851       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
852    }
853
854 #if 0
855     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
856                                                  "%s", param);
857     if (rc < 0) {
858         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
859     }
860 #endif
861 }
862
863 void SerDesXML::translate(string &param, const char *tag)
864 {
865    assert(tag);
866    assert(param.c_str());
867
868    bool rc = write_xml_elem(writer, tag,
869          "%s", param.c_str());
870
871    if (!rc) 
872    {
873       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
874    }
875
876 #if 0
877     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
878                                                  "%s", param.c_str());
879     if (rc < 0) {
880         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
881     }
882 #endif
883 }
884
885 #if 0
886 void SerDesXML::translate(pdstring &param, const char *tag)
887 {
888     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
889                                                  "%s", param.c_str());
890     if (rc < 0) {
891         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
892     }
893 }
894 #endif
895
896 void SerDesXML::translate(std::vector<std::string> &param, const char *tag,
897                           const char *elem_tag)
898 {
899    bool rc = ::start_xml_elem(writer, tag);
900    if (!rc)
901    {
902       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
903    }
904
905 #if 0
906     int rc = my_xmlTextWriterStartElement(writer, XMLCHAR_CAST tag) ;
907     if (rc < 0) {
908         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
909     }
910 #endif
911
912     for (unsigned int i = 0; i < param.size(); ++i) 
913       translate(param[i], elem_tag);
914     
915
916    rc = ::end_xml_elem(writer);
917    if (!rc)
918    {
919       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterEndElement");
920    }
921
922 #if 0
923     rc = my_xmlTextWriterEndElement(writer);
924     if (rc < 0) {
925         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
926     }
927 #endif
928 }
929
930 #if 0
931 void SerDesXML::start_element(const char *tag)
932 {
933    int rc = my_xmlTextWriterStartElement(writer, XMLCHAR_CAST tag) ;
934    if (rc < 0) {
935       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
936    }
937 }
938
939 void SerDesXML::end_element()
940 {
941    int rc = my_xmlTextWriterEndElement(writer);
942    if (rc < 0) {
943       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
944    }
945 }
946
947 void SerDesXML::xml_value(const char *s, const char *tag)
948 {
949     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
950                                                  "%s", s);
951     if (rc < 0) {
952         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
953     }
954 }
955 #endif