Bug Summary

File:.Linux_CentOS6-x86_64-clang3.7.0/libraries/HDDM/hddm_mc_s.c
Location:line 1369, column 13
Description:Potential leak of memory pointed to by 'this1'

Annotated Source Code

1/*
2 * .Linux_CentOS6-x86_64-clang3.7.0/libraries/HDDM/hddm_mc_s.c - DO NOT EDIT THIS FILE
3 *
4 * This file was generated automatically by hddm-c from the file
5 * libraries/HDDM/mc.xml
6
7 * This c file contains the i/o interface to the c structures
8 * described in the data model (from libraries/HDDM/mc.xml).
9 *
10 * The hddm data model tool set was written by
11 * Richard Jones, University of Connecticut.
12 *
13 * For more information see the following web site
14 *
15 * http://zeus.phys.uconn.edu/halld/datamodel/doc
16 */
17
18int hddm_mc_s_nullTarget=0;
19#define HDDM_NULL(void*)&hddm_mc_s_nullTarget (void*)&hddm_mc_s_nullTarget
20
21#include ".Linux_CentOS6-x86_64-clang3.7.0/libraries/HDDM/hddm_mc_s.h"
22
23int hddm_mc_s_buffersize = 1000000;
24int hddm_mc_s_stringsize = 1000000;
25int hddm_mc_s_headersize = 1000000;
26
27void set_mc_s_HDDM_buffersize(int size)
28{
29 hddm_mc_s_buffersize = size;
30}
31
32int get_mc_s_HDDM_buffersize()
33{
34 return hddm_mc_s_buffersize;
35}
36
37void set_mc_s_HDDM_stringsize(int size)
38{
39 hddm_mc_s_stringsize = size;
40}
41
42int get_mc_s_HDDM_stringsize()
43{
44 return hddm_mc_s_stringsize;
45}
46
47void set_mc_s_HDDM_headersize(int size)
48{
49 hddm_mc_s_headersize = size;
50}
51
52int get_mc_s_HDDM_headersize()
53{
54 return hddm_mc_s_headersize;
55}
56
57static int XDRerror()
58{
59 fprintf(stderrstderr,"hddm xdr library error - "
60 "data buffering has failed for some reason,"
61 " probably buffer overflow.\n"
62 "Try increasing the size of the hddm i/o"
63 " buffers or maximum string size.\n");
64 exit(9);
65 return 0;
66}
67
68mc_s_HDDM_t* make_mc_s_HDDM()
69{
70 int size = sizeof(mc_s_HDDM_t);
71 mc_s_HDDM_t* p = (mc_s_HDDM_t*)MALLOC(size,"mc_s_HDDM_t")malloc(size);
72 p->physicsEvents = (mc_s_PhysicsEvents_t*)&hddm_mc_s_nullTarget;
73 return p;
74}
75
76mc_s_PhysicsEvents_t* make_mc_s_PhysicsEvents(int n)
77{
78 int i;
79 int rep = (n > 1) ? n-1 : 0;
80 int size = sizeof(mc_s_PhysicsEvents_t) + rep * sizeof(mc_s_PhysicsEvent_t);
81 mc_s_PhysicsEvents_t* p = (mc_s_PhysicsEvents_t*)MALLOC(size,"mc_s_PhysicsEvents_t")malloc(size);
82 p->mult = 0;
83 for (i=0; i<n; i++) {
84 mc_s_PhysicsEvent_t* pp = &p->in[i];
85 pp->eventNo = 0;
86 pp->runNo = 0;
87 pp->reactions = (mc_s_Reactions_t*)&hddm_mc_s_nullTarget;
88 }
89 return p;
90}
91
92mc_s_Reactions_t* make_mc_s_Reactions(int n)
93{
94 int i;
95 int rep = (n > 1) ? n-1 : 0;
96 int size = sizeof(mc_s_Reactions_t) + rep * sizeof(mc_s_Reaction_t);
97 mc_s_Reactions_t* p = (mc_s_Reactions_t*)MALLOC(size,"mc_s_Reactions_t")malloc(size);
98 p->mult = 0;
99 for (i=0; i<n; i++) {
100 mc_s_Reaction_t* pp = &p->in[i];
101 pp->type = 0;
102 pp->weight = 0;
103 pp->beam = (mc_s_Beam_t*)&hddm_mc_s_nullTarget;
104 pp->target = (mc_s_Target_t*)&hddm_mc_s_nullTarget;
105 pp->vertices = (mc_s_Vertices_t*)&hddm_mc_s_nullTarget;
106 pp->random = (mc_s_Random_t*)&hddm_mc_s_nullTarget;
107 }
108 return p;
109}
110
111mc_s_Beam_t* make_mc_s_Beam()
112{
113 int size = sizeof(mc_s_Beam_t);
114 mc_s_Beam_t* p = (mc_s_Beam_t*)MALLOC(size,"mc_s_Beam_t")malloc(size);
115 p->type = (Particle_t)0;
116 p->momentum = (mc_s_Momentum_t*)&hddm_mc_s_nullTarget;
117 p->properties = (mc_s_Properties_t*)&hddm_mc_s_nullTarget;
118 return p;
119}
120
121mc_s_Momentum_t* make_mc_s_Momentum()
122{
123 int size = sizeof(mc_s_Momentum_t);
124 mc_s_Momentum_t* p = (mc_s_Momentum_t*)MALLOC(size,"mc_s_Momentum_t")malloc(size);
125 p->E = 0;
126 p->px = 0;
127 p->py = 0;
128 p->pz = 0;
129 return p;
130}
131
132mc_s_Properties_t* make_mc_s_Properties()
133{
134 int size = sizeof(mc_s_Properties_t);
135 mc_s_Properties_t* p = (mc_s_Properties_t*)MALLOC(size,"mc_s_Properties_t")malloc(size);
136 p->charge = 0;
137 p->mass = 0;
138 return p;
139}
140
141mc_s_Target_t* make_mc_s_Target()
142{
143 int size = sizeof(mc_s_Target_t);
144 mc_s_Target_t* p = (mc_s_Target_t*)MALLOC(size,"mc_s_Target_t")malloc(size);
145 p->type = (Particle_t)0;
146 p->momentum = (mc_s_Momentum_t*)&hddm_mc_s_nullTarget;
147 p->properties = (mc_s_Properties_t*)&hddm_mc_s_nullTarget;
148 return p;
149}
150
151mc_s_Vertices_t* make_mc_s_Vertices(int n)
152{
153 int i;
154 int rep = (n > 1) ? n-1 : 0;
155 int size = sizeof(mc_s_Vertices_t) + rep * sizeof(mc_s_Vertex_t);
156 mc_s_Vertices_t* p = (mc_s_Vertices_t*)MALLOC(size,"mc_s_Vertices_t")malloc(size);
157 p->mult = 0;
158 for (i=0; i<n; i++) {
159 mc_s_Vertex_t* pp = &p->in[i];
160 pp->products = (mc_s_Products_t*)&hddm_mc_s_nullTarget;
161 pp->origin = (mc_s_Origin_t*)&hddm_mc_s_nullTarget;
162 }
163 return p;
164}
165
166mc_s_Products_t* make_mc_s_Products(int n)
167{
168 int i;
169 int rep = (n > 1) ? n-1 : 0;
170 int size = sizeof(mc_s_Products_t) + rep * sizeof(mc_s_Product_t);
171 mc_s_Products_t* p = (mc_s_Products_t*)MALLOC(size,"mc_s_Products_t")malloc(size);
172 p->mult = 0;
173 for (i=0; i<n; i++) {
174 mc_s_Product_t* pp = &p->in[i];
175 pp->decayVertex = 0;
176 pp->id = 0;
177 pp->mech = 0;
178 pp->parentid = 0;
179 pp->pdgtype = 0;
180 pp->type = (Particle_t)0;
181 pp->momentum = (mc_s_Momentum_t*)&hddm_mc_s_nullTarget;
182 pp->properties = (mc_s_Properties_t*)&hddm_mc_s_nullTarget;
183 }
184 return p;
185}
186
187mc_s_Origin_t* make_mc_s_Origin()
188{
189 int size = sizeof(mc_s_Origin_t);
190 mc_s_Origin_t* p = (mc_s_Origin_t*)MALLOC(size,"mc_s_Origin_t")malloc(size);
191 p->t = 0;
192 p->vx = 0;
193 p->vy = 0;
194 p->vz = 0;
195 return p;
196}
197
198mc_s_Random_t* make_mc_s_Random()
199{
200 int size = sizeof(mc_s_Random_t);
201 mc_s_Random_t* p = (mc_s_Random_t*)MALLOC(size,"mc_s_Random_t")malloc(size);
202 p->seed1 = 0;
203 p->seed2 = 0;
204 p->seed3 = 0;
205 p->seed4 = 0;
206 return p;
207}
208
209char HDDM_mc_s_DocumentString[] =
210"<HDDM class=\"mc_s\" version=\"1.0\" xmlns=\"http://www.gluex.org/hddm\">\n"
211" <physicsEvent eventNo=\"int\" maxOccurs=\"unbounded\" runNo=\"int\">\n"
212" <reaction maxOccurs=\"unbounded\" minOccurs=\"0\" type=\"int\" weight=\"float\">\n"
213" <beam minOccurs=\"0\" type=\"Particle_t\">\n"
214" <momentum E=\"float\" px=\"float\" py=\"float\" pz=\"float\" />\n"
215" <properties charge=\"int\" mass=\"float\" />\n"
216" </beam>\n"
217" <target minOccurs=\"0\" type=\"Particle_t\">\n"
218" <momentum E=\"float\" px=\"float\" py=\"float\" pz=\"float\" />\n"
219" <properties charge=\"int\" mass=\"float\" />\n"
220" </target>\n"
221" <vertex maxOccurs=\"unbounded\">\n"
222" <product decayVertex=\"int\" id=\"int\" maxOccurs=\"unbounded\" mech=\"int\" parentid=\"int\" pdgtype=\"int\" type=\"Particle_t\">\n"
223" <momentum E=\"float\" px=\"float\" py=\"float\" pz=\"float\" />\n"
224" <properties charge=\"int\" mass=\"float\" minOccurs=\"0\" />\n"
225" </product>\n"
226" <origin t=\"float\" vx=\"float\" vy=\"float\" vz=\"float\" />\n"
227" </vertex>\n"
228" <random maxOccurs=\"1\" minOccurs=\"0\" seed1=\"int\" seed2=\"int\" seed3=\"int\" seed4=\"int\" />\n"
229" </reaction>\n"
230" </physicsEvent>\n"
231"</HDDM>\n"
232;
233
234#ifndef _FILE_OFFSET_BITS64
235# define _FILE_OFFSET_BITS64 64
236#endif
237
238static off_t xdr_getpos64(XDR *xdrs)
239{
240 if (xdrs->x_base == 0) {
241 return ftello((FILE *)xdrs->x_private);
242 }
243 off_t pos = xdr_getpos(xdrs)(*(xdrs)->x_ops->x_getpostn)(xdrs);
244 return pos;
245}
246
247static bool_t xdr_setpos64(XDR *xdrs, off_t pos)
248{
249 if (xdrs->x_base == 0) {
250 return ((fseeko((FILE *)xdrs->x_private, pos, 0) < 0)? FALSE(0) : TRUE(1));
251 }
252 return xdr_setpos(xdrs,pos)(*(xdrs)->x_ops->x_setpostn)(xdrs, pos);
253}
254
255
256static mc_s_HDDM_t* unpack_mc_s_HDDM(XDR* xdrs, popNode* pop)
257{
258 mc_s_HDDM_t* this1 = (mc_s_HDDM_t*)HDDM_NULL(void*)&hddm_mc_s_nullTarget;
259 unsigned int size;
260 if (! xdr_u_int(xdrs,&size))
261 {
262 return this1;
263 }
264 else if (size > 0)
265 {
266 off_t start = xdr_getpos64(xdrs);
267 this1 = make_mc_s_HDDM();
268 {
269 int p;
270 void* (*ptr) = (void**) &this1->physicsEvents;
271 for (p = 0; p < pop->popListLength; p++)
272 {
273 popNode* pnode = pop->popList[p];
274 if (pnode)
275 {
276 int kid = pnode->inParent;
277 ptr[kid] = pnode->unpacker(xdrs,pnode);
278 }
279 else
280 {
281 unsigned int skip;
282 if (! xdr_u_int(xdrs,&skip))
283 XDRerror();
284 xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
285 }
286 }
287 }
288 xdr_setpos64(xdrs,start+size);
289 }
290 return this1;
291}
292
293static mc_s_PhysicsEvents_t* unpack_mc_s_PhysicsEvents(XDR* xdrs, popNode* pop)
294{
295 mc_s_PhysicsEvents_t* this1 = (mc_s_PhysicsEvents_t*)HDDM_NULL(void*)&hddm_mc_s_nullTarget;
296 unsigned int size;
297 if (! xdr_u_int(xdrs,&size))
298 {
299 return this1;
300 }
301 else if (size > 0)
302 {
303 off_t start = xdr_getpos64(xdrs);
304 int m;
305 unsigned int mult;
306 if (! xdr_u_int(xdrs,&mult))
307 XDRerror();
308 this1 = make_mc_s_PhysicsEvents(mult);
309 this1->mult = mult;
310 for (m = 0; m < mult; m++ )
311 {
312 int p;
313 void* (*ptr) = (void**) &this1->in[m].reactions;
314 if (! xdr_int(xdrs,&this1->in[m].eventNo))
315 XDRerror();
316 if (! xdr_int(xdrs,&this1->in[m].runNo))
317 XDRerror();
318 for (p = 0; p < pop->popListLength; p++)
319 {
320 popNode* pnode = pop->popList[p];
321 if (pnode)
322 {
323 int kid = pnode->inParent;
324 ptr[kid] = pnode->unpacker(xdrs,pnode);
325 }
326 else
327 {
328 unsigned int skip;
329 if (! xdr_u_int(xdrs,&skip))
330 XDRerror();
331 xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
332 }
333 }
334 }
335 xdr_setpos64(xdrs,start+size);
336 }
337 return this1;
338}
339
340static mc_s_Reactions_t* unpack_mc_s_Reactions(XDR* xdrs, popNode* pop)
341{
342 mc_s_Reactions_t* this1 = (mc_s_Reactions_t*)HDDM_NULL(void*)&hddm_mc_s_nullTarget;
343 unsigned int size;
344 if (! xdr_u_int(xdrs,&size))
345 {
346 return this1;
347 }
348 else if (size > 0)
349 {
350 off_t start = xdr_getpos64(xdrs);
351 int m;
352 unsigned int mult;
353 if (! xdr_u_int(xdrs,&mult))
354 XDRerror();
355 this1 = make_mc_s_Reactions(mult);
356 this1->mult = mult;
357 for (m = 0; m < mult; m++ )
358 {
359 int p;
360 void* (*ptr) = (void**) &this1->in[m].beam;
361 if (! xdr_int(xdrs,&this1->in[m].type))
362 XDRerror();
363 if (! xdr_float(xdrs,&this1->in[m].weight))
364 XDRerror();
365 for (p = 0; p < pop->popListLength; p++)
366 {
367 popNode* pnode = pop->popList[p];
368 if (pnode)
369 {
370 int kid = pnode->inParent;
371 ptr[kid] = pnode->unpacker(xdrs,pnode);
372 }
373 else
374 {
375 unsigned int skip;
376 if (! xdr_u_int(xdrs,&skip))
377 XDRerror();
378 xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
379 }
380 }
381 }
382 xdr_setpos64(xdrs,start+size);
383 }
384 return this1;
385}
386
387static mc_s_Beam_t* unpack_mc_s_Beam(XDR* xdrs, popNode* pop)
388{
389 mc_s_Beam_t* this1 = (mc_s_Beam_t*)HDDM_NULL(void*)&hddm_mc_s_nullTarget;
390 unsigned int size;
391 if (! xdr_u_int(xdrs,&size))
392 {
393 return this1;
394 }
395 else if (size > 0)
396 {
397 off_t start = xdr_getpos64(xdrs);
398 this1 = make_mc_s_Beam();
399 {
400 int p;
401 void* (*ptr) = (void**) &this1->momentum;
402 if (! xdr_int(xdrs,(int*)&this1->type))
403 XDRerror();
404 for (p = 0; p < pop->popListLength; p++)
405 {
406 popNode* pnode = pop->popList[p];
407 if (pnode)
408 {
409 int kid = pnode->inParent;
410 ptr[kid] = pnode->unpacker(xdrs,pnode);
411 }
412 else
413 {
414 unsigned int skip;
415 if (! xdr_u_int(xdrs,&skip))
416 XDRerror();
417 xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
418 }
419 }
420 }
421 xdr_setpos64(xdrs,start+size);
422 }
423 return this1;
424}
425
426static mc_s_Momentum_t* unpack_mc_s_Momentum(XDR* xdrs, popNode* pop)
427{
428 mc_s_Momentum_t* this1 = (mc_s_Momentum_t*)HDDM_NULL(void*)&hddm_mc_s_nullTarget;
429 unsigned int size;
430 if (! xdr_u_int(xdrs,&size))
431 {
432 return this1;
433 }
434 else if (size > 0)
435 {
436 off_t start = xdr_getpos64(xdrs);
437 this1 = make_mc_s_Momentum();
438 {
439 if (! xdr_float(xdrs,&this1->E))
440 XDRerror();
441 if (! xdr_float(xdrs,&this1->px))
442 XDRerror();
443 if (! xdr_float(xdrs,&this1->py))
444 XDRerror();
445 if (! xdr_float(xdrs,&this1->pz))
446 XDRerror();
447 }
448 xdr_setpos64(xdrs,start+size);
449 }
450 return this1;
451}
452
453static mc_s_Properties_t* unpack_mc_s_Properties(XDR* xdrs, popNode* pop)
454{
455 mc_s_Properties_t* this1 = (mc_s_Properties_t*)HDDM_NULL(void*)&hddm_mc_s_nullTarget;
456 unsigned int size;
457 if (! xdr_u_int(xdrs,&size))
458 {
459 return this1;
460 }
461 else if (size > 0)
462 {
463 off_t start = xdr_getpos64(xdrs);
464 this1 = make_mc_s_Properties();
465 {
466 if (! xdr_int(xdrs,&this1->charge))
467 XDRerror();
468 if (! xdr_float(xdrs,&this1->mass))
469 XDRerror();
470 }
471 xdr_setpos64(xdrs,start+size);
472 }
473 return this1;
474}
475
476static mc_s_Target_t* unpack_mc_s_Target(XDR* xdrs, popNode* pop)
477{
478 mc_s_Target_t* this1 = (mc_s_Target_t*)HDDM_NULL(void*)&hddm_mc_s_nullTarget;
479 unsigned int size;
480 if (! xdr_u_int(xdrs,&size))
481 {
482 return this1;
483 }
484 else if (size > 0)
485 {
486 off_t start = xdr_getpos64(xdrs);
487 this1 = make_mc_s_Target();
488 {
489 int p;
490 void* (*ptr) = (void**) &this1->momentum;
491 if (! xdr_int(xdrs,(int*)&this1->type))
492 XDRerror();
493 for (p = 0; p < pop->popListLength; p++)
494 {
495 popNode* pnode = pop->popList[p];
496 if (pnode)
497 {
498 int kid = pnode->inParent;
499 ptr[kid] = pnode->unpacker(xdrs,pnode);
500 }
501 else
502 {
503 unsigned int skip;
504 if (! xdr_u_int(xdrs,&skip))
505 XDRerror();
506 xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
507 }
508 }
509 }
510 xdr_setpos64(xdrs,start+size);
511 }
512 return this1;
513}
514
515static mc_s_Vertices_t* unpack_mc_s_Vertices(XDR* xdrs, popNode* pop)
516{
517 mc_s_Vertices_t* this1 = (mc_s_Vertices_t*)HDDM_NULL(void*)&hddm_mc_s_nullTarget;
518 unsigned int size;
519 if (! xdr_u_int(xdrs,&size))
520 {
521 return this1;
522 }
523 else if (size > 0)
524 {
525 off_t start = xdr_getpos64(xdrs);
526 int m;
527 unsigned int mult;
528 if (! xdr_u_int(xdrs,&mult))
529 XDRerror();
530 this1 = make_mc_s_Vertices(mult);
531 this1->mult = mult;
532 for (m = 0; m < mult; m++ )
533 {
534 int p;
535 void* (*ptr) = (void**) &this1->in[m].products;
536 for (p = 0; p < pop->popListLength; p++)
537 {
538 popNode* pnode = pop->popList[p];
539 if (pnode)
540 {
541 int kid = pnode->inParent;
542 ptr[kid] = pnode->unpacker(xdrs,pnode);
543 }
544 else
545 {
546 unsigned int skip;
547 if (! xdr_u_int(xdrs,&skip))
548 XDRerror();
549 xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
550 }
551 }
552 }
553 xdr_setpos64(xdrs,start+size);
554 }
555 return this1;
556}
557
558static mc_s_Products_t* unpack_mc_s_Products(XDR* xdrs, popNode* pop)
559{
560 mc_s_Products_t* this1 = (mc_s_Products_t*)HDDM_NULL(void*)&hddm_mc_s_nullTarget;
561 unsigned int size;
562 if (! xdr_u_int(xdrs,&size))
563 {
564 return this1;
565 }
566 else if (size > 0)
567 {
568 off_t start = xdr_getpos64(xdrs);
569 int m;
570 unsigned int mult;
571 if (! xdr_u_int(xdrs,&mult))
572 XDRerror();
573 this1 = make_mc_s_Products(mult);
574 this1->mult = mult;
575 for (m = 0; m < mult; m++ )
576 {
577 int p;
578 void* (*ptr) = (void**) &this1->in[m].momentum;
579 if (! xdr_int(xdrs,&this1->in[m].decayVertex))
580 XDRerror();
581 if (! xdr_int(xdrs,&this1->in[m].id))
582 XDRerror();
583 if (! xdr_int(xdrs,&this1->in[m].mech))
584 XDRerror();
585 if (! xdr_int(xdrs,&this1->in[m].parentid))
586 XDRerror();
587 if (! xdr_int(xdrs,&this1->in[m].pdgtype))
588 XDRerror();
589 if (! xdr_int(xdrs,(int*)&this1->in[m].type))
590 XDRerror();
591 for (p = 0; p < pop->popListLength; p++)
592 {
593 popNode* pnode = pop->popList[p];
594 if (pnode)
595 {
596 int kid = pnode->inParent;
597 ptr[kid] = pnode->unpacker(xdrs,pnode);
598 }
599 else
600 {
601 unsigned int skip;
602 if (! xdr_u_int(xdrs,&skip))
603 XDRerror();
604 xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
605 }
606 }
607 }
608 xdr_setpos64(xdrs,start+size);
609 }
610 return this1;
611}
612
613static mc_s_Origin_t* unpack_mc_s_Origin(XDR* xdrs, popNode* pop)
614{
615 mc_s_Origin_t* this1 = (mc_s_Origin_t*)HDDM_NULL(void*)&hddm_mc_s_nullTarget;
616 unsigned int size;
617 if (! xdr_u_int(xdrs,&size))
618 {
619 return this1;
620 }
621 else if (size > 0)
622 {
623 off_t start = xdr_getpos64(xdrs);
624 this1 = make_mc_s_Origin();
625 {
626 if (! xdr_float(xdrs,&this1->t))
627 XDRerror();
628 if (! xdr_float(xdrs,&this1->vx))
629 XDRerror();
630 if (! xdr_float(xdrs,&this1->vy))
631 XDRerror();
632 if (! xdr_float(xdrs,&this1->vz))
633 XDRerror();
634 }
635 xdr_setpos64(xdrs,start+size);
636 }
637 return this1;
638}
639
640static mc_s_Random_t* unpack_mc_s_Random(XDR* xdrs, popNode* pop)
641{
642 mc_s_Random_t* this1 = (mc_s_Random_t*)HDDM_NULL(void*)&hddm_mc_s_nullTarget;
643 unsigned int size;
644 if (! xdr_u_int(xdrs,&size))
645 {
646 return this1;
647 }
648 else if (size > 0)
649 {
650 off_t start = xdr_getpos64(xdrs);
651 this1 = make_mc_s_Random();
652 {
653 if (! xdr_int(xdrs,&this1->seed1))
654 XDRerror();
655 if (! xdr_int(xdrs,&this1->seed2))
656 XDRerror();
657 if (! xdr_int(xdrs,&this1->seed3))
658 XDRerror();
659 if (! xdr_int(xdrs,&this1->seed4))
660 XDRerror();
661 }
662 xdr_setpos64(xdrs,start+size);
663 }
664 return this1;
665}
666
667mc_s_HDDM_t* read_mc_s_HDDM(mc_s_iostream_t* fp)
668{
669 off_t base;
670 unsigned int size;
671 xdrmem_create(fp->xdrs,fp->iobuffer,fp->iobuffer_size,XDR_DECODE);
672 base = xdr_getpos64(fp->xdrs);
673 if (fread(fp->iobuffer,1,4,fp->fd) != 4 || ! xdr_u_int(fp->xdrs,&size))
674 {
675 xdr_destroy(fp->xdrs)do { if ((fp->xdrs)->x_ops->x_destroy) (*(fp->xdrs
)->x_ops->x_destroy)(fp->xdrs); } while (0);
676 return 0;
677 }
678 else if (size == 1)
679 {
680 fprintf(stderrstderr,"hddm error - "
681 "stream compression and/or integrity checks found in input stream.\n"
682 "These features are not supported by the hddm c i/o interface.\n");
683 fprintf(stderrstderr,"You must use the c++ interface to read this file.\n");
684 exit(9);
685 }
686 else if (size + 4 > fp->iobuffer_size)
687 {
688 xdr_destroy(fp->xdrs)do { if ((fp->xdrs)->x_ops->x_destroy) (*(fp->xdrs
)->x_ops->x_destroy)(fp->xdrs); } while (0);
689 char *newbuf = (char*)malloc(fp->iobuffer_size *= 2);
690 memcpy(newbuf,fp->iobuffer,4);
691 free(fp->iobuffer);
692 fp->iobuffer = newbuf;
693 xdrmem_create(fp->xdrs,fp->iobuffer,fp->iobuffer_size,XDR_DECODE);
694 base = xdr_getpos64(fp->xdrs);
695 }
696 if (fread(fp->iobuffer+4,1,size,fp->fd) != size)
697 {
698 fprintf(stderrstderr,"hddm error - "
699 "read failed on input hddm stream, "
700 "cannot continue.\n");
701 exit(9);
702 }
703 xdr_setpos64(fp->xdrs,base);
704 mc_s_HDDM_t* nextEvent = unpack_mc_s_HDDM(fp->xdrs,fp->popTop);
705 xdr_destroy(fp->xdrs)do { if ((fp->xdrs)->x_ops->x_destroy) (*(fp->xdrs
)->x_ops->x_destroy)(fp->xdrs); } while (0);
706 return (nextEvent == HDDM_NULL(void*)&hddm_mc_s_nullTarget)? 0 : nextEvent;
707}
708
709int skip_mc_s_HDDM(mc_s_iostream_t* fp, int nskip)
710{
711 int skipped;
712 for (skipped=0; skipped < nskip; ++skipped)
713 {
714 unsigned int size;
715 xdrmem_create(fp->xdrs,fp->iobuffer,fp->iobuffer_size,XDR_DECODE);
716 if (fread(fp->iobuffer,1,4,fp->fd) != 4 || ! xdr_u_int(fp->xdrs,&size))
717 {
718 break;
719 }
720 else if (size == 1)
721 {
722 fprintf(stderrstderr,"hddm error - "
723 "stream compression and/or integrity checks found in input stream.\n"
724 "These features are not supported by the hddm c i/o interface.\n");
725 fprintf(stderrstderr,"You must use the c++ interface to read this file.\n");
726 exit(9);
727 }
728 else if (size + 4 > fp->iobuffer_size)
729 {
730 xdr_destroy(fp->xdrs)do { if ((fp->xdrs)->x_ops->x_destroy) (*(fp->xdrs
)->x_ops->x_destroy)(fp->xdrs); } while (0);
731 char *newbuf = (char*)malloc(fp->iobuffer_size *= 2);
732 memcpy(newbuf,fp->iobuffer,4);
733 free(fp->iobuffer);
734 fp->iobuffer = newbuf;
735 xdrmem_create(fp->xdrs,fp->iobuffer,fp->iobuffer_size,XDR_DECODE);
736 }
737 if (fread(fp->iobuffer+4,1,size,fp->fd) != size)
738 {
739 fprintf(stderrstderr,"hddm error - "
740 "read failed on input hddm stream, "
741 "cannot continue.\n");
742 exit(9);
743 }
744 }
745 xdr_destroy(fp->xdrs)do { if ((fp->xdrs)->x_ops->x_destroy) (*(fp->xdrs
)->x_ops->x_destroy)(fp->xdrs); } while (0);
746 return skipped;
747}
748
749static int pack_mc_s_HDDM(XDR* xdrs, mc_s_HDDM_t* this1);
750static int pack_mc_s_PhysicsEvents(XDR* xdrs, mc_s_PhysicsEvents_t* this1);
751static int pack_mc_s_Reactions(XDR* xdrs, mc_s_Reactions_t* this1);
752static int pack_mc_s_Beam(XDR* xdrs, mc_s_Beam_t* this1);
753static int pack_mc_s_Momentum(XDR* xdrs, mc_s_Momentum_t* this1);
754static int pack_mc_s_Properties(XDR* xdrs, mc_s_Properties_t* this1);
755static int pack_mc_s_Target(XDR* xdrs, mc_s_Target_t* this1);
756static int pack_mc_s_Vertices(XDR* xdrs, mc_s_Vertices_t* this1);
757static int pack_mc_s_Products(XDR* xdrs, mc_s_Products_t* this1);
758static int pack_mc_s_Origin(XDR* xdrs, mc_s_Origin_t* this1);
759static int pack_mc_s_Random(XDR* xdrs, mc_s_Random_t* this1);
760
761static int pack_mc_s_HDDM(XDR* xdrs, mc_s_HDDM_t* this1)
762{
763 unsigned int size=0;
764 off_t base,start,end;
765 base = xdr_getpos64(xdrs);
766 if (base == -1)
767 {
768 fprintf(stderrstderr,"hddm error - "
769 "stream offset request failed on output hddm stream, "
770 "cannot continue.\n");
771 return -1;
772 }
773 if (! xdr_u_int(xdrs,&size))
774 XDRerror();
775 start = xdr_getpos64(xdrs);
776
777 {
778 if (this1->physicsEvents != (mc_s_PhysicsEvents_t*)&hddm_mc_s_nullTarget)
779 {
780 if (pack_mc_s_PhysicsEvents(xdrs,this1->physicsEvents) < 0) {
781 return -1;
782 }
783 }
784 else
785 {
786 int zero=0;
787 if (! xdr_int(xdrs,&zero))
788 XDRerror();
789 }
790 }
791 end = xdr_getpos64(xdrs);
792 xdr_setpos64(xdrs,base);
793 size = end-start;
794 if (size + 4 > hddm_mc_s_buffersize) {
795 fprintf(stderrstderr,"hddm error - "
796 "output buffer overflow on hddm stream, cannot continue.\n");
797 fprintf(stderrstderr,"Please increase buffer size using "
798 "set_mc_s_HDDM_buffersize(s) with s > %d.", hddm_mc_s_buffersize);
799 exit(9);
800 }
801 if (! xdr_u_int(xdrs,&size))
802 XDRerror();
803 xdr_setpos64(xdrs,end);
804 FREE(this1)free(this1);
805 return size;
806}
807
808static int pack_mc_s_PhysicsEvents(XDR* xdrs, mc_s_PhysicsEvents_t* this1)
809{
810 int m=0;
811 unsigned int size=0;
812 off_t base,start,end;
813 base = xdr_getpos64(xdrs);
814 if (! xdr_u_int(xdrs,&size))
815 XDRerror();
816 start = xdr_getpos64(xdrs);
817
818 if (! xdr_u_int(xdrs,&this1->mult))
819 XDRerror();
820 for (m = 0; m < this1->mult; m++)
821 {
822 if (! xdr_int(xdrs,&this1->in[m].eventNo))
823 XDRerror();
824 if (! xdr_int(xdrs,&this1->in[m].runNo))
825 XDRerror();
826 if (this1->in[m].reactions != (mc_s_Reactions_t*)&hddm_mc_s_nullTarget)
827 {
828 if (pack_mc_s_Reactions(xdrs,this1->in[m].reactions) < 0) {
829 return -1;
830 }
831 }
832 else
833 {
834 int zero=0;
835 if (! xdr_int(xdrs,&zero))
836 XDRerror();
837 }
838 }
839 end = xdr_getpos64(xdrs);
840 xdr_setpos64(xdrs,base);
841 size = end-start;
842 if (! xdr_u_int(xdrs,&size))
843 XDRerror();
844 xdr_setpos64(xdrs,end);
845 FREE(this1)free(this1);
846 return size;
847}
848
849static int pack_mc_s_Reactions(XDR* xdrs, mc_s_Reactions_t* this1)
850{
851 int m=0;
852 unsigned int size=0;
853 off_t base,start,end;
854 base = xdr_getpos64(xdrs);
855 if (! xdr_u_int(xdrs,&size))
856 XDRerror();
857 start = xdr_getpos64(xdrs);
858
859 if (! xdr_u_int(xdrs,&this1->mult))
860 XDRerror();
861 for (m = 0; m < this1->mult; m++)
862 {
863 if (! xdr_int(xdrs,&this1->in[m].type))
864 XDRerror();
865 if (! xdr_float(xdrs,&this1->in[m].weight))
866 XDRerror();
867 if (this1->in[m].beam != (mc_s_Beam_t*)&hddm_mc_s_nullTarget)
868 {
869 if (pack_mc_s_Beam(xdrs,this1->in[m].beam) < 0) {
870 return -1;
871 }
872 }
873 else
874 {
875 int zero=0;
876 if (! xdr_int(xdrs,&zero))
877 XDRerror();
878 }
879 if (this1->in[m].target != (mc_s_Target_t*)&hddm_mc_s_nullTarget)
880 {
881 if (pack_mc_s_Target(xdrs,this1->in[m].target) < 0) {
882 return -1;
883 }
884 }
885 else
886 {
887 int zero=0;
888 if (! xdr_int(xdrs,&zero))
889 XDRerror();
890 }
891 if (this1->in[m].vertices != (mc_s_Vertices_t*)&hddm_mc_s_nullTarget)
892 {
893 if (pack_mc_s_Vertices(xdrs,this1->in[m].vertices) < 0) {
894 return -1;
895 }
896 }
897 else
898 {
899 int zero=0;
900 if (! xdr_int(xdrs,&zero))
901 XDRerror();
902 }
903 if (this1->in[m].random != (mc_s_Random_t*)&hddm_mc_s_nullTarget)
904 {
905 if (pack_mc_s_Random(xdrs,this1->in[m].random) < 0) {
906 return -1;
907 }
908 }
909 else
910 {
911 int zero=0;
912 if (! xdr_int(xdrs,&zero))
913 XDRerror();
914 }
915 }
916 end = xdr_getpos64(xdrs);
917 xdr_setpos64(xdrs,base);
918 size = end-start;
919 if (! xdr_u_int(xdrs,&size))
920 XDRerror();
921 xdr_setpos64(xdrs,end);
922 FREE(this1)free(this1);
923 return size;
924}
925
926static int pack_mc_s_Beam(XDR* xdrs, mc_s_Beam_t* this1)
927{
928 unsigned int size=0;
929 off_t base,start,end;
930 base = xdr_getpos64(xdrs);
931 if (! xdr_u_int(xdrs,&size))
932 XDRerror();
933 start = xdr_getpos64(xdrs);
934
935 {
936 if (! xdr_int(xdrs,(int*)&this1->type))
937 XDRerror();
938 if (this1->momentum != (mc_s_Momentum_t*)&hddm_mc_s_nullTarget)
939 {
940 if (pack_mc_s_Momentum(xdrs,this1->momentum) < 0) {
941 return -1;
942 }
943 }
944 else
945 {
946 int zero=0;
947 if (! xdr_int(xdrs,&zero))
948 XDRerror();
949 }
950 if (this1->properties != (mc_s_Properties_t*)&hddm_mc_s_nullTarget)
951 {
952 if (pack_mc_s_Properties(xdrs,this1->properties) < 0) {
953 return -1;
954 }
955 }
956 else
957 {
958 int zero=0;
959 if (! xdr_int(xdrs,&zero))
960 XDRerror();
961 }
962 }
963 end = xdr_getpos64(xdrs);
964 xdr_setpos64(xdrs,base);
965 size = end-start;
966 if (! xdr_u_int(xdrs,&size))
967 XDRerror();
968 xdr_setpos64(xdrs,end);
969 FREE(this1)free(this1);
970 return size;
971}
972
973static int pack_mc_s_Momentum(XDR* xdrs, mc_s_Momentum_t* this1)
974{
975 unsigned int size=0;
976 off_t base,start,end;
977 base = xdr_getpos64(xdrs);
978 if (! xdr_u_int(xdrs,&size))
979 XDRerror();
980 start = xdr_getpos64(xdrs);
981
982 {
983 if (! xdr_float(xdrs,&this1->E))
984 XDRerror();
985 if (! xdr_float(xdrs,&this1->px))
986 XDRerror();
987 if (! xdr_float(xdrs,&this1->py))
988 XDRerror();
989 if (! xdr_float(xdrs,&this1->pz))
990 XDRerror();
991 }
992 end = xdr_getpos64(xdrs);
993 xdr_setpos64(xdrs,base);
994 size = end-start;
995 if (! xdr_u_int(xdrs,&size))
996 XDRerror();
997 xdr_setpos64(xdrs,end);
998 FREE(this1)free(this1);
999 return size;
1000}
1001
1002static int pack_mc_s_Properties(XDR* xdrs, mc_s_Properties_t* this1)
1003{
1004 unsigned int size=0;
1005 off_t base,start,end;
1006 base = xdr_getpos64(xdrs);
1007 if (! xdr_u_int(xdrs,&size))
1008 XDRerror();
1009 start = xdr_getpos64(xdrs);
1010
1011 {
1012 if (! xdr_int(xdrs,&this1->charge))
1013 XDRerror();
1014 if (! xdr_float(xdrs,&this1->mass))
1015 XDRerror();
1016 }
1017 end = xdr_getpos64(xdrs);
1018 xdr_setpos64(xdrs,base);
1019 size = end-start;
1020 if (! xdr_u_int(xdrs,&size))
1021 XDRerror();
1022 xdr_setpos64(xdrs,end);
1023 FREE(this1)free(this1);
1024 return size;
1025}
1026
1027static int pack_mc_s_Target(XDR* xdrs, mc_s_Target_t* this1)
1028{
1029 unsigned int size=0;
1030 off_t base,start,end;
1031 base = xdr_getpos64(xdrs);
1032 if (! xdr_u_int(xdrs,&size))
1033 XDRerror();
1034 start = xdr_getpos64(xdrs);
1035
1036 {
1037 if (! xdr_int(xdrs,(int*)&this1->type))
1038 XDRerror();
1039 if (this1->momentum != (mc_s_Momentum_t*)&hddm_mc_s_nullTarget)
1040 {
1041 if (pack_mc_s_Momentum(xdrs,this1->momentum) < 0) {
1042 return -1;
1043 }
1044 }
1045 else
1046 {
1047 int zero=0;
1048 if (! xdr_int(xdrs,&zero))
1049 XDRerror();
1050 }
1051 if (this1->properties != (mc_s_Properties_t*)&hddm_mc_s_nullTarget)
1052 {
1053 if (pack_mc_s_Properties(xdrs,this1->properties) < 0) {
1054 return -1;
1055 }
1056 }
1057 else
1058 {
1059 int zero=0;
1060 if (! xdr_int(xdrs,&zero))
1061 XDRerror();
1062 }
1063 }
1064 end = xdr_getpos64(xdrs);
1065 xdr_setpos64(xdrs,base);
1066 size = end-start;
1067 if (! xdr_u_int(xdrs,&size))
1068 XDRerror();
1069 xdr_setpos64(xdrs,end);
1070 FREE(this1)free(this1);
1071 return size;
1072}
1073
1074static int pack_mc_s_Vertices(XDR* xdrs, mc_s_Vertices_t* this1)
1075{
1076 int m=0;
1077 unsigned int size=0;
1078 off_t base,start,end;
1079 base = xdr_getpos64(xdrs);
1080 if (! xdr_u_int(xdrs,&size))
1081 XDRerror();
1082 start = xdr_getpos64(xdrs);
1083
1084 if (! xdr_u_int(xdrs,&this1->mult))
1085 XDRerror();
1086 for (m = 0; m < this1->mult; m++)
1087 {
1088 if (this1->in[m].products != (mc_s_Products_t*)&hddm_mc_s_nullTarget)
1089 {
1090 if (pack_mc_s_Products(xdrs,this1->in[m].products) < 0) {
1091 return -1;
1092 }
1093 }
1094 else
1095 {
1096 int zero=0;
1097 if (! xdr_int(xdrs,&zero))
1098 XDRerror();
1099 }
1100 if (this1->in[m].origin != (mc_s_Origin_t*)&hddm_mc_s_nullTarget)
1101 {
1102 if (pack_mc_s_Origin(xdrs,this1->in[m].origin) < 0) {
1103 return -1;
1104 }
1105 }
1106 else
1107 {
1108 int zero=0;
1109 if (! xdr_int(xdrs,&zero))
1110 XDRerror();
1111 }
1112 }
1113 end = xdr_getpos64(xdrs);
1114 xdr_setpos64(xdrs,base);
1115 size = end-start;
1116 if (! xdr_u_int(xdrs,&size))
1117 XDRerror();
1118 xdr_setpos64(xdrs,end);
1119 FREE(this1)free(this1);
1120 return size;
1121}
1122
1123static int pack_mc_s_Products(XDR* xdrs, mc_s_Products_t* this1)
1124{
1125 int m=0;
1126 unsigned int size=0;
1127 off_t base,start,end;
1128 base = xdr_getpos64(xdrs);
1129 if (! xdr_u_int(xdrs,&size))
1130 XDRerror();
1131 start = xdr_getpos64(xdrs);
1132
1133 if (! xdr_u_int(xdrs,&this1->mult))
1134 XDRerror();
1135 for (m = 0; m < this1->mult; m++)
1136 {
1137 if (! xdr_int(xdrs,&this1->in[m].decayVertex))
1138 XDRerror();
1139 if (! xdr_int(xdrs,&this1->in[m].id))
1140 XDRerror();
1141 if (! xdr_int(xdrs,&this1->in[m].mech))
1142 XDRerror();
1143 if (! xdr_int(xdrs,&this1->in[m].parentid))
1144 XDRerror();
1145 if (! xdr_int(xdrs,&this1->in[m].pdgtype))
1146 XDRerror();
1147 if (! xdr_int(xdrs,(int*)&this1->in[m].type))
1148 XDRerror();
1149 if (this1->in[m].momentum != (mc_s_Momentum_t*)&hddm_mc_s_nullTarget)
1150 {
1151 if (pack_mc_s_Momentum(xdrs,this1->in[m].momentum) < 0) {
1152 return -1;
1153 }
1154 }
1155 else
1156 {
1157 int zero=0;
1158 if (! xdr_int(xdrs,&zero))
1159 XDRerror();
1160 }
1161 if (this1->in[m].properties != (mc_s_Properties_t*)&hddm_mc_s_nullTarget)
1162 {
1163 if (pack_mc_s_Properties(xdrs,this1->in[m].properties) < 0) {
1164 return -1;
1165 }
1166 }
1167 else
1168 {
1169 int zero=0;
1170 if (! xdr_int(xdrs,&zero))
1171 XDRerror();
1172 }
1173 }
1174 end = xdr_getpos64(xdrs);
1175 xdr_setpos64(xdrs,base);
1176 size = end-start;
1177 if (! xdr_u_int(xdrs,&size))
1178 XDRerror();
1179 xdr_setpos64(xdrs,end);
1180 FREE(this1)free(this1);
1181 return size;
1182}
1183
1184static int pack_mc_s_Origin(XDR* xdrs, mc_s_Origin_t* this1)
1185{
1186 unsigned int size=0;
1187 off_t base,start,end;
1188 base = xdr_getpos64(xdrs);
1189 if (! xdr_u_int(xdrs,&size))
1190 XDRerror();
1191 start = xdr_getpos64(xdrs);
1192
1193 {
1194 if (! xdr_float(xdrs,&this1->t))
1195 XDRerror();
1196 if (! xdr_float(xdrs,&this1->vx))
1197 XDRerror();
1198 if (! xdr_float(xdrs,&this1->vy))
1199 XDRerror();
1200 if (! xdr_float(xdrs,&this1->vz))
1201 XDRerror();
1202 }
1203 end = xdr_getpos64(xdrs);
1204 xdr_setpos64(xdrs,base);
1205 size = end-start;
1206 if (! xdr_u_int(xdrs,&size))
1207 XDRerror();
1208 xdr_setpos64(xdrs,end);
1209 FREE(this1)free(this1);
1210 return size;
1211}
1212
1213static int pack_mc_s_Random(XDR* xdrs, mc_s_Random_t* this1)
1214{
1215 unsigned int size=0;
1216 off_t base,start,end;
1217 base = xdr_getpos64(xdrs);
1218 if (! xdr_u_int(xdrs,&size))
1219 XDRerror();
1220 start = xdr_getpos64(xdrs);
1221
1222 {
1223 if (! xdr_int(xdrs,&this1->seed1))
1224 XDRerror();
1225 if (! xdr_int(xdrs,&this1->seed2))
1226 XDRerror();
1227 if (! xdr_int(xdrs,&this1->seed3))
1228 XDRerror();
1229 if (! xdr_int(xdrs,&this1->seed4))
1230 XDRerror();
1231 }
1232 end = xdr_getpos64(xdrs);
1233 xdr_setpos64(xdrs,base);
1234 size = end-start;
1235 if (! xdr_u_int(xdrs,&size))
1236 XDRerror();
1237 xdr_setpos64(xdrs,end);
1238 FREE(this1)free(this1);
1239 return size;
1240}
1241
1242int flush_mc_s_HDDM(mc_s_HDDM_t* this1,mc_s_iostream_t* fp)
1243{
1244 if (this1 == 0)
1245 {
1246 return 0;
1247 }
1248 else if (fp == 0)
1249 {
1250 XDR* xdrs = (XDR*)malloc(sizeof(XDR));
1251 char* dump = (char*)malloc(hddm_mc_s_buffersize);
1252 xdrmem_create(xdrs,dump,hddm_mc_s_buffersize,XDR_ENCODE);
1253 pack_mc_s_HDDM(xdrs,this1);
1254 xdr_destroy(xdrs)do { if ((xdrs)->x_ops->x_destroy) (*(xdrs)->x_ops->
x_destroy)(xdrs); } while (0);
1255 free(xdrs);
1256 free(dump);
1257 }
1258 else if (fp->iomode == HDDM_STREAM_OUTPUT-92)
1259 {
1260 int size;
1261 xdrmem_create(fp->xdrs,fp->iobuffer,fp->iobuffer_size,XDR_ENCODE);
1262 size = pack_mc_s_HDDM(fp->xdrs,this1);
1263 if (size < 0)
1264 {
1265 fp->lerrno = errno(*__errno_location ());
1266 xdr_destroy(fp->xdrs)do { if ((fp->xdrs)->x_ops->x_destroy) (*(fp->xdrs
)->x_ops->x_destroy)(fp->xdrs); } while (0);
1267 return -1;
1268 }
1269 else if (size > 0)
1270 {
1271 int wsize = fwrite(fp->iobuffer,1,size+4,fp->fd);
1272 if (wsize != size + 4)
1273 {
1274 fprintf(stderrstderr,"HDDM Error: error writing to "
1275 "output hddm file.\n");
1276 fprintf(stderrstderr,"%d bytes of %d actually written.\n",
1277 wsize, size+4);
1278 exit(9);
1279 }
1280 }
1281 xdr_destroy(fp->xdrs)do { if ((fp->xdrs)->x_ops->x_destroy) (*(fp->xdrs
)->x_ops->x_destroy)(fp->xdrs); } while (0);
1282 }
1283 return 0;
1284}
1285
1286static int getTag(char* d, char* tag)
1287{
1288 int level;
1289 char* token;
1290 char line[500];
1291 strncpy(line,d,500)__builtin_strncpy (line, d, 500);
1292 line[499] = 0;
1293 level = index(line,'<')-line;
1294 if (level < 500 &&
1295 (token = strtok(line+level+1," >")))
1296 {
1297 strncpy(tag,token,500)__builtin_strncpy (tag, token, 500);
1298 return level/2;
1299 }
1300 return -1;
1301}
1302
1303static char* getEndTag(char* d, char* tag)
1304{
1305 char line[500];
1306 char endTag[510];
1307 strncpy(line,d,500)__builtin_strncpy (line, d, 500);
1308 line[499] = 0;
1309 if (strstr(strtok(line,"\n"),"/>") == 0)
1310 {
1311 sprintf(endTag,"</%s>",tag);
1312 }
1313 else
1314 {
1315 strcpy(endTag,"/>");
1316 }
1317 return strstr(d,endTag);
1318}
1319
1320static void collide(char* b, char* c)
1321{
1322 char btag[500];
1323 getTag(b,btag);
1324 b = index(b,'<');
1325 c = index(c,'<');
1326 *(index(b,'\n')) = 0;
1327 *(index(c,'\n')) = 0;
1328 fprintf(stderrstderr,"HDDM warning: ");
1329 fprintf(stderrstderr,"tag %s in input file ", btag);
1330 fprintf(stderrstderr,"does not match c header hddm_mc_s.h\n");
1331 fprintf(stderrstderr," input file: %s\n", b);
1332 fprintf(stderrstderr," c header: %s\n", c);
1333 fprintf(stderrstderr," === Tag %s will be ignored,", btag);
1334 fprintf(stderrstderr," rebuild to cure the problem ===\n");
1335 *(index(b,0)) = '\n';
1336 *(index(c,0)) = '\n';
1337}
1338
1339static int tag_strncmp(char* a, char* b, int len)
1340{
1341 if (strncmp(a,b,len)(__extension__ (__builtin_constant_p (len) && ((__builtin_constant_p
(a) && strlen (a) < ((size_t) (len))) || (__builtin_constant_p
(b) && strlen (b) < ((size_t) (len)))) ? __extension__
({ size_t __s1_len, __s2_len; (__builtin_constant_p (a) &&
__builtin_constant_p (b) && (__s1_len = strlen (a), __s2_len
= strlen (b), (!((size_t)(const void *)((a) + 1) - (size_t)(
const void *)(a) == 1) || __s1_len >= 4) && (!((size_t
)(const void *)((b) + 1) - (size_t)(const void *)(b) == 1) ||
__s2_len >= 4)) ? __builtin_strcmp (a, b) : (__builtin_constant_p
(a) && ((size_t)(const void *)((a) + 1) - (size_t)(const
void *)(a) == 1) && (__s1_len = strlen (a), __s1_len
< 4) ? (__builtin_constant_p (b) && ((size_t)(const
void *)((b) + 1) - (size_t)(const void *)(b) == 1) ? __builtin_strcmp
(a, b) : (__extension__ ({ __const unsigned char *__s2 = (__const
unsigned char *) (__const char *) (b); register int __result
= (((__const unsigned char *) (__const char *) (a))[0] - __s2
[0]); if (__s1_len > 0 && __result == 0) { __result
= (((__const unsigned char *) (__const char *) (a))[1] - __s2
[1]); if (__s1_len > 1 && __result == 0) { __result
= (((__const unsigned char *) (__const char *) (a))[2] - __s2
[2]); if (__s1_len > 2 && __result == 0) __result =
(((__const unsigned char *) (__const char *) (a))[3] - __s2[
3]); } } __result; }))) : (__builtin_constant_p (b) &&
((size_t)(const void *)((b) + 1) - (size_t)(const void *)(b)
== 1) && (__s2_len = strlen (b), __s2_len < 4) ? (
__builtin_constant_p (a) && ((size_t)(const void *)((
a) + 1) - (size_t)(const void *)(a) == 1) ? __builtin_strcmp (
a, b) : (__extension__ ({ __const unsigned char *__s1 = (__const
unsigned char *) (__const char *) (a); register int __result
= __s1[0] - ((__const unsigned char *) (__const char *) (b))
[0]; if (__s2_len > 0 && __result == 0) { __result
= (__s1[1] - ((__const unsigned char *) (__const char *) (b)
)[1]); if (__s2_len > 1 && __result == 0) { __result
= (__s1[2] - ((__const unsigned char *) (__const char *) (b)
)[2]); if (__s2_len > 2 && __result == 0) __result
= (__s1[3] - ((__const unsigned char *) (__const char *) (b)
)[3]); } } __result; }))) : __builtin_strcmp (a, b)))); }) : strncmp
(a, b, len))) == 0) {
1342 return 0;
1343 }
1344 else {
1345 for (; *a == *b; ++a, ++b, --len) {}
1346 for (; *a == ' '; ++a, --len) {}
1347 for (; *a == '/'; ++a, --len) {}
1348 for (; *b == ' '; ++b) {}
1349 for (; *b == '/'; ++b) {}
1350 return strncmp(a,b,len)(__extension__ (__builtin_constant_p (len) && ((__builtin_constant_p
(a) && strlen (a) < ((size_t) (len))) || (__builtin_constant_p
(b) && strlen (b) < ((size_t) (len)))) ? __extension__
({ size_t __s1_len, __s2_len; (__builtin_constant_p (a) &&
__builtin_constant_p (b) && (__s1_len = strlen (a), __s2_len
= strlen (b), (!((size_t)(const void *)((a) + 1) - (size_t)(
const void *)(a) == 1) || __s1_len >= 4) && (!((size_t
)(const void *)((b) + 1) - (size_t)(const void *)(b) == 1) ||
__s2_len >= 4)) ? __builtin_strcmp (a, b) : (__builtin_constant_p
(a) && ((size_t)(const void *)((a) + 1) - (size_t)(const
void *)(a) == 1) && (__s1_len = strlen (a), __s1_len
< 4) ? (__builtin_constant_p (b) && ((size_t)(const
void *)((b) + 1) - (size_t)(const void *)(b) == 1) ? __builtin_strcmp
(a, b) : (__extension__ ({ __const unsigned char *__s2 = (__const
unsigned char *) (__const char *) (b); register int __result
= (((__const unsigned char *) (__const char *) (a))[0] - __s2
[0]); if (__s1_len > 0 && __result == 0) { __result
= (((__const unsigned char *) (__const char *) (a))[1] - __s2
[1]); if (__s1_len > 1 && __result == 0) { __result
= (((__const unsigned char *) (__const char *) (a))[2] - __s2
[2]); if (__s1_len > 2 && __result == 0) __result =
(((__const unsigned char *) (__const char *) (a))[3] - __s2[
3]); } } __result; }))) : (__builtin_constant_p (b) &&
((size_t)(const void *)((b) + 1) - (size_t)(const void *)(b)
== 1) && (__s2_len = strlen (b), __s2_len < 4) ? (
__builtin_constant_p (a) && ((size_t)(const void *)((
a) + 1) - (size_t)(const void *)(a) == 1) ? __builtin_strcmp (
a, b) : (__extension__ ({ __const unsigned char *__s1 = (__const
unsigned char *) (__const char *) (a); register int __result
= __s1[0] - ((__const unsigned char *) (__const char *) (b))
[0]; if (__s2_len > 0 && __result == 0) { __result
= (__s1[1] - ((__const unsigned char *) (__const char *) (b)
)[1]); if (__s2_len > 1 && __result == 0) { __result
= (__s1[2] - ((__const unsigned char *) (__const char *) (b)
)[2]); if (__s2_len > 2 && __result == 0) __result
= (__s1[3] - ((__const unsigned char *) (__const char *) (b)
)[3]); } } __result; }))) : __builtin_strcmp (a, b)))); }) : strncmp
(a, b, len)));
1351 }
1352}
1353
1354static popNode* matches(char* b, char* c)
1355{
1356 char btag[500];
1357 char ctag[500];
1358 int blevel, clevel;
1359 int ptrSeqNo = 0;
1360 blevel = getTag(b,btag);
1361 while ((clevel = getTag(c,ctag)) == blevel)
1
Loop condition is true. Entering loop body
→
3
←
Loop condition is true. Entering loop body
→
1362 {
1363 if ((clevel == blevel) && (strcmp(ctag,btag)__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(ctag) && __builtin_constant_p (btag) && (__s1_len
= strlen (ctag), __s2_len = strlen (btag), (!((size_t)(const
void *)((ctag) + 1) - (size_t)(const void *)(ctag) == 1) || __s1_len
>= 4) && (!((size_t)(const void *)((btag) + 1) - (
size_t)(const void *)(btag) == 1) || __s2_len >= 4)) ? __builtin_strcmp
(ctag, btag) : (__builtin_constant_p (ctag) && ((size_t
)(const void *)((ctag) + 1) - (size_t)(const void *)(ctag) ==
1) && (__s1_len = strlen (ctag), __s1_len < 4) ? (
__builtin_constant_p (btag) && ((size_t)(const void *
)((btag) + 1) - (size_t)(const void *)(btag) == 1) ? __builtin_strcmp
(ctag, btag) : (__extension__ ({ __const unsigned char *__s2
= (__const unsigned char *) (__const char *) (btag); register
int __result = (((__const unsigned char *) (__const char *) (
ctag))[0] - __s2[0]); if (__s1_len > 0 && __result
== 0) { __result = (((__const unsigned char *) (__const char
*) (ctag))[1] - __s2[1]); if (__s1_len > 1 && __result
== 0) { __result = (((__const unsigned char *) (__const char
*) (ctag))[2] - __s2[2]); if (__s1_len > 2 && __result
== 0) __result = (((__const unsigned char *) (__const char *
) (ctag))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p
(btag) && ((size_t)(const void *)((btag) + 1) - (size_t
)(const void *)(btag) == 1) && (__s2_len = strlen (btag
), __s2_len < 4) ? (__builtin_constant_p (ctag) &&
((size_t)(const void *)((ctag) + 1) - (size_t)(const void *)
(ctag) == 1) ? __builtin_strcmp (ctag, btag) : (__extension__
({ __const unsigned char *__s1 = (__const unsigned char *) (
__const char *) (ctag); register int __result = __s1[0] - ((__const
unsigned char *) (__const char *) (btag))[0]; if (__s2_len >
0 && __result == 0) { __result = (__s1[1] - ((__const
unsigned char *) (__const char *) (btag))[1]); if (__s2_len >
1 && __result == 0) { __result = (__s1[2] - ((__const
unsigned char *) (__const char *) (btag))[2]); if (__s2_len >
2 && __result == 0) __result = (__s1[3] - ((__const unsigned
char *) (__const char *) (btag))[3]); } } __result; }))) : __builtin_strcmp
(ctag, btag)))); }) == 0))
2
←
Taking false branch
→
4
←
Taking true branch
→
1364 {
1365 popNode* this1 = (popNode*)malloc(sizeof(popNode));
5
←
Memory is allocated
→
1366 int len = index(c+1,'\n') - c;
1367 if (tag_strncmp(c,b,len) != 0)
6
←
Taking true branch
→
1368 {
1369 collide(b,c);
7
←
Potential leak of memory pointed to by 'this1'
1370 return 0;
1371 }
1372 else if (strcmp(btag,"HDDM")__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(btag) && __builtin_constant_p ("HDDM") && (
__s1_len = strlen (btag), __s2_len = strlen ("HDDM"), (!((size_t
)(const void *)((btag) + 1) - (size_t)(const void *)(btag) ==
1) || __s1_len >= 4) && (!((size_t)(const void *)
(("HDDM") + 1) - (size_t)(const void *)("HDDM") == 1) || __s2_len
>= 4)) ? __builtin_strcmp (btag, "HDDM") : (__builtin_constant_p
(btag) && ((size_t)(const void *)((btag) + 1) - (size_t
)(const void *)(btag) == 1) && (__s1_len = strlen (btag
), __s1_len < 4) ? (__builtin_constant_p ("HDDM") &&
((size_t)(const void *)(("HDDM") + 1) - (size_t)(const void *
)("HDDM") == 1) ? __builtin_strcmp (btag, "HDDM") : (__extension__
({ __const unsigned char *__s2 = (__const unsigned char *) (
__const char *) ("HDDM"); register int __result = (((__const unsigned
char *) (__const char *) (btag))[0] - __s2[0]); if (__s1_len
> 0 && __result == 0) { __result = (((__const unsigned
char *) (__const char *) (btag))[1] - __s2[1]); if (__s1_len
> 1 && __result == 0) { __result = (((__const unsigned
char *) (__const char *) (btag))[2] - __s2[2]); if (__s1_len
> 2 && __result == 0) __result = (((__const unsigned
char *) (__const char *) (btag))[3] - __s2[3]); } } __result
; }))) : (__builtin_constant_p ("HDDM") && ((size_t)(
const void *)(("HDDM") + 1) - (size_t)(const void *)("HDDM") ==
1) && (__s2_len = strlen ("HDDM"), __s2_len < 4) ?
(__builtin_constant_p (btag) && ((size_t)(const void
*)((btag) + 1) - (size_t)(const void *)(btag) == 1) ? __builtin_strcmp
(btag, "HDDM") : (__extension__ ({ __const unsigned char *__s1
= (__const unsigned char *) (__const char *) (btag); register
int __result = __s1[0] - ((__const unsigned char *) (__const
char *) ("HDDM"))[0]; if (__s2_len > 0 && __result
== 0) { __result = (__s1[1] - ((__const unsigned char *) (__const
char *) ("HDDM"))[1]); if (__s2_len > 1 && __result
== 0) { __result = (__s1[2] - ((__const unsigned char *) (__const
char *) ("HDDM"))[2]); if (__s2_len > 2 && __result
== 0) __result = (__s1[3] - ((__const unsigned char *) (__const
char *) ("HDDM"))[3]); } } __result; }))) : __builtin_strcmp
(btag, "HDDM")))); }) == 0)
1373 {
1374 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_mc_s_HDDM;
1375 }
1376 else if (strcmp(btag,"physicsEvent")__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(btag) && __builtin_constant_p ("physicsEvent") &&
(__s1_len = strlen (btag), __s2_len = strlen ("physicsEvent"
), (!((size_t)(const void *)((btag) + 1) - (size_t)(const void
*)(btag) == 1) || __s1_len >= 4) && (!((size_t)(const
void *)(("physicsEvent") + 1) - (size_t)(const void *)("physicsEvent"
) == 1) || __s2_len >= 4)) ? __builtin_strcmp (btag, "physicsEvent"
) : (__builtin_constant_p (btag) && ((size_t)(const void
*)((btag) + 1) - (size_t)(const void *)(btag) == 1) &&
(__s1_len = strlen (btag), __s1_len < 4) ? (__builtin_constant_p
("physicsEvent") && ((size_t)(const void *)(("physicsEvent"
) + 1) - (size_t)(const void *)("physicsEvent") == 1) ? __builtin_strcmp
(btag, "physicsEvent") : (__extension__ ({ __const unsigned char
*__s2 = (__const unsigned char *) (__const char *) ("physicsEvent"
); register int __result = (((__const unsigned char *) (__const
char *) (btag))[0] - __s2[0]); if (__s1_len > 0 &&
__result == 0) { __result = (((__const unsigned char *) (__const
char *) (btag))[1] - __s2[1]); if (__s1_len > 1 &&
__result == 0) { __result = (((__const unsigned char *) (__const
char *) (btag))[2] - __s2[2]); if (__s1_len > 2 &&
__result == 0) __result = (((__const unsigned char *) (__const
char *) (btag))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p
("physicsEvent") && ((size_t)(const void *)(("physicsEvent"
) + 1) - (size_t)(const void *)("physicsEvent") == 1) &&
(__s2_len = strlen ("physicsEvent"), __s2_len < 4) ? (__builtin_constant_p
(btag) && ((size_t)(const void *)((btag) + 1) - (size_t
)(const void *)(btag) == 1) ? __builtin_strcmp (btag, "physicsEvent"
) : (__extension__ ({ __const unsigned char *__s1 = (__const unsigned
char *) (__const char *) (btag); register int __result = __s1
[0] - ((__const unsigned char *) (__const char *) ("physicsEvent"
))[0]; if (__s2_len > 0 && __result == 0) { __result
= (__s1[1] - ((__const unsigned char *) (__const char *) ("physicsEvent"
))[1]); if (__s2_len > 1 && __result == 0) { __result
= (__s1[2] - ((__const unsigned char *) (__const char *) ("physicsEvent"
))[2]); if (__s2_len > 2 && __result == 0) __result
= (__s1[3] - ((__const unsigned char *) (__const char *) ("physicsEvent"
))[3]); } } __result; }))) : __builtin_strcmp (btag, "physicsEvent"
)))); }) == 0)
1377 {
1378 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_mc_s_PhysicsEvents;
1379 }
1380 else if (strcmp(btag,"reaction")__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(btag) && __builtin_constant_p ("reaction") &&
(__s1_len = strlen (btag), __s2_len = strlen ("reaction"), (
!((size_t)(const void *)((btag) + 1) - (size_t)(const void *)
(btag) == 1) || __s1_len >= 4) && (!((size_t)(const
void *)(("reaction") + 1) - (size_t)(const void *)("reaction"
) == 1) || __s2_len >= 4)) ? __builtin_strcmp (btag, "reaction"
) : (__builtin_constant_p (btag) && ((size_t)(const void
*)((btag) + 1) - (size_t)(const void *)(btag) == 1) &&
(__s1_len = strlen (btag), __s1_len < 4) ? (__builtin_constant_p
("reaction") && ((size_t)(const void *)(("reaction")
+ 1) - (size_t)(const void *)("reaction") == 1) ? __builtin_strcmp
(btag, "reaction") : (__extension__ ({ __const unsigned char
*__s2 = (__const unsigned char *) (__const char *) ("reaction"
); register int __result = (((__const unsigned char *) (__const
char *) (btag))[0] - __s2[0]); if (__s1_len > 0 &&
__result == 0) { __result = (((__const unsigned char *) (__const
char *) (btag))[1] - __s2[1]); if (__s1_len > 1 &&
__result == 0) { __result = (((__const unsigned char *) (__const
char *) (btag))[2] - __s2[2]); if (__s1_len > 2 &&
__result == 0) __result = (((__const unsigned char *) (__const
char *) (btag))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p
("reaction") && ((size_t)(const void *)(("reaction")
+ 1) - (size_t)(const void *)("reaction") == 1) && (
__s2_len = strlen ("reaction"), __s2_len < 4) ? (__builtin_constant_p
(btag) && ((size_t)(const void *)((btag) + 1) - (size_t
)(const void *)(btag) == 1) ? __builtin_strcmp (btag, "reaction"
) : (__extension__ ({ __const unsigned char *__s1 = (__const unsigned
char *) (__const char *) (btag); register int __result = __s1
[0] - ((__const unsigned char *) (__const char *) ("reaction"
))[0]; if (__s2_len > 0 && __result == 0) { __result
= (__s1[1] - ((__const unsigned char *) (__const char *) ("reaction"
))[1]); if (__s2_len > 1 && __result == 0) { __result
= (__s1[2] - ((__const unsigned char *) (__const char *) ("reaction"
))[2]); if (__s2_len > 2 && __result == 0) __result
= (__s1[3] - ((__const unsigned char *) (__const char *) ("reaction"
))[3]); } } __result; }))) : __builtin_strcmp (btag, "reaction"
)))); }) == 0)
1381 {
1382 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_mc_s_Reactions;
1383 }
1384 else if (strcmp(btag,"beam")__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(btag) && __builtin_constant_p ("beam") && (
__s1_len = strlen (btag), __s2_len = strlen ("beam"), (!((size_t
)(const void *)((btag) + 1) - (size_t)(const void *)(btag) ==
1) || __s1_len >= 4) && (!((size_t)(const void *)
(("beam") + 1) - (size_t)(const void *)("beam") == 1) || __s2_len
>= 4)) ? __builtin_strcmp (btag, "beam") : (__builtin_constant_p
(btag) && ((size_t)(const void *)((btag) + 1) - (size_t
)(const void *)(btag) == 1) && (__s1_len = strlen (btag
), __s1_len < 4) ? (__builtin_constant_p ("beam") &&
((size_t)(const void *)(("beam") + 1) - (size_t)(const void *
)("beam") == 1) ? __builtin_strcmp (btag, "beam") : (__extension__
({ __const unsigned char *__s2 = (__const unsigned char *) (
__const char *) ("beam"); register int __result = (((__const unsigned
char *) (__const char *) (btag))[0] - __s2[0]); if (__s1_len
> 0 && __result == 0) { __result = (((__const unsigned
char *) (__const char *) (btag))[1] - __s2[1]); if (__s1_len
> 1 && __result == 0) { __result = (((__const unsigned
char *) (__const char *) (btag))[2] - __s2[2]); if (__s1_len
> 2 && __result == 0) __result = (((__const unsigned
char *) (__const char *) (btag))[3] - __s2[3]); } } __result
; }))) : (__builtin_constant_p ("beam") && ((size_t)(
const void *)(("beam") + 1) - (size_t)(const void *)("beam") ==
1) && (__s2_len = strlen ("beam"), __s2_len < 4) ?
(__builtin_constant_p (btag) && ((size_t)(const void
*)((btag) + 1) - (size_t)(const void *)(btag) == 1) ? __builtin_strcmp
(btag, "beam") : (__extension__ ({ __const unsigned char *__s1
= (__const unsigned char *) (__const char *) (btag); register
int __result = __s1[0] - ((__const unsigned char *) (__const
char *) ("beam"))[0]; if (__s2_len > 0 && __result
== 0) { __result = (__s1[1] - ((__const unsigned char *) (__const
char *) ("beam"))[1]); if (__s2_len > 1 && __result
== 0) { __result = (__s1[2] - ((__const unsigned char *) (__const
char *) ("beam"))[2]); if (__s2_len > 2 && __result
== 0) __result = (__s1[3] - ((__const unsigned char *) (__const
char *) ("beam"))[3]); } } __result; }))) : __builtin_strcmp
(btag, "beam")))); }) == 0)
1385 {
1386 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_mc_s_Beam;
1387 }
1388 else if (strcmp(btag,"momentum")__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(btag) && __builtin_constant_p ("momentum") &&
(__s1_len = strlen (btag), __s2_len = strlen ("momentum"), (
!((size_t)(const void *)((btag) + 1) - (size_t)(const void *)
(btag) == 1) || __s1_len >= 4) && (!((size_t)(const
void *)(("momentum") + 1) - (size_t)(const void *)("momentum"
) == 1) || __s2_len >= 4)) ? __builtin_strcmp (btag, "momentum"
) : (__builtin_constant_p (btag) && ((size_t)(const void
*)((btag) + 1) - (size_t)(const void *)(btag) == 1) &&
(__s1_len = strlen (btag), __s1_len < 4) ? (__builtin_constant_p
("momentum") && ((size_t)(const void *)(("momentum")
+ 1) - (size_t)(const void *)("momentum") == 1) ? __builtin_strcmp
(btag, "momentum") : (__extension__ ({ __const unsigned char
*__s2 = (__const unsigned char *) (__const char *) ("momentum"
); register int __result = (((__const unsigned char *) (__const
char *) (btag))[0] - __s2[0]); if (__s1_len > 0 &&
__result == 0) { __result = (((__const unsigned char *) (__const
char *) (btag))[1] - __s2[1]); if (__s1_len > 1 &&
__result == 0) { __result = (((__const unsigned char *) (__const
char *) (btag))[2] - __s2[2]); if (__s1_len > 2 &&
__result == 0) __result = (((__const unsigned char *) (__const
char *) (btag))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p
("momentum") && ((size_t)(const void *)(("momentum")
+ 1) - (size_t)(const void *)("momentum") == 1) && (
__s2_len = strlen ("momentum"), __s2_len < 4) ? (__builtin_constant_p
(btag) && ((size_t)(const void *)((btag) + 1) - (size_t
)(const void *)(btag) == 1) ? __builtin_strcmp (btag, "momentum"
) : (__extension__ ({ __const unsigned char *__s1 = (__const unsigned
char *) (__const char *) (btag); register int __result = __s1
[0] - ((__const unsigned char *) (__const char *) ("momentum"
))[0]; if (__s2_len > 0 && __result == 0) { __result
= (__s1[1] - ((__const unsigned char *) (__const char *) ("momentum"
))[1]); if (__s2_len > 1 && __result == 0) { __result
= (__s1[2] - ((__const unsigned char *) (__const char *) ("momentum"
))[2]); if (__s2_len > 2 && __result == 0) __result
= (__s1[3] - ((__const unsigned char *) (__const char *) ("momentum"
))[3]); } } __result; }))) : __builtin_strcmp (btag, "momentum"
)))); }) == 0)
1389 {
1390 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_mc_s_Momentum;
1391 }
1392 else if (strcmp(btag,"properties")__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(btag) && __builtin_constant_p ("properties") &&
(__s1_len = strlen (btag), __s2_len = strlen ("properties"),
(!((size_t)(const void *)((btag) + 1) - (size_t)(const void *
)(btag) == 1) || __s1_len >= 4) && (!((size_t)(const
void *)(("properties") + 1) - (size_t)(const void *)("properties"
) == 1) || __s2_len >= 4)) ? __builtin_strcmp (btag, "properties"
) : (__builtin_constant_p (btag) && ((size_t)(const void
*)((btag) + 1) - (size_t)(const void *)(btag) == 1) &&
(__s1_len = strlen (btag), __s1_len < 4) ? (__builtin_constant_p
("properties") && ((size_t)(const void *)(("properties"
) + 1) - (size_t)(const void *)("properties") == 1) ? __builtin_strcmp
(btag, "properties") : (__extension__ ({ __const unsigned char
*__s2 = (__const unsigned char *) (__const char *) ("properties"
); register int __result = (((__const unsigned char *) (__const
char *) (btag))[0] - __s2[0]); if (__s1_len > 0 &&
__result == 0) { __result = (((__const unsigned char *) (__const
char *) (btag))[1] - __s2[1]); if (__s1_len > 1 &&
__result == 0) { __result = (((__const unsigned char *) (__const
char *) (btag))[2] - __s2[2]); if (__s1_len > 2 &&
__result == 0) __result = (((__const unsigned char *) (__const
char *) (btag))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p
("properties") && ((size_t)(const void *)(("properties"
) + 1) - (size_t)(const void *)("properties") == 1) &&
(__s2_len = strlen ("properties"), __s2_len < 4) ? (__builtin_constant_p
(btag) && ((size_t)(const void *)((btag) + 1) - (size_t
)(const void *)(btag) == 1) ? __builtin_strcmp (btag, "properties"
) : (__extension__ ({ __const unsigned char *__s1 = (__const unsigned
char *) (__const char *) (btag); register int __result = __s1
[0] - ((__const unsigned char *) (__const char *) ("properties"
))[0]; if (__s2_len > 0 && __result == 0) { __result
= (__s1[1] - ((__const unsigned char *) (__const char *) ("properties"
))[1]); if (__s2_len > 1 && __result == 0) { __result
= (__s1[2] - ((__const unsigned char *) (__const char *) ("properties"
))[2]); if (__s2_len > 2 && __result == 0) __result
= (__s1[3] - ((__const unsigned char *) (__const char *) ("properties"
))[3]); } } __result; }))) : __builtin_strcmp (btag, "properties"
)))); }) == 0)
1393 {
1394 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_mc_s_Properties;
1395 }
1396 else if (strcmp(btag,"target")__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(btag) && __builtin_constant_p ("target") &&
(__s1_len = strlen (btag), __s2_len = strlen ("target"), (!(
(size_t)(const void *)((btag) + 1) - (size_t)(const void *)(btag
) == 1) || __s1_len >= 4) && (!((size_t)(const void
*)(("target") + 1) - (size_t)(const void *)("target") == 1) ||
__s2_len >= 4)) ? __builtin_strcmp (btag, "target") : (__builtin_constant_p
(btag) && ((size_t)(const void *)((btag) + 1) - (size_t
)(const void *)(btag) == 1) && (__s1_len = strlen (btag
), __s1_len < 4) ? (__builtin_constant_p ("target") &&
((size_t)(const void *)(("target") + 1) - (size_t)(const void
*)("target") == 1) ? __builtin_strcmp (btag, "target") : (__extension__
({ __const unsigned char *__s2 = (__const unsigned char *) (
__const char *) ("target"); register int __result = (((__const
unsigned char *) (__const char *) (btag))[0] - __s2[0]); if (
__s1_len > 0 && __result == 0) { __result = (((__const
unsigned char *) (__const char *) (btag))[1] - __s2[1]); if (
__s1_len > 1 && __result == 0) { __result = (((__const
unsigned char *) (__const char *) (btag))[2] - __s2[2]); if (
__s1_len > 2 && __result == 0) __result = (((__const
unsigned char *) (__const char *) (btag))[3] - __s2[3]); } }
__result; }))) : (__builtin_constant_p ("target") &&
((size_t)(const void *)(("target") + 1) - (size_t)(const void
*)("target") == 1) && (__s2_len = strlen ("target"),
__s2_len < 4) ? (__builtin_constant_p (btag) && (
(size_t)(const void *)((btag) + 1) - (size_t)(const void *)(btag
) == 1) ? __builtin_strcmp (btag, "target") : (__extension__ (
{ __const unsigned char *__s1 = (__const unsigned char *) (__const
char *) (btag); register int __result = __s1[0] - ((__const unsigned
char *) (__const char *) ("target"))[0]; if (__s2_len > 0
&& __result == 0) { __result = (__s1[1] - ((__const unsigned
char *) (__const char *) ("target"))[1]); if (__s2_len > 1
&& __result == 0) { __result = (__s1[2] - ((__const unsigned
char *) (__const char *) ("target"))[2]); if (__s2_len > 2
&& __result == 0) __result = (__s1[3] - ((__const unsigned
char *) (__const char *) ("target"))[3]); } } __result; })))
: __builtin_strcmp (btag, "target")))); }) == 0)
1397 {
1398 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_mc_s_Target;
1399 }
1400 else if (strcmp(btag,"vertex")__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(btag) && __builtin_constant_p ("vertex") &&
(__s1_len = strlen (btag), __s2_len = strlen ("vertex"), (!(
(size_t)(const void *)((btag) + 1) - (size_t)(const void *)(btag
) == 1) || __s1_len >= 4) && (!((size_t)(const void
*)(("vertex") + 1) - (size_t)(const void *)("vertex") == 1) ||
__s2_len >= 4)) ? __builtin_strcmp (btag, "vertex") : (__builtin_constant_p
(btag) && ((size_t)(const void *)((btag) + 1) - (size_t
)(const void *)(btag) == 1) && (__s1_len = strlen (btag
), __s1_len < 4) ? (__builtin_constant_p ("vertex") &&
((size_t)(const void *)(("vertex") + 1) - (size_t)(const void
*)("vertex") == 1) ? __builtin_strcmp (btag, "vertex") : (__extension__
({ __const unsigned char *__s2 = (__const unsigned char *) (
__const char *) ("vertex"); register int __result = (((__const
unsigned char *) (__const char *) (btag))[0] - __s2[0]); if (
__s1_len > 0 && __result == 0) { __result = (((__const
unsigned char *) (__const char *) (btag))[1] - __s2[1]); if (
__s1_len > 1 && __result == 0) { __result = (((__const
unsigned char *) (__const char *) (btag))[2] - __s2[2]); if (
__s1_len > 2 && __result == 0) __result = (((__const
unsigned char *) (__const char *) (btag))[3] - __s2[3]); } }
__result; }))) : (__builtin_constant_p ("vertex") &&
((size_t)(const void *)(("vertex") + 1) - (size_t)(const void
*)("vertex") == 1) && (__s2_len = strlen ("vertex"),
__s2_len < 4) ? (__builtin_constant_p (btag) && (
(size_t)(const void *)((btag) + 1) - (size_t)(const void *)(btag
) == 1) ? __builtin_strcmp (btag, "vertex") : (__extension__ (
{ __const unsigned char *__s1 = (__const unsigned char *) (__const
char *) (btag); register int __result = __s1[0] - ((__const unsigned
char *) (__const char *) ("vertex"))[0]; if (__s2_len > 0
&& __result == 0) { __result = (__s1[1] - ((__const unsigned
char *) (__const char *) ("vertex"))[1]); if (__s2_len > 1
&& __result == 0) { __result = (__s1[2] - ((__const unsigned
char *) (__const char *) ("vertex"))[2]); if (__s2_len > 2
&& __result == 0) __result = (__s1[3] - ((__const unsigned
char *) (__const char *) ("vertex"))[3]); } } __result; })))
: __builtin_strcmp (btag, "vertex")))); }) == 0)
1401 {
1402 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_mc_s_Vertices;
1403 }
1404 else if (strcmp(btag,"product")__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(btag) && __builtin_constant_p ("product") &&
(__s1_len = strlen (btag), __s2_len = strlen ("product"), (!
((size_t)(const void *)((btag) + 1) - (size_t)(const void *)(
btag) == 1) || __s1_len >= 4) && (!((size_t)(const
void *)(("product") + 1) - (size_t)(const void *)("product")
== 1) || __s2_len >= 4)) ? __builtin_strcmp (btag, "product"
) : (__builtin_constant_p (btag) && ((size_t)(const void
*)((btag) + 1) - (size_t)(const void *)(btag) == 1) &&
(__s1_len = strlen (btag), __s1_len < 4) ? (__builtin_constant_p
("product") && ((size_t)(const void *)(("product") +
1) - (size_t)(const void *)("product") == 1) ? __builtin_strcmp
(btag, "product") : (__extension__ ({ __const unsigned char *
__s2 = (__const unsigned char *) (__const char *) ("product")
; register int __result = (((__const unsigned char *) (__const
char *) (btag))[0] - __s2[0]); if (__s1_len > 0 &&
__result == 0) { __result = (((__const unsigned char *) (__const
char *) (btag))[1] - __s2[1]); if (__s1_len > 1 &&
__result == 0) { __result = (((__const unsigned char *) (__const
char *) (btag))[2] - __s2[2]); if (__s1_len > 2 &&
__result == 0) __result = (((__const unsigned char *) (__const
char *) (btag))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p
("product") && ((size_t)(const void *)(("product") +
1) - (size_t)(const void *)("product") == 1) && (__s2_len
= strlen ("product"), __s2_len < 4) ? (__builtin_constant_p
(btag) && ((size_t)(const void *)((btag) + 1) - (size_t
)(const void *)(btag) == 1) ? __builtin_strcmp (btag, "product"
) : (__extension__ ({ __const unsigned char *__s1 = (__const unsigned
char *) (__const char *) (btag); register int __result = __s1
[0] - ((__const unsigned char *) (__const char *) ("product")
)[0]; if (__s2_len > 0 && __result == 0) { __result
= (__s1[1] - ((__const unsigned char *) (__const char *) ("product"
))[1]); if (__s2_len > 1 && __result == 0) { __result
= (__s1[2] - ((__const unsigned char *) (__const char *) ("product"
))[2]); if (__s2_len > 2 && __result == 0) __result
= (__s1[3] - ((__const unsigned char *) (__const char *) ("product"
))[3]); } } __result; }))) : __builtin_strcmp (btag, "product"
)))); }) == 0)
1405 {
1406 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_mc_s_Products;
1407 }
1408 else if (strcmp(btag,"origin")__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(btag) && __builtin_constant_p ("origin") &&
(__s1_len = strlen (btag), __s2_len = strlen ("origin"), (!(
(size_t)(const void *)((btag) + 1) - (size_t)(const void *)(btag
) == 1) || __s1_len >= 4) && (!((size_t)(const void
*)(("origin") + 1) - (size_t)(const void *)("origin") == 1) ||
__s2_len >= 4)) ? __builtin_strcmp (btag, "origin") : (__builtin_constant_p
(btag) && ((size_t)(const void *)((btag) + 1) - (size_t
)(const void *)(btag) == 1) && (__s1_len = strlen (btag
), __s1_len < 4) ? (__builtin_constant_p ("origin") &&
((size_t)(const void *)(("origin") + 1) - (size_t)(const void
*)("origin") == 1) ? __builtin_strcmp (btag, "origin") : (__extension__
({ __const unsigned char *__s2 = (__const unsigned char *) (
__const char *) ("origin"); register int __result = (((__const
unsigned char *) (__const char *) (btag))[0] - __s2[0]); if (
__s1_len > 0 && __result == 0) { __result = (((__const
unsigned char *) (__const char *) (btag))[1] - __s2[1]); if (
__s1_len > 1 && __result == 0) { __result = (((__const
unsigned char *) (__const char *) (btag))[2] - __s2[2]); if (
__s1_len > 2 && __result == 0) __result = (((__const
unsigned char *) (__const char *) (btag))[3] - __s2[3]); } }
__result; }))) : (__builtin_constant_p ("origin") &&
((size_t)(const void *)(("origin") + 1) - (size_t)(const void
*)("origin") == 1) && (__s2_len = strlen ("origin"),
__s2_len < 4) ? (__builtin_constant_p (btag) && (
(size_t)(const void *)((btag) + 1) - (size_t)(const void *)(btag
) == 1) ? __builtin_strcmp (btag, "origin") : (__extension__ (
{ __const unsigned char *__s1 = (__const unsigned char *) (__const
char *) (btag); register int __result = __s1[0] - ((__const unsigned
char *) (__const char *) ("origin"))[0]; if (__s2_len > 0
&& __result == 0) { __result = (__s1[1] - ((__const unsigned
char *) (__const char *) ("origin"))[1]); if (__s2_len > 1
&& __result == 0) { __result = (__s1[2] - ((__const unsigned
char *) (__const char *) ("origin"))[2]); if (__s2_len > 2
&& __result == 0) __result = (__s1[3] - ((__const unsigned
char *) (__const char *) ("origin"))[3]); } } __result; })))
: __builtin_strcmp (btag, "origin")))); }) == 0)
1409 {
1410 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_mc_s_Origin;
1411 }
1412 else if (strcmp(btag,"random")__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(btag) && __builtin_constant_p ("random") &&
(__s1_len = strlen (btag), __s2_len = strlen ("random"), (!(
(size_t)(const void *)((btag) + 1) - (size_t)(const void *)(btag
) == 1) || __s1_len >= 4) && (!((size_t)(const void
*)(("random") + 1) - (size_t)(const void *)("random") == 1) ||
__s2_len >= 4)) ? __builtin_strcmp (btag, "random") : (__builtin_constant_p
(btag) && ((size_t)(const void *)((btag) + 1) - (size_t
)(const void *)(btag) == 1) && (__s1_len = strlen (btag
), __s1_len < 4) ? (__builtin_constant_p ("random") &&
((size_t)(const void *)(("random") + 1) - (size_t)(const void
*)("random") == 1) ? __builtin_strcmp (btag, "random") : (__extension__
({ __const unsigned char *__s2 = (__const unsigned char *) (
__const char *) ("random"); register int __result = (((__const
unsigned char *) (__const char *) (btag))[0] - __s2[0]); if (
__s1_len > 0 && __result == 0) { __result = (((__const
unsigned char *) (__const char *) (btag))[1] - __s2[1]); if (
__s1_len > 1 && __result == 0) { __result = (((__const
unsigned char *) (__const char *) (btag))[2] - __s2[2]); if (
__s1_len > 2 && __result == 0) __result = (((__const
unsigned char *) (__const char *) (btag))[3] - __s2[3]); } }
__result; }))) : (__builtin_constant_p ("random") &&
((size_t)(const void *)(("random") + 1) - (size_t)(const void
*)("random") == 1) && (__s2_len = strlen ("random"),
__s2_len < 4) ? (__builtin_constant_p (btag) && (
(size_t)(const void *)((btag) + 1) - (size_t)(const void *)(btag
) == 1) ? __builtin_strcmp (btag, "random") : (__extension__ (
{ __const unsigned char *__s1 = (__const unsigned char *) (__const
char *) (btag); register int __result = __s1[0] - ((__const unsigned
char *) (__const char *) ("random"))[0]; if (__s2_len > 0
&& __result == 0) { __result = (__s1[1] - ((__const unsigned
char *) (__const char *) ("random"))[1]); if (__s2_len > 1
&& __result == 0) { __result = (__s1[2] - ((__const unsigned
char *) (__const char *) ("random"))[2]); if (__s2_len > 2
&& __result == 0) __result = (__s1[3] - ((__const unsigned
char *) (__const char *) ("random"))[3]); } } __result; })))
: __builtin_strcmp (btag, "random")))); }) == 0)
1413 {
1414 this1->unpacker = (void*(*)(XDR*,popNode*))unpack_mc_s_Random;
1415 }
1416 this1->inParent = ptrSeqNo;
1417 this1->popListLength = 0;
1418 c = index(c+1,'\n');
1419 b = index(b+1,'\n');
1420 while (getTag(b,btag) > blevel)
1421 {
1422 this1->popList[this1->popListLength++] = matches(b,c);
1423 if (this1->popListLength > 99)
1424 {
1425 fprintf(stderrstderr,"hddm error - popList overflow.\n");
1426 fprintf(stderrstderr,"Increase MAX_POPLIST_LENGTH and recompile.\n");
1427 exit(9);
1428 }
1429 b = getEndTag(b,btag);
1430 b = index(b+1,'\n');
1431 }
1432 return this1;
1433 }
1434 else
1435 {
1436 c = getEndTag(c,ctag);
1437 c = index(c+1,'\n');
1438 ++ptrSeqNo;
1439 }
1440 }
1441 return 0;
1442}
1443
1444mc_s_iostream_t* open_mc_s_HDDM(char* filename)
1445{
1446 mc_s_iostream_t* fp = (mc_s_iostream_t*)malloc(sizeof(mc_s_iostream_t));
1447 char* p;
1448 char* head;
1449 char* nullfilename="";
1450 if (filename)
1451 {
1452 fp->fd = fopen(filename,"r");
1453 }
1454 else
1455 {
1456 fp->fd = fdopen(0,"r");
1457 filename = nullfilename;
1458 }
1459 if (fp->fd == 0)
1460 {
1461 free(fp);
1462 return 0;
1463 }
1464 fp->iomode = HDDM_STREAM_INPUT-91;
1465 head = (char*)malloc(hddm_mc_s_headersize);
1466 if ((fgets(head,7,fp->fd) != 0) &&
1467 (strstr(head,"<HDDM ") != head))
1468 {
1469 fprintf(stderrstderr,"HDDM Error: input file ");
1470 fprintf(stderrstderr,"file does not have a ");
1471 fprintf(stderrstderr,"valid HDDM header.");
1472 fprintf(stderrstderr," Please check.\n");
1473 exit(9);
1474 }
1475 for (p = head+6;
1476 strstr(head,"</HDDM>") == 0;
1477 p += strlen(p))
1478 {
1479 if (p-head + 10 > hddm_mc_s_headersize)
1480 {
1481 fprintf(stderrstderr,"HDDM Error: ");
1482 fprintf(stderrstderr,"input template model overflows "
1483 "the hddm header input buffer, cannot continue.\n");
1484 fprintf(stderrstderr,"Please increase header buffer size using "
1485 "set_mc_s_HDDM_headersize(s) with s > %d.\n", hddm_mc_s_headersize);
1486 exit(9);
1487 }
1488 if (fgets(p,1000,fp->fd) == 0)
1489 {
1490 break;
1491 }
1492 }
1493 fp->popTop = matches(head,HDDM_mc_s_DocumentString);
1494 free(head);
1495 if (fp->popTop == 0 || fp->popTop->popListLength == 0)
1496 {
1497 fprintf(stderrstderr,"HDDM Error: ");
1498 fprintf(stderrstderr,"input template model ");
1499 fprintf(stderrstderr,"does not match c header.");
1500 fprintf(stderrstderr," Please recompile.\n");
1501 exit(9);
1502 }
1503 fp->filename = (char*)malloc(strlen(filename) + 1);
1504 strcpy(fp->filename,filename);
1505 fp->xdrs = (XDR*)malloc(sizeof(XDR));
1506 fp->iobuffer = (char*)malloc(fp->iobuffer_size = hddm_mc_s_buffersize);
1507 return fp;
1508}
1509
1510mc_s_iostream_t* init_mc_s_HDDM(char* filename)
1511{
1512 int len;
1513 char* head;
1514 char* nullfilename="";
1515 mc_s_iostream_t* fp = (mc_s_iostream_t*)malloc(sizeof(mc_s_iostream_t));
1516 if (filename)
1517 {
1518 fp->fd = fopen(filename,"w");
1519 }
1520 else
1521 {
1522 fp->fd = fdopen(1,"w");
1523 filename = nullfilename;
1524 }
1525 if (fp->fd == 0)
1526 {
1527 free(fp);
1528 return 0;
1529 }
1530 fp->iomode = HDDM_STREAM_OUTPUT-92;
1531 len = strlen(HDDM_mc_s_DocumentString);
1532 head = (char*)malloc(len+1);
1533 strcpy(head,HDDM_mc_s_DocumentString);
1534 if (fwrite(head,1,len,fp->fd) != len)
1535 {
1536 fprintf(stderrstderr,"HDDM Error: ");
1537 fprintf(stderrstderr,"error writing to ");
1538 fprintf(stderrstderr,"output file %s\n",filename);
1539 exit(9);
1540 }
1541 fp->filename = (char*)malloc(strlen(filename) + 1);
1542 strcpy(fp->filename,filename);
1543 fp->popTop = 0;
1544 fp->xdrs = (XDR*)malloc(sizeof(XDR));
1545 fp->iobuffer = (char*)malloc(fp->iobuffer_size = hddm_mc_s_buffersize);
1546 free(head);
1547 return fp;
1548}
1549
1550static void popaway(popNode* p)
1551{
1552 if (p)
1553 {
1554 int n;
1555 for (n = 0; n < p->popListLength; n++)
1556 {
1557 popaway(p->popList[n]);
1558 }
1559 free(p);
1560 }
1561}
1562
1563void close_mc_s_HDDM(mc_s_iostream_t* fp)
1564{
1565 xdr_destroy(fp->xdrs)do { if ((fp->xdrs)->x_ops->x_destroy) (*(fp->xdrs
)->x_ops->x_destroy)(fp->xdrs); } while (0);
1566 free(fp->xdrs);
1567 free(fp->iobuffer);
1568 fclose(fp->fd);
1569 free(fp->filename);
1570 popaway(fp->popTop);
1571 free(fp);
1572}