usr/src/lib/libkmsagent/common/SOAP/envC.cpp

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
  24  */
  25
  26 /* envC.cpp
  27    Generated by gSOAP 2.7.17 from ../gsoapStubs/Env/env.h
  28    Copyright(C) 2000-2010, Robert van Engelen, Genivia Inc. All Rights Reserved.
  29    This part of the software is released under one of the following licenses:
  30    GPL, the gSOAP public license, or Genivia's license for commercial use.
  31 */
  32
  33 #if defined(__BORLANDC__)
  34 #pragma option push -w-8060
  35 #pragma option push -w-8004
  36 #endif
  37
  38 #include "envH.h"
  39
  40 SOAP_SOURCE_STAMP("@(#) envC.cpp ver 2.7.17 2010-06-08 19:16:38 GMT")
  41
  42
  43 #ifndef WITH_NOGLOBAL
  44
  45 SOAP_FMAC3 void SOAP_FMAC4 soap_serializeheader(struct soap *soap)
  46 {
  47         if (soap->header)
  48                 soap_serialize_SOAP_ENV__Header(soap, soap->header);
  49 }
  50
  51 SOAP_FMAC3 int SOAP_FMAC4 soap_putheader(struct soap *soap)
  52 {
  53         if (soap->header)
  54         {       soap->part = SOAP_IN_HEADER;
  55                 if (soap_out_SOAP_ENV__Header(soap, "SOAP-ENV:Header", 0, soap->header, NULL))
  56                         return soap->error;
  57                 soap->part = SOAP_END_HEADER;
  58         }
  59         return SOAP_OK;
  60 }
  61
  62 SOAP_FMAC3 int SOAP_FMAC4 soap_getheader(struct soap *soap)
  63 {
  64         soap->part = SOAP_IN_HEADER;
  65         soap->header = soap_in_SOAP_ENV__Header(soap, "SOAP-ENV:Header", NULL, NULL);
  66         soap->part = SOAP_END_HEADER;
  67         return soap->header == NULL;
  68 }
  69
  70 SOAP_FMAC3 void SOAP_FMAC4 soap_header(struct soap *soap)
  71 {
  72         if (!soap->header)
  73         {       if ((soap->header = soap_new_SOAP_ENV__Header(soap, -1)))
  74                         soap_default_SOAP_ENV__Header(soap, soap->header);
  75         }
  76 }
  77
  78 SOAP_FMAC3 void SOAP_FMAC4 soap_fault(struct soap *soap)
  79 {
  80         if (!soap->fault)
  81         {       soap->fault = soap_new_SOAP_ENV__Fault(soap, -1);
  82                 if (!soap->fault)
  83                         return;
  84                 soap_default_SOAP_ENV__Fault(soap, soap->fault);
  85         }
  86         if (soap->version == 2 && !soap->fault->SOAP_ENV__Code)
  87         {       soap->fault->SOAP_ENV__Code = soap_new_SOAP_ENV__Code(soap, -1);
  88                 soap_default_SOAP_ENV__Code(soap, soap->fault->SOAP_ENV__Code);
  89         }
  90         if (soap->version == 2 && !soap->fault->SOAP_ENV__Reason)
  91         {       soap->fault->SOAP_ENV__Reason = soap_new_SOAP_ENV__Reason(soap, -1);
  92                 soap_default_SOAP_ENV__Reason(soap, soap->fault->SOAP_ENV__Reason);
  93         }
  94 }
  95
  96 SOAP_FMAC3 void SOAP_FMAC4 soap_serializefault(struct soap *soap)
  97 {
  98         soap_fault(soap);
  99         if (soap->fault)
 100                 soap_serialize_SOAP_ENV__Fault(soap, soap->fault);
 101 }
 102
 103 SOAP_FMAC3 int SOAP_FMAC4 soap_putfault(struct soap *soap)
 104 {
 105         if (soap->fault)
 106                 return soap_put_SOAP_ENV__Fault(soap, soap->fault, "SOAP-ENV:Fault", NULL);
 107         return SOAP_OK;
 108 }
 109
 110 SOAP_FMAC3 int SOAP_FMAC4 soap_getfault(struct soap *soap)
 111 {
 112         return (soap->fault = soap_get_SOAP_ENV__Fault(soap, NULL, "SOAP-ENV:Fault", NULL)) == NULL;
 113 }
 114
 115 SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultcode(struct soap *soap)
 116 {
 117         soap_fault(soap);
 118         if (soap->version == 2)
 119                 return (const char**)&soap->fault->SOAP_ENV__Code->SOAP_ENV__Value;
 120         return (const char**)&soap->fault->faultcode;
 121 }
 122
 123 SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultsubcode(struct soap *soap)
 124 {
 125         soap_fault(soap);
 126         if (soap->version == 2)
 127         {       if (!soap->fault->SOAP_ENV__Code->SOAP_ENV__Subcode)
 128                 {       soap->fault->SOAP_ENV__Code->SOAP_ENV__Subcode = soap_new_SOAP_ENV__Code(soap, -1);
 129                         soap_default_SOAP_ENV__Code(soap, soap->fault->SOAP_ENV__Code->SOAP_ENV__Subcode);
 130                 }
 131                 return (const char**)&soap->fault->SOAP_ENV__Code->SOAP_ENV__Subcode->SOAP_ENV__Value;
 132         }
 133         return (const char**)&soap->fault->faultcode;
 134 }
 135
 136 SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultstring(struct soap *soap)
 137 {
 138         soap_fault(soap);
 139         if (soap->version == 2)
 140                 return (const char**)&soap->fault->SOAP_ENV__Reason->SOAP_ENV__Text;
 141         return (const char**)&soap->fault->faultstring;
 142 }
 143
 144 SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultdetail(struct soap *soap)
 145 {
 146         soap_fault(soap);
 147         if (soap->version == 1)
 148         {       if (!soap->fault->detail)
 149                 {       soap->fault->detail = (struct SOAP_ENV__Detail*)soap_malloc(soap, sizeof(struct SOAP_ENV__Detail));
 150                         soap_default_SOAP_ENV__Detail(soap, soap->fault->detail);
 151                 }
 152                 return (const char**)&soap->fault->detail->__any;
 153         }
 154         if (!soap->fault->SOAP_ENV__Detail)
 155         {       soap->fault->SOAP_ENV__Detail = soap_new_SOAP_ENV__Detail(soap, -1);
 156                 soap_default_SOAP_ENV__Detail(soap, soap->fault->SOAP_ENV__Detail);
 157         }
 158         return (const char**)&soap->fault->SOAP_ENV__Detail->__any;
 159 }
 160
 161 #endif
 162
 163 #ifndef WITH_NOIDREF
 164 SOAP_FMAC3 int SOAP_FMAC4 soap_getindependent(struct soap *soap)
 165 {
 166         int t;
 167         if (soap->version == 1)
 168         {       for (;;)
 169                 {       if (!soap_getelement(soap, &t))
 170                                 if (soap->error || soap_ignore_element(soap))
 171                                         break;
 172                 }
 173         }
 174         if (soap->error == SOAP_NO_TAG || soap->error == SOAP_EOF)
 175                 soap->error = SOAP_OK;
 176         return soap->error;
 177 }
 178 #endif
 179
 180 #ifndef WITH_NOIDREF
 181
 182 #ifdef __cplusplus
 183 extern "C" {
 184 #endif
 185 SOAP_FMAC3 void * SOAP_FMAC4 soap_getelement(struct soap *soap, int *type)
 186 {
 187         if (soap_peek_element(soap))
 188                 return NULL;
 189         if (!*soap->id || !(*type = soap_lookup_type(soap, soap->id)))
 190                 *type = soap_lookup_type(soap, soap->href);
 191         switch (*type)
 192         {
 193         case SOAP_TYPE_byte:
 194                 return soap_in_byte(soap, NULL, NULL, "xsd:byte");
 195         case SOAP_TYPE_int:
 196                 return soap_in_int(soap, NULL, NULL, "xsd:int");
 197         case SOAP_TYPE__QName:
 198         {       char **s;
 199                 s = soap_in__QName(soap, NULL, NULL, "xsd:QName");
 200                 return s ? *s : NULL;
 201         }
 202         case SOAP_TYPE_string:
 203         {       char **s;
 204                 s = soap_in_string(soap, NULL, NULL, "xsd:string");
 205                 return s ? *s : NULL;
 206         }
 207         default:
 208         {       const char *t = soap->type;
 209                 if (!*t)
 210                         t = soap->tag;
 211                 if (!soap_match_tag(soap, t, "xsd:byte"))
 212                 {       *type = SOAP_TYPE_byte;
 213                         return soap_in_byte(soap, NULL, NULL, NULL);
 214                 }
 215                 if (!soap_match_tag(soap, t, "xsd:int"))
 216                 {       *type = SOAP_TYPE_int;
 217                         return soap_in_int(soap, NULL, NULL, NULL);
 218                 }
 219                 if (!soap_match_tag(soap, t, "xsd:QName"))
 220                 {       char **s;
 221                         *type = SOAP_TYPE__QName;
 222                         s = soap_in__QName(soap, NULL, NULL, NULL);
 223                         return s ? *s : NULL;
 224                 }
 225                 if (!soap_match_tag(soap, t, "xsd:string"))
 226                 {       char **s;
 227                         *type = SOAP_TYPE_string;
 228                         s = soap_in_string(soap, NULL, NULL, NULL);
 229                         return s ? *s : NULL;
 230                 }
 231                 t = soap->tag;
 232         }
 233         }
 234         soap->error = SOAP_TAG_MISMATCH;
 235         return NULL;
 236 }
 237
 238 #ifdef __cplusplus
 239 }
 240 #endif
 241 #endif
 242
 243 SOAP_FMAC3 int SOAP_FMAC4 soap_ignore_element(struct soap *soap)
 244 {
 245         if (!soap_peek_element(soap))
 246         {       int t;
 247                 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Unexpected element '%s' in input (level=%u, %d)\n", soap->tag, soap->level, soap->body));
 248                 if (soap->mustUnderstand && !soap->other)
 249                         return soap->error = SOAP_MUSTUNDERSTAND;
 250                 if (((soap->mode & SOAP_XML_STRICT) && soap->part != SOAP_IN_HEADER) || !soap_match_tag(soap, soap->tag, "SOAP-ENV:"))
 251                 {       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "REJECTING element '%s'\n", soap->tag));
 252                         return soap->error = SOAP_TAG_MISMATCH;
 253                 }
 254                 if (!*soap->id || !soap_getelement(soap, &t))
 255                 {       soap->peeked = 0;
 256                         if (soap->fignore)
 257                                 soap->error = soap->fignore(soap, soap->tag);
 258                         else
 259                                 soap->error = SOAP_OK;
 260                         DBGLOG(TEST, if (!soap->error) SOAP_MESSAGE(fdebug, "IGNORING element '%s'\n", soap->tag));
 261                         if (!soap->error && soap->body)
 262                         {       soap->level++;
 263                                 while (!soap_ignore_element(soap))
 264                                         ;
 265                                 if (soap->error == SOAP_NO_TAG)
 266                                         soap->error = soap_element_end_in(soap, NULL);
 267                         }
 268                 }
 269         }
 270         return soap->error;
 271 }
 272
 273 #ifndef WITH_NOIDREF
 274 SOAP_FMAC3 int SOAP_FMAC4 soap_putindependent(struct soap *soap)
 275 {
 276         int i;
 277         struct soap_plist *pp;
 278         if (soap->version == 1 && soap->encodingStyle && !(soap->mode & (SOAP_XML_TREE | SOAP_XML_GRAPH)))
 279                 for (i = 0; i < SOAP_PTRHASH; i++)
 280                         for (pp = soap->pht[i]; pp; pp = pp->next)
 281                                 if (pp->mark1 == 2 || pp->mark2 == 2)
 282                                         if (soap_putelement(soap, pp->ptr, "id", pp->id, pp->type))
 283                                                 return soap->error;
 284         return SOAP_OK;
 285 }
 286 #endif
 287
 288 #ifndef WITH_NOIDREF
 289
 290 #ifdef __cplusplus
 291 extern "C" {
 292 #endif
 293 SOAP_FMAC3 int SOAP_FMAC4 soap_putelement(struct soap *soap, const void *ptr, const char *tag, int id, int type)
 294 {
 295         switch (type)
 296         {
 297         case SOAP_TYPE_byte:
 298                 return soap_out_byte(soap, tag, id, (const char *)ptr, "xsd:byte");
 299         case SOAP_TYPE_int:
 300                 return soap_out_int(soap, tag, id, (const int *)ptr, "xsd:int");
 301         case SOAP_TYPE__QName:
 302                 return soap_out_string(soap, tag, id, (char*const*)&ptr, "xsd:QName");
 303         case SOAP_TYPE_string:
 304                 return soap_out_string(soap, tag, id, (char*const*)&ptr, "xsd:string");
 305         }
 306         return SOAP_OK;
 307 }
 308
 309 #ifdef __cplusplus
 310 }
 311 #endif
 312 #endif
 313
 314 #ifndef WITH_NOIDREF
 315
 316 #ifdef __cplusplus
 317 extern "C" {
 318 #endif
 319 SOAP_FMAC3 void SOAP_FMAC4 soap_markelement(struct soap *soap, const void *ptr, int type)
 320 {
 321         (void)soap; (void)ptr; (void)type; /* appease -Wall -Werror */
 322         switch (type)
 323         {
 324         case SOAP_TYPE__QName:
 325                 soap_serialize_string(soap, (char*const*)&ptr);
 326                 break;
 327         case SOAP_TYPE_string:
 328                 soap_serialize_string(soap, (char*const*)&ptr);
 329                 break;
 330         }
 331 }
 332
 333 #ifdef __cplusplus
 334 }
 335 #endif
 336 #endif
 337
 338 SOAP_FMAC3 void * SOAP_FMAC4 soap_instantiate(struct soap *soap, int t, const char *type, const char *arrayType, size_t *n)
 339 {
 340         switch (t)
 341         {
 342 #ifndef WITH_NOGLOBAL
 343         case SOAP_TYPE_SOAP_ENV__Header:
 344                 return (void*)soap_instantiate_SOAP_ENV__Header(soap, -1, type, arrayType, n);
 345 #endif
 346 #ifndef WITH_NOGLOBAL
 347         case SOAP_TYPE_SOAP_ENV__Code:
 348                 return (void*)soap_instantiate_SOAP_ENV__Code(soap, -1, type, arrayType, n);
 349 #endif
 350 #ifndef WITH_NOGLOBAL
 351         case SOAP_TYPE_SOAP_ENV__Detail:
 352                 return (void*)soap_instantiate_SOAP_ENV__Detail(soap, -1, type, arrayType, n);
 353 #endif
 354 #ifndef WITH_NOGLOBAL
 355         case SOAP_TYPE_SOAP_ENV__Reason:
 356                 return (void*)soap_instantiate_SOAP_ENV__Reason(soap, -1, type, arrayType, n);
 357 #endif
 358 #ifndef WITH_NOGLOBAL
 359         case SOAP_TYPE_SOAP_ENV__Fault:
 360                 return (void*)soap_instantiate_SOAP_ENV__Fault(soap, -1, type, arrayType, n);
 361 #endif
 362         }
 363         return NULL;
 364 }
 365
 366 SOAP_FMAC3 int SOAP_FMAC4 soap_fdelete(struct soap_clist *p)
 367 {       switch (p->type)
 368         {
 369         case SOAP_TYPE_SOAP_ENV__Header:
 370                 if (p->size < 0)
 371                         SOAP_DELETE((struct SOAP_ENV__Header*)p->ptr);
 372                 else
 373                         SOAP_DELETE_ARRAY((struct SOAP_ENV__Header*)p->ptr);
 374                 break;
 375         case SOAP_TYPE_SOAP_ENV__Code:
 376                 if (p->size < 0)
 377                         SOAP_DELETE((struct SOAP_ENV__Code*)p->ptr);
 378                 else
 379                         SOAP_DELETE_ARRAY((struct SOAP_ENV__Code*)p->ptr);
 380                 break;
 381         case SOAP_TYPE_SOAP_ENV__Detail:
 382                 if (p->size < 0)
 383                         SOAP_DELETE((struct SOAP_ENV__Detail*)p->ptr);
 384                 else
 385                         SOAP_DELETE_ARRAY((struct SOAP_ENV__Detail*)p->ptr);
 386                 break;
 387         case SOAP_TYPE_SOAP_ENV__Reason:
 388                 if (p->size < 0)
 389                         SOAP_DELETE((struct SOAP_ENV__Reason*)p->ptr);
 390                 else
 391                         SOAP_DELETE_ARRAY((struct SOAP_ENV__Reason*)p->ptr);
 392                 break;
 393         case SOAP_TYPE_SOAP_ENV__Fault:
 394                 if (p->size < 0)
 395                         SOAP_DELETE((struct SOAP_ENV__Fault*)p->ptr);
 396                 else
 397                         SOAP_DELETE_ARRAY((struct SOAP_ENV__Fault*)p->ptr);
 398                 break;
 399         default:        return SOAP_ERR;
 400         }
 401         return SOAP_OK;
 402 }
 403
 404 SOAP_FMAC3 void* SOAP_FMAC4 soap_class_id_enter(struct soap *soap, const char *id, void *p, int t, size_t n, const char *type, const char *arrayType)
 405 {       return soap_id_enter(soap, id, p, t, n, 0, type, arrayType, soap_instantiate);
 406 }
 407
 408 SOAP_FMAC3 void SOAP_FMAC4 soap_default_byte(struct soap *soap, char *a)
 409 {
 410         (void)soap; /* appease -Wall -Werror */
 411 #ifdef SOAP_DEFAULT_byte
 412         *a = SOAP_DEFAULT_byte;
 413 #else
 414         *a = (char)0;
 415 #endif
 416 }
 417
 418 SOAP_FMAC3 int SOAP_FMAC4 soap_out_byte(struct soap *soap, const char *tag, int id, const char *a, const char *type)
 419 {
 420         return soap_outbyte(soap, tag, id, a, type, SOAP_TYPE_byte);
 421 }
 422
 423 SOAP_FMAC3 char * SOAP_FMAC4 soap_in_byte(struct soap *soap, const char *tag, char *a, const char *type)
 424 {       char *p;
 425         p = soap_inbyte(soap, tag, a, type, SOAP_TYPE_byte);
 426         return p;
 427 }
 428
 429 SOAP_FMAC3 int SOAP_FMAC4 soap_put_byte(struct soap *soap, const char *a, const char *tag, const char *type)
 430 {
 431         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_byte);
 432         if (soap_out_byte(soap, tag?tag:"byte", id, a, type))
 433                 return soap->error;
 434         return soap_putindependent(soap);
 435 }
 436
 437 SOAP_FMAC3 char * SOAP_FMAC4 soap_get_byte(struct soap *soap, char *p, const char *tag, const char *type)
 438 {
 439         if ((p = soap_in_byte(soap, tag, p, type)))
 440                 if (soap_getindependent(soap))
 441                         return NULL;
 442         return p;
 443 }
 444
 445 SOAP_FMAC3 void SOAP_FMAC4 soap_default_int(struct soap *soap, int *a)
 446 {
 447         (void)soap; /* appease -Wall -Werror */
 448 #ifdef SOAP_DEFAULT_int
 449         *a = SOAP_DEFAULT_int;
 450 #else
 451         *a = (int)0;
 452 #endif
 453 }
 454
 455 SOAP_FMAC3 int SOAP_FMAC4 soap_out_int(struct soap *soap, const char *tag, int id, const int *a, const char *type)
 456 {
 457         return soap_outint(soap, tag, id, a, type, SOAP_TYPE_int);
 458 }
 459
 460 SOAP_FMAC3 int * SOAP_FMAC4 soap_in_int(struct soap *soap, const char *tag, int *a, const char *type)
 461 {       int *p;
 462         p = soap_inint(soap, tag, a, type, SOAP_TYPE_int);
 463         return p;
 464 }
 465
 466 SOAP_FMAC3 int SOAP_FMAC4 soap_put_int(struct soap *soap, const int *a, const char *tag, const char *type)
 467 {
 468         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_int);
 469         if (soap_out_int(soap, tag?tag:"int", id, a, type))
 470                 return soap->error;
 471         return soap_putindependent(soap);
 472 }
 473
 474 SOAP_FMAC3 int * SOAP_FMAC4 soap_get_int(struct soap *soap, int *p, const char *tag, const char *type)
 475 {
 476         if ((p = soap_in_int(soap, tag, p, type)))
 477                 if (soap_getindependent(soap))
 478                         return NULL;
 479         return p;
 480 }
 481
 482 #ifndef WITH_NOGLOBAL
 483
 484 SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Fault(struct soap *soap, struct SOAP_ENV__Fault *a)
 485 {
 486         (void)soap; (void)a; /* appease -Wall -Werror */
 487         soap_default__QName(soap, &a->faultcode);
 488         soap_default_string(soap, &a->faultstring);
 489         soap_default_string(soap, &a->faultactor);
 490         a->detail = NULL;
 491         a->SOAP_ENV__Code = NULL;
 492         a->SOAP_ENV__Reason = NULL;
 493         soap_default_string(soap, &a->SOAP_ENV__Node);
 494         soap_default_string(soap, &a->SOAP_ENV__Role);
 495         a->SOAP_ENV__Detail = NULL;
 496 }
 497
 498 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Fault(struct soap *soap, const struct SOAP_ENV__Fault *a)
 499 {
 500         (void)soap; (void)a; /* appease -Wall -Werror */
 501         soap_serialize__QName(soap, &a->faultcode);
 502         soap_serialize_string(soap, &a->faultstring);
 503         soap_serialize_string(soap, &a->faultactor);
 504         soap_serialize_PointerToSOAP_ENV__Detail(soap, &a->detail);
 505         soap_serialize_PointerToSOAP_ENV__Code(soap, &a->SOAP_ENV__Code);
 506         soap_serialize_PointerToSOAP_ENV__Reason(soap, &a->SOAP_ENV__Reason);
 507         soap_serialize_string(soap, &a->SOAP_ENV__Node);
 508         soap_serialize_string(soap, &a->SOAP_ENV__Role);
 509         soap_serialize_PointerToSOAP_ENV__Detail(soap, &a->SOAP_ENV__Detail);
 510 }
 511
 512 SOAP_FMAC3 int SOAP_FMAC4 soap_out_SOAP_ENV__Fault(struct soap *soap, const char *tag, int id, const struct SOAP_ENV__Fault *a, const char *type)
 513 {
 514         const char *soap_tmp_faultcode = soap_QName2s(soap, a->faultcode);
 515         if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Fault), type))
 516                 return soap->error;
 517         if (soap_out__QName(soap, "faultcode", -1, (char*const*)&soap_tmp_faultcode, ""))
 518                 return soap->error;
 519         if (soap_out_string(soap, "faultstring", -1, &a->faultstring, ""))
 520                 return soap->error;
 521         if (soap_out_string(soap, "faultactor", -1, &a->faultactor, ""))
 522                 return soap->error;
 523         if (soap_out_PointerToSOAP_ENV__Detail(soap, "detail", -1, &a->detail, ""))
 524                 return soap->error;
 525         if (soap_out_PointerToSOAP_ENV__Code(soap, "SOAP-ENV:Code", -1, &a->SOAP_ENV__Code, ""))
 526                 return soap->error;
 527         if (soap_out_PointerToSOAP_ENV__Reason(soap, "SOAP-ENV:Reason", -1, &a->SOAP_ENV__Reason, ""))
 528                 return soap->error;
 529         if (soap_out_string(soap, "SOAP-ENV:Node", -1, &a->SOAP_ENV__Node, ""))
 530                 return soap->error;
 531         if (soap_out_string(soap, "SOAP-ENV:Role", -1, &a->SOAP_ENV__Role, ""))
 532                 return soap->error;
 533         if (soap_out_PointerToSOAP_ENV__Detail(soap, "SOAP-ENV:Detail", -1, &a->SOAP_ENV__Detail, ""))
 534                 return soap->error;
 535         return soap_element_end_out(soap, tag);
 536 }
 537
 538 SOAP_FMAC3 struct SOAP_ENV__Fault * SOAP_FMAC4 soap_in_SOAP_ENV__Fault(struct soap *soap, const char *tag, struct SOAP_ENV__Fault *a, const char *type)
 539 {
 540         size_t soap_flag_faultcode = 1;
 541         size_t soap_flag_faultstring = 1;
 542         size_t soap_flag_faultactor = 1;
 543         size_t soap_flag_detail = 1;
 544         size_t soap_flag_SOAP_ENV__Code = 1;
 545         size_t soap_flag_SOAP_ENV__Reason = 1;
 546         size_t soap_flag_SOAP_ENV__Node = 1;
 547         size_t soap_flag_SOAP_ENV__Role = 1;
 548         size_t soap_flag_SOAP_ENV__Detail = 1;
 549         if (soap_element_begin_in(soap, tag, 0, type))
 550                 return NULL;
 551         a = (struct SOAP_ENV__Fault *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_SOAP_ENV__Fault, sizeof(struct SOAP_ENV__Fault), 0, NULL, NULL, NULL);
 552         if (!a)
 553                 return NULL;
 554         soap_default_SOAP_ENV__Fault(soap, a);
 555         if (soap->body && !*soap->href)
 556         {
 557                 for (;;)
 558                 {       soap->error = SOAP_TAG_MISMATCH;
 559                         if (soap_flag_faultcode && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
 560                                 if (soap_in__QName(soap, "faultcode", &a->faultcode, ""))
 561                                 {       soap_flag_faultcode--;
 562                                         continue;
 563                                 }
 564                         if (soap_flag_faultstring && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
 565                                 if (soap_in_string(soap, "faultstring", &a->faultstring, "xsd:string"))
 566                                 {       soap_flag_faultstring--;
 567                                         continue;
 568                                 }
 569                         if (soap_flag_faultactor && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
 570                                 if (soap_in_string(soap, "faultactor", &a->faultactor, "xsd:string"))
 571                                 {       soap_flag_faultactor--;
 572                                         continue;
 573                                 }
 574                         if (soap_flag_detail && soap->error == SOAP_TAG_MISMATCH)
 575                                 if (soap_in_PointerToSOAP_ENV__Detail(soap, "detail", &a->detail, ""))
 576                                 {       soap_flag_detail--;
 577                                         continue;
 578                                 }
 579                         if (soap_flag_SOAP_ENV__Code && soap->error == SOAP_TAG_MISMATCH)
 580                                 if (soap_in_PointerToSOAP_ENV__Code(soap, "SOAP-ENV:Code", &a->SOAP_ENV__Code, ""))
 581                                 {       soap_flag_SOAP_ENV__Code--;
 582                                         continue;
 583                                 }
 584                         if (soap_flag_SOAP_ENV__Reason && soap->error == SOAP_TAG_MISMATCH)
 585                                 if (soap_in_PointerToSOAP_ENV__Reason(soap, "SOAP-ENV:Reason", &a->SOAP_ENV__Reason, ""))
 586                                 {       soap_flag_SOAP_ENV__Reason--;
 587                                         continue;
 588                                 }
 589                         if (soap_flag_SOAP_ENV__Node && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
 590                                 if (soap_in_string(soap, "SOAP-ENV:Node", &a->SOAP_ENV__Node, "xsd:string"))
 591                                 {       soap_flag_SOAP_ENV__Node--;
 592                                         continue;
 593                                 }
 594                         if (soap_flag_SOAP_ENV__Role && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
 595                                 if (soap_in_string(soap, "SOAP-ENV:Role", &a->SOAP_ENV__Role, "xsd:string"))
 596                                 {       soap_flag_SOAP_ENV__Role--;
 597                                         continue;
 598                                 }
 599                         if (soap_flag_SOAP_ENV__Detail && soap->error == SOAP_TAG_MISMATCH)
 600                                 if (soap_in_PointerToSOAP_ENV__Detail(soap, "SOAP-ENV:Detail", &a->SOAP_ENV__Detail, ""))
 601                                 {       soap_flag_SOAP_ENV__Detail--;
 602                                         continue;
 603                                 }
 604                         if (soap->error == SOAP_TAG_MISMATCH)
 605                                 soap->error = soap_ignore_element(soap);
 606                         if (soap->error == SOAP_NO_TAG)
 607                                 break;
 608                         if (soap->error)
 609                                 return NULL;
 610                 }
 611                 if (soap_element_end_in(soap, tag))
 612                         return NULL;
 613         }
 614         else
 615         {       a = (struct SOAP_ENV__Fault *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_SOAP_ENV__Fault, 0, sizeof(struct SOAP_ENV__Fault), 0, NULL);
 616                 if (soap->body && soap_element_end_in(soap, tag))
 617                         return NULL;
 618         }
 619         return a;
 620 }
 621
 622 SOAP_FMAC3 int SOAP_FMAC4 soap_put_SOAP_ENV__Fault(struct soap *soap, const struct SOAP_ENV__Fault *a, const char *tag, const char *type)
 623 {
 624         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_SOAP_ENV__Fault);
 625         if (soap_out_SOAP_ENV__Fault(soap, tag?tag:"SOAP-ENV:Fault", id, a, type))
 626                 return soap->error;
 627         return soap_putindependent(soap);
 628 }
 629
 630 SOAP_FMAC3 struct SOAP_ENV__Fault * SOAP_FMAC4 soap_get_SOAP_ENV__Fault(struct soap *soap, struct SOAP_ENV__Fault *p, const char *tag, const char *type)
 631 {
 632         if ((p = soap_in_SOAP_ENV__Fault(soap, tag, p, type)))
 633                 if (soap_getindependent(soap))
 634                         return NULL;
 635         return p;
 636 }
 637
 638 SOAP_FMAC1 struct SOAP_ENV__Fault * SOAP_FMAC2 soap_instantiate_SOAP_ENV__Fault(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
 639 {
 640         (void)type; (void)arrayType; /* appease -Wall -Werror */
 641         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_SOAP_ENV__Fault(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:""));
 642         struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_SOAP_ENV__Fault, n, soap_fdelete);
 643         if (!cp)
 644                 return NULL;
 645         if (n < 0)
 646         {       cp->ptr = (void*)SOAP_NEW(struct SOAP_ENV__Fault);
 647                 if (size)
 648                         *size = sizeof(struct SOAP_ENV__Fault);
 649         }
 650         else
 651         {       cp->ptr = (void*)SOAP_NEW(struct SOAP_ENV__Fault[n]);
 652                 if (!cp->ptr)
 653                 {       soap->error = SOAP_EOM;
 654                         return NULL;
 655                 }
 656                 if (size)
 657                         *size = n * sizeof(struct SOAP_ENV__Fault);
 658         }
 659                 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
 660         return (struct SOAP_ENV__Fault*)cp->ptr;
 661 }
 662
 663 SOAP_FMAC3 void SOAP_FMAC4 soap_copy_SOAP_ENV__Fault(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
 664 {
 665         (void)soap; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
 666         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct SOAP_ENV__Fault %p -> %p\n", q, p));
 667         *(struct SOAP_ENV__Fault*)p = *(struct SOAP_ENV__Fault*)q;
 668 }
 669
 670 #endif
 671
 672 #ifndef WITH_NOGLOBAL
 673
 674 SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason *a)
 675 {
 676         (void)soap; (void)a; /* appease -Wall -Werror */
 677         soap_default_string(soap, &a->SOAP_ENV__Text);
 678 }
 679
 680 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Reason(struct soap *soap, const struct SOAP_ENV__Reason *a)
 681 {
 682         (void)soap; (void)a; /* appease -Wall -Werror */
 683         soap_serialize_string(soap, &a->SOAP_ENV__Text);
 684 }
 685
 686 SOAP_FMAC3 int SOAP_FMAC4 soap_out_SOAP_ENV__Reason(struct soap *soap, const char *tag, int id, const struct SOAP_ENV__Reason *a, const char *type)
 687 {
 688         if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Reason), type))
 689                 return soap->error;
 690         if (soap->lang)
 691                 soap_set_attr(soap, "xml:lang", soap->lang, 1);
 692         if (soap_out_string(soap, "SOAP-ENV:Text", -1, &a->SOAP_ENV__Text, ""))
 693                 return soap->error;
 694         return soap_element_end_out(soap, tag);
 695 }
 696
 697 SOAP_FMAC3 struct SOAP_ENV__Reason * SOAP_FMAC4 soap_in_SOAP_ENV__Reason(struct soap *soap, const char *tag, struct SOAP_ENV__Reason *a, const char *type)
 698 {
 699         size_t soap_flag_SOAP_ENV__Text = 1;
 700         if (soap_element_begin_in(soap, tag, 0, type))
 701                 return NULL;
 702         a = (struct SOAP_ENV__Reason *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_SOAP_ENV__Reason, sizeof(struct SOAP_ENV__Reason), 0, NULL, NULL, NULL);
 703         if (!a)
 704                 return NULL;
 705         soap_default_SOAP_ENV__Reason(soap, a);
 706         if (soap->body && !*soap->href)
 707         {
 708                 for (;;)
 709                 {       soap->error = SOAP_TAG_MISMATCH;
 710                         if (soap_flag_SOAP_ENV__Text && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
 711                                 if (soap_in_string(soap, "SOAP-ENV:Text", &a->SOAP_ENV__Text, "xsd:string"))
 712                                 {       soap_flag_SOAP_ENV__Text--;
 713                                         continue;
 714                                 }
 715                         if (soap->error == SOAP_TAG_MISMATCH)
 716                                 soap->error = soap_ignore_element(soap);
 717                         if (soap->error == SOAP_NO_TAG)
 718                                 break;
 719                         if (soap->error)
 720                                 return NULL;
 721                 }
 722                 if (soap_element_end_in(soap, tag))
 723                         return NULL;
 724         }
 725         else
 726         {       a = (struct SOAP_ENV__Reason *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_SOAP_ENV__Reason, 0, sizeof(struct SOAP_ENV__Reason), 0, NULL);
 727                 if (soap->body && soap_element_end_in(soap, tag))
 728                         return NULL;
 729         }
 730         return a;
 731 }
 732
 733 SOAP_FMAC3 int SOAP_FMAC4 soap_put_SOAP_ENV__Reason(struct soap *soap, const struct SOAP_ENV__Reason *a, const char *tag, const char *type)
 734 {
 735         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_SOAP_ENV__Reason);
 736         if (soap_out_SOAP_ENV__Reason(soap, tag?tag:"SOAP-ENV:Reason", id, a, type))
 737                 return soap->error;
 738         return soap_putindependent(soap);
 739 }
 740
 741 SOAP_FMAC3 struct SOAP_ENV__Reason * SOAP_FMAC4 soap_get_SOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason *p, const char *tag, const char *type)
 742 {
 743         if ((p = soap_in_SOAP_ENV__Reason(soap, tag, p, type)))
 744                 if (soap_getindependent(soap))
 745                         return NULL;
 746         return p;
 747 }
 748
 749 SOAP_FMAC1 struct SOAP_ENV__Reason * SOAP_FMAC2 soap_instantiate_SOAP_ENV__Reason(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
 750 {
 751         (void)type; (void)arrayType; /* appease -Wall -Werror */
 752         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_SOAP_ENV__Reason(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:""));
 753         struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_SOAP_ENV__Reason, n, soap_fdelete);
 754         if (!cp)
 755                 return NULL;
 756         if (n < 0)
 757         {       cp->ptr = (void*)SOAP_NEW(struct SOAP_ENV__Reason);
 758                 if (size)
 759                         *size = sizeof(struct SOAP_ENV__Reason);
 760         }
 761         else
 762         {       cp->ptr = (void*)SOAP_NEW(struct SOAP_ENV__Reason[n]);
 763                 if (!cp->ptr)
 764                 {       soap->error = SOAP_EOM;
 765                         return NULL;
 766                 }
 767                 if (size)
 768                         *size = n * sizeof(struct SOAP_ENV__Reason);
 769         }
 770                 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
 771         return (struct SOAP_ENV__Reason*)cp->ptr;
 772 }
 773
 774 SOAP_FMAC3 void SOAP_FMAC4 soap_copy_SOAP_ENV__Reason(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
 775 {
 776         (void)soap; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
 777         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct SOAP_ENV__Reason %p -> %p\n", q, p));
 778         *(struct SOAP_ENV__Reason*)p = *(struct SOAP_ENV__Reason*)q;
 779 }
 780
 781 #endif
 782
 783 #ifndef WITH_NOGLOBAL
 784
 785 SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Detail(struct soap *soap, struct SOAP_ENV__Detail *a)
 786 {
 787         (void)soap; (void)a; /* appease -Wall -Werror */
 788         a->__type = 0;
 789         a->fault = NULL;
 790         a->__any = NULL;
 791 }
 792
 793 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Detail(struct soap *soap, const struct SOAP_ENV__Detail *a)
 794 {
 795         (void)soap; (void)a; /* appease -Wall -Werror */
 796         soap_markelement(soap, a->fault, a->__type);
 797 }
 798
 799 SOAP_FMAC3 int SOAP_FMAC4 soap_out_SOAP_ENV__Detail(struct soap *soap, const char *tag, int id, const struct SOAP_ENV__Detail *a, const char *type)
 800 {
 801         if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Detail), type))
 802                 return soap->error;
 803         if (soap_putelement(soap, a->fault, "fault", -1, a->__type))
 804                 return soap->error;
 805         soap_outliteral(soap, "-any", &a->__any, NULL);
 806         return soap_element_end_out(soap, tag);
 807 }
 808
 809 SOAP_FMAC3 struct SOAP_ENV__Detail * SOAP_FMAC4 soap_in_SOAP_ENV__Detail(struct soap *soap, const char *tag, struct SOAP_ENV__Detail *a, const char *type)
 810 {
 811         size_t soap_flag_fault = 1;
 812         size_t soap_flag___any = 1;
 813         if (soap_element_begin_in(soap, tag, 0, type))
 814                 return NULL;
 815         a = (struct SOAP_ENV__Detail *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_SOAP_ENV__Detail, sizeof(struct SOAP_ENV__Detail), 0, NULL, NULL, NULL);
 816         if (!a)
 817                 return NULL;
 818         soap_default_SOAP_ENV__Detail(soap, a);
 819         if (soap->body && !*soap->href)
 820         {
 821                 for (;;)
 822                 {       soap->error = SOAP_TAG_MISMATCH;
 823                         if (soap_flag_fault && soap->error == SOAP_TAG_MISMATCH)
 824                                 if ((a->fault = soap_getelement(soap, &a->__type)))
 825                                 {       soap_flag_fault = 0;
 826                                         continue;
 827                                 }
 828                         if (soap_flag___any && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
 829                                 if (soap_inliteral(soap, "-any", &a->__any))
 830                                 {       soap_flag___any--;
 831                                         continue;
 832                                 }
 833                         if (soap->error == SOAP_TAG_MISMATCH)
 834                                 soap->error = soap_ignore_element(soap);
 835                         if (soap->error == SOAP_NO_TAG)
 836                                 break;
 837                         if (soap->error)
 838                                 return NULL;
 839                 }
 840                 if (soap_element_end_in(soap, tag))
 841                         return NULL;
 842         }
 843         else
 844         {       a = (struct SOAP_ENV__Detail *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_SOAP_ENV__Detail, 0, sizeof(struct SOAP_ENV__Detail), 0, NULL);
 845                 if (soap->body && soap_element_end_in(soap, tag))
 846                         return NULL;
 847         }
 848         return a;
 849 }
 850
 851 SOAP_FMAC3 int SOAP_FMAC4 soap_put_SOAP_ENV__Detail(struct soap *soap, const struct SOAP_ENV__Detail *a, const char *tag, const char *type)
 852 {
 853         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_SOAP_ENV__Detail);
 854         if (soap_out_SOAP_ENV__Detail(soap, tag?tag:"SOAP-ENV:Detail", id, a, type))
 855                 return soap->error;
 856         return soap_putindependent(soap);
 857 }
 858
 859 SOAP_FMAC3 struct SOAP_ENV__Detail * SOAP_FMAC4 soap_get_SOAP_ENV__Detail(struct soap *soap, struct SOAP_ENV__Detail *p, const char *tag, const char *type)
 860 {
 861         if ((p = soap_in_SOAP_ENV__Detail(soap, tag, p, type)))
 862                 if (soap_getindependent(soap))
 863                         return NULL;
 864         return p;
 865 }
 866
 867 SOAP_FMAC1 struct SOAP_ENV__Detail * SOAP_FMAC2 soap_instantiate_SOAP_ENV__Detail(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
 868 {
 869         (void)type; (void)arrayType; /* appease -Wall -Werror */
 870         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_SOAP_ENV__Detail(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:""));
 871         struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_SOAP_ENV__Detail, n, soap_fdelete);
 872         if (!cp)
 873                 return NULL;
 874         if (n < 0)
 875         {       cp->ptr = (void*)SOAP_NEW(struct SOAP_ENV__Detail);
 876                 if (size)
 877                         *size = sizeof(struct SOAP_ENV__Detail);
 878         }
 879         else
 880         {       cp->ptr = (void*)SOAP_NEW(struct SOAP_ENV__Detail[n]);
 881                 if (!cp->ptr)
 882                 {       soap->error = SOAP_EOM;
 883                         return NULL;
 884                 }
 885                 if (size)
 886                         *size = n * sizeof(struct SOAP_ENV__Detail);
 887         }
 888                 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
 889         return (struct SOAP_ENV__Detail*)cp->ptr;
 890 }
 891
 892 SOAP_FMAC3 void SOAP_FMAC4 soap_copy_SOAP_ENV__Detail(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
 893 {
 894         (void)soap; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
 895         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct SOAP_ENV__Detail %p -> %p\n", q, p));
 896         *(struct SOAP_ENV__Detail*)p = *(struct SOAP_ENV__Detail*)q;
 897 }
 898
 899 #endif
 900
 901 #ifndef WITH_NOGLOBAL
 902
 903 SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code *a)
 904 {
 905         (void)soap; (void)a; /* appease -Wall -Werror */
 906         soap_default__QName(soap, &a->SOAP_ENV__Value);
 907         a->SOAP_ENV__Subcode = NULL;
 908 }
 909
 910 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Code(struct soap *soap, const struct SOAP_ENV__Code *a)
 911 {
 912         (void)soap; (void)a; /* appease -Wall -Werror */
 913         soap_serialize__QName(soap, &a->SOAP_ENV__Value);
 914         soap_serialize_PointerToSOAP_ENV__Code(soap, &a->SOAP_ENV__Subcode);
 915 }
 916
 917 SOAP_FMAC3 int SOAP_FMAC4 soap_out_SOAP_ENV__Code(struct soap *soap, const char *tag, int id, const struct SOAP_ENV__Code *a, const char *type)
 918 {
 919         const char *soap_tmp_SOAP_ENV__Value = soap_QName2s(soap, a->SOAP_ENV__Value);
 920         if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Code), type))
 921                 return soap->error;
 922         if (soap_out__QName(soap, "SOAP-ENV:Value", -1, (char*const*)&soap_tmp_SOAP_ENV__Value, ""))
 923                 return soap->error;
 924         if (soap_out_PointerToSOAP_ENV__Code(soap, "SOAP-ENV:Subcode", -1, &a->SOAP_ENV__Subcode, ""))
 925                 return soap->error;
 926         return soap_element_end_out(soap, tag);
 927 }
 928
 929 SOAP_FMAC3 struct SOAP_ENV__Code * SOAP_FMAC4 soap_in_SOAP_ENV__Code(struct soap *soap, const char *tag, struct SOAP_ENV__Code *a, const char *type)
 930 {
 931         size_t soap_flag_SOAP_ENV__Value = 1;
 932         size_t soap_flag_SOAP_ENV__Subcode = 1;
 933         if (soap_element_begin_in(soap, tag, 0, type))
 934                 return NULL;
 935         a = (struct SOAP_ENV__Code *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_SOAP_ENV__Code, sizeof(struct SOAP_ENV__Code), 0, NULL, NULL, NULL);
 936         if (!a)
 937                 return NULL;
 938         soap_default_SOAP_ENV__Code(soap, a);
 939         if (soap->body && !*soap->href)
 940         {
 941                 for (;;)
 942                 {       soap->error = SOAP_TAG_MISMATCH;
 943                         if (soap_flag_SOAP_ENV__Value && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
 944                                 if (soap_in__QName(soap, "SOAP-ENV:Value", &a->SOAP_ENV__Value, ""))
 945                                 {       soap_flag_SOAP_ENV__Value--;
 946                                         continue;
 947                                 }
 948                         if (soap_flag_SOAP_ENV__Subcode && soap->error == SOAP_TAG_MISMATCH)
 949                                 if (soap_in_PointerToSOAP_ENV__Code(soap, "SOAP-ENV:Subcode", &a->SOAP_ENV__Subcode, ""))
 950                                 {       soap_flag_SOAP_ENV__Subcode--;
 951                                         continue;
 952                                 }
 953                         if (soap->error == SOAP_TAG_MISMATCH)
 954                                 soap->error = soap_ignore_element(soap);
 955                         if (soap->error == SOAP_NO_TAG)
 956                                 break;
 957                         if (soap->error)
 958                                 return NULL;
 959                 }
 960                 if (soap_element_end_in(soap, tag))
 961                         return NULL;
 962         }
 963         else
 964         {       a = (struct SOAP_ENV__Code *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_SOAP_ENV__Code, 0, sizeof(struct SOAP_ENV__Code), 0, NULL);
 965                 if (soap->body && soap_element_end_in(soap, tag))
 966                         return NULL;
 967         }
 968         return a;
 969 }
 970
 971 SOAP_FMAC3 int SOAP_FMAC4 soap_put_SOAP_ENV__Code(struct soap *soap, const struct SOAP_ENV__Code *a, const char *tag, const char *type)
 972 {
 973         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_SOAP_ENV__Code);
 974         if (soap_out_SOAP_ENV__Code(soap, tag?tag:"SOAP-ENV:Code", id, a, type))
 975                 return soap->error;
 976         return soap_putindependent(soap);
 977 }
 978
 979 SOAP_FMAC3 struct SOAP_ENV__Code * SOAP_FMAC4 soap_get_SOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code *p, const char *tag, const char *type)
 980 {
 981         if ((p = soap_in_SOAP_ENV__Code(soap, tag, p, type)))
 982                 if (soap_getindependent(soap))
 983                         return NULL;
 984         return p;
 985 }
 986
 987 SOAP_FMAC1 struct SOAP_ENV__Code * SOAP_FMAC2 soap_instantiate_SOAP_ENV__Code(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
 988 {
 989         (void)type; (void)arrayType; /* appease -Wall -Werror */
 990         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_SOAP_ENV__Code(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:""));
 991         struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_SOAP_ENV__Code, n, soap_fdelete);
 992         if (!cp)
 993                 return NULL;
 994         if (n < 0)
 995         {       cp->ptr = (void*)SOAP_NEW(struct SOAP_ENV__Code);
 996                 if (size)
 997                         *size = sizeof(struct SOAP_ENV__Code);
 998         }
 999         else
