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