ECCE @ EIC Software
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
MCGIDI_map.cc
Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file MCGIDI_map.cc
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"
10 
11 #ifndef PATH_MAX
12 #define PATH_MAX 4096
13 #endif
14 
15 #ifdef WIN32
16 #include <windows.h>
17 #define realpath( a, b ) GetFullPathName( a, PATH_MAX, b, NULL )
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( statusMessageReporting *smr, MCGIDI_map *map, enum MCGIDI_mapEntry_type type, const char *schema, const char *path,
28  const char *evaluation, const char *projectile, const char *target );
29 static char *_MCGIDI_map_findTargetViaPoPIDs2( statusMessageReporting *smr, MCGIDI_map *map, const char *evaluation,
30  int projectile_PoPID, int target_PoPID );
32  int projectile_PoPID, int target_PoPID );
33 static int _MCGIDI_map_walkTree2( statusMessageReporting *smr, MCGIDI_map *map, int level, int (*handler)( MCGIDI_mapEntry *entry, int level, void *userData),
34  void *userData );
35 static void _MCGIDI_map_simpleWrite2( FILE *f, MCGIDI_map *map, int level );
36 static char *_MCGIDI_map_smrUserInterface( void *userData );
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 */
50 
51  MCGIDI_map *map;
52 
53  if( ( map = (MCGIDI_map *) smr_malloc2( smr, sizeof( MCGIDI_map ), 0, "map" ) ) == NULL ) return( NULL );
54  if( MCGIDI_map_initialize( smr, map ) ) map = (MCGIDI_map *) MCGIDI_map_free( NULL, map );
55  return( map );
56 }
57 /*
58 ************************************************************
59 */
61 
62  memset( map, 0, sizeof( MCGIDI_map ) );
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 until aliases are fully supported.
73 */
74 if( aliasesNeeded ) { /* Support all meta-stables in ENDF/B-VII.1 */
75  char const *aliases[] = { "Co58m1", "Ag110m1", "Cd115m1", "Te127m1", "Te129m1", "Pm148m1", "Ho166m1", "Am242m1", "Am244m1", "Es254m1" };
76  char const *targets[] = { "Co58_e1", "Ag110_e2", "Cd115_e1", "Te127_e2", "Te129_e1", "Pm148_e2", "Ho166_e1", "Am242_e2", "Am244_e1", "Es254_e2" };
77  int i1, n1 = sizeof( aliases ) / sizeof( aliases[1] );
78 
79 
80  for( i1 = 0; i1 < n1; i1++ ) {
81  lPoPs_addParticleIfNeeded( smr, targets[i1], NULL );
82  if( !smr_isOk( smr ) ) return( 1 );
83  PoPs_addAliasIfNeeded( smr, targets[i1], aliases[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( statusMessageReporting *smr, const char *basePath, const char *mapFileName ) {
94 /*
95 * If an error occurrs, map is freed and NULL is returned.
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, *targetName, *path, *schema;
103  char realPath[2 * ( PATH_MAX + 1 )], *p = &(realPath[PATH_MAX+1]);
104 
105  if( ( map = MCGIDI_map_new( smr ) ) == NULL ) return( NULL );
106 
107  if( ( basePath == NULL ) || ( mapFileName[0] == '/' ) ) {
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_unknownID, MCGIDI_map_status_mapParsing, "No map file %s\n", mapFileName );
116  return( (MCGIDI_map *) MCGIDI_map_free( NULL, map ) );
117  }
118  n = (int) strlen( p ) + 2;
119  if( ( map->path = (char *) smr_malloc2( smr, 2 * n, 0, "map->path" ) ) == NULL ) return( (MCGIDI_map *) MCGIDI_map_free( NULL, map ) );
120  map->mapFileName = &(map->path[n + 1]);
121  strcpy( map->mapFileName, p );
122  strcpy( map->path, p );
123  if( ( p = strrchr( map->path, '/' ) ) != NULL ) {
124  *p = 0; }
125  else {
126  strcpy( map->path, "." );
127  }
128 
129  if( ( doc = xDataXML_importFile2( smr, map->mapFileName ) ) == NULL ) return( (MCGIDI_map *) MCGIDI_map_free( NULL, map ) );
130 
131  element = xDataXML_getDocumentsElement( doc );
132  for( child = xDataXML_getFirstElement( element ); child != NULL; child = xDataXML_getNextElement( child ) ) {
133  if( strcmp( child->name, "path" ) == 0 ) {
134  if( ( path = xDataXML_getAttributesValueInElement( child , "path" ) ) == NULL ) {
135  smr_setReportError3p( smr, &(map->smrUserInterface), smr_unknownID, MCGIDI_map_status_mapParsing, "path missing path attribute" );
136  break;
137  }
138  MCGIDI_map_addPath( smr, map, path ); }
139  else if( strcmp( child->name, "target" ) == 0 ) {
140  if( ( schema = xDataXML_getAttributesValueInElement( child , "schema" ) ) == NULL ) {
141  smr_setReportError3p( smr, &(map->smrUserInterface), smr_unknownID, MCGIDI_map_status_mapParsing, "target missing 'schema' attribute" );
142  break;
143  }
144  if( ( path = xDataXML_getAttributesValueInElement( child , "path" ) ) == NULL ) {
145  smr_setReportError3p( smr, &(map->smrUserInterface), smr_unknownID, MCGIDI_map_status_mapParsing, "target missing 'path' attribute" );
146  break;
147  }
148  if( ( evaluation = xDataXML_getAttributesValueInElement( child , "evaluation" ) ) == NULL ) {
149  smr_setReportError3p( smr, &(map->smrUserInterface), smr_unknownID, MCGIDI_map_status_mapParsing, "target missing 'evaluation' attribute" );
150  break;
151  }
152  if( ( projectile = xDataXML_getAttributesValueInElement( child , "projectile" ) ) == NULL ) {
153  smr_setReportError3p( smr, &(map->smrUserInterface), smr_unknownID, MCGIDI_map_status_mapParsing, "target missing 'projectile' attribute" );
154  break;
155  }
156  if( ( targetName = xDataXML_getAttributesValueInElement( child , "target" ) ) == NULL ) {
157  smr_setReportError3p( smr, &(map->smrUserInterface), smr_unknownID, MCGIDI_map_status_mapParsing, "target missing 'target' attribute" );
158  break;
159  }
160  MCGIDI_map_addTarget( smr, map, schema, path, evaluation, projectile, targetName ); }
161  else {
162  smr_setReportError3( smr, &(map->smrUserInterface), smr_unknownID, MCGIDI_map_status_mapParsing, "invalid element = %s", child->name );
163  }
164  if( !smr_isOk( smr ) ) break;
165  }
166  xDataXML_freeDoc( smr, doc );
167  if( !smr_isOk( smr ) ) map = (MCGIDI_map *) MCGIDI_map_free( NULL, map );
168  return( map );
169 }
170 /*
171 ************************************************************
172 */
174 
175  MCGIDI_map_release( smr, map );
176  smr_freeMemory( (void **) &map );
177  return( NULL );
178 }
179 /*
180 ************************************************************
181 */
183 
184  MCGIDI_mapEntry *entry, *next;
185 
186  if( map->path != NULL ) smr_freeMemory( (void **) &(map->path) );
187  for( entry = map->mapEntries; entry != NULL; entry = next ) {
188  next = entry->next;
189  if( entry->schema != NULL ) smr_freeMemory( (void **) &(entry->schema) );
190  if( entry->path != NULL ) smr_freeMemory( (void **) &(entry->path) );
191  if( entry->evaluation != NULL ) smr_freeMemory( (void **) &(entry->evaluation) );
192  if( entry->projectile != NULL ) smr_freeMemory( (void **) &(entry->projectile) );
193  if( entry->targetName != NULL ) smr_freeMemory( (void **) &(entry->targetName) );
194  if( entry->map != NULL ) MCGIDI_map_free( smr, entry->map );
195  smr_freeMemory( (void **) &entry );
196  }
197  map->numberOfEntries = 0;
198  map->mapEntries = NULL;
200 }
201 /*
202 ************************************************************
203 */
205 
206  return( map->mapEntries );
207 }
208 /*
209 ************************************************************
210 */
212 
213  return( entry->next );
214 }
215 /*
216 ************************************************************
217 */
218 int MCGIDI_map_addTarget( statusMessageReporting *smr, MCGIDI_map *map, const char *schema, const char *path, const char *evaluation, const char *projectile, const char *target ) {
219 
220  return( _MCGIDI_map_addEntry( smr, map, MCGIDI_mapEntry_type_target, schema, path, evaluation, projectile, target ) != NULL );
221 }
222 /*
223 ************************************************************
224 */
225 int MCGIDI_map_addPath( statusMessageReporting *smr, MCGIDI_map *map, const char *path ) {
226 
227  MCGIDI_mapEntry *entry = _MCGIDI_map_addEntry( smr, map, MCGIDI_mapEntry_type_path, NULL, path, NULL, NULL, NULL );
228 
229  if( entry != NULL ) {
230  if( ( entry->map = MCGIDI_map_readFile( smr, map->path, entry->path ) ) == NULL ) entry = NULL;
231  }
232  return( entry != NULL );
233 }
234 /*
235 ************************************************************
236 */
238  const char *path, const char *evaluation, const char *projectile, const char *targetName ) {
239 
241  MCGIDI_mapEntry *entry;
242 
243  if( ( entry = (MCGIDI_mapEntry * ) smr_malloc2( smr, sizeof( MCGIDI_mapEntry ), 1, "entry" ) ) == NULL ) return( NULL );
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;
253  entry->map = NULL;
254 
255  if( path != NULL ) {
256  if( ( entry->path = (char *) smr_malloc2( smr, strlen( path ) + 1, 0, "path" ) ) == NULL ) goto err;
257  strcpy( entry->path, path );
258  }
259 
260  if( evaluation != NULL ) {
261  if( ( entry->evaluation = (char *) smr_malloc2( smr, strlen( evaluation ) + 1, 0, "evaluation" ) ) == NULL ) goto err;
262  strcpy( entry->evaluation, evaluation );
263  }
264 
265  if( projectile != NULL ) {
266  if( ( entry->globalPoPsIndexProjectile = lPoPs_addParticleIfNeeded( smr, projectile, "LLNL" ) ) < 0 ) goto err;
267  if( ( entry->projectile = (char *) smr_malloc2( smr, strlen( projectile ) + 1, 0, "projectile" ) ) == NULL ) goto err;
268  strcpy( entry->projectile, projectile );
269  }
270 
271  if( targetName != NULL ) {
272  if( ( entry->globalPoPsIndexTarget = lPoPs_addParticleIfNeeded( smr, targetName, "LLNL" ) ) < 0 ) goto err;
273  if( ( entry->targetName = (char *) smr_malloc2( smr, strlen( targetName ) + 1, 0, "target" ) ) == NULL ) goto err;
274  strcpy( entry->targetName, targetName );
275  }
276 
277  if( schema != NULL ) {
278  if( ( entry->schema = (char *) smr_malloc2( smr, strlen( schema ) + 1, 0, "schema" ) ) == NULL ) goto err;
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 != NULL; p = p->next );
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->evaluation) );
294  smr_freeMemory( (void **) &(entry->projectile) );
295  smr_freeMemory( (void **) &(entry->targetName) );
296  smr_freeMemory( (void **) &entry );
297  return( NULL );
298 }
299 /*
300 ************************************************************
301 */
302 char *MCGIDI_map_findTargetViaPoPIDs( statusMessageReporting *smr, MCGIDI_map *map, const char *evaluation,
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_atIndex( smr, projectile_PoPID );
309  char const *targetName = PoPs_getName_atIndex( smr, target_PoPID );
310 
311  if( !smr_isOk( smr ) ) return( NULL );
312  if( map->status != MCGIDI_map_status_Ok ) return( NULL );
313 
314  path = _MCGIDI_map_findTargetViaPoPIDs2( smr, map, evaluation, projectile_PoPID, target_PoPID );
315  if( ( path == NULL ) && smr_isOk( smr ) ) {
316  if( evaluation == NULL ) {
317  smr_setReportInfo3( smr, &(map->smrUserInterface), smr_unknownID, 1, "target %s for projectile %s not found",
318  targetName, projectileName ); }
319  else {
320  smr_setReportInfo3( smr, &(map->smrUserInterface), smr_unknownID, 1, "target %s for projectile %s and evaluation %s not found",
321  targetName, projectileName, evaluation );
322  }
323  }
324  return( path );
325 }
326 /*
327 ************************************************************
328 */
329 static char *_MCGIDI_map_findTargetViaPoPIDs2( statusMessageReporting *smr, MCGIDI_map *map, const char *evaluation,
330  int projectile_PoPID, int target_PoPID ) {
331 
332  MCGIDI_mapEntry *entry;
333  char *path = NULL;
334  int n, status;
335 
336  if( evaluation != NULL ) {
337  if( strlen( evaluation ) == 0 ) evaluation = NULL;
338  }
339 
340  for( entry = map->mapEntries; entry != NULL; entry = entry->next ) {
341  switch( entry->type ) {
343  if( ( projectile_PoPID == entry->globalPoPsIndexProjectile ) && ( target_PoPID == entry->globalPoPsIndexTarget ) ) {
344  if( evaluation == NULL ) {
345  status = 1; }
346  else {
347  status = strcmp( evaluation, entry->evaluation ) == 0;
348  }
349  if( status ) {
350  n = (int) strlen( map->path ) + 1 + (int) strlen( entry->path ) + 1;
351  if( ( path = (char * ) smr_malloc2( smr, n, 0, "path" ) ) == NULL ) return( NULL );
352  strcpy( path, map->path );
353  strcat( path, "/" );
354  if( entry->path[0] == '/' ) {
355  strcpy( path, entry->path ); }
356  else {
357  strcat( path, entry->path );
358  }
359  return( path );
360  }
361  }
362  break;
364  if( ( path = _MCGIDI_map_findTargetViaPoPIDs2( smr, entry->map, evaluation, projectile_PoPID, target_PoPID ) ) != NULL ) return( path );
365  break;
366  default :
367  smr_setReportInfo3( smr, &(map->smrUserInterface), smr_unknownID, MCGIDI_map_status_UnknownType, "unknown type = %d", entry->type );
368  return( NULL );
369  }
370  }
371  return( NULL );
372 }
373 /*
374 ************************************************************
375 */
376 char *MCGIDI_map_findTarget( statusMessageReporting *smr, MCGIDI_map *map, const char *evaluation, const char *projectile, const char *targetName ) {
377 
378  int projectile_PoPID, target_PoPID;
379 
380  if( ( projectile_PoPID = lPoPs_addParticleIfNeeded( smr, projectile, "LLNL" ) ) < 0 ) return( NULL );
381  if( ( target_PoPID = lPoPs_addParticleIfNeeded( smr, targetName, "LLNL" ) ) < 0 ) return( NULL );
382  return( MCGIDI_map_findTargetViaPoPIDs( smr, map, evaluation, projectile_PoPID, target_PoPID ) );
383 }
384 /*
385 ************************************************************
386 */
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 ) return( NULL );
396  if( ( mapAllOfTarget = MCGIDI_map_new( smr ) ) == NULL ) return( NULL );
397  status = _MCGIDI_map_findAllOfTargetViaPoPIDs2( smr, mapAllOfTarget, map, projectile_PoPID, target_PoPID );
398  if( ( status != 0 ) ) mapAllOfTarget = (MCGIDI_map *) MCGIDI_map_free( smr, mapAllOfTarget );
399  return( mapAllOfTarget );
400 }
401 /*
402 ************************************************************
403 */
405  int projectile_PoPID, int target_PoPID ) {
406 
407  MCGIDI_mapEntry *entry;
408 
409  for( entry = map->mapEntries; entry != NULL; entry = entry->next ) {
410  switch( entry->type ) {
412  if( ( projectile_PoPID == entry->globalPoPsIndexProjectile ) && ( target_PoPID == entry->globalPoPsIndexTarget ) ) {
413  if( _MCGIDI_map_addEntry( smr, mapAllOfTarget, entry->type, entry->schema, entry->path, entry->evaluation, entry->projectile,
414  entry->targetName ) == NULL ) return( 1 );
415  }
416  break;
418  if( _MCGIDI_map_findAllOfTargetViaPoPIDs2( smr, mapAllOfTarget, entry->map, projectile_PoPID, target_PoPID ) != 0 ) return( 1 );
419  break;
420  default :
421  smr_setReportInfo3( smr, &(map->smrUserInterface), smr_unknownID, MCGIDI_map_status_UnknownType, "unknown type = %d", entry->type );
422  return( 1 );
423  }
424  }
425  return( 0 );
426 }
427 /*
428 ************************************************************
429 */
430 MCGIDI_map *MCGIDI_map_findAllOfTarget( statusMessageReporting *smr, MCGIDI_map *map, const char *projectile, const char *targetName ) {
431 
432  int projectile_PoPID, target_PoPID;
433 
434  if( ( projectile_PoPID = lPoPs_addParticleIfNeeded( smr, projectile, "LLNL" ) ) < 0 ) return( NULL );
435  if( ( target_PoPID = lPoPs_addParticleIfNeeded( smr, targetName, "LLNL" ) ) < 0 ) return( NULL );
436  return( MCGIDI_map_findAllOfTargetViaPoPIDs( smr, map, projectile_PoPID, target_PoPID ) );
437 }
438 /*
439 ************************************************************
440 */
441 char *MCGIDI_map_getFullPath( statusMessageReporting *smr, MCGIDI_map *map, const char *endPath ) {
442 
443  char *path;
444 
445  if( endPath[0] == '/' ) {
446  if( ( path = (char *) smr_malloc2( smr, strlen( endPath ) + 1, 0, "path" ) ) == NULL ) return( NULL );
447  path[0] = 0; }
448  else {
449  if( ( path = (char *) smr_malloc2( smr, strlen( map->path ) + strlen( endPath ) + 2, 0, "path" ) ) == NULL ) return( NULL );
450  strcpy( path, map->path );
451  strcat( path, "/" );
452  }
453  strcat( path, endPath );
454  return( path );
455 }
456 /*
457 ************************************************************
458 */
460 
461  char *path = NULL;
462  MCGIDI_map *map = target->parent;
463 
464  switch( target->type ) {
466  path = MCGIDI_map_getFullPath( smr, map, target->path );
467  break;
469  smr_setReportInfo3p( smr, &(map->smrUserInterface), smr_unknownID, MCGIDI_map_status_UnknownType, "path type not allowed" );
470  break;
471  default :
472  smr_setReportInfo3( smr, &(map->smrUserInterface), smr_unknownID, MCGIDI_map_status_UnknownType, "unknown type = %d", target->type );
473  break;
474  }
475  return( path );
476 }
477 /*
478 ************************************************************
479 */
480 static int _MCGIDI_map_walkTree2( statusMessageReporting *smr, MCGIDI_map *map, int level, int (*handler)( MCGIDI_mapEntry *entry, int level, void *userData),
481  void *userData ) {
482 
483  MCGIDI_mapEntry *entry;
484 
485  for( entry = map->mapEntries; entry != NULL; entry = entry->next ) {
486  if( handler( entry, level, userData ) != 0 ) return( 1 );
487  if( entry->type == MCGIDI_mapEntry_type_path ) if( _MCGIDI_map_walkTree2( smr, entry->map, level + 1, handler, userData ) != 0 ) return( 1 );
488  }
489  return( 0 );
490 }
491 /*
492 ************************************************************
493 */
494 int MCGIDI_map_walkTree( statusMessageReporting *smr, MCGIDI_map *map, int (*handler)( MCGIDI_mapEntry *entry, int level, void *userData), void *userData ) {
495 
496  return( _MCGIDI_map_walkTree2( smr, map, 0, handler, userData ) );
497 }
498 /*
499 ************************************************************
500 */
502 
503  MCGIDI_mapEntry *entry;
504  char *s, *p;
505  char targetFormat[] = "<target schema=\"%s\" evaluation=\"%s\" projectile=\"%s\" target=\"%s\" path=\"%s\"/>\n";
506  char pathFormat[] = "<path projectile=\"%s\" path=\"%s\"/>\n";
507  char start[] = "<map>\n";
508  char end[] = "</map>";
509  int n = 0, nStart = (int) strlen( start ), nEnd = (int) strlen( end );
510  int nTarget = (int) strlen( targetFormat ) - 10, nPath = (int) strlen( pathFormat ) - 4;
511 
512  if( map->status != MCGIDI_map_status_Ok ) return( NULL );
513 
514  n = nStart + nEnd + 1;
515  for( entry = map->mapEntries; entry != NULL; entry = entry->next ) {
516  switch( entry->type ) {
518  n += (int) ( strlen( entry->schema ) + strlen( entry->path ) + strlen( entry->evaluation ) + strlen( entry->projectile ) + strlen( entry->targetName ) + nTarget );
519  break;
521  n += (int ) strlen( entry->path ) + (int ) strlen( entry->projectile ) + nPath;
522  break;
523  default :
524  smr_setReportInfo3( smr, &(map->smrUserInterface), smr_unknownID, MCGIDI_map_status_UnknownType, "unknown type = %d", entry->type );
525  return( NULL );
526  }
527  }
528 
529  if( ( s = (char *) smr_malloc2( smr, n, 0, "xml string" ) ) == NULL ) return( NULL );
530  p = s;
531  strcpy( p, start );
532  while( *p ) p++; // Loop checking, 11.06.2015, T. Koi
533  for( entry = map->mapEntries; entry != NULL; entry = entry->next ) {
534  switch( entry->type ) {
536  sprintf( p, targetFormat, entry->schema, entry->evaluation, entry->projectile, entry->targetName, entry->path );
537  break;
539  sprintf( p, pathFormat, entry->projectile, entry->path );
540  break;
541  }
542  while( *p ) p++; // Loop checking, 11.06.2015, T. Koi
543  }
544  strcpy( p, end );
545  return( s );
546 }
547 /*
548 ************************************************************
549 */
550 void MCGIDI_map_simpleWrite( FILE *f, MCGIDI_map *map ) { _MCGIDI_map_simpleWrite2( f, map, 0 ); }
551 /*
552 ************************************************************
553 */
554 static void _MCGIDI_map_simpleWrite2( FILE *f, MCGIDI_map *map, int level ) {
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", map->status );
562  return;
563  }
564  if( level < n ) sLevel[4 * level] = 0;
565  fprintf( f, "%smap->path = %s\n", sLevel, map->path );
566  fprintf( f, "%smap->mapFileName = %s\n", sLevel, map->mapFileName );
567  for( entry = map->mapEntries; entry != NULL; entry = entry->next ) {
568  switch( entry->type ) {
570  fprintf( f, "%sType = target: schema = %s: evaluation = %s: projectile = %s: target = %s: path = %s\n", sLevel, entry->schema,
571  entry->evaluation, entry->projectile, entry->targetName, entry->path );
572  break;
574  fprintf( f, "%sType = path: path = %s\n", sLevel, entry->path );
575  _MCGIDI_map_simpleWrite2( f, entry->map, level + 1 );
576  break;
577  default :
578  fprintf( f, "%sUnknown type = %d\n", sLevel, entry->type );
579  }
580  }
581 }
582 /*
583 ************************************************************
584 */
585 static char *_MCGIDI_map_smrUserInterface( void *userData ) {
586 
587  MCGIDI_map_smr *smrUserInterface = (MCGIDI_map_smr *) userData;
588 
589  return( smr_allocateFormatMessage( "map file = %s", smrUserInterface->map->mapFileName ) );
590 }
591 
592 #if defined __cplusplus
593 }
594 #endif
595