1000         {       cp->ptr = (void*)SOAP_NEW(struct SOAP_ENV__Code[n]);
1001                 if (!cp->ptr)
1002                 {       soap->error = SOAP_EOM;
1003                         return NULL;
1004                 }
1005                 if (size)
1006                         *size = n * sizeof(struct SOAP_ENV__Code);
1007         }
1008                 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
1009         return (struct SOAP_ENV__Code*)cp->ptr;
1010 }
1011
1012 SOAP_FMAC3 void SOAP_FMAC4 soap_copy_SOAP_ENV__Code(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
1013 {
1014         (void)soap; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
1015         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct SOAP_ENV__Code %p -> %p\n", q, p));
1016         *(struct SOAP_ENV__Code*)p = *(struct SOAP_ENV__Code*)q;
1017 }
1018
1019 #endif
1020
1021 #ifndef WITH_NOGLOBAL
1022
1023 SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Header(struct soap *soap, struct SOAP_ENV__Header *a)
1024 {
1025         (void)soap; (void)a; /* appease -Wall -Werror */
1026 }
1027
1028 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Header(struct soap *soap, const struct SOAP_ENV__Header *a)
1029 {
1030         (void)soap; (void)a; /* appease -Wall -Werror */
1031 }
1032
1033 SOAP_FMAC3 int SOAP_FMAC4 soap_out_SOAP_ENV__Header(struct soap *soap, const char *tag, int id, const struct SOAP_ENV__Header *a, const char *type)
1034 {
1035         if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Header), type))
1036                 return soap->error;
1037         return soap_element_end_out(soap, tag);
1038 }
1039
1040 SOAP_FMAC3 struct SOAP_ENV__Header * SOAP_FMAC4 soap_in_SOAP_ENV__Header(struct soap *soap, const char *tag, struct SOAP_ENV__Header *a, const char *type)
1041 {
1042         if (soap_element_begin_in(soap, tag, 0, type))
1043                 return NULL;
1044         a = (struct SOAP_ENV__Header *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_SOAP_ENV__Header, sizeof(struct SOAP_ENV__Header), 0, NULL, NULL, NULL);
1045         if (!a)
1046                 return NULL;
1047         soap_default_SOAP_ENV__Header(soap, a);
1048         if (soap->body && !*soap->href)
1049         {
1050                 for (;;)
1051                 {       soap->error = SOAP_TAG_MISMATCH;
1052                         if (soap->error == SOAP_TAG_MISMATCH)
1053                                 soap->error = soap_ignore_element(soap);
1054                         if (soap->error == SOAP_NO_TAG)
1055                                 break;
1056                         if (soap->error)
1057                                 return NULL;
1058                 }
1059                 if (soap_element_end_in(soap, tag))
1060                         return NULL;
1061         }
1062         else
1063         {       a = (struct SOAP_ENV__Header *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_SOAP_ENV__Header, 0, sizeof(struct SOAP_ENV__Header), 0, NULL);
1064                 if (soap->body && soap_element_end_in(soap, tag))
1065                         return NULL;
1066         }
1067         return a;
1068 }
1069
1070 SOAP_FMAC3 int SOAP_FMAC4 soap_put_SOAP_ENV__Header(struct soap *soap, const struct SOAP_ENV__Header *a, const char *tag, const char *type)
1071 {
1072         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_SOAP_ENV__Header);
1073         if (soap_out_SOAP_ENV__Header(soap, tag?tag:"SOAP-ENV:Header", id, a, type))
1074                 return soap->error;
1075         return soap_putindependent(soap);
1076 }
1077
1078 SOAP_FMAC3 struct SOAP_ENV__Header * SOAP_FMAC4 soap_get_SOAP_ENV__Header(struct soap *soap, struct SOAP_ENV__Header *p, const char *tag, const char *type)
1079 {
1080         if ((p = soap_in_SOAP_ENV__Header(soap, tag, p, type)))
1081                 if (soap_getindependent(soap))
1082                         return NULL;
1083         return p;
1084 }
1085
1086 SOAP_FMAC1 struct SOAP_ENV__Header * SOAP_FMAC2 soap_instantiate_SOAP_ENV__Header(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
1087 {
1088         (void)type; (void)arrayType; /* appease -Wall -Werror */
1089         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_SOAP_ENV__Header(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:""));
1090         struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_SOAP_ENV__Header, n, soap_fdelete);
1091         if (!cp)
1092                 return NULL;
1093         if (n < 0)
1094         {       cp->ptr = (void*)SOAP_NEW(struct SOAP_ENV__Header);
1095                 if (size)
1096                         *size = sizeof(struct SOAP_ENV__Header);
1097         }
1098         else
1099         {       cp->ptr = (void*)SOAP_NEW(struct SOAP_ENV__Header[n]);
1100                 if (!cp->ptr)
1101                 {       soap->error = SOAP_EOM;
1102                         return NULL;
1103                 }
1104                 if (size)
1105                         *size = n * sizeof(struct SOAP_ENV__Header);
1106         }
1107                 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
1108         return (struct SOAP_ENV__Header*)cp->ptr;
1109 }
1110
1111 SOAP_FMAC3 void SOAP_FMAC4 soap_copy_SOAP_ENV__Header(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
1112 {
1113         (void)soap; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
1114         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct SOAP_ENV__Header %p -> %p\n", q, p));
1115         *(struct SOAP_ENV__Header*)p = *(struct SOAP_ENV__Header*)q;
1116 }
1117
1118 #endif
1119
1120 #ifndef WITH_NOGLOBAL
1121
1122 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToSOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason *const*a)
1123 {
1124         if (!soap_reference(soap, *a, SOAP_TYPE_SOAP_ENV__Reason))
1125                 soap_serialize_SOAP_ENV__Reason(soap, *a);
1126 }
1127
1128 SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToSOAP_ENV__Reason(struct soap *soap, const char *tag, int id, struct SOAP_ENV__Reason *const*a, const char *type)
1129 {
1130         id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_SOAP_ENV__Reason);
1131         if (id < 0)
1132                 return soap->error;
1133         return soap_out_SOAP_ENV__Reason(soap, tag, id, *a, type);
1134 }
1135
1136 SOAP_FMAC3 struct SOAP_ENV__Reason ** SOAP_FMAC4 soap_in_PointerToSOAP_ENV__Reason(struct soap *soap, const char *tag, struct SOAP_ENV__Reason **a, const char *type)
1137 {
1138         if (soap_element_begin_in(soap, tag, 1, NULL))
1139                 return NULL;
1140         if (!a)
1141                 if (!(a = (struct SOAP_ENV__Reason **)soap_malloc(soap, sizeof(struct SOAP_ENV__Reason *))))
1142                         return NULL;
1143         *a = NULL;
1144         if (!soap->null && *soap->href != '#')
1145         {       soap_revert(soap);
1146                 if (!(*a = soap_in_SOAP_ENV__Reason(soap, tag, *a, type)))
1147                         return NULL;
1148         }
1149         else
1150         {       a = (struct SOAP_ENV__Reason **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_SOAP_ENV__Reason, sizeof(struct SOAP_ENV__Reason), 0);
1151                 if (soap->body && soap_element_end_in(soap, tag))
1152                         return NULL;
1153         }
1154         return a;
1155 }
1156
1157 SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToSOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason *const*a, const char *tag, const char *type)
1158 {
1159         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToSOAP_ENV__Reason);
1160         if (soap_out_PointerToSOAP_ENV__Reason(soap, tag?tag:"SOAP-ENV:Reason", id, a, type))
1161                 return soap->error;
1162         return soap_putindependent(soap);
1163 }
1164
1165 SOAP_FMAC3 struct SOAP_ENV__Reason ** SOAP_FMAC4 soap_get_PointerToSOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason **p, const char *tag, const char *type)
1166 {
1167         if ((p = soap_in_PointerToSOAP_ENV__Reason(soap, tag, p, type)))
1168                 if (soap_getindependent(soap))
1169                         return NULL;
1170         return p;
1171 }
1172
1173 #endif
1174
1175 #ifndef WITH_NOGLOBAL
1176
1177 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToSOAP_ENV__Detail(struct soap *soap, struct SOAP_ENV__Detail *const*a)
1178 {
1179         if (!soap_reference(soap, *a, SOAP_TYPE_SOAP_ENV__Detail))
1180                 soap_serialize_SOAP_ENV__Detail(soap, *a);
1181 }
1182
1183 SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToSOAP_ENV__Detail(struct soap *soap, const char *tag, int id, struct SOAP_ENV__Detail *const*a, const char *type)
1184 {
1185         id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_SOAP_ENV__Detail);
1186         if (id < 0)
1187                 return soap->error;
1188         return soap_out_SOAP_ENV__Detail(soap, tag, id, *a, type);
1189 }
1190
1191 SOAP_FMAC3 struct SOAP_ENV__Detail ** SOAP_FMAC4 soap_in_PointerToSOAP_ENV__Detail(struct soap *soap, const char *tag, struct SOAP_ENV__Detail **a, const char *type)
1192 {
1193         if (soap_element_begin_in(soap, tag, 1, NULL))
1194                 return NULL;
1195         if (!a)
1196                 if (!(a = (struct SOAP_ENV__Detail **)soap_malloc(soap, sizeof(struct SOAP_ENV__Detail *))))
1197                         return NULL;
1198         *a = NULL;
1199         if (!soap->null && *soap->href != '#')
1200         {       soap_revert(soap);
1201                 if (!(*a = soap_in_SOAP_ENV__Detail(soap, tag, *a, type)))
1202                         return NULL;
1203         }
1204         else
1205         {       a = (struct SOAP_ENV__Detail **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_SOAP_ENV__Detail, sizeof(struct SOAP_ENV__Detail), 0);
1206                 if (soap->body && soap_element_end_in(soap, tag))
1207                         return NULL;
1208         }
1209         return a;
1210 }
1211
1212 SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToSOAP_ENV__Detail(struct soap *soap, struct SOAP_ENV__Detail *const*a, const char *tag, const char *type)
1213 {
1214         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToSOAP_ENV__Detail);
1215         if (soap_out_PointerToSOAP_ENV__Detail(soap, tag?tag:"SOAP-ENV:Detail", id, a, type))
1216                 return soap->error;
1217         return soap_putindependent(soap);
1218 }
1219
1220 SOAP_FMAC3 struct SOAP_ENV__Detail ** SOAP_FMAC4 soap_get_PointerToSOAP_ENV__Detail(struct soap *soap, struct SOAP_ENV__Detail **p, const char *tag, const char *type)
1221 {
1222         if ((p = soap_in_PointerToSOAP_ENV__Detail(soap, tag, p, type)))
1223                 if (soap_getindependent(soap))
1224                         return NULL;
1225         return p;
1226 }
1227
1228 #endif
1229
1230 #ifndef WITH_NOGLOBAL
1231
1232 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToSOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code *const*a)
1233 {
1234         if (!soap_reference(soap, *a, SOAP_TYPE_SOAP_ENV__Code))
1235                 soap_serialize_SOAP_ENV__Code(soap, *a);
1236 }
1237
1238 SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToSOAP_ENV__Code(struct soap *soap, const char *tag, int id, struct SOAP_ENV__Code *const*a, const char *type)
1239 {
1240         id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_SOAP_ENV__Code);
1241         if (id < 0)
1242                 return soap->error;
1243         return soap_out_SOAP_ENV__Code(soap, tag, id, *a, type);
1244 }
1245
1246 SOAP_FMAC3 struct SOAP_ENV__Code ** SOAP_FMAC4 soap_in_PointerToSOAP_ENV__Code(struct soap *soap, const char *tag, struct SOAP_ENV__Code **a, const char *type)
1247 {
1248         if (soap_element_begin_in(soap, tag, 1, NULL))
1249                 return NULL;
1250         if (!a)
1251                 if (!(a = (struct SOAP_ENV__Code **)soap_malloc(soap, sizeof(struct SOAP_ENV__Code *))))
1252                         return NULL;
1253         *a = NULL;
1254         if (!soap->null && *soap->href != '#')
1255         {       soap_revert(soap);
1256                 if (!(*a = soap_in_SOAP_ENV__Code(soap, tag, *a, type)))
1257                         return NULL;
1258         }
1259         else
1260         {       a = (struct SOAP_ENV__Code **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_SOAP_ENV__Code, sizeof(struct SOAP_ENV__Code), 0);
1261                 if (soap->body && soap_element_end_in(soap, tag))
1262                         return NULL;
1263         }
1264         return a;
1265 }
1266
1267 SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToSOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code *const*a, const char *tag, const char *type)
1268 {
1269         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToSOAP_ENV__Code);
1270         if (soap_out_PointerToSOAP_ENV__Code(soap, tag?tag:"SOAP-ENV:Code", id, a, type))
1271                 return soap->error;
1272         return soap_putindependent(soap);
1273 }
1274
1275 SOAP_FMAC3 struct SOAP_ENV__Code ** SOAP_FMAC4 soap_get_PointerToSOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code **p, const char *tag, const char *type)
1276 {
1277         if ((p = soap_in_PointerToSOAP_ENV__Code(soap, tag, p, type)))
1278                 if (soap_getindependent(soap))
1279                         return NULL;
1280         return p;
1281 }
1282
1283 #endif
1284
1285 SOAP_FMAC3 int SOAP_FMAC4 soap_out__QName(struct soap *soap, const char *tag, int id, char *const*a, const char *type)
1286 {
1287         return soap_outstring(soap, tag, id, a, type, SOAP_TYPE__QName);
1288 }
1289
1290 SOAP_FMAC3 char * * SOAP_FMAC4 soap_in__QName(struct soap *soap, const char *tag, char **a, const char *type)
1291 {       char **p;
1292         p = soap_instring(soap, tag, a, type, SOAP_TYPE__QName, 2, -1, -1);
1293         return p;
1294 }
1295
1296 SOAP_FMAC3 int SOAP_FMAC4 soap_put__QName(struct soap *soap, char *const*a, const char *tag, const char *type)
1297 {
1298         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE__QName);
1299         if (soap_out__QName(soap, tag?tag:"byte", id, a, type))
1300                 return soap->error;
1301         return soap_putindependent(soap);
1302 }
1303
1304 SOAP_FMAC3 char ** SOAP_FMAC4 soap_get__QName(struct soap *soap, char **p, const char *tag, const char *type)
1305 {
1306         if ((p = soap_in__QName(soap, tag, p, type)))
1307                 if (soap_getindependent(soap))
1308                         return NULL;
1309         return p;
1310 }
1311
1312 SOAP_FMAC3 void SOAP_FMAC4 soap_default_string(struct soap *soap, char **a)
1313 {
1314         (void)soap; /* appease -Wall -Werror */
1315 #ifdef SOAP_DEFAULT_string
1316         *a = SOAP_DEFAULT_string;
1317 #else
1318         *a = (char *)0;
1319 #endif
1320 }
1321
1322 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_string(struct soap *soap, char *const*a)
1323 {
1324         soap_reference(soap, *a, SOAP_TYPE_string);
1325 }
1326
1327 SOAP_FMAC3 int SOAP_FMAC4 soap_out_string(struct soap *soap, const char *tag, int id, char *const*a, const char *type)
1328 {
1329         return soap_outstring(soap, tag, id, a, type, SOAP_TYPE_string);
1330 }
1331
1332 SOAP_FMAC3 char * * SOAP_FMAC4 soap_in_string(struct soap *soap, const char *tag, char **a, const char *type)
1333 {       char **p;
1334         p = soap_instring(soap, tag, a, type, SOAP_TYPE_string, 1, -1, -1);
1335         return p;
1336 }
1337
1338 SOAP_FMAC3 int SOAP_FMAC4 soap_put_string(struct soap *soap, char *const*a, const char *tag, const char *type)
1339 {
1340         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_string);
1341         if (soap_out_string(soap, tag?tag:"byte", id, a, type))
1342                 return soap->error;
1343         return soap_putindependent(soap);
1344 }
1345
1346 SOAP_FMAC3 char ** SOAP_FMAC4 soap_get_string(struct soap *soap, char **p, const char *tag, const char *type)
1347 {
1348         if ((p = soap_in_string(soap, tag, p, type)))
1349                 if (soap_getindependent(soap))
1350                         return NULL;
1351         return p;
1352 }
1353
1354 #if defined(__BORLANDC__)
1355 #pragma option pop
1356 #pragma option pop
1357 #endif
1358
1359 /* End of envC.cpp */