For the most part all the changes here are behind-the-scenes and disabled
[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 //libxml2 functions
39 void *hXML;
40 #else
41 #include "windows.h"
42 #include <libxml/xmlversion.h>
43 #undef LIBXML_ICONV_ENABLED
44 HINSTANCE hXML;
45 #endif
46
47 #if defined (os_linux) || defined (os_aix) || defined(os_solaris)
48 //  gcc is complaining about the constness of the library-provided
49 //  typecast (BAD_CAST) (which is defined in xmlstring.h), so we make our own
50 #define XMLCHAR_CAST (const xmlChar *)
51 #else
52 #define XMLCHAR_CAST BAD_CAST
53 #endif
54
55 SerDesXML &SerializerXML::getSD_xml()
56 {
57    SerDes &sd = getSD();
58    SerDesXML *sdxml = dynamic_cast<SerDesXML *> (&sd);
59    assert(sdxml);
60    return *sdxml;
61 }
62
63 bool SerializerXML::start_xml_element(SerializerBase *sb, const char *tag)
64 {
65    SerializerXML *sxml = dynamic_cast<SerializerXML *>(sb);
66    if (!sxml) {
67       fprintf(stderr, "%s[%d]:  FIXME:  called xml function with non xml serializer\n", FILE__, __LINE__);
68       return false;
69    }
70
71    SerDesXML sdxml = sxml->getSD_xml();
72    sdxml.start_element(tag); 
73    return true;
74 }
75
76 bool SerializerXML::end_xml_element(SerializerBase * sb, const char  * /*tag*/)
77 {
78    SerializerXML *sxml = dynamic_cast<SerializerXML *>(sb);
79    if (!sxml) {
80       fprintf(stderr, "%s[%d]:  FIXME:  called xml function with non xml serializer\n", FILE__, __LINE__);
81       return false;
82    }
83
84    SerDesXML sdxml = sxml->getSD_xml();
85    sdxml.end_element(); 
86    return true;
87 }
88
89 #if 0
90 bool end_xml_element(SerializerBase *, const char *);
91 #endif
92
93 xmlTextWriterPtr(*my_xmlNewTextWriterFilename)(const char *,int) = NULL;
94 int(*my_xmlTextWriterStartDocument)(xmlTextWriterPtr, const char *, const char *, const char * ) = NULL;
95 int(*my_xmlTextWriterStartElement)(xmlTextWriterPtr, const xmlChar *) = NULL;
96 int(*my_xmlTextWriterWriteFormatElement)(xmlTextWriterPtr,const xmlChar *,const char *,...) = NULL;
97 int(*my_xmlTextWriterEndDocument)(xmlTextWriterPtr) = NULL;
98 void(*my_xmlFreeTextWriter)(xmlTextWriterPtr) = NULL;
99 int(*my_xmlTextWriterWriteFormatAttribute)(xmlTextWriterPtr, const xmlChar *,const char *,...) = NULL;
100 int(*my_xmlTextWriterEndElement)(xmlTextWriterPtr) = NULL;
101
102 //SerDesXML::SerDesXML(std::string fname, iomode_t mode, bool verbose) :
103 //  SerDes(fname, mode, verbose)
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       char buf[1000];
110       DWORD result = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(),
111         MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
112         buf, 1000, NULL);
113       SER_ERR(buf);
114     }
115     my_xmlNewTextWriterFilename = (xmlTextWriterPtr(*)(const char *,int))GetProcAddress(hXML,"xmlNewTextWriterFilename");
116     my_xmlTextWriterStartDocument = (int(*)(xmlTextWriterPtr, const char *, const char *, const char * ))GetProcAddress(hXML,"xmlTextWriterStartDocument");
117     my_xmlTextWriterStartElement = (int(*)(xmlTextWriterPtr, const xmlChar *))GetProcAddress(hXML,"xmlTextWriterStartElement");
118     my_xmlTextWriterWriteFormatElement = (int(*)(xmlTextWriterPtr,const xmlChar *,const char *,...))GetProcAddress(hXML,"xmlTextWriterWriteFormatElement");
119     my_xmlTextWriterEndDocument = (int(*)(xmlTextWriterPtr))GetProcAddress(hXML,"xmlTextWriterEndDocument");
120     my_xmlFreeTextWriter = (void(*)(xmlTextWriterPtr))GetProcAddress(hXML,"xmlFreeTextWriter");
121     my_xmlTextWriterWriteFormatAttribute = (int(*)(xmlTextWriterPtr, const xmlChar *,const char *,...))GetProcAddress(hXML,"xmlTextWriterWriteFormatAttribute");
122     my_xmlTextWriterEndElement = (int(*)(xmlTextWriterPtr))GetProcAddress(hXML,"xmlTextWriterEndElement");
123 #else
124     hXML = dlopen("libxml2.so", RTLD_LAZY);
125     if(hXML == NULL){
126       SER_ERR("Unable to find libxml2");
127       return NULL;
128    }
129     my_xmlNewTextWriterFilename = (xmlTextWriterPtr(*)(const char *,int))dlsym(hXML,"xmlNewTextWriterFilename");
130     my_xmlTextWriterStartDocument = (int(*)(xmlTextWriterPtr, const char *, const char *, const char * ))dlsym(hXML,"xmlTextWriterStartDocument");
131     my_xmlTextWriterStartElement = (int(*)(xmlTextWriterPtr, const xmlChar *))dlsym(hXML,"xmlTextWriterStartElement");
132     my_xmlTextWriterWriteFormatElement = (int(*)(xmlTextWriterPtr,const xmlChar *,const char *,...))dlsym(hXML,"xmlTextWriterWriteFormatElement");
133     my_xmlTextWriterEndDocument = (int(*)(xmlTextWriterPtr))dlsym(hXML,"xmlTextWriterEndDocument");
134     my_xmlFreeTextWriter = (void(*)(xmlTextWriterPtr))dlsym(hXML,"xmlFreeTextWriter");
135     my_xmlTextWriterWriteFormatAttribute = (int(*)(xmlTextWriterPtr, const xmlChar *,const char *,...))dlsym(hXML,"xmlTextWriterWriteFormatAttribute");
136     my_xmlTextWriterEndElement = (int(*)(xmlTextWriterPtr))dlsym(hXML,"xmlTextWriterEndElement");
137
138 #endif
139     /* Create a new XmlWriter for DOM */
140     xmlTextWriterPtr writer = my_xmlNewTextWriterFilename(fname.c_str(), 0);
141     if (writer == NULL) {
142         SER_ERR("testXmlwriterDoc: Error creating the xml writer");
143       return NULL;
144     }
145     int rc = my_xmlTextWriterStartDocument(writer, NULL, "ISO-8859-1", NULL);
146     if (rc < 0) {
147         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartDocument");
148     return NULL;
149     }
150
151     return writer;
152 }
153
154 SerDesXML::~SerDesXML()
155 {
156     my_xmlFreeTextWriter(writer);
157
158 #if defined(_MSC_VER)
159     FreeLibrary(hXML);
160 #else
161     //  should we dlclose??
162 #endif
163
164 }
165
166 void SerDesXML::vector_start(unsigned int &/*size*/, const char *tag) DECLTHROW(SerializerError)
167 {
168     int rc = my_xmlTextWriterStartElement(writer, XMLCHAR_CAST tag);
169     if (rc < 0) {
170         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
171     }
172 }
173
174 void SerDesXML::vector_end()
175 {
176     int rc = my_xmlTextWriterEndElement(writer);
177     if (rc < 0) {
178         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
179     }
180 }
181
182 void SerDesXML::multimap_start(unsigned int &/*size*/, const char *tag) DECLTHROW(SerializerError)
183 {
184     int rc = my_xmlTextWriterStartElement(writer, XMLCHAR_CAST tag);
185     if (rc < 0) {
186         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
187     }
188 }
189
190 void SerDesXML::multimap_end()
191 {
192     int rc = my_xmlTextWriterEndElement(writer);
193     if (rc < 0) {
194         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
195     }
196 }
197
198 void SerDesXML::hash_map_start(unsigned int &/*size*/, const char *tag) DECLTHROW(SerializerError)
199 {
200     int rc = my_xmlTextWriterStartElement(writer, XMLCHAR_CAST tag);
201     if (rc < 0) {
202         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
203     }
204 }
205
206 void SerDesXML::hash_map_end()
207 {
208     int rc = my_xmlTextWriterEndElement(writer);
209     if (rc < 0) {
210         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
211     }
212 }
213
214 void SerDesXML::annotation_start(const char * /*id*/, const char * /*tag*/) 
215 {
216 }
217
218 void SerDesXML::annotation_end()
219 {
220 }
221
222 void SerDesXML::translate(bool &param, const char *tag)
223 {       
224     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
225                                                 "%s", param ? "true" : "false");
226     if (rc < 0) {
227         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
228     }
229     
230 }     
231
232 void SerDesXML::translate(char &param, const char *tag)
233 {       
234     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
235                                                 "%c", param);
236     if (rc < 0) {
237         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
238     }
239     
240 }     
241
242 void SerDesXML::translate(int &param, const char *tag)
243 {   
244     
245     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
246                                                  "%d", param);
247     if (rc < 0) {
248         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
249     }
250 }
251
252 void SerDesXML::translate(long &param, const char *tag)
253 {   
254     
255     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
256                                                  "%l", param);
257     if (rc < 0) {
258         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
259     }
260 }
261
262 void SerDesXML::translate(short &param, const char *tag)
263 {   
264     
265     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
266                                                  "%h", param);
267     if (rc < 0) {
268         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
269     }
270 }
271
272 void SerDesXML::translate(unsigned int &param, const char *tag)
273 {   
274   translate( param, tag);
275 }
276
277 #if 0
278 void SerDesXML::translate(OFFSET &param, const char *tag)
279 {
280
281     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
282                                                  "%lx", param);
283     if (rc < 0) {
284         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
285     }
286 }
287 #endif
288
289 void SerDesXML::translate(float &param, const char *tag)
290 {
291
292     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
293                                                  "%e", param);
294     if (rc < 0) {
295         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
296     }
297 }
298
299 void SerDesXML::translate(double &param, const char *tag)
300 {
301
302     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
303                                                  "%g", param);
304     if (rc < 0) {
305         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
306     }
307 }
308
309 void SerDesXML::translate(Address &param, const char *tag)
310 {
311
312     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
313                                                  "%p", param);
314     if (rc < 0) {
315         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
316     }
317 }
318
319 void SerDesXML::translate(const char * &param, int /*bufsize*/, const char *tag)
320 {
321     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
322                                                  "%s", param);
323     if (rc < 0) {
324         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
325     }
326 }
327
328 void SerDesXML::translate(char * &param, int /*bufsize*/, const char *tag)
329 {
330     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
331                                                  "%s", param);
332     if (rc < 0) {
333         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
334     }
335 }
336
337 void SerDesXML::translate(string &param, const char *tag)
338 {
339     assert(tag);
340     assert(param.c_str());
341     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
342                                                  "%s", param.c_str());
343     if (rc < 0) {
344         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
345     }
346 }
347
348 #if 0
349 void SerDesXML::translate(pdstring &param, const char *tag)
350 {
351     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
352                                                  "%s", param.c_str());
353     if (rc < 0) {
354         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
355     }
356 }
357 #endif
358
359 void SerDesXML::translate(std::vector<std::string> &param, const char *tag,
360                           const char *elem_tag)
361 {
362     int rc = my_xmlTextWriterStartElement(writer, XMLCHAR_CAST tag) ;
363     if (rc < 0) {
364         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
365     }
366
367     for (unsigned int i = 0; i < param.size(); ++i) 
368       translate(param[i], elem_tag);
369     
370
371     rc = my_xmlTextWriterEndElement(writer);
372     if (rc < 0) {
373         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
374     }
375 }
376
377 void SerDesXML::start_element(const char *tag)
378 {
379    int rc = my_xmlTextWriterStartElement(writer, XMLCHAR_CAST tag) ;
380    if (rc < 0) {
381       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
382    }
383 }
384
385 void SerDesXML::end_element()
386 {
387    int rc = my_xmlTextWriterEndElement(writer);
388    if (rc < 0) {
389       SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
390    }
391 }
392
393 void SerDesXML::xml_value(const char *s, const char *tag)
394 {
395     int rc = my_xmlTextWriterWriteFormatElement(writer, XMLCHAR_CAST tag,
396                                                  "%s", s);
397     if (rc < 0) {
398         SER_ERR("testXmlwriterDoc: Error at my_xmlTextWriterStartElement");
399     }
400 }