Mercurial > repos > ktnyt > gembassy

comparison GEMBASSY-1.0.3/gsoap/dom.cpp @ 0:8300eb051bea draft

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Initial upload
author ktnyt
date Fri, 26 Jun 2015 05:19:29 -0400
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:8300eb051bea
1 /*
2 dom.c[pp]
3
4 gSOAP DOM implementation v3
5
6 gSOAP XML Web services tools
7 Copyright (C) 2000-2012, Robert van Engelen, Genivia, Inc. All Rights Reserved.
8 This part of the software is released under ONE of the following licenses:
9 GPL, or the gSOAP public license, or Genivia's license for commercial use.
10 --------------------------------------------------------------------------------
11 gSOAP public license.
12
13 The contents of this file are subject to the gSOAP Public License Version 1.3
14 (the "License"); you may not use this file except in compliance with the
15 License. You may obtain a copy of the License at
16 http://www.cs.fsu.edu/~engelen/soaplicense.html
17 Software distributed under the License is distributed on an "AS IS" basis,
18 WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
19 for the specific language governing rights and limitations under the License.
20
21 The Initial Developer of the Original Code is Robert A. van Engelen.
22 Copyright (C) 2000-2012 Robert A. van Engelen, Genivia inc. All Rights Reserved.
23 --------------------------------------------------------------------------------
24 GPL license.
25
26 This program is free software; you can redistribute it and/or modify it under
27 the terms of the GNU General Public License as published by the Free Software
28 Foundation; either version 2 of the License, or (at your option) any later
29 version.
30
31 This program is distributed in the hope that it will be useful, but WITHOUT ANY
32 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
33 PARTICULAR PURPOSE. See the GNU General Public License for more details.
34
35 You should have received a copy of the GNU General Public License along with
36 this program; if not, write to the Free Software Foundation, Inc., 59 Temple
37 Place, Suite 330, Boston, MA 02111-1307 USA
38
39 Author contact information:
40 engelen@genivia.com / engelen@acm.org
41
42 This program is released under the GPL with the additional exemption that
43 compiling, linking, and/or using OpenSSL is allowed.
44 --------------------------------------------------------------------------------
45 A commercial use license is available from Genivia, Inc., contact@genivia.com
46 --------------------------------------------------------------------------------
47 */
48
49 #include "stdsoap2.h"
50
51 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_xsd__anyType(struct soap*, struct soap_dom_element const*);
52 SOAP_FMAC3 void SOAP_FMAC4 soap_traverse_xsd__anyType(struct soap*, struct soap_dom_element*, const char*, soap_walker, soap_walker);
53 SOAP_FMAC1 void SOAP_FMAC2 soap_default_xsd__anyType(struct soap*, struct soap_dom_element *);
54 SOAP_FMAC3 int SOAP_FMAC4 soap_put_xsd__anyType(struct soap*, const struct soap_dom_element *, const char*, const char*);
55 SOAP_FMAC1 int SOAP_FMAC2 soap_out_xsd__anyType(struct soap*, const char*, int, const struct soap_dom_element *, const char*);
56 SOAP_FMAC3 struct soap_dom_element * SOAP_FMAC4 soap_get_xsd__anyType(struct soap*, struct soap_dom_element *, const char*, const char*);
57 SOAP_FMAC1 struct soap_dom_element * SOAP_FMAC2 soap_in_xsd__anyType(struct soap*, const char*, struct soap_dom_element *, const char*);
58
59 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_xsd__anyAttribute(struct soap*, struct soap_dom_attribute const*);
60 SOAP_FMAC3 void SOAP_FMAC4 soap_traverse_xsd__anyAttribute(struct soap*, struct soap_dom_attribute*, const char*, soap_walker, soap_walker);
61 SOAP_FMAC1 void SOAP_FMAC2 soap_default_xsd__anyAttribute(struct soap*, struct soap_dom_attribute *);
62 SOAP_FMAC3 int SOAP_FMAC4 soap_put_xsd__anyAttribute(struct soap*, const struct soap_dom_attribute *, const char*, const char*);
63 SOAP_FMAC1 int SOAP_FMAC2 soap_out_xsd__anyAttribute(struct soap*, const char*, int, const struct soap_dom_attribute *, const char*);
64 SOAP_FMAC3 struct soap_dom_attribute * SOAP_FMAC4 soap_get_xsd__anyAttribute(struct soap*, struct soap_dom_attribute *, const char*, const char*);
65 SOAP_FMAC1 struct soap_dom_attribute * SOAP_FMAC2 soap_in_xsd__anyAttribute(struct soap*, const char*, struct soap_dom_attribute *, const char*);
66
67 #ifdef __cplusplus
68 extern "C" {
69 #endif
70
71 #ifndef WITH_NOIDREF
72 SOAP_FMAC1 void SOAP_FMAC2 soap_markelement(struct soap*, const void*, int);
73 #endif
74
75 SOAP_FMAC1 int SOAP_FMAC2 soap_putelement(struct soap*, const void*, const char*, int, int);
76 SOAP_FMAC1 void *SOAP_FMAC2 soap_getelement(struct soap*, int*);
77
78 #ifdef __cplusplus
79 }
80 #endif
81
82 /* format string for generating DOM namespace prefixes (<= 16 chars total) */
83 #define SOAP_DOMID_FORMAT "dom%d"
84
85 /* namespace name (URI) lookup and store routines */
86 static const char *soap_lookup_ns_prefix(struct soap*, const char*);
87 static const char *soap_push_ns_prefix(struct soap*, const char*, const char*, int);
88
89 static int out_element(struct soap *soap, const struct soap_dom_element *node, const char *prefix, const char *name);
90 static int out_attribute(struct soap *soap, const char *prefix, const char *name, const char *data, const wchar_t *wide, int flag);
91
92 /******************************************************************************\
93 *
94 * DOM custom (de)serializers
95 *
96 \******************************************************************************/
97
98 SOAP_FMAC1
99 void
100 SOAP_FMAC2
101 soap_serialize_xsd__anyType(struct soap *soap, const struct soap_dom_element *node)
102 { if (node)
103 { if (node->type && node->node)
104 soap_markelement(soap, node->node, node->type);
105 else
106 { const struct soap_dom_element *elt;
107 for (elt = node->elts; elt; elt = elt->next)
108 soap_serialize_xsd__anyType(soap, elt);
109 }
110 }
111 }
112
113 SOAP_FMAC3
114 void
115 SOAP_FMAC4
116 soap_traverse_xsd__anyType(struct soap *soap, struct soap_dom_element *node, const char *s, soap_walker p, soap_walker q)
117 {
118 }
119
120 /******************************************************************************/
121
122 SOAP_FMAC1
123 void
124 SOAP_FMAC2
125 soap_serialize_xsd__anyAttribute(struct soap *soap, const struct soap_dom_attribute *node)
126 {
127 }
128
129 SOAP_FMAC1
130 void
131 SOAP_FMAC2
132 soap_traverse_xsd__anyAttribute(struct soap *soap, struct soap_dom_attribute *node, const char *s, soap_walker p, soap_walker q)
133 {
134 }
135
136 /******************************************************************************/
137
138 SOAP_FMAC1
139 void
140 SOAP_FMAC2
141 soap_default_xsd__anyType(struct soap *soap, struct soap_dom_element *node)
142 { node->next = NULL;
143 node->prnt = NULL;
144 node->elts = NULL;
145 node->atts = NULL;
146 node->nstr = NULL;
147 node->name = NULL;
148 node->data = NULL;
149 node->wide = NULL;
150 node->node = NULL;
151 node->type = 0;
152 node->head = NULL;
153 node->tail = NULL;
154 node->soap = soap;
155 }
156
157 /******************************************************************************/
158
159 SOAP_FMAC1
160 void
161 SOAP_FMAC2
162 soap_default_xsd__anyAttribute(struct soap *soap, struct soap_dom_attribute *node)
163 { node->next = NULL;
164 node->nstr = NULL;
165 node->name = NULL;
166 node->data = NULL;
167 node->wide = NULL;
168 node->soap = soap;
169 }
170
171 /******************************************************************************/
172
173 static int
174 out_element(struct soap *soap, const struct soap_dom_element *node, const char *prefix, const char *name)
175 { if (node->head && soap_send(soap, node->head))
176 return soap->error;
177 if (node->type && node->node)
178 { if (prefix && *prefix)
179 { char *s = (char*)SOAP_MALLOC(soap, strlen(prefix) + strlen(name) + 2);
180 if (!s)
181 return soap->error = SOAP_EOM;
182 sprintf(s, "%s:%s", prefix, name);
183 soap_putelement(soap, node->node, s, 0, node->type);
184 SOAP_FREE(soap, s);
185 }
186 else
187 return soap_putelement(soap, node->node, name, 0, node->type);
188 }
189 else if (prefix && *prefix)
190 { char *s;
191 if (strlen(prefix) + strlen(name) < sizeof(soap->msgbuf))
192 s = soap->msgbuf;
193 else
194 { s = (char*)SOAP_MALLOC(soap, strlen(prefix) + strlen(name) + 2);
195 if (!s)
196 return soap->error = SOAP_EOM;
197 }
198 sprintf(s, "%s:%s", prefix, name);
199 soap_element(soap, s, 0, NULL); /* element() */
200 if (s != soap->msgbuf)
201 SOAP_FREE(soap, s);
202 }
203 else if (*name != '-')
204 { soap_mode m = soap->mode;
205 if ((soap->mode & SOAP_DOM_ASIS))
206 soap->mode &= ~SOAP_XML_INDENT;
207 soap_element(soap, name, 0, NULL); /* element() */
208 soap->mode = m;
209 }
210 return soap->error;
211 }
212
213 /******************************************************************************/
214
215 static int
216 out_attribute(struct soap *soap, const char *prefix, const char *name, const char *data, const wchar_t *wide, int flag)
217 { char *s;
218 const char *t;
219 int err;
220 if (wide)
221 data = soap_wchar2s(soap, wide);
222 if (!prefix || !*prefix)
223 { if (wide)
224 return soap_set_attr(soap, name, data, 2);
225 if (flag)
226 return soap_set_attr(soap, name, data, 1);
227 return soap_attribute(soap, name, data);
228 }
229 t = strchr(name, ':');
230 if (t)
231 t++;
232 else
233 t = name;
234 if (strlen(prefix) + strlen(t) < sizeof(soap->msgbuf))
235 s = soap->msgbuf;
236 else
237 { s = (char*)SOAP_MALLOC(soap, strlen(prefix) + strlen(t) + 2);
238 if (!s)
239 return soap->error = SOAP_EOM;
240 }
241 sprintf(s, "%s:%s", prefix, t);
242 if (wide)
243 err = soap_set_attr(soap, s, data, 2);
244 else if (flag)
245 err = soap_set_attr(soap, s, data, 1);
246 else
247 err = soap_attribute(soap, s, data);
248 if (s != soap->msgbuf)
249 SOAP_FREE(soap, s);
250 return err;
251 }
252
253 /******************************************************************************/
254
255 SOAP_FMAC1
256 int
257 SOAP_FMAC2
258 soap_out_xsd__anyType(struct soap *soap, const char *tag, int id, const struct soap_dom_element *node, const char *type)
259 { if (node)
260 { const char *prefix; /* namespace prefix, if namespace is present */
261 size_t colon;
262 if (!(soap->mode & SOAP_DOM_ASIS))
263 { const struct soap_dom_attribute *att;
264 for (att = node->atts; att; att = att->next)
265 { if (att->name && att->data && !strncmp(att->name, "xmlns:", 6))
266 { if (soap_push_namespace(soap, att->name + 6, att->data) == NULL)
267 return soap->error;
268 }
269 else if (att->name && att->data && !strcmp(att->name, "xmlns"))
270 { if (soap_push_namespace(soap, "", att->data) == NULL)
271 return soap->error;
272 }
273 }
274 }
275 if (node->name)
276 tag = node->name;
277 else if (!tag)
278 tag = "-";
279 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "DOM node '%s' output at level %u\n", tag, soap->level));
280 if ((prefix = strchr(tag, ':')))
281 { colon = prefix - tag + 1;
282 if (colon > sizeof(soap->tag))
283 colon = sizeof(soap->tag);
284 }
285 else
286 colon = 0;
287 prefix = NULL;
288 if (node->nstr && *node->nstr && !(soap->mode & SOAP_DOM_ASIS))
289 { if (colon)
290 { strncpy(soap->tag, tag, colon - 1);
291 soap->tag[colon - 1] = '\0';
292 if ((prefix = soap_push_ns_prefix(soap, soap->tag, node->nstr, 1)) == NULL
293 || out_element(soap, node, prefix, tag + colon))
294 return soap->error;
295 }
296 else
297 { if ((prefix = soap_lookup_ns_prefix(soap, node->nstr)))
298 { if (out_element(soap, node, prefix, tag + colon))
299 return soap->error;
300 }
301 else
302 { if ((prefix = soap_push_ns_prefix(soap, NULL, node->nstr, 1)) == NULL
303 || out_element(soap, node, prefix, tag + colon))
304 return soap->error;
305 }
306 }
307 }
308 else
309 { colon = 0;
310 if (out_element(soap, node, NULL, tag))
311 return soap->error;
312 }
313 if (!node->type || !node->node)
314 { struct soap_dom_attribute *att;
315 struct soap_dom_element *elt;
316 for (att = node->atts; att; att = att->next)
317 { if (att->name)
318 { if (att->nstr && !(soap->mode & SOAP_DOM_ASIS))
319 { const char *p;
320 if ((att->nstr == node->nstr || (node->nstr && !strcmp(att->nstr, node->nstr))) && prefix)
321 { if (out_attribute(soap, prefix, att->name, att->data, att->wide, 0))
322 return soap->error;
323 }
324 else if ((p = soap_lookup_ns_prefix(soap, att->nstr)))
325 { if (out_attribute(soap, p, att->name, att->data, att->wide, 0))
326 return soap->error;
327 }
328 else if (!strncmp(att->name, "xml", 3))
329 { if (out_attribute(soap, NULL, att->name, att->data, att->wide, 0))
330 return soap->error;
331 }
332 else if ((p = soap_push_ns_prefix(soap, NULL, att->nstr, 0)) == NULL
333 || out_attribute(soap, p, att->name, att->data, att->wide, 0))
334 return soap->error;
335 }
336 else if (soap_attribute(soap, att->name, att->wide ? soap_wchar2s(soap, att->wide) : att->data))
337 return soap->error;
338 }
339 }
340 if ((soap->mode & SOAP_DOM_ASIS) && !node->data && !node->wide && !node->elts && !node->tail)
341 { soap_mode m = soap->mode;
342 soap->mode &= ~SOAP_XML_INDENT;
343 if (*tag != '-' && soap_element_start_end_out(soap, tag))
344 return soap->error;
345 soap->mode = m;
346 }
347 else
348 { if (*tag != '-' && soap_element_start_end_out(soap, NULL))
349 return soap->error;
350 if (*tag != '-' && node->data)
351 { if (soap_string_out(soap, node->data, 0))
352 return soap->error;
353 }
354 else if (node->data)
355 { if (soap_send(soap, node->data))
356 return soap->error;
357 }
358 else if (node->wide)
359 { if (soap_wstring_out(soap, node->wide, 0))
360 return soap->error;
361 }
362 for (elt = node->elts; elt; elt = elt->next)
363 { if (soap_out_xsd__anyType(soap, NULL, 0, elt, NULL))
364 return soap->error;
365 }
366 if (node->tail && soap_send(soap, node->tail))
367 return soap->error;
368 if (!prefix || !*prefix)
369 { soap_mode m = soap->mode;
370 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "End of DOM node '%s'\n", tag + colon));
371 if ((soap->mode & SOAP_DOM_ASIS))
372 soap->mode &= ~SOAP_XML_INDENT;
373 if (soap_element_end_out(soap, tag + colon))
374 return soap->error;
375 soap->mode = m;
376 }
377 else
378 { char *s;
379 if (strlen(prefix) + strlen(tag + colon) < sizeof(soap->msgbuf))
380 s = soap->msgbuf;
381 else
382 { s = (char*)SOAP_MALLOC(soap, strlen(prefix) + strlen(tag + colon) + 2);
383 if (!s)
384 return soap->error = SOAP_EOM;
385 }
386 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "End of DOM node '%s'\n", tag));
387 sprintf(s, "%s:%s", prefix, tag + colon);
388 soap_pop_namespace(soap);
389 if (soap_element_end_out(soap, s))
390 return soap->error;
391 if (s != soap->msgbuf)
392 SOAP_FREE(soap, s);
393 }
394 }
395 }
396 }
397 return SOAP_OK;
398 }
399
400 /******************************************************************************/
401
402 SOAP_FMAC1
403 int
404 SOAP_FMAC2
405 soap_out_xsd__anyAttribute(struct soap *soap, const char *tag, int id, const struct soap_dom_attribute *node, const char *type)
406 { if (!(soap->mode & SOAP_DOM_ASIS))
407 { const struct soap_dom_attribute *att;
408 for (att = node; att; att = att->next)
409 { if (att->name && att->data && !strncmp(att->name, "xmlns:", 6))
410 { if (soap_push_namespace(soap, att->name + 6, att->data) == NULL)
411 return soap->error;
412 }
413 else if (att->name && att->data && !strcmp(att->name, "xmlns"))
414 { if (soap_push_namespace(soap, "", att->data) == NULL)
415 return soap->error;
416 }
417 }
418 }
419 while (node)
420 { if (node->name)
421 { if (node->nstr && !(soap->mode & SOAP_DOM_ASIS) && strncmp(node->name, "xml", 3) && !strchr(node->name, ':'))
422 { const char *p;
423 p = soap_lookup_ns_prefix(soap, node->nstr);
424 if (!p && !(p = soap_push_ns_prefix(soap, NULL, node->nstr, 1)))
425 return soap->error;
426 if (out_attribute(soap, p, node->name, node->data, node->wide, 1))
427 return soap->error;
428 }
429 else
430 out_attribute(soap, NULL, node->name, node->data, node->wide, 1);
431 }
432 node = node->next;
433 }
434 return SOAP_OK;
435 }
436
437 /******************************************************************************/
438
439 SOAP_FMAC1
440 struct soap_dom_element *
441 SOAP_FMAC2
442 soap_in_xsd__anyType(struct soap *soap, const char *tag, struct soap_dom_element *node, const char *type)
443 { register struct soap_attribute *tp;
444 register struct soap_dom_attribute **att;
445 if (soap_peek_element(soap))
446 { if (soap->error != SOAP_NO_TAG)
447 return NULL;
448 if (!node)
449 { if (!(node = (struct soap_dom_element*)soap_malloc(soap, sizeof(struct soap_dom_element))))
450 { soap->error = SOAP_EOM;
451 return NULL;
452 }
453 }
454 soap_default_xsd__anyType(soap, node);
455 if (!(node->data = soap_string_in(soap, 1, -1, -1)) || !*node->data)
456 return NULL;
457 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "DOM node with cdata\n"));
458 soap->error = SOAP_OK;
459 return node;
460 }
461 if (!node)
462 { if (!(node = (struct soap_dom_element*)soap_malloc(soap, sizeof(struct soap_dom_element))))
463 { soap->error = SOAP_EOM;
464 return NULL;
465 }
466 }
467 soap_default_xsd__anyType(soap, node);
468 node->nstr = soap_current_namespace(soap, soap->tag);
469 if ((soap->mode & SOAP_DOM_ASIS))
470 node->name = soap_strdup(soap, soap->tag);
471 else
472 { char *s = strchr(soap->tag, ':');
473 if (s)
474 node->name = soap_strdup(soap, s+1);
475 else
476 node->name = soap_strdup(soap, soap->tag);
477 }
478 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "DOM node '%s' start xmlns='%s'\n", node->name, node->nstr?node->nstr:""));
479 if ((soap->mode & SOAP_DOM_NODE) || (!(soap->mode & SOAP_DOM_TREE) && *soap->id))
480 { if ((node->node = soap_getelement(soap, &node->type)) && node->type)
481 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "DOM node contains type %d from xsi:type\n", node->type));
482 return node;
483 }
484 if (soap->error == SOAP_TAG_MISMATCH)
485 soap->error = SOAP_OK;
486 else
487 return NULL;
488 }
489 att = &node->atts;
490 for (tp = soap->attributes; tp; tp = tp->next)
491 { if (tp->visible)
492 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "DOM node attribute='%s'\n", tp->name));
493 *att = (struct soap_dom_attribute*)soap_malloc(soap, sizeof(struct soap_dom_attribute));
494 if (!*att)
495 { soap->error = SOAP_EOM;
496 return NULL;
497 }
498 (*att)->next = NULL;
499 (*att)->nstr = soap_current_namespace(soap, tp->name);
500 if ((soap->mode & SOAP_DOM_ASIS) || !strncmp(tp->name, "xml", 3))
501 (*att)->name = soap_strdup(soap, tp->name);
502 else
503 { char *s = strchr(tp->name, ':');
504 if (s)
505 (*att)->name = soap_strdup(soap, s+1);
506 else
507 (*att)->name = soap_strdup(soap, tp->name);
508 }
509 if (tp->visible == 2)
510 (*att)->data = soap_strdup(soap, tp->value);
511 else
512 (*att)->data = NULL;
513 (*att)->wide = NULL;
514 (*att)->soap = soap;
515 att = &(*att)->next;
516 tp->visible = 0;
517 }
518 }
519 soap_element_begin_in(soap, NULL, 1, NULL);
520 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "DOM node '%s' pulled\n", node->name));
521 if (soap->body)
522 { if (!soap_peek_element(soap))
523 { struct soap_dom_element **elt;
524 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "DOM node '%s' has subelements\n", node->name));
525 elt = &node->elts;
526 for (;;)
527 { if (!(*elt = soap_in_xsd__anyType(soap, NULL, NULL, NULL)))
528 { if (soap->error != SOAP_NO_TAG)
529 return NULL;
530 soap->error = SOAP_OK;
531 break;
532 }
533 (*elt)->prnt = node;
534 elt = &(*elt)->next;
535 }
536 }
537 else if (soap->error == SOAP_NO_TAG)
538 { DBGLOG(TEST, SOAP_MESSAGE(fdebug, "DOM node '%s' has cdata\n", node->name));
539 if ((soap->mode & SOAP_C_UTFSTRING) || (soap->mode & SOAP_C_MBSTRING))
540 { if (!(node->data = soap_string_in(soap, 1, -1, -1)))
541 return NULL;
542 }
543 else if (!(node->wide = soap_wstring_in(soap, 1, -1, -1)))
544 return NULL;
545 }
546 else
547 return NULL;
548 if (soap_element_end_in(soap, node->name))
549 return NULL;
550 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "DOM node end '%s'\n", node->name));
551 }
552 return node;
553 }
554
555 /******************************************************************************/
556
557 SOAP_FMAC1
558 struct soap_dom_attribute *
559 SOAP_FMAC2
560 soap_in_xsd__anyAttribute(struct soap *soap, const char *tag, struct soap_dom_attribute *node, const char *type)
561 { register struct soap_attribute *tp;
562 struct soap_dom_attribute *tmp = node;
563 struct soap_dom_attribute *att = node;
564 for (tp = soap->attributes; tp; tp = tp->next)
565 { if (tp->visible)
566 { if (!att)
567 { att = (struct soap_dom_attribute*)soap_malloc(soap, sizeof(struct soap_dom_attribute));
568 if (tmp)
569 tmp->next = att;
570 else
571 node = att;
572 tmp = att;
573 }
574 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "DOM node attribute='%s'\n", tp->name));
575 if (!att)
576 { soap->error = SOAP_EOM;
577 return NULL;
578 }
579 att->next = NULL;
580 att->nstr = soap_current_namespace(soap, tp->name);
581 if ((soap->mode & SOAP_DOM_ASIS) || !strncmp(tp->name, "xml", 3))
582 att->name = soap_strdup(soap, tp->name);
583 else
584 { char *s = strchr(tp->name, ':');
585 if (s)
586 att->name = soap_strdup(soap, s+1);
587 else
588 att->name = soap_strdup(soap, tp->name);
589 }
590 if (tp->visible == 2)
591 att->data = soap_strdup(soap, tp->value);
592 else
593 att->data = NULL;
594 att->wide = NULL;
595 att->soap = soap;
596 att = NULL;
597 }
598 }
599 return node;
600 }
601
602 /******************************************************************************\
603 *
604 * DOM traversing
605 *
606 \******************************************************************************/
607
608 SOAP_FMAC1
609 struct soap_dom_element *
610 SOAP_FMAC2
611 soap_dom_next_element(struct soap_dom_element *elt)
612 { if (elt->elts)
613 return elt->elts;
614 if (elt->next)
615 return elt->next;
616 do elt = elt->prnt;
617 while (elt && !elt->next);
618 if (elt)
619 elt = elt->next;
620 return elt;
621 }
622
623 /******************************************************************************/
624
625 struct soap_dom_attribute *
626 soap_dom_next_attribute(struct soap_dom_attribute *att)
627 { return att->next;
628 }
629
630 /******************************************************************************\
631 *
632 * Namespace prefix lookup/store
633 *
634 \******************************************************************************/
635
636 static const char *
637 soap_lookup_ns_prefix(struct soap *soap, const char *ns)
638 { register struct soap_nlist *np;
639 for (np = soap->nlist; np; np = np->next)
640 { if (np->ns && !strcmp(np->ns, ns))
641 return np->id;
642 }
643 return NULL;
644 }
645
646 /******************************************************************************/
647
648 static const char *
649 soap_push_ns_prefix(struct soap *soap, const char *id, const char *ns, int flag)
650 { register struct soap_nlist *np;
651 if (!id)
652 { struct Namespace *n;
653 for (n = soap->local_namespaces; n && n->id; n++)
654 { if (n->ns && !strcmp(n->ns, ns))
655 { id = n->id;
656 break;
657 }
658 }
659 if (!id)
660 { sprintf(soap->tag, SOAP_DOMID_FORMAT, soap->idnum++);
661 id = soap->tag;
662 }
663 }
664 /* fix advance generation of xmlns, when element (level) is not output yet */
665 if (flag)
666 soap->level++;
667 np = soap_push_namespace(soap, id, ns);
668 if (flag)
669 soap->level--;
670 if (!np)
671 return NULL;
672 if (!np->ns)
673 { np->ns = soap->local_namespaces[np->index].out;
674 if (!np->ns)
675 np->ns = soap->local_namespaces[np->index].ns;
676 }
677 np->index = 0; /* for C14N utilized mark */
678 if (*np->id)
679 { sprintf(soap->msgbuf, "xmlns:%s", np->id);
680 out_attribute(soap, NULL, soap->msgbuf, ns, NULL, flag);
681 }
682 else
683 out_attribute(soap, NULL, "xmlns", ns, NULL, flag);
684 return np->id;
685 }
686
687 #ifdef __cplusplus
688
689 /******************************************************************************\
690 *
691 * soap_dom_element class
692 *
693 \******************************************************************************/
694
695 soap_dom_element::soap_dom_element()
696 { soap_default_xsd__anyType(NULL, this);
697 }
698
699 /******************************************************************************/
700
701 soap_dom_element::soap_dom_element(struct soap *soap)
702 { soap_default_xsd__anyType(soap, this);
703 }
704
705 /******************************************************************************/
706
707 soap_dom_element::soap_dom_element(struct soap *soap, const char *nstr, const char *name)
708 { soap_default_xsd__anyType(soap, this);
709 this->nstr = soap_strdup(soap, nstr);
710 this->name = soap_strdup(soap, name);
711 }
712
713 /******************************************************************************/
714
715 soap_dom_element::soap_dom_element(struct soap *soap, const char *nstr, const char *name, const char *data)
716 { soap_default_xsd__anyType(soap, this);
717 this->nstr = soap_strdup(soap, nstr);
718 this->name = soap_strdup(soap, name);
719 this->data = soap_strdup(soap, data);
720 }
721
722 /******************************************************************************/
723
724 soap_dom_element::soap_dom_element(struct soap *soap, const char *nstr, const char *name, void *node, int type)
725 { soap_default_xsd__anyType(soap, this);
726 this->nstr = soap_strdup(soap, nstr);
727 this->name = soap_strdup(soap, name);
728 this->node = node;
729 this->type = type;
730 }
731
732 /******************************************************************************/
733
734 soap_dom_element::~soap_dom_element()
735 { }
736
737 /******************************************************************************/
738
739 soap_dom_element &soap_dom_element::set(const char *nstr, const char *name)
740 { this->nstr = soap_strdup(soap, nstr);
741 this->name = soap_strdup(soap, name);
742 return *this;
743 }
744
745 /******************************************************************************/
746
747 soap_dom_element &soap_dom_element::set(const char *data)
748 { this->data = soap_strdup(soap, data);
749 return *this;
750 }
751
752 /******************************************************************************/
753
754 soap_dom_element &soap_dom_element::set(void *node, int type)
755 { this->node = node;
756 this->type = type;
757 return *this;
758 }
759
760 /******************************************************************************/
761
762 soap_dom_element &soap_dom_element::add(struct soap_dom_element *elt)
763 { elt->prnt = this;
764 for (struct soap_dom_element *e = elts; e; e = e->next)
765 { if (!e->next)
766 { e->next = elt;
767 return *this;
768 }
769 }
770 elts = elt;
771 return *this;
772 }
773
774 /******************************************************************************/
775
776 soap_dom_element &soap_dom_element::add(struct soap_dom_element &elt)
777 { return add(&elt);
778 }
779
780 /******************************************************************************/
781
782 soap_dom_element &soap_dom_element::add(struct soap_dom_attribute *att)
783 { for (struct soap_dom_attribute *a = atts; a; a = a->next)
784 { if (!a->next)
785 { a->next = att;
786 return *this;
787 }
788 }
789 atts = att;
790 return *this;
791 }
792
793 /******************************************************************************/
794
795 soap_dom_element &soap_dom_element::add(struct soap_dom_attribute &att)
796 { return add(&att);
797 }
798
799 /******************************************************************************/
800
801 soap_dom_element_iterator soap_dom_element::begin()
802 { soap_dom_element_iterator iter(this);
803 return iter;
804 }
805
806 /******************************************************************************/
807
808 soap_dom_element_iterator soap_dom_element::end()
809 { soap_dom_element_iterator iter(NULL);
810 return iter;
811 }
812
813 /******************************************************************************/
814
815 soap_dom_element_iterator soap_dom_element::find(const char *nstr, const char *name)
816 { soap_dom_element_iterator iter(this);
817 iter.nstr = nstr;
818 iter.name = name;
819 if (name && soap_tag_cmp(this->name, name))
820 return ++iter;
821 if (nstr && this->nstr && soap_tag_cmp(this->nstr, nstr))
822 return ++iter;
823 return iter;
824 }
825
826 /******************************************************************************/
827
828 soap_dom_element_iterator soap_dom_element::find(int type)
829 { soap_dom_element_iterator iter(this);
830 iter.type = type;
831 if (this->type != type)
832 return ++iter;
833 return iter;
834 }
835
836 /******************************************************************************/
837
838 void soap_dom_element::unlink()
839 { soap_unlink(soap, this);
840 soap_unlink(soap, nstr);
841 soap_unlink(soap, name);
842 soap_unlink(soap, data);
843 soap_unlink(soap, wide);
844 if (elts)
845 elts->unlink();
846 if (atts)
847 atts->unlink();
848 if (next)
849 next->unlink();
850 node = NULL;
851 type = 0;
852 }
853
854 /******************************************************************************\
855 *
856 * soap_dom_attribute class
857 *
858 \******************************************************************************/
859
860 soap_dom_attribute::soap_dom_attribute()
861 { this->soap = NULL;
862 this->next = NULL;
863 this->nstr = NULL;
864 this->name = NULL;
865 this->data = NULL;
866 this->wide = NULL;
867 }
868
869 /******************************************************************************/
870
871 soap_dom_attribute::soap_dom_attribute(struct soap *soap)
872 { this->soap = soap;
873 this->next = NULL;
874 this->nstr = NULL;
875 this->name = NULL;
876 this->data = NULL;
877 this->wide = NULL;
878 }
879
880 /******************************************************************************/
881
882 soap_dom_attribute::soap_dom_attribute(struct soap *soap, const char *nstr, const char *name, const char *data)
883 { this->soap = soap;
884 this->next = NULL;
885 this->nstr = soap_strdup(soap, nstr);
886 this->name = soap_strdup(soap, name);
887 this->data = soap_strdup(soap, data);
888 this->wide = NULL;
889 }
890
891 /******************************************************************************/
892
893 soap_dom_attribute::~soap_dom_attribute()
894 { }
895
896 /******************************************************************************/
897
898 soap_dom_attribute &soap_dom_attribute::set(const char *nstr, const char *name)
899 { this->nstr = soap_strdup(soap, nstr);
900 this->name = soap_strdup(soap, name);
901 return *this;
902 }
903
904 /******************************************************************************/
905
906 soap_dom_attribute &soap_dom_attribute::set(const char *data)
907 { this->data = soap_strdup(soap, data);
908 return *this;
909 }
910
911 /******************************************************************************/
912
913 soap_dom_attribute_iterator soap_dom_attribute::begin()
914 { soap_dom_attribute_iterator iter(this);
915 return iter;
916 }
917
918 /******************************************************************************/
919
920 soap_dom_attribute_iterator soap_dom_attribute::end()
921 { soap_dom_attribute_iterator iter(NULL);
922 return iter;
923 }
924
925 /******************************************************************************/
926
927 soap_dom_attribute_iterator soap_dom_attribute::find(const char *nstr, const char *name)
928 { soap_dom_attribute_iterator iter(this);
929 iter.nstr = nstr;
930 iter.name = name;
931 if (name && soap_tag_cmp(this->name, name))
932 return ++iter;
933 if (nstr && this->nstr && soap_tag_cmp(this->nstr, nstr))
934 return ++iter;
935 return iter;
936 }
937
938 /******************************************************************************/
939
940 void soap_dom_attribute::unlink()
941 { soap_unlink(soap, this);
942 soap_unlink(soap, nstr);
943 soap_unlink(soap, name);
944 soap_unlink(soap, data);
945 soap_unlink(soap, wide);
946 if (next)
947 next->unlink();
948 }
949
950 /******************************************************************************\
951 *
952 * soap_dom_element_iterator class
953 *
954 \******************************************************************************/
955
956 soap_dom_element_iterator::soap_dom_element_iterator()
957 { elt = NULL;
958 nstr = NULL;
959 name = NULL;
960 type = 0;
961 }
962
963 /******************************************************************************/
964
965 soap_dom_element_iterator::soap_dom_element_iterator(struct soap_dom_element *elt)
966 { this->elt = elt;
967 nstr = NULL;
968 name = NULL;
969 type = 0;
970 }
971
972 /******************************************************************************/
973
974 soap_dom_element_iterator::~soap_dom_element_iterator()
975 { }
976
977 /******************************************************************************/
978
979 bool soap_dom_element_iterator::operator==(const soap_dom_element_iterator &iter) const
980 { return this->elt == iter.elt;
981 }
982
983 /******************************************************************************/
984
985 bool soap_dom_element_iterator::operator!=(const soap_dom_element_iterator &iter) const
986 { return this->elt != iter.elt;
987 }
988
989 /******************************************************************************/
990
991 struct soap_dom_element &soap_dom_element_iterator::operator*() const
992 { return *this->elt;
993 }
994
995 /******************************************************************************/
996
997 soap_dom_element_iterator &soap_dom_element_iterator::operator++()
998 { while (elt)
999 { elt = soap_dom_next_element(elt);
1000 if (!elt)
1001 break;
1002 if (name && elt->name)
1003 { if (!soap_tag_cmp(elt->name, name))
1004 { if (nstr && elt->nstr)
1005 { if (!soap_tag_cmp(elt->nstr, nstr))
1006 break;
1007 }
1008 else
1009 break;
1010 }
1011 }
1012 else if (type)
1013 { if (elt->type == type)
1014 break;
1015 }
1016 else
1017 break;
1018 }
1019 return *this;
1020 }
1021
1022 /******************************************************************************\
1023 *
1024 * soap_dom_attribute_iterator class
1025 *
1026 \******************************************************************************/
1027
1028 soap_dom_attribute_iterator::soap_dom_attribute_iterator()
1029 { att = NULL;
1030 nstr = NULL;
1031 name = NULL;
1032 }
1033
1034 /******************************************************************************/
1035
1036 soap_dom_attribute_iterator::soap_dom_attribute_iterator(struct soap_dom_attribute *att)
1037 { this->att = att;
1038 nstr = NULL;
1039 name = NULL;
1040 }
1041
1042 /******************************************************************************/
1043
1044 soap_dom_attribute_iterator::~soap_dom_attribute_iterator()
1045 { }
1046
1047 /******************************************************************************/
1048
1049 bool soap_dom_attribute_iterator::operator==(const soap_dom_attribute_iterator &iter) const
1050 { return this->att == iter.att;
1051 }
1052
1053 /******************************************************************************/
1054
1055 bool soap_dom_attribute_iterator::operator!=(const soap_dom_attribute_iterator &iter) const
1056 { return this->att != iter.att;
1057 }
1058
1059 /******************************************************************************/
1060
1061 struct soap_dom_attribute &soap_dom_attribute_iterator::operator*() const
1062 { return *this->att;
1063 }
1064
1065 /******************************************************************************/
1066
1067 soap_dom_attribute_iterator &soap_dom_attribute_iterator::operator++()
1068 { while (att)
1069 { att = soap_dom_next_attribute(att);
1070 if (!att)
1071 break;
1072 if (name && att->name)
1073 { if (!soap_tag_cmp(att->name, name))
1074 { if (nstr && att->nstr)
1075 { if (!soap_tag_cmp(att->nstr, nstr))
1076 break;
1077 }
1078 else
1079 break;
1080 }
1081 }
1082 else
1083 break;
1084 }
1085 return *this;
1086 }
1087
1088 /******************************************************************************\
1089 *
1090 * I/O
1091 *
1092 \******************************************************************************/
1093
1094 #ifndef UNDER_CE
1095
1096 std::ostream &operator<<(std::ostream &o, const struct soap_dom_element &e)
1097 { if (!e.soap)
1098 { struct soap soap;
1099 soap_init2(&soap, SOAP_IO_DEFAULT, SOAP_XML_GRAPH);
1100 soap_serialize_xsd__anyType(&soap, &e);
1101 soap_begin_send(&soap);
1102 soap.ns = 2; /* do not dump namespace table */
1103 soap_out_xsd__anyType(&soap, NULL, 0, &e, NULL);
1104 soap_end_send(&soap);
1105 soap_end(&soap);
1106 soap_done(&soap);
1107 }
1108 else
1109 { std::ostream *os = e.soap->os;
1110 e.soap->os = &o;
1111 soap_mode omode = e.soap->omode;
1112 soap_set_omode(e.soap, SOAP_XML_GRAPH);
1113 soap_serialize_xsd__anyType(e.soap, &e);
1114 soap_begin_send(e.soap);
1115 e.soap->ns = 2; /* do not dump namespace table */
1116 soap_out_xsd__anyType(e.soap, NULL, 0, &e, NULL);
1117 soap_end_send(e.soap);
1118 e.soap->os = os;
1119 e.soap->omode = omode;
1120 }
1121 return o;
1122 }
1123
1124 /******************************************************************************/
1125
1126 std::istream &operator>>(std::istream &i, struct soap_dom_element &e)
1127 { if (!e.soap)
1128 e.soap = soap_new();
1129 std::istream *is = e.soap->is;
1130 e.soap->is = &i;
1131 if (soap_begin_recv(e.soap)
1132 || !soap_in_xsd__anyType(e.soap, NULL, &e, NULL)
1133 || soap_end_recv(e.soap))
1134 { /* handle error? Note: e.soap->error is set and app should check */
1135 }
1136 e.soap->is = is;
1137 return i;
1138 }
1139
1140 #endif
1141
1142 #endif