1 /* envC.cpp

     2    Generated by gSOAP 2.7.6b from env.h

     3    Copyright (C) 2000-2005, Robert van Engelen, Genivia Inc. All Rights Reserved.

     4    This part of the software is released under one of the following licenses:

     5    GPL, the gSOAP public license, or Genivia's license for commercial use.

     6 */

     7 

     8 #include "envH.h"

     9 

    10 SOAP_SOURCE_STAMP("@(#) envC.cpp ver 2.7.6b 2005-09-27 12:23:39 GMT")

    11 

    12 

    13 #ifndef WITH_NOGLOBAL

    14 

    15 SOAP_FMAC3 void SOAP_FMAC4 soap_serializeheader(struct soap *soap)

    16 {

    17 	if (soap->header)

    18 		soap_serialize_SOAP_ENV__Header(soap, soap->header);

    19 }

    20 

    21 SOAP_FMAC3 int SOAP_FMAC4 soap_putheader(struct soap *soap)

    22 {

    23 	if (soap->header)

    24 	{	soap->part = SOAP_IN_HEADER;

    25 		soap_out_SOAP_ENV__Header(soap, "SOAP-ENV:Header", 0, soap->header, NULL);

    26 		soap->part = SOAP_END_HEADER;

    27 	}

    28 	return SOAP_OK;

    29 }

    30 

    31 SOAP_FMAC3 int SOAP_FMAC4 soap_getheader(struct soap *soap)

    32 {

    33 	soap->part = SOAP_IN_HEADER;

    34 	soap->header = soap_in_SOAP_ENV__Header(soap, "SOAP-ENV:Header", NULL, NULL);

    35 	soap->part = SOAP_END_HEADER;

    36 	return soap->header == NULL;

    37 }

    38 

    39 SOAP_FMAC3 void SOAP_FMAC4 soap_fault(struct soap *soap)

    40 {

    41 	if (!soap->fault)

    42 	{	soap->fault = (struct SOAP_ENV__Fault*)soap_malloc(soap, sizeof(struct SOAP_ENV__Fault));

    43 		soap_default_SOAP_ENV__Fault(soap, soap->fault);

    44 	}

    45 	if (soap->version == 2 && !soap->fault->SOAP_ENV__Code)

    46 	{	soap->fault->SOAP_ENV__Code = (struct SOAP_ENV__Code*)soap_malloc(soap, sizeof(struct SOAP_ENV__Code));

    47 		soap_default_SOAP_ENV__Code(soap, soap->fault->SOAP_ENV__Code);

    48 	}

    49 	if (soap->version == 2 && !soap->fault->SOAP_ENV__Reason)

    50 	{	soap->fault->SOAP_ENV__Reason = (struct SOAP_ENV__Reason*)soap_malloc(soap, sizeof(struct SOAP_ENV__Reason));

    51 		soap_default_SOAP_ENV__Reason(soap, soap->fault->SOAP_ENV__Reason);

    52 	}

    53 }

    54 

    55 SOAP_FMAC3 void SOAP_FMAC4 soap_serializefault(struct soap *soap)

    56 {

    57 	if (soap->fault)

    58 		soap_serialize_SOAP_ENV__Fault(soap, soap->fault);

    59 }

    60 

    61 SOAP_FMAC3 int SOAP_FMAC4 soap_putfault(struct soap *soap)

    62 {

    63 	if (soap->fault)

    64 		return soap_put_SOAP_ENV__Fault(soap, soap->fault, "SOAP-ENV:Fault", NULL);

    65 	return SOAP_OK;

    66 }

    67 

    68 SOAP_FMAC3 int SOAP_FMAC4 soap_getfault(struct soap *soap)

    69 {

    70 	return (soap->fault = soap_get_SOAP_ENV__Fault(soap, NULL, "SOAP-ENV:Fault", NULL)) == NULL;

    71 }

    72 

    73 SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultcode(struct soap *soap)

    74 {

    75 	soap_fault(soap);

    76 	if (soap->version == 2)

    77 		return (const char**)&soap->fault->SOAP_ENV__Code->SOAP_ENV__Value;

    78 	return (const char**)&soap->fault->faultcode;

    79 }

    80 

    81 SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultsubcode(struct soap *soap)

    82 {

    83 	soap_fault(soap);

    84 	if (soap->version == 2)

    85 	{	if (!soap->fault->SOAP_ENV__Code->SOAP_ENV__Subcode)

    86 		{	soap->fault->SOAP_ENV__Code->SOAP_ENV__Subcode = (struct SOAP_ENV__Code*)soap_malloc(soap, sizeof(struct SOAP_ENV__Code));

    87 			soap_default_SOAP_ENV__Code(soap, soap->fault->SOAP_ENV__Code->SOAP_ENV__Subcode);

    88 		}

    89 		return (const char**)&soap->fault->SOAP_ENV__Code->SOAP_ENV__Subcode->SOAP_ENV__Value;

    90 	}

    91 	return (const char**)&soap->fault->faultcode;

    92 }

    93 

    94 SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultstring(struct soap *soap)

    95 {

    96 	soap_fault(soap);

    97 	if (soap->version == 2)

    98 		return (const char**)&soap->fault->SOAP_ENV__Reason->SOAP_ENV__Text;

    99 	return (const char**)&soap->fault->faultstring;

   100 }

   101 

   102 SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultdetail(struct soap *soap)

   103 {

   104 	soap_fault(soap);

   105 	if (soap->version == 1)

   106 	{	if (!soap->fault->detail)

   107 		{	soap->fault->detail = (struct SOAP_ENV__Detail*)soap_malloc(soap, sizeof(struct SOAP_ENV__Detail));

   108 			soap_default_SOAP_ENV__Detail(soap, soap->fault->detail);

   109 		}

   110 		return (const char**)&soap->fault->detail->__any;

   111 	}

   112 	if (!soap->fault->SOAP_ENV__Detail)

   113 	{	soap->fault->SOAP_ENV__Detail = (struct SOAP_ENV__Detail*)soap_malloc(soap, sizeof(struct SOAP_ENV__Detail));

   114 		soap_default_SOAP_ENV__Detail(soap, soap->fault->SOAP_ENV__Detail);

   115 	}

   116 	return (const char**)&soap->fault->SOAP_ENV__Detail->__any;

   117 }

   118 

   119 #endif

   120 

   121 #ifndef WITH_NOIDREF

   122 SOAP_FMAC3 int SOAP_FMAC4 soap_getindependent(struct soap *soap)

   123 {

   124 	int t;

   125 	for (;;)

   126 		if (!soap_getelement(soap, &t))

   127 			if (soap->error || soap_ignore_element(soap))

   128 				break;

   129 	if (soap->error == SOAP_NO_TAG || soap->error == SOAP_EOF)

   130 		soap->error = SOAP_OK;

   131 	return soap->error;

   132 }

   133 #endif

   134 

   135 #ifndef WITH_NOIDREF

   136 SOAP_FMAC3 void * SOAP_FMAC4 soap_getelement(struct soap *soap, int *type)

   137 {

   138 	if (soap_peek_element(soap))

   139 		return NULL;

   140 	if (!*soap->id || !(*type = soap_lookup_type(soap, soap->id)))

   141 		*type = soap_lookup_type(soap, soap->href);

   142 	switch (*type)

   143 	{

   144 	case SOAP_TYPE_byte:

   145 		return soap_in_byte(soap, NULL, NULL, "xsd:byte");

   146 	case SOAP_TYPE_int:

   147 		return soap_in_int(soap, NULL, NULL, "xsd:int");

   148 	case SOAP_TYPE_SOAP_ENV__Reason:

   149 		return soap_in_SOAP_ENV__Reason(soap, NULL, NULL, "SOAP-ENV:Reason");

   150 	case SOAP_TYPE_PointerToSOAP_ENV__Reason:

   151 		return soap_in_PointerToSOAP_ENV__Reason(soap, NULL, NULL, "SOAP-ENV:Reason");

   152 	case SOAP_TYPE__QName:

   153 	{	char **s;

   154 		s = soap_in__QName(soap, NULL, NULL, "QName");

   155 		return s ? *s : NULL;

   156 	}

   157 	case SOAP_TYPE_string:

   158 	{	char **s;

   159 		s = soap_in_string(soap, NULL, NULL, "xsd:string");

   160 		return s ? *s : NULL;

   161 	}

   162 	default:

   163 	{	const char *t = soap->type;

   164 		if (!*t)

   165 			t = soap->tag;

   166 		if (!soap_match_tag(soap, t, "xsd:byte"))

   167 		{	*type = SOAP_TYPE_byte;

   168 			return soap_in_byte(soap, NULL, NULL, NULL);

   169 		}

   170 		if (!soap_match_tag(soap, t, "xsd:int"))

   171 		{	*type = SOAP_TYPE_int;

   172 			return soap_in_int(soap, NULL, NULL, NULL);

   173 		}

   174 		if (!soap_match_tag(soap, t, "SOAP-ENV:Reason"))

   175 		{	*type = SOAP_TYPE_SOAP_ENV__Reason;

   176 			return soap_in_SOAP_ENV__Reason(soap, NULL, NULL, NULL);

   177 		}

   178 		if (!soap_match_tag(soap, t, "QName"))

   179 		{	char **s;

   180 			*type = SOAP_TYPE__QName;

   181 			s = soap_in__QName(soap, NULL, NULL, NULL);

   182 			return s ? *s : NULL;

   183 		}

   184 		if (!soap_match_tag(soap, t, "xsd:string"))

   185 		{	char **s;

   186 			*type = SOAP_TYPE_string;

   187 			s = soap_in_string(soap, NULL, NULL, NULL);

   188 			return s ? *s : NULL;

   189 		}

   190 	}

   191 	}

   192 	soap->error = SOAP_TAG_MISMATCH;

   193 	return NULL;

   194 }

   195 #endif

   196 

   197 SOAP_FMAC3 int SOAP_FMAC4 soap_ignore_element(struct soap *soap)

   198 {

   199 	if (!soap_peek_element(soap))

   200 	{	int t;

   201 		if (soap->mustUnderstand && !soap->other)

   202 			return soap->error = SOAP_MUSTUNDERSTAND;

   203 		if (((soap->mode & SOAP_XML_STRICT) && soap->part != SOAP_IN_HEADER) || !soap_match_tag(soap, soap->tag, "SOAP-ENV:"))

   204 			return soap->error = SOAP_TAG_MISMATCH;

   205 		if (!*soap->id || !soap_getelement(soap, &t))

   206 		{	soap->peeked = 0;

   207 			DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Unknown element '%s' (level=%u, %d)\n", soap->tag, soap->level, soap->body));

   208 			if (soap->fignore)

   209 				soap->error = soap->fignore(soap, soap->tag);

   210 			else

   211 				soap->error = SOAP_OK;

   212 			DBGLOG(TEST, if (!soap->error) SOAP_MESSAGE(fdebug, "IGNORING element '%s'\n", soap->tag));

   213 			if (!soap->error && soap->body)

   214 			{	soap->level++;

   215 				while (!soap_ignore_element(soap))

   216 					;

   217 				if (soap->error == SOAP_NO_TAG)

   218 					soap->error = soap_element_end_in(soap, NULL);

   219 			}

   220 		}

   221 	}

   222 	return soap->error;

   223 }

   224 

   225 #ifndef WITH_NOIDREF

   226 SOAP_FMAC3 int SOAP_FMAC4 soap_putindependent(struct soap *soap)

   227 {

   228 	int i;

   229 	struct soap_plist *pp;

   230 	if (soap->version == 1 && soap->encodingStyle && !(soap->mode & (SOAP_XML_TREE | SOAP_XML_GRAPH)))

   231 		for (i = 0; i < SOAP_PTRHASH; i++)

   232 			for (pp = soap->pht[i]; pp; pp = pp->next)

   233 				if (pp->mark1 == 2 || pp->mark2 == 2)

   234 					if (soap_putelement(soap, pp->ptr, "id", pp->id, pp->type))

   235 						return soap->error;

   236 	return SOAP_OK;

   237 }

   238 #endif

   239 

   240 #ifndef WITH_NOIDREF

   241 SOAP_FMAC3 int SOAP_FMAC4 soap_putelement(struct soap *soap, const void *ptr, const char *tag, int id, int type)

   242 {

   243 	switch (type)

   244 	{

   245 	case SOAP_TYPE_byte:

   246 		return soap_out_byte(soap, tag, id, (const char *)ptr, "xsd:byte");

   247 	case SOAP_TYPE_int:

   248 		return soap_out_int(soap, tag, id, (const int *)ptr, "xsd:int");

   249 	case SOAP_TYPE_SOAP_ENV__Reason:

   250 		return soap_out_SOAP_ENV__Reason(soap, tag, id, (const struct SOAP_ENV__Reason *)ptr, "SOAP-ENV:Reason");

   251 	case SOAP_TYPE_PointerToSOAP_ENV__Reason:

   252 		return soap_out_PointerToSOAP_ENV__Reason(soap, tag, id, (struct SOAP_ENV__Reason *const*)ptr, "SOAP-ENV:Reason");

   253 	case SOAP_TYPE__QName:

   254 		return soap_out_string(soap, "QName", id, (char**)&ptr, NULL);

   255 	case SOAP_TYPE_string:

   256 		return soap_out_string(soap, tag, id, (char**)&ptr, "xsd:string");

   257 	}

   258 	return SOAP_OK;

   259 }

   260 #endif

   261 

   262 #ifndef WITH_NOIDREF

   263 SOAP_FMAC3 void SOAP_FMAC4 soap_markelement(struct soap *soap, const void *ptr, int type)

   264 {

   265 	(void)soap; (void)ptr; (void)type; /* appease -Wall -Werror */

   266 	switch (type)

   267 	{

   268 	case SOAP_TYPE_SOAP_ENV__Reason:

   269 		soap_serialize_SOAP_ENV__Reason(soap, (const struct SOAP_ENV__Reason *)ptr);

   270 		break;

   271 	case SOAP_TYPE_PointerToSOAP_ENV__Reason:

   272 		soap_serialize_PointerToSOAP_ENV__Reason(soap, (struct SOAP_ENV__Reason *const*)ptr);

   273 		break;

   274 	case SOAP_TYPE__QName:

   275 		soap_serialize_string(soap, (char**)&ptr);

   276 		break;

   277 	case SOAP_TYPE_string:

   278 		soap_serialize_string(soap, (char**)&ptr);

   279 		break;

   280 	}

   281 }

   282 #endif

   283 

   284 SOAP_FMAC3 void SOAP_FMAC4 soap_default_byte(struct soap *soap, char *a)

   285 {

   286 (void)soap; /* appease -Wall -Werror */

   287 #ifdef SOAP_DEFAULT_byte

   288 	*a = SOAP_DEFAULT_byte;

   289 #else

   290 	*a = (char)0;

   291 #endif

   292 }

   293 

   294 SOAP_FMAC3 int SOAP_FMAC4 soap_put_byte(struct soap *soap, const char *a, const char *tag, const char *type)

   295 {

   296 	register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_byte);

   297 	if (soap_out_byte(soap, tag, id, a, type))

   298 		return soap->error;

   299 	return soap_putindependent(soap);

   300 }

   301 

   302 SOAP_FMAC3 int SOAP_FMAC4 soap_out_byte(struct soap *soap, const char *tag, int id, const char *a, const char *type)

   303 {

   304 	return soap_outbyte(soap, tag, id, a, type, SOAP_TYPE_byte);

   305 }

   306 

   307 SOAP_FMAC3 char * SOAP_FMAC4 soap_get_byte(struct soap *soap, char *p, const char *tag, const char *type)

   308 {

   309 	if ((p = soap_in_byte(soap, tag, p, type)))

   310 		soap_getindependent(soap);

   311 	return p;

   312 }

   313 

   314 SOAP_FMAC3 char * SOAP_FMAC4 soap_in_byte(struct soap *soap, const char *tag, char *a, const char *type)

   315 {

   316 	return soap_inbyte(soap, tag, a, type, SOAP_TYPE_byte);

   317 }

   318 

   319 SOAP_FMAC3 void SOAP_FMAC4 soap_default_int(struct soap *soap, int *a)

   320 {

   321 (void)soap; /* appease -Wall -Werror */

   322 #ifdef SOAP_DEFAULT_int

   323 	*a = SOAP_DEFAULT_int;

   324 #else

   325 	*a = (int)0;

   326 #endif

   327 }

   328 

   329 SOAP_FMAC3 int SOAP_FMAC4 soap_put_int(struct soap *soap, const int *a, const char *tag, const char *type)

   330 {

   331 	register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_int);

   332 	if (soap_out_int(soap, tag, id, a, type))

   333 		return soap->error;

   334 	return soap_putindependent(soap);

   335 }

   336 

   337 SOAP_FMAC3 int SOAP_FMAC4 soap_out_int(struct soap *soap, const char *tag, int id, const int *a, const char *type)

   338 {

   339 	return soap_outint(soap, tag, id, a, type, SOAP_TYPE_int);

   340 }

   341 

   342 SOAP_FMAC3 int * SOAP_FMAC4 soap_get_int(struct soap *soap, int *p, const char *tag, const char *type)

   343 {

   344 	if ((p = soap_in_int(soap, tag, p, type)))

   345 		soap_getindependent(soap);

   346 	return p;

   347 }

   348 

   349 SOAP_FMAC3 int * SOAP_FMAC4 soap_in_int(struct soap *soap, const char *tag, int *a, const char *type)

   350 {

   351 	return soap_inint(soap, tag, a, type, SOAP_TYPE_int);

   352 }

   353 

   354 #ifndef WITH_NOGLOBAL

   355 

   356 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Fault(struct soap *soap, const struct SOAP_ENV__Fault *a)

   357 {

   358 	(void)soap; (void)a; /* appease -Wall -Werror */

   359 	soap_serialize__QName(soap, &a->faultcode);

   360 	soap_serialize_string(soap, &a->faultstring);

   361 	soap_serialize_string(soap, &a->faultactor);

   362 	soap_serialize_PointerToSOAP_ENV__Detail(soap, &a->detail);

   363 	soap_serialize_PointerToSOAP_ENV__Code(soap, &a->SOAP_ENV__Code);

   364 	soap_serialize_PointerToSOAP_ENV__Reason(soap, &a->SOAP_ENV__Reason);

   365 	soap_serialize_string(soap, &a->SOAP_ENV__Node);

   366 	soap_serialize_string(soap, &a->SOAP_ENV__Role);

   367 	soap_serialize_PointerToSOAP_ENV__Detail(soap, &a->SOAP_ENV__Detail);

   368 }

   369 

   370 SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Fault(struct soap *soap, struct SOAP_ENV__Fault *a)

   371 {

   372 	(void)soap; (void)a; /* appease -Wall -Werror */

   373 	soap_default__QName(soap, &a->faultcode);

   374 	soap_default_string(soap, &a->faultstring);

   375 	soap_default_string(soap, &a->faultactor);

   376 	a->detail = NULL;

   377 	a->SOAP_ENV__Code = NULL;

   378 	a->SOAP_ENV__Reason = NULL;

   379 	soap_default_string(soap, &a->SOAP_ENV__Node);

   380 	soap_default_string(soap, &a->SOAP_ENV__Role);

   381 	a->SOAP_ENV__Detail = NULL;

   382 }

   383 

   384 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)

   385 {

   386 	register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_SOAP_ENV__Fault);

   387 	if (soap_out_SOAP_ENV__Fault(soap, tag, id, a, type))

   388 		return soap->error;

   389 	return soap_putindependent(soap);

   390 }

   391 

   392 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)

   393 {

   394 	const char *soap_tmp_faultcode = soap_QName2s(soap, a->faultcode);

   395 	soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Fault), type);

   396 	soap_out__QName(soap, "faultcode", -1, (char*const*)&soap_tmp_faultcode, "");

   397 	soap_out_string(soap, "faultstring", -1, &a->faultstring, "");

   398 	soap_out_string(soap, "faultactor", -1, &a->faultactor, "");

   399 	soap_out_PointerToSOAP_ENV__Detail(soap, "detail", -1, &a->detail, "");

   400 	soap_out_PointerToSOAP_ENV__Code(soap, "SOAP-ENV:Code", -1, &a->SOAP_ENV__Code, "");

   401 	soap_out_PointerToSOAP_ENV__Reason(soap, "SOAP-ENV:Reason", -1, &a->SOAP_ENV__Reason, "");

   402 	soap_out_string(soap, "SOAP-ENV:Node", -1, &a->SOAP_ENV__Node, "");

   403 	soap_out_string(soap, "SOAP-ENV:Role", -1, &a->SOAP_ENV__Role, "");

   404 	soap_out_PointerToSOAP_ENV__Detail(soap, "SOAP-ENV:Detail", -1, &a->SOAP_ENV__Detail, "");

   405 	soap_element_end_out(soap, tag);

   406 	return SOAP_OK;

   407 }

   408 

   409 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)

   410 {

   411 	if ((p = soap_in_SOAP_ENV__Fault(soap, tag, p, type)))

   412 		soap_getindependent(soap);

   413 	return p;

   414 }

   415 

   416 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)

   417 {

   418 	short soap_flag_faultcode = 1, soap_flag_faultstring = 1, soap_flag_faultactor = 1, soap_flag_detail = 1, soap_flag_SOAP_ENV__Code = 1, soap_flag_SOAP_ENV__Reason = 1, soap_flag_SOAP_ENV__Node = 1, soap_flag_SOAP_ENV__Role = 1, soap_flag_SOAP_ENV__Detail = 1;

   419 	if (soap_element_begin_in(soap, tag, 0))

   420 		return NULL;

   421 	if (*soap->type && soap_match_tag(soap, soap->type, type))

   422 	{	soap->error = SOAP_TYPE;

   423 		return NULL;

   424 	}

   425 	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);

   426 	if (!a)

   427 		return NULL;

   428 	soap_default_SOAP_ENV__Fault(soap, a);

   429 	if (soap->body && !*soap->href)

   430 	{

   431 		for (;;)

   432 		{	soap->error = SOAP_TAG_MISMATCH;

   433 			if (soap_flag_faultcode && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))

   434 				if (soap_in__QName(soap, "faultcode", &a->faultcode, ""))

   435 				{	soap_flag_faultcode--;

   436 					continue;

   437 				}

   438 			if (soap_flag_faultstring && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))

   439 				if (soap_in_string(soap, "faultstring", &a->faultstring, "xsd:string"))

   440 				{	soap_flag_faultstring--;

   441 					continue;

   442 				}

   443 			if (soap_flag_faultactor && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))

   444 				if (soap_in_string(soap, "faultactor", &a->faultactor, "xsd:string"))

   445 				{	soap_flag_faultactor--;

   446 					continue;

   447 				}

   448 			if (soap_flag_detail && soap->error == SOAP_TAG_MISMATCH)

   449 				if (soap_in_PointerToSOAP_ENV__Detail(soap, "detail", &a->detail, ""))

   450 				{	soap_flag_detail--;

   451 					continue;

   452 				}

   453 			if (soap_flag_SOAP_ENV__Code && soap->error == SOAP_TAG_MISMATCH)

   454 				if (soap_in_PointerToSOAP_ENV__Code(soap, "SOAP-ENV:Code", &a->SOAP_ENV__Code, ""))

   455 				{	soap_flag_SOAP_ENV__Code--;

   456 					continue;

   457 				}

   458 			if (soap_flag_SOAP_ENV__Reason && soap->error == SOAP_TAG_MISMATCH)

   459 				if (soap_in_PointerToSOAP_ENV__Reason(soap, "SOAP-ENV:Reason", &a->SOAP_ENV__Reason, ""))

   460 				{	soap_flag_SOAP_ENV__Reason--;

   461 					continue;

   462 				}

   463 			if (soap_flag_SOAP_ENV__Node && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))

   464 				if (soap_in_string(soap, "SOAP-ENV:Node", &a->SOAP_ENV__Node, "xsd:string"))

   465 				{	soap_flag_SOAP_ENV__Node--;

   466 					continue;

   467 				}

   468 			if (soap_flag_SOAP_ENV__Role && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))

   469 				if (soap_in_string(soap, "SOAP-ENV:Role", &a->SOAP_ENV__Role, "xsd:string"))

   470 				{	soap_flag_SOAP_ENV__Role--;

   471 					continue;

   472 				}

   473 			if (soap_flag_SOAP_ENV__Detail && soap->error == SOAP_TAG_MISMATCH)

   474 				if (soap_in_PointerToSOAP_ENV__Detail(soap, "SOAP-ENV:Detail", &a->SOAP_ENV__Detail, ""))

   475 				{	soap_flag_SOAP_ENV__Detail--;

   476 					continue;

   477 				}

   478 			if (soap->error == SOAP_TAG_MISMATCH)

   479 				soap->error = soap_ignore_element(soap);

   480 			if (soap->error == SOAP_NO_TAG)

   481 				break;

   482 			if (soap->error)

   483 				return NULL;

   484 		}

   485 		if (soap_element_end_in(soap, tag))

   486 			return NULL;

   487 	}

   488 	else

   489 	{	a = (struct SOAP_ENV__Fault *)soap_id_forward(soap, soap->href, (void**)a, SOAP_TYPE_SOAP_ENV__Fault, 0, sizeof(struct SOAP_ENV__Fault), 0, NULL);

   490 		if (soap->body && soap_element_end_in(soap, tag))

   491 			return NULL;

   492 	}

   493 	return a;

   494 }

   495 

   496 #endif

   497 

   498 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Reason(struct soap *soap, const struct SOAP_ENV__Reason *a)

   499 {

   500 	(void)soap; (void)a; /* appease -Wall -Werror */

   501 	soap_serialize_string(soap, &a->SOAP_ENV__Text);

   502 }

   503 

   504 SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason *a)

   505 {

   506 	(void)soap; (void)a; /* appease -Wall -Werror */

   507 	soap_default_string(soap, &a->SOAP_ENV__Text);

   508 }

   509 

   510 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)

   511 {

   512 	register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_SOAP_ENV__Reason);

   513 	if (soap_out_SOAP_ENV__Reason(soap, tag, id, a, type))

   514 		return soap->error;

   515 	return soap_putindependent(soap);

   516 }

   517 

   518 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)

   519 {

   520 	soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Reason), type);

   521 	soap_out_string(soap, "SOAP-ENV:Text", -1, &a->SOAP_ENV__Text, "");

   522 	soap_element_end_out(soap, tag);

   523 	return SOAP_OK;

   524 }

   525 

   526 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)

   527 {

   528 	if ((p = soap_in_SOAP_ENV__Reason(soap, tag, p, type)))

   529 		soap_getindependent(soap);

   530 	return p;

   531 }

   532 

   533 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)

   534 {

   535 	short soap_flag_SOAP_ENV__Text = 1;

   536 	if (soap_element_begin_in(soap, tag, 0))

   537 		return NULL;

   538 	if (*soap->type && soap_match_tag(soap, soap->type, type))

   539 	{	soap->error = SOAP_TYPE;

   540 		return NULL;

   541 	}

   542 	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);

   543 	if (!a)

   544 		return NULL;

   545 	soap_default_SOAP_ENV__Reason(soap, a);

   546 	if (soap->body && !*soap->href)

   547 	{

   548 		for (;;)

   549 		{	soap->error = SOAP_TAG_MISMATCH;

   550 			if (soap_flag_SOAP_ENV__Text && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))

   551 				if (soap_in_string(soap, "SOAP-ENV:Text", &a->SOAP_ENV__Text, "xsd:string"))

   552 				{	soap_flag_SOAP_ENV__Text--;

   553 					continue;

   554 				}

   555 			if (soap->error == SOAP_TAG_MISMATCH)

   556 				soap->error = soap_ignore_element(soap);

   557 			if (soap->error == SOAP_NO_TAG)

   558 				break;

   559 			if (soap->error)

   560 				return NULL;

   561 		}

   562 		if (soap_element_end_in(soap, tag))

   563 			return NULL;

   564 	}

   565 	else

   566 	{	a = (struct SOAP_ENV__Reason *)soap_id_forward(soap, soap->href, (void**)a, SOAP_TYPE_SOAP_ENV__Reason, 0, sizeof(struct SOAP_ENV__Reason), 0, NULL);

   567 		if (soap->body && soap_element_end_in(soap, tag))

   568 			return NULL;

   569 	}

   570 	return a;

   571 }

   572 

   573 #ifndef WITH_NOGLOBAL

   574 

   575 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Detail(struct soap *soap, const struct SOAP_ENV__Detail *a)

   576 {

   577 	(void)soap; (void)a; /* appease -Wall -Werror */

   578 	soap_markelement(soap, a->fault, a->__type);

   579 }

   580 

   581 SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Detail(struct soap *soap, struct SOAP_ENV__Detail *a)

   582 {

   583 	(void)soap; (void)a; /* appease -Wall -Werror */

   584 	a->__type = 0;

   585 	a->fault = NULL;

   586 	a->__any = NULL;

   587 }

   588 

   589 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)

   590 {

   591 	register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_SOAP_ENV__Detail);

   592 	if (soap_out_SOAP_ENV__Detail(soap, tag, id, a, type))

   593 		return soap->error;

   594 	return soap_putindependent(soap);

   595 }

   596 

   597 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)

   598 {

   599 	soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Detail), type);

   600 	soap_putelement(soap, a->fault, "fault", -1, a->__type);

   601 	soap_outliteral(soap, "-any", &a->__any);

   602 	soap_element_end_out(soap, tag);

   603 	return SOAP_OK;

   604 }

   605 

   606 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)

   607 {

   608 	if ((p = soap_in_SOAP_ENV__Detail(soap, tag, p, type)))

   609 		soap_getindependent(soap);

   610 	return p;

   611 }

   612 

   613 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)

   614 {

   615 	short soap_flag_fault = 1, soap_flag___any = 1;

   616 	if (soap_element_begin_in(soap, tag, 0))

   617 		return NULL;

   618 	if (*soap->type && soap_match_tag(soap, soap->type, type))

   619 	{	soap->error = SOAP_TYPE;

   620 		return NULL;

   621 	}

   622 	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);

   623 	if (!a)

   624 		return NULL;

   625 	soap_default_SOAP_ENV__Detail(soap, a);

   626 	if (soap->body && !*soap->href)

   627 	{

   628 		for (;;)

   629 		{	soap->error = SOAP_TAG_MISMATCH;

   630 			if (soap_flag_fault && soap->error == SOAP_TAG_MISMATCH)

   631 				if ((a->fault = soap_getelement(soap, &a->__type)))

   632 				{	soap_flag_fault = 0;

   633 					continue;

   634 				}

   635 			if (soap_flag___any && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))

   636 				if (soap_inliteral(soap, "-any", &a->__any))

   637 				{	soap_flag___any--;

   638 					continue;

   639 				}

   640 			if (soap->error == SOAP_TAG_MISMATCH)

   641 				soap->error = soap_ignore_element(soap);

   642 			if (soap->error == SOAP_NO_TAG)

   643 				break;

   644 			if (soap->error)

   645 				return NULL;

   646 		}

   647 		if (soap_element_end_in(soap, tag))

   648 			return NULL;

   649 	}

   650 	else

   651 	{	a = (struct SOAP_ENV__Detail *)soap_id_forward(soap, soap->href, (void**)a, SOAP_TYPE_SOAP_ENV__Detail, 0, sizeof(struct SOAP_ENV__Detail), 0, NULL);

   652 		if (soap->body && soap_element_end_in(soap, tag))

   653 			return NULL;

   654 	}

   655 	return a;

   656 }

   657 

   658 #endif

   659 

   660 #ifndef WITH_NOGLOBAL

   661 

   662 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Code(struct soap *soap, const struct SOAP_ENV__Code *a)

   663 {

   664 	(void)soap; (void)a; /* appease -Wall -Werror */

   665 	soap_serialize__QName(soap, &a->SOAP_ENV__Value);

   666 	soap_serialize_PointerToSOAP_ENV__Code(soap, &a->SOAP_ENV__Subcode);

   667 }

   668 

   669 SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code *a)

   670 {

   671 	(void)soap; (void)a; /* appease -Wall -Werror */

   672 	soap_default__QName(soap, &a->SOAP_ENV__Value);

   673 	a->SOAP_ENV__Subcode = NULL;

   674 }

   675 

   676 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)

   677 {

   678 	register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_SOAP_ENV__Code);

   679 	if (soap_out_SOAP_ENV__Code(soap, tag, id, a, type))

   680 		return soap->error;

   681 	return soap_putindependent(soap);

   682 }

   683 

   684 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)

   685 {

   686 	const char *soap_tmp_SOAP_ENV__Value = soap_QName2s(soap, a->SOAP_ENV__Value);

   687 	soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Code), type);

   688 	soap_out__QName(soap, "SOAP-ENV:Value", -1, (char*const*)&soap_tmp_SOAP_ENV__Value, "");

   689 	soap_out_PointerToSOAP_ENV__Code(soap, "SOAP-ENV:Subcode", -1, &a->SOAP_ENV__Subcode, "");

   690 	soap_element_end_out(soap, tag);

   691 	return SOAP_OK;

   692 }

   693 

   694 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)

   695 {

   696 	if ((p = soap_in_SOAP_ENV__Code(soap, tag, p, type)))

   697 		soap_getindependent(soap);

   698 	return p;

   699 }

   700 

   701 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)

   702 {

   703 	short soap_flag_SOAP_ENV__Value = 1, soap_flag_SOAP_ENV__Subcode = 1;

   704 	if (soap_element_begin_in(soap, tag, 0))

   705 		return NULL;

   706 	if (*soap->type && soap_match_tag(soap, soap->type, type))

   707 	{	soap->error = SOAP_TYPE;

   708 		return NULL;

   709 	}

   710 	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);

   711 	if (!a)

   712 		return NULL;

   713 	soap_default_SOAP_ENV__Code(soap, a);

   714 	if (soap->body && !*soap->href)

   715 	{

   716 		for (;;)

   717 		{	soap->error = SOAP_TAG_MISMATCH;

   718 			if (soap_flag_SOAP_ENV__Value && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))

   719 				if (soap_in__QName(soap, "SOAP-ENV:Value", &a->SOAP_ENV__Value, ""))

   720 				{	soap_flag_SOAP_ENV__Value--;

   721 					continue;

   722 				}

   723 			if (soap_flag_SOAP_ENV__Subcode && soap->error == SOAP_TAG_MISMATCH)

   724 				if (soap_in_PointerToSOAP_ENV__Code(soap, "SOAP-ENV:Subcode", &a->SOAP_ENV__Subcode, ""))

   725 				{	soap_flag_SOAP_ENV__Subcode--;

   726 					continue;

   727 				}

   728 			if (soap->error == SOAP_TAG_MISMATCH)

   729 				soap->error = soap_ignore_element(soap);

   730 			if (soap->error == SOAP_NO_TAG)

   731 				break;

   732 			if (soap->error)

   733 				return NULL;

   734 		}

   735 		if (soap_element_end_in(soap, tag))

   736 			return NULL;

   737 	}

   738 	else

   739 	{	a = (struct SOAP_ENV__Code *)soap_id_forward(soap, soap->href, (void**)a, SOAP_TYPE_SOAP_ENV__Code, 0, sizeof(struct SOAP_ENV__Code), 0, NULL);

   740 		if (soap->body && soap_element_end_in(soap, tag))

   741 			return NULL;

   742 	}

   743 	return a;

   744 }

   745 

   746 #endif

   747 

   748 #ifndef WITH_NOGLOBAL

   749 

   750 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Header(struct soap *soap, const struct SOAP_ENV__Header *a)

   751 {

   752 	(void)soap; (void)a; /* appease -Wall -Werror */

   753 	/* transient dummy skipped */

   754 }

   755 

   756 SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Header(struct soap *soap, struct SOAP_ENV__Header *a)

   757 {

   758 	(void)soap; (void)a; /* appease -Wall -Werror */

   759 	/* transient dummy skipped */

   760 }

   761 

   762 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)

   763 {

   764 	register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_SOAP_ENV__Header);

   765 	if (soap_out_SOAP_ENV__Header(soap, tag, id, a, type))

   766 		return soap->error;

   767 	return soap_putindependent(soap);

   768 }

   769 

   770 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)

   771 {

   772 	soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Header), type);

   773 	/* transient dummy skipped */

   774 	soap_element_end_out(soap, tag);

   775 	return SOAP_OK;

   776 }

   777 

   778 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)

   779 {

   780 	if ((p = soap_in_SOAP_ENV__Header(soap, tag, p, type)))

   781 		soap_getindependent(soap);

   782 	return p;

   783 }

   784 

   785 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)

   786 {;

   787 	if (soap_element_begin_in(soap, tag, 0))

   788 		return NULL;

   789 	if (*soap->type && soap_match_tag(soap, soap->type, type))

   790 	{	soap->error = SOAP_TYPE;

   791 		return NULL;

   792 	}

   793 	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);

   794 	if (!a)

   795 		return NULL;

   796 	soap_default_SOAP_ENV__Header(soap, a);

   797 	if (soap->body && !*soap->href)

   798 	{

   799 		for (;;)

   800 		{	soap->error = SOAP_TAG_MISMATCH;

   801 		/* transient dummy skipped */

   802 			if (soap->error == SOAP_TAG_MISMATCH)

   803 				soap->error = soap_ignore_element(soap);

   804 			if (soap->error == SOAP_NO_TAG)

   805 				break;

   806 			if (soap->error)

   807 				return NULL;

   808 		}

   809 		if (soap_element_end_in(soap, tag))

   810 			return NULL;

   811 	}

   812 	else

   813 	{	a = (struct SOAP_ENV__Header *)soap_id_forward(soap, soap->href, (void**)a, SOAP_TYPE_SOAP_ENV__Header, 0, sizeof(struct SOAP_ENV__Header), 0, NULL);

   814 		if (soap->body && soap_element_end_in(soap, tag))

   815 			return NULL;

   816 	}

   817 	return a;

   818 }

   819 

   820 #endif

   821 

   822 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToSOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason *const*a)

   823 {

   824 	if (!soap_reference(soap, *a, SOAP_TYPE_SOAP_ENV__Reason))

   825 		soap_serialize_SOAP_ENV__Reason(soap, *a);

   826 }

   827 

   828 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)

   829 {

   830 	register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToSOAP_ENV__Reason);

   831 	if (soap_out_PointerToSOAP_ENV__Reason(soap, tag, id, a, type))

   832 		return soap->error;

   833 	return soap_putindependent(soap);

   834 }

   835 

   836 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)

   837 {

   838 	id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_SOAP_ENV__Reason);

   839 	if (id < 0)

   840 		return soap->error;

   841 	return soap_out_SOAP_ENV__Reason(soap, tag, id, *a, type);

   842 }

   843 

   844 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)

   845 {

   846 	if ((p = soap_in_PointerToSOAP_ENV__Reason(soap, tag, p, type)))

   847 		soap_getindependent(soap);

   848 	return p;

   849 }

   850 

   851 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)

   852 {

   853 	if (soap_element_begin_in(soap, tag, 1))

   854 		return NULL;

   855 	if (!a)

   856 		if (!(a = (struct SOAP_ENV__Reason **)soap_malloc(soap, sizeof(struct SOAP_ENV__Reason *))))

   857 			return NULL;

   858 	*a = NULL;

   859 	if (!soap->null && *soap->href != '#')

   860 	{	soap_revert(soap);

   861 		if (!(*a = soap_in_SOAP_ENV__Reason(soap, tag, *a, type)))

   862 			return NULL;

   863 	}

   864 	else

   865 	{	a = (struct SOAP_ENV__Reason **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_SOAP_ENV__Reason, sizeof(struct SOAP_ENV__Reason), 0);

   866 		if (soap->body && soap_element_end_in(soap, tag))

   867 			return NULL;

   868 	}

   869 	return a;

   870 }

   871 

   872 #ifndef WITH_NOGLOBAL

   873 

   874 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToSOAP_ENV__Detail(struct soap *soap, struct SOAP_ENV__Detail *const*a)

   875 {

   876 	if (!soap_reference(soap, *a, SOAP_TYPE_SOAP_ENV__Detail))

   877 		soap_serialize_SOAP_ENV__Detail(soap, *a);

   878 }

   879 

   880 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)

   881 {

   882 	register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToSOAP_ENV__Detail);

   883 	if (soap_out_PointerToSOAP_ENV__Detail(soap, tag, id, a, type))

   884 		return soap->error;

   885 	return soap_putindependent(soap);

   886 }

   887 

   888 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)

   889 {

   890 	id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_SOAP_ENV__Detail);

   891 	if (id < 0)

   892 		return soap->error;

   893 	return soap_out_SOAP_ENV__Detail(soap, tag, id, *a, type);

   894 }

   895 

   896 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)

   897 {

   898 	if ((p = soap_in_PointerToSOAP_ENV__Detail(soap, tag, p, type)))

   899 		soap_getindependent(soap);

   900 	return p;

   901 }

   902 

   903 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)

   904 {

   905 	if (soap_element_begin_in(soap, tag, 1))

   906 		return NULL;

   907 	if (!a)

   908 		if (!(a = (struct SOAP_ENV__Detail **)soap_malloc(soap, sizeof(struct SOAP_ENV__Detail *))))

   909 			return NULL;

   910 	*a = NULL;

   911 	if (!soap->null && *soap->href != '#')

   912 	{	soap_revert(soap);

   913 		if (!(*a = soap_in_SOAP_ENV__Detail(soap, tag, *a, type)))

   914 			return NULL;

   915 	}

   916 	else

   917 	{	a = (struct SOAP_ENV__Detail **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_SOAP_ENV__Detail, sizeof(struct SOAP_ENV__Detail), 0);

   918 		if (soap->body && soap_element_end_in(soap, tag))

   919 			return NULL;

   920 	}

   921 	return a;

   922 }

   923 

   924 #endif

   925 

   926 #ifndef WITH_NOGLOBAL

   927 

   928 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToSOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code *const*a)

   929 {

   930 	if (!soap_reference(soap, *a, SOAP_TYPE_SOAP_ENV__Code))

   931 		soap_serialize_SOAP_ENV__Code(soap, *a);

   932 }

   933 

   934 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)

   935 {

   936 	register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_PointerToSOAP_ENV__Code);

   937 	if (soap_out_PointerToSOAP_ENV__Code(soap, tag, id, a, type))

   938 		return soap->error;

   939 	return soap_putindependent(soap);

   940 }

   941 

   942 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)

   943 {

   944 	id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_SOAP_ENV__Code);

   945 	if (id < 0)

   946 		return soap->error;

   947 	return soap_out_SOAP_ENV__Code(soap, tag, id, *a, type);

   948 }

   949 

   950 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)

   951 {

   952 	if ((p = soap_in_PointerToSOAP_ENV__Code(soap, tag, p, type)))

   953 		soap_getindependent(soap);

   954 	return p;

   955 }

   956 

   957 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)

   958 {

   959 	if (soap_element_begin_in(soap, tag, 1))

   960 		return NULL;

   961 	if (!a)

   962 		if (!(a = (struct SOAP_ENV__Code **)soap_malloc(soap, sizeof(struct SOAP_ENV__Code *))))

   963 			return NULL;

   964 	*a = NULL;

   965 	if (!soap->null && *soap->href != '#')

   966 	{	soap_revert(soap);

   967 		if (!(*a = soap_in_SOAP_ENV__Code(soap, tag, *a, type)))

   968 			return NULL;

   969 	}

   970 	else

   971 	{	a = (struct SOAP_ENV__Code **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_SOAP_ENV__Code, sizeof(struct SOAP_ENV__Code), 0);

   972 		if (soap->body && soap_element_end_in(soap, tag))

   973 			return NULL;

   974 	}

   975 	return a;

   976 }

   977 

   978 #endif

   979 

   980 SOAP_FMAC3 void SOAP_FMAC4 soap_default__QName(struct soap *soap, char **a)

   981 {	soap_default_string(soap, a);

   982 }

   983 

   984 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize__QName(struct soap *soap, char *const*a)

   985 {	soap_serialize_string(soap, a);

   986 }

   987 

   988 SOAP_FMAC3 int SOAP_FMAC4 soap_put__QName(struct soap *soap, char *const*a, const char *tag, const char *type)

   989 {

   990 	register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE__QName);

   991 	if (soap_out__QName(soap, tag, id, a, type))

   992 		return soap->error;

   993 	return soap_putindependent(soap);

   994 }

   995 

   996 SOAP_FMAC3 int SOAP_FMAC4 soap_out__QName(struct soap *soap, const char *tag, int id, char *const*a, const char *type)

   997 {

   998 	return soap_outstring(soap, tag, id, a, type, SOAP_TYPE__QName);

   999 }

  1000 

  1001 SOAP_FMAC3 char ** SOAP_FMAC4 soap_get__QName(struct soap *soap, char **p, const char *tag, const char *type)

  1002 {

  1003 	if ((p = soap_in__QName(soap, tag, p, type)))

  1004 		soap_getindependent(soap);

  1005 	return p;

  1006 }

  1007 

  1008 SOAP_FMAC3 char * * SOAP_FMAC4 soap_in__QName(struct soap *soap, const char *tag, char **a, const char *type)

  1009 {

  1010 	return soap_instring(soap, tag, a, type, SOAP_TYPE__QName, 2, -1, -1);

  1011 }

  1012 

  1013 SOAP_FMAC3 void SOAP_FMAC4 soap_default_string(struct soap *soap, char **a)

  1014 {

  1015 (void)soap; /* appease -Wall -Werror */

  1016 #ifdef SOAP_DEFAULT_string

  1017 	*a = SOAP_DEFAULT_string;

  1018 #else

  1019 	*a = (char *)0;

  1020 #endif

  1021 }

  1022 

  1023 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_string(struct soap *soap, char *const*a)

  1024 {

  1025 	soap_reference(soap, *a, SOAP_TYPE_string);

  1026 }

  1027 

  1028 SOAP_FMAC3 int SOAP_FMAC4 soap_put_string(struct soap *soap, char *const*a, const char *tag, const char *type)

  1029 {

  1030 	register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_string);

  1031 	if (soap_out_string(soap, tag, id, a, type))

  1032 		return soap->error;

  1033 	return soap_putindependent(soap);

  1034 }

  1035 

  1036 SOAP_FMAC3 int SOAP_FMAC4 soap_out_string(struct soap *soap, const char *tag, int id, char *const*a, const char *type)

  1037 {

  1038 	return soap_outstring(soap, tag, id, a, type, SOAP_TYPE_string);

  1039 }

  1040 

  1041 SOAP_FMAC3 char ** SOAP_FMAC4 soap_get_string(struct soap *soap, char **p, const char *tag, const char *type)

  1042 {

  1043 	if ((p = soap_in_string(soap, tag, p, type)))

  1044 		soap_getindependent(soap);

  1045 	return p;

  1046 }

  1047 

  1048 SOAP_FMAC3 char * * SOAP_FMAC4 soap_in_string(struct soap *soap, const char *tag, char **a, const char *type)

  1049 {

  1050 	return soap_instring(soap, tag, a, type, SOAP_TYPE_string, 1, -1, -1);

  1051 }

  1052 

  1053 /* End of envC.cpp */