| Geant4 Cross Reference |
1 /* 1
2 # <<BEGIN-copyright>>
3 # <<END-copyright>>
4 */
5 #include <string.h>
6 #include <limits.h>
7 #include <PoPs.h>
8 #include "MCGIDI_map.h"
9 #include <xDataTOM_importXML_private.h>
10
11 #ifndef PATH_MAX
12 #define PATH_MAX 4096
13 #endif
14
15 #if defined(WIN32) || defined(__MINGW32__)
16 #include <windows.h>
17 #define realpath( a, b ) GetFullPathName( a, P
18 #endif
19
20 static int aliasesNeeded = 1;
21
22 #if defined __cplusplus
23 extern "C" {
24 namespace GIDI {
25 using namespace GIDI;
26 #endif
27 static MCGIDI_mapEntry *_MCGIDI_map_addEntry(
28 const char *evaluation, const char *projec
29 static char *_MCGIDI_map_findTargetViaPoPIDs2(
30 int projectile_PoPID, int target_P
31 static int _MCGIDI_map_findAllOfTargetViaPoPID
32 int projectile_PoPID, int target_PoPID
33 static int _MCGIDI_map_walkTree2( statusMessag
34 void *userData );
35 static void _MCGIDI_map_simpleWrite2( FILE *f,
36 static char *_MCGIDI_map_smrUserInterface( voi
37 #if defined __cplusplus
38 }
39 }
40 #endif
41
42 #if defined __cplusplus
43 namespace GIDI {
44 using namespace GIDI;
45 #endif
46 /*
47 **********************************************
48 */
49 MCGIDI_map *MCGIDI_map_new( statusMessageRepor
50
51 MCGIDI_map *map;
52
53 if( ( map = (MCGIDI_map *) smr_malloc2( sm
54 if( MCGIDI_map_initialize( smr, map ) ) ma
55 return( map );
56 }
57 /*
58 **********************************************
59 */
60 int MCGIDI_map_initialize( statusMessageReport
61
62 memset( map, 0, sizeof( MCGIDI_map ) );
63 map->status = MCGIDI_map_status_Ok;
64 map->smrUserInterface.smrUserInterface = _
65 map->smrUserInterface.map = map;
66 map->path = NULL;
67 map->mapFileName = NULL;
68 map->numberOfEntries = 0;
69 map->mapEntries = NULL;
70
71 /*
72 * Add some default aliases. This is a kludge
73 */
74 if( aliasesNeeded ) { /* Support all meta-stab
75 char const *aliases[] = { "Co58m1", "Ag11
76 char const *targets[] = { "Co58_e1", "Ag11
77 int i1, n1 = sizeof( aliases ) / sizeof( a
78
79
80 for( i1 = 0; i1 < n1; i1++ ) {
81 lPoPs_addParticleIfNeeded( smr, target
82 if( !smr_isOk( smr ) ) return( 1 );
83 PoPs_addAliasIfNeeded( smr, targets[i1
84 if( !smr_isOk( smr ) ) return( 1 );
85 }
86 aliasesNeeded = 0;
87 }
88 return( 0 );
89 }
90 /*
91 **********************************************
92 */
93 MCGIDI_map *MCGIDI_map_readFile( statusMessage
94 /*
95 * If an error occurrs, map is freed and NULL
96 */
97 int n = 0;
98 xDataXML_document *doc;
99 xDataXML_element *element;
100 xDataXML_element *child;
101 MCGIDI_map *map;
102 const char *evaluation, *projectile, *targ
103 char realPath[2 * ( PATH_MAX + 1 )], *p =
104
105 if( ( map = MCGIDI_map_new( smr ) ) == NUL
106
107 if( ( basePath == NULL ) || ( mapFileName[
108 strcpy( realPath, mapFileName ); }
109 else {
110 strcpy( realPath, basePath );
111 strcat( realPath, "/" );
112 strcat( realPath, mapFileName );
113 }
114 if( realpath( realPath, p ) == NULL ) {
115 smr_setReportError2( smr, smr_unknownI
116 return( (MCGIDI_map *) MCGIDI_map_free
117 }
118 n = (int) strlen( p ) + 2;
119 if( ( map->path = (char *) smr_malloc2( sm
120 map->mapFileName = &(map->path[n + 1]);
121 strcpy( map->mapFileName, p );
122 strcpy( map->path, p );
123 if( ( p = strrchr( map->path, '/' ) ) != N
124 *p = 0; }
125 else {
126 strcpy( map->path, "." );
127 }
128
129 if( ( doc = xDataXML_importFile2( smr, map
130
131 element = xDataXML_getDocumentsElement( do
132 for( child = xDataXML_getFirstElement( ele
133 if( strcmp( child->name, "path" ) == 0
134 if( ( path = xDataXML_getAttribute
135 smr_setReportError3p( smr, &(m
136 break;
137 }
138 MCGIDI_map_addPath( smr, map, path
139 else if( strcmp( child->name, "target"
140 if( ( schema = xDataXML_getAttribu
141 smr_setReportError3p( smr, &(m
142 break;
143 }
144 if( ( path = xDataXML_getAttribute
145 smr_setReportError3p( smr, &(m
146 break;
147 }
148 if( ( evaluation = xDataXML_getAtt
149 smr_setReportError3p( smr, &(m
150 break;
151 }
152 if( ( projectile = xDataXML_getAtt
153 smr_setReportError3p( smr, &(m
154 break;
155 }
156 if( ( targetName = xDataXML_getAtt
157 smr_setReportError3p( smr, &(m
158 break;
159 }
160 MCGIDI_map_addTarget( smr, map, sc
161 else {
162 smr_setReportError3( smr, &(map->s
163 }
164 if( !smr_isOk( smr ) ) break;
165 }
166 xDataXML_freeDoc( smr, doc );
167 if( !smr_isOk( smr ) ) map = (MCGIDI_map *
168 return( map );
169 }
170 /*
171 **********************************************
172 */
173 void *MCGIDI_map_free( statusMessageReporting
174
175 MCGIDI_map_release( smr, map );
176 smr_freeMemory( (void **) &map );
177 return( NULL );
178 }
179 /*
180 **********************************************
181 */
182 void MCGIDI_map_release( statusMessageReportin
183
184 MCGIDI_mapEntry *entry, *next;
185
186 if( map->path != NULL ) smr_freeMemory( (v
187 for( entry = map->mapEntries; entry != NUL
188 next = entry->next;
189 if( entry->schema != NULL ) smr_freeMe
190 if( entry->path != NULL ) smr_freeMemo
191 if( entry->evaluation != NULL ) smr_fr
192 if( entry->projectile != NULL ) smr_fr
193 if( entry->targetName != NULL ) smr_fr
194 if( entry->map != NULL ) MCGIDI_map_fr
195 smr_freeMemory( (void **) &entry );
196 }
197 map->numberOfEntries = 0;
198 map->mapEntries = NULL;
199 map->status = MCGIDI_map_status_Ok;
200 }
201 /*
202 **********************************************
203 */
204 MCGIDI_mapEntry *MCGIDI_map_getFirstEntry( MCG
205
206 return( map->mapEntries );
207 }
208 /*
209 **********************************************
210 */
211 MCGIDI_mapEntry *MCGIDI_map_getNextEntry( MCGI
212
213 return( entry->next );
214 }
215 /*
216 **********************************************
217 */
218 int MCGIDI_map_addTarget( statusMessageReporti
219
220 return( _MCGIDI_map_addEntry( smr, map, MC
221 }
222 /*
223 **********************************************
224 */
225 int MCGIDI_map_addPath( statusMessageReporting
226
227 MCGIDI_mapEntry *entry = _MCGIDI_map_addEn
228
229 if( entry != NULL ) {
230 if( ( entry->map = MCGIDI_map_readFile
231 }
232 return( entry != NULL );
233 }
234 /*
235 **********************************************
236 */
237 static MCGIDI_mapEntry *_MCGIDI_map_addEntry(
238 const char *path, const char *evaluation,
239
240 MCGIDI_mapEntry *p;
241 MCGIDI_mapEntry *entry;
242
243 if( ( entry = (MCGIDI_mapEntry * ) smr_mal
244 entry->next = NULL;
245 entry->type = type;
246 entry->parent = map;
247 entry->schema = NULL;
248 entry->path = NULL;
249 entry->evaluation = NULL;
250 entry->projectile = NULL;
251 entry->targetName = NULL;
252 entry->globalPoPsIndexProjectile = entry->
253 entry->map = NULL;
254
255 if( path != NULL ) {
256 if( ( entry->path = (char *) smr_mallo
257 strcpy( entry->path, path );
258 }
259
260 if( evaluation != NULL ) {
261 if( ( entry->evaluation = (char *) smr
262 strcpy( entry->evaluation, evaluation
263 }
264
265 if( projectile != NULL ) {
266 if( ( entry->globalPoPsIndexProjectile
267 if( ( entry->projectile = (char *) smr
268 strcpy( entry->projectile, projectile
269 }
270
271 if( targetName != NULL ) {
272 if( ( entry->globalPoPsIndexTarget = l
273 if( ( entry->targetName = (char *) smr
274 strcpy( entry->targetName, targetName
275 }
276
277 if( schema != NULL ) {
278 if( ( entry->schema = (char *) smr_mal
279 strcpy( entry->schema, schema );
280 }
281
282 if( map->mapEntries == NULL ) {
283 map->mapEntries = entry; }
284 else {
285 for( p = map->mapEntries; p->next != N
286 p->next = entry;
287 }
288 map->numberOfEntries++;
289 return( entry );
290
291 err:
292 smr_freeMemory( (void **) &(entry->path) )
293 smr_freeMemory( (void **) &(entry->evaluat
294 smr_freeMemory( (void **) &(entry->project
295 smr_freeMemory( (void **) &(entry->targetN
296 smr_freeMemory( (void **) &entry );
297 return( NULL );
298 }
299 /*
300 **********************************************
301 */
302 char *MCGIDI_map_findTargetViaPoPIDs( statusMe
303 int projectile_PoPID, int target_PoPID ) {
304 /*
305 * Calling routine must free returned pointer.
306 */
307 char *path;
308 char const *projectileName = PoPs_getName_
309 char const *targetName = PoPs_getName_atIn
310
311 if( !smr_isOk( smr ) ) return( NULL );
312 if( map->status != MCGIDI_map_status_Ok )
313
314 path = _MCGIDI_map_findTargetViaPoPIDs2( s
315 if( ( path == NULL ) && smr_isOk( smr ) )
316 if( evaluation == NULL ) {
317 smr_setReportInfo3( smr, &(map->sm
318 targetName, projectileName );
319 else {
320 smr_setReportInfo3( smr, &(map->sm
321 targetName, projectileName, ev
322 }
323 }
324 return( path );
325 }
326 /*
327 **********************************************
328 */
329 static char *_MCGIDI_map_findTargetViaPoPIDs2(
330 int projectile_PoPID, int target_P
331
332 MCGIDI_mapEntry *entry;
333 char *path = NULL;
334 int n, status;
335
336 if( evaluation != NULL ) {
337 if( strlen( evaluation ) == 0 ) evalua
338 }
339
340 for( entry = map->mapEntries; entry != NUL
341 switch( entry->type ) {
342 case MCGIDI_mapEntry_type_target :
343 if( ( projectile_PoPID == entry->g
344 if( evaluation == NULL ) {
345 status = 1; }
346 else {
347 status = strcmp( evaluatio
348 }
349 if( status ) {
350 n = (int) strlen( map->pat
351 if( ( path = (char * ) smr
352 strcpy( path, map->path );
353 strcat( path, "/" );
354 if( entry->path[0] == '/'
355 strcpy( path, entry->p
356 else {
357 strcat( path, entry->p
358 }
359 return( path );
360 }
361 }
362 break;
363 case MCGIDI_mapEntry_type_path :
364 if( ( path = _MCGIDI_map_findTarge
365 break;
366 default :
367 smr_setReportInfo3( smr, &(map->sm
368 return( NULL );
369 }
370 }
371 return( NULL );
372 }
373 /*
374 **********************************************
375 */
376 char *MCGIDI_map_findTarget( statusMessageRepo
377
378 int projectile_PoPID, target_PoPID;
379
380 if( ( projectile_PoPID = lPoPs_addParticle
381 if( ( target_PoPID = lPoPs_addParticle
382 return( MCGIDI_map_findTargetViaPoPIDs( sm
383 }
384 /*
385 **********************************************
386 */
387 MCGIDI_map *MCGIDI_map_findAllOfTargetViaPoPID
388 int target_PoPID ) {
389 /*
390 * Calling routine must free returned pointer.
391 */
392 int status;
393 MCGIDI_map *mapAllOfTarget;
394
395 if( map->status != MCGIDI_map_status_Ok )
396 if( ( mapAllOfTarget = MCGIDI_map_new( smr
397 status = _MCGIDI_map_findAllOfTargetViaPoP
398 if( ( status != 0 ) ) mapAllOfTarget = (MC
399 return( mapAllOfTarget );
400 }
401 /*
402 **********************************************
403 */
404 static int _MCGIDI_map_findAllOfTargetViaPoPID
405 int projectile_PoPID, int target_PoPID
406
407 MCGIDI_mapEntry *entry;
408
409 for( entry = map->mapEntries; entry != NUL
410 switch( entry->type ) {
411 case MCGIDI_mapEntry_type_target :
412 if( ( projectile_PoPID == entry->g
413 if( _MCGIDI_map_addEntry( smr,
414 entry->targetName ) == NUL
415 }
416 break;
417 case MCGIDI_mapEntry_type_path :
418 if( _MCGIDI_map_findAllOfTargetVia
419 break;
420 default :
421 smr_setReportInfo3( smr, &(map->sm
422 return( 1 );
423 }
424 }
425 return( 0 );
426 }
427 /*
428 **********************************************
429 */
430 MCGIDI_map *MCGIDI_map_findAllOfTarget( status
431
432 int projectile_PoPID, target_PoPID;
433
434 if( ( projectile_PoPID = lPoPs_addParticle
435 if( ( target_PoPID = lPoPs_addParticle
436 return( MCGIDI_map_findAllOfTargetViaPoPID
437 }
438 /*
439 **********************************************
440 */
441 char *MCGIDI_map_getFullPath( statusMessageRep
442
443 char *path;
444
445 if( endPath[0] == '/' ) {
446 if( ( path = (char *) smr_malloc2( smr
447 path[0] = 0; }
448 else {
449 if( ( path = (char *) smr_malloc2( smr
450 strcpy( path, map->path );
451 strcat( path, "/" );
452 }
453 strcat( path, endPath );
454 return( path );
455 }
456 /*
457 **********************************************
458 */
459 char *MCGIDI_map_getTargetsFullPath( statusMes
460
461 char *path = NULL;
462 MCGIDI_map *map = target->parent;
463
464 switch( target->type ) {
465 case MCGIDI_mapEntry_type_target :
466 path = MCGIDI_map_getFullPath( smr, ma
467 break;
468 case MCGIDI_mapEntry_type_path :
469 smr_setReportInfo3p( smr, &(map->smrUs
470 break;
471 default :
472 smr_setReportInfo3( smr, &(map->smrUse
473 break;
474 }
475 return( path );
476 }
477 /*
478 **********************************************
479 */
480 static int _MCGIDI_map_walkTree2( statusMessag
481 void *userData ) {
482
483 MCGIDI_mapEntry *entry;
484
485 for( entry = map->mapEntries; entry != NUL
486 if( handler( entry, level, userData )
487 if( entry->type == MCGIDI_mapEntry_typ
488 }
489 return( 0 );
490 }
491 /*
492 **********************************************
493 */
494 int MCGIDI_map_walkTree( statusMessageReportin
495
496 return( _MCGIDI_map_walkTree2( smr, map, 0
497 }
498 /*
499 **********************************************
500 */
501 char *MCGIDI_map_toXMLString( statusMessageRep
502
503 MCGIDI_mapEntry *entry;
504 char *s, *p;
505 char targetFormat[] = "<target schema=\"%s
506 char pathFormat[] = "<path projectile=\"%s
507 char start[] = "<map>\n";
508 char end[] = "</map>";
509 int n = 0, nStart = (int) strlen( start ),
510 int nTarget = (int) strlen( targetFormat )
511
512 if( map->status != MCGIDI_map_status_Ok )
513
514 n = nStart + nEnd + 1;
515 for( entry = map->mapEntries; entry != NUL
516 switch( entry->type ) {
517 case MCGIDI_mapEntry_type_target :
518 n += (int) ( strlen( entry->schema
519 break;
520 case MCGIDI_mapEntry_type_path :
521 n += (int ) strlen( entry->path )
522 break;
523 default :
524 smr_setReportInfo3( smr, &(map->sm
525 return( NULL );
526 }
527 }
528
529 if( ( s = (char *) smr_malloc2( smr, n, 0,
530 p = s;
531 strcpy( p, start );
532 while( *p ) p++; // Loop checking, 11.06.2
533 for( entry = map->mapEntries; entry != NUL
534 switch( entry->type ) {
535 case MCGIDI_mapEntry_type_target :
536 snprintf( p, sizeof start, targetF
537 break;
538 case MCGIDI_mapEntry_type_path :
539 snprintf( p, sizeof start, pathFor
540 break;
541 }
542 while( *p ) p++; // Loop checking, 11.
543 }
544 strcpy( p, end );
545 return( s );
546 }
547 /*
548 **********************************************
549 */
550 void MCGIDI_map_simpleWrite( FILE *f, MCGIDI_m
551 /*
552 **********************************************
553 */
554 static void _MCGIDI_map_simpleWrite2( FILE *f,
555
556 MCGIDI_mapEntry *entry;
557 char sLevel[] = " "
558 int n = (int ) strlen( sLevel ) / 4;
559
560 if( map->status != MCGIDI_map_status_Ok )
561 fprintf( f, "Bad map status = %d\n", m
562 return;
563 }
564 if( level < n ) sLevel[4 * level] = 0;
565 fprintf( f, "%smap->path = %s\n", sLevel,
566 fprintf( f, "%smap->mapFileName = %s\n", s
567 for( entry = map->mapEntries; entry != NUL
568 switch( entry->type ) {
569 case MCGIDI_mapEntry_type_target :
570 fprintf( f, "%sType = target: sche
571 entry->evaluation, entry->proj
572 break;
573 case MCGIDI_mapEntry_type_path :
574 fprintf( f, "%sType = path: path
575 _MCGIDI_map_simpleWrite2( f, entry
576 break;
577 default :
578 fprintf( f, "%sUnknown type = %d\n
579 }
580 }
581 }
582 /*
583 **********************************************
584 */
585 static char *_MCGIDI_map_smrUserInterface( voi
586
587 MCGIDI_map_smr *smrUserInterface = (MCGIDI
588
589 return( smr_allocateFormatMessage( "map fi
590 }
591
592 #if defined __cplusplus
593 }
594 #endif
595
596