| Geant4 Cross Reference |
1 #include <stdio.h> 1
2 #include <stdlib.h>
3 #include <string.h>
4 #include <stdarg.h>
5
6 #ifdef WIN32
7 /*#define va_copy(dst, src) ((dst) = (src))*/
8 #endif
9
10 #include "statusMessageReporting.h"
11
12 #if defined __cplusplus
13 namespace GIDI {
14 using namespace GIDI;
15 #endif
16
17 #define SMR_InitialMessageSize 1024
18 #define SMR_IncrementMessageSize 1024
19
20 static int smrIsSetup = 0;
21 static char smr_mallocFailed[] = "statusMessag
22 static char statusStringOk[] = "Ok", statusSt
23 statusStringWarning[] = "Warning", statusS
24
25 static int numberOfRegisteredLibraries = 0;
26 static char unknownLibrary[] = "unknownID";
27 static char tooManyLibrary[] = "tooManyIDs";
28 static char invalidLibrary[] = "invalidID";
29 static char errnoLibrary[] = "errnoID";
30 static char smrLibrary[] = "statusMessageRepor
31 static char *registeredLibraries[smr_maximumNu
32
33 static statusMessageReport *smr_reportNew( voi
34 static int smr_reportInitialize( statusMessage
35 static void smr_reportRelease( statusMessageRe
36 static int smr_setReport( statusMessageReporti
37 enum smr_status status, char const *fmt, v
38 static int smr_setAllocationFailure( statusMes
39 /*
40 ==============================================
41 */
42 int smr_setup( void ) {
43
44 int i;
45
46 if( smrIsSetup ) return( 0 );
47 smrIsSetup = 1;
48 for( i = 0; i < smr_maximumNumberOfRegiste
49 registeredLibraries[smr_unknownID] = unkno
50 ++numberOfRegisteredLibraries;
51 registeredLibraries[smr_tooManyIDs] = tooM
52 ++numberOfRegisteredLibraries;
53 registeredLibraries[smr_invalidID] = inval
54 ++numberOfRegisteredLibraries;
55 registeredLibraries[smr_errnoID] = errnoLi
56 ++numberOfRegisteredLibraries;
57 registeredLibraries[smr_smrID] = smrLibrar
58 ++numberOfRegisteredLibraries;
59 return( 1 );
60 }
61 /*
62 ==============================================
63 */
64 int smr_cleanup( void ) {
65
66 int i;
67
68 if( smrIsSetup == 0 ) return( 0 );
69 for( i = smr_smrID + 1; i < numberOfRegist
70 numberOfRegisteredLibraries = 0;
71 smrIsSetup = 0;
72
73 return( 0 );
74 }
75 /*
76 ==============================================
77 */
78 int smr_registerLibrary( char const *libraryNa
79
80 int i;
81
82 if( smrIsSetup == 0 ) return( -1 );
83 if( numberOfRegisteredLibraries == smr_max
84 for( i = 0; i < numberOfRegisteredLibrarie
85 if( strcmp( libraryName, registeredLib
86 }
87 if( ( registeredLibraries[numberOfRegister
88 ++numberOfRegisteredLibraries;
89 return( numberOfRegisteredLibraries - 1 );
90 }
91 /*
92 ==============================================
93 */
94 int smr_numberOfRegisteredLibraries( void ) {
95
96 return( numberOfRegisteredLibraries );
97 }
98 /*
99 ==============================================
100 */
101 char const *smr_getRegisteredLibrariesName( in
102
103 if( ( ID < 0 ) || ( ID >= smr_maximumNumbe
104 return( registeredLibraries[ID] );
105 }
106 /*
107 ==============================================
108 */
109 statusMessageReporting *smr_new( statusMessage
110
111 statusMessageReporting *new_SMR;
112
113 if( ( new_SMR = (statusMessageReporting *)
114 smr_initialize( new_SMR, verbosity, append
115 return( new_SMR );
116 }
117 /*
118 ==============================================
119 */
120 int smr_initialize( statusMessageReporting *sm
121
122 if( smr == NULL ) return( 0 );
123 smr->verbosity = verbosity;
124 smr->append = append;
125 smr_reportInitialize( &(smr->report) );
126 return( 0 );
127 }
128 /*
129 ==============================================
130 */
131 statusMessageReporting *smr_clone( statusMessa
132
133 if( smr == NULL ) return( NULL );
134 return( smr_new( NULL, smr->verbosity, smr
135 }
136 /*
137 ==============================================
138 */
139 void smr_release( statusMessageReporting *smr
140
141 statusMessageReport *current, *next, *firs
142
143 if( smr == NULL ) return;
144 for( current = first; current != NULL; cur
145 next = smr_nextReport( current );
146 smr_reportRelease( current );
147 if( current != first ) smr_freeMemory(
148 }
149 smr_initialize( smr, smr->verbosity, smr->
150 }
151 /*
152 ==============================================
153 */
154 void *smr_free( statusMessageReporting **smr )
155
156 if( smr == NULL ) return( NULL );
157 if( *smr != NULL ) {
158 smr_release( *smr );
159 smr_freeMemory( (void **) smr );
160 }
161 return( *smr );
162 }
163 /*
164 ==============================================
165 */
166 static statusMessageReport *smr_reportNew( voi
167
168 statusMessageReport *report;
169
170 if( ( report = (statusMessageReport *) smr
171 smr_reportInitialize( report );
172 return( report );
173 }
174 /*
175 ==============================================
176 */
177 static int smr_reportInitialize( statusMessage
178
179 report->next = NULL;
180 report->status = smr_status_Ok;
181 report->libraryID = smr_unknownID;
182 report->code = smr_codeNULL;
183 report->line = -1;
184 report->fileName[0] = 0;
185 report->function[0] = 0;
186 report->message = NULL;
187 return( 0 );
188 }
189 /*
190 ==============================================
191 */
192 static void smr_reportRelease( statusMessageRe
193
194 if( report->message != NULL ) {
195 if( report->message != smr_mallocFaile
196 }
197 smr_reportInitialize( report );
198 }
199 /*
200 ==============================================
201 */
202 static int smr_setReport( statusMessageReporti
203 enum smr_status status, char const *fmt, v
204
205 char *userMsg;
206 statusMessageReport *report, *next;
207
208 if( smr == NULL ) return( 0 );
209 if( (int) status < (int) smr->verbosity )
210 if( status == smr_status_Ok ) return( 0 );
211 if( ( smr->report.status != smr_status_Ok
212 if( ( report = smr_reportNew( ) ) == N
213 for( next = smr_firstReport( smr ); ne
214 next->next = report; }
215 else {
216 if( status <= smr->report.status ) ret
217 smr_release( smr );
218 report = &(smr->report);
219 }
220 report->status = status;
221 if( ( libraryID < 0 ) || ( libraryID >= nu
222 report->libraryID = libraryID;
223 report->code = code;
224 report->line = line;
225 if( file != NULL ) strncpy( report->fileNa
226 report->fileName[smr_maximumFileNameSize]
227 if( function != NULL ) strncpy( report->fu
228 report->function[smr_maximumFileNameSize]
229
230 if( ( report->message = smr_vallocateForma
231 if( userInterface != NULL ) {
232 if( ( userMsg = (*(smr_userInterface *
233 int userSize = (int) strlen( userM
234 if( ( report->message = (char *) s
235 free( userMsg );
236 return( smr_setAllocationFailu
237 }
238 strcat( report->message, userMsg )
239 free( userMsg );
240 }
241 }
242 return( 0 );
243 }
244 /*
245 ==============================================
246 */
247 static int smr_setAllocationFailure( statusMes
248
249 vfprintf( stderr, fmt, *args );
250 va_end( *args );
251 fprintf( stderr, "\nAt line %d of %s in fu
252 if( report != NULL ) {
253 report->status = smr_status_Error;
254 report->message = (char *) smr_mallocF
255 return( 1 );
256 }
257 return( -1 );
258 }
259 /*
260 ==============================================
261 */
262 int smr_setReportInfo( statusMessageReporting
263
264 int status;
265 va_list args;
266
267 va_start( args, fmt );
268 status = smr_setReport( smr, userInterface
269 va_end( args );
270 return( status );
271 }
272 /*
273 ==============================================
274 */
275 int smr_vsetReportInfo( statusMessageReporting
276
277 return( smr_setReport( smr, userInterface,
278 }
279 /*
280 ==============================================
281 */
282 int smr_setReportWarning( statusMessageReporti
283
284 int status;
285 va_list args;
286
287 va_start( args, fmt );
288 status = smr_setReport( smr, userInterface
289 va_end( args );
290 return( status );
291 }
292 /*
293 ==============================================
294 */
295 int smr_vsetReportWarning( statusMessageReport
296
297 return( smr_setReport( smr, userInterface,
298 }
299 /*
300 ==============================================
301 */
302 int smr_setReportError( statusMessageReporting
303
304 int status;
305 va_list args;
306
307 va_start( args, fmt );
308 status = smr_setReport( smr, userInterface
309 va_end( args );
310 return( status );
311 }
312 /*
313 ==============================================
314 */
315 int smr_vsetReportError( statusMessageReportin
316
317 return( smr_setReport( smr, userInterface,
318 }
319 /*
320 ==============================================
321 */
322 enum smr_status smr_highestStatus( statusMessa
323
324 enum smr_status status = smr_status_Ok;
325 statusMessageReport *report;
326
327 if( smr == NULL ) return( smr_status_Ok );
328 for( report = smr_firstReport( smr ); repo
329 return( status );
330 }
331 /*
332 ==============================================
333 */
334 int smr_isOk( statusMessageReporting *smr ) {
335
336 return( smr_highestStatus( smr ) == smr_st
337 }
338 /*
339 ==============================================
340 */
341 int smr_isInfo( statusMessageReporting *smr )
342
343 return( smr_highestStatus( smr ) == smr_st
344 }
345 /*
346 ==============================================
347 */
348 int smr_isWarning( statusMessageReporting *smr
349
350 return( smr_highestStatus( smr ) == smr_st
351 }
352 /*
353 ==============================================
354 */
355 int smr_isError( statusMessageReporting *smr )
356
357 return( smr_highestStatus( smr ) == smr_st
358 }
359 /*
360 ==============================================
361 */
362 int smr_isWarningOrError( statusMessageReporti
363
364 enum smr_status status = smr_highestStatus
365
366 return( ( status == smr_status_Warning ) |
367 }
368 /*
369 ==============================================
370 */
371 int smr_isReportOk( statusMessageReport *repor
372
373 if( report == NULL ) return( 0 );
374 return( report->status == smr_status_Ok );
375 }
376 /*
377 ==============================================
378 */
379 int smr_isReportInfo( statusMessageReport *rep
380
381 if( report == NULL ) return( 0 );
382 return( report->status == smr_status_Info
383 }
384 /*
385 ==============================================
386 */
387 int smr_isReportWarning( statusMessageReport *
388
389 if( report == NULL ) return( 0 );
390 return( report->status == smr_status_Warni
391 }
392 /*
393 ==============================================
394 */
395 int smr_isReportError( statusMessageReport *re
396
397 if( report == NULL ) return( 0 );
398 return( report->status == smr_status_Error
399 }
400 /*
401 ==============================================
402 */
403 int smr_isReportWarningOrError( statusMessageR
404
405 if( report == NULL ) return( 0 );
406 return( ( report->status == smr_status_War
407 }
408 /*
409 ==============================================
410 */
411 int smr_numberOfReports( statusMessageReportin
412
413 int n = 0;
414 statusMessageReport *report;
415
416 if( smr == NULL ) return( 0 );
417 if( smr->report.status == smr_status_Ok )
418 for( report = smr_firstReport( smr ); repo
419 return( n );
420 }
421 /*
422 ==============================================
423 */
424 statusMessageReport *smr_firstReport( statusMe
425
426 if( smr == NULL ) return( NULL );
427 if( smr->report.status == smr_status_Ok )
428 return( &(smr->report) );
429 }
430 /*
431 ==============================================
432 */
433 statusMessageReport *smr_nextReport( statusMes
434
435 if( report == NULL ) return( NULL );
436 return( report->next );
437 }
438 /*
439 ==============================================
440 */
441 enum smr_status smr_getVerbosity( statusMessag
442
443 if( smr == NULL ) return( smr_status_Ok );
444 return( smr->verbosity );
445 }
446 /*
447 ==============================================
448 */
449 int smr_getAppend( statusMessageReporting *smr
450
451 if( smr == NULL ) return( 0 );
452 return( smr->append );
453 }
454 /*
455 ==============================================
456 */
457 int smr_getLibraryID( statusMessageReport *rep
458
459 if( report == NULL ) return( 0 );
460 return( report->libraryID );
461 }
462 /*
463 ==============================================
464 */
465 int smr_getCode( statusMessageReport *report )
466
467 if( report == NULL ) return( -1 );
468 return( report->code );
469 }
470 /*
471 ==============================================
472 */
473 int smr_getLine( statusMessageReport *report )
474
475 if( report == NULL ) return( -1 );
476 return( report->line );
477 }
478 /*
479 ==============================================
480 */
481 char const *smr_getFile( statusMessageReport *
482
483 if( report == NULL ) return( NULL );
484 return( report->fileName );
485 }
486 /*
487 ==============================================
488 */
489 char const *smr_getFunction( statusMessageRepo
490
491 if( report == NULL ) return( NULL );
492 return( report->function );
493 }
494 /*
495 ==============================================
496 */
497 char const *smr_getMessage( statusMessageRepor
498
499 if( report == NULL ) return( NULL );
500 return( report->message );
501 }
502 /*
503 ==============================================
504 */
505 char *smr_copyMessage( statusMessageReport *re
506
507 if( report == NULL ) return( NULL );
508 if( report->status == smr_status_Ok ) retu
509 return( smr_allocateFormatMessage( report-
510 }
511 /*
512 ==============================================
513 */
514 char *smr_copyFullMessage( statusMessageReport
515
516 if( report == NULL ) return( NULL );
517 if( report->status == smr_status_Ok ) retu
518 return( smr_allocateFormatMessage( "%s\nAt
519 }
520 /*
521 ==============================================
522 */
523 void smr_print( statusMessageReporting *smr, i
524
525 smr_write( smr, stdout, clear );
526 }
527 /*
528 ==============================================
529 */
530 void smr_write( statusMessageReporting *smr, F
531
532 statusMessageReport *report;
533
534 if( smr == NULL ) return;
535 for( report = smr_firstReport( smr ); repo
536 if( clear ) smr_release( smr );
537 }
538 /*
539 ==============================================
540 */
541 void smr_reportPrint( statusMessageReport *rep
542
543 smr_reportWrite( report, stderr );
544 }
545 /*
546 ==============================================
547 */
548 void smr_reportWrite( statusMessageReport *rep
549
550 if( report->message != NULL ) fprintf( f,
551 }
552 /*
553 ==============================================
554 */
555 char const *smr_statusToString( enum smr_statu
556
557 switch( status ) {
558 case smr_status_Ok : return( statusStringO
559 case smr_status_Info : return( statusStrin
560 case smr_status_Warning : return( statusSt
561 case smr_status_Error : return( statusStri
562 }
563 return( statusStringInvalid );
564 }
565 /*
566 ==============================================
567 */
568 char *smr_allocateFormatMessage( char const *f
569
570 char *s;
571 va_list args;
572
573 va_start( args, fmt );
574 s = smr_vallocateFormatMessage( fmt, &args
575 va_end( args );
576 return( s );
577 }
578 /*
579 ==============================================
580 */
581 char *smr_vallocateFormatMessage( char const *
582
583 int n, size = SMR_InitialMessageSize;
584 char buffer[SMR_InitialMessageSize], *mess
585 va_list args_;
586
587 while( 1 ) {
588 va_copy( args_, *args );
589 n = vsnprintf( message, size, fmt, arg
590 va_end( args_ );
591 if( ( n > -1 ) && ( n < size ) ) break
592 if( n > -1 ) { /* glibc 2.1 */
593 size = n + 3; }
594 else { /* glibc 2.0 */
595 size += SMR_IncrementMessageSize;
596 }
597 if( message == buffer ) message = NULL
598 if( ( message = (char *) realloc( mess
599 } // Loop checking, 11.06.2015, T. Koi
600 if( message == buffer ) {
601 if( ( message = (char *) malloc( n + 1
602 strcpy( message, buffer ); }
603 else {
604 if( ( message = (char *) realloc( mess
605 }
606 return( message );
607 }
608 /*
609 ==============================================
610 */
611 void *smr_malloc( statusMessageReporting *smr,
612
613 void *p = smr_realloc( smr, NULL, size, fo
614 size_t i;
615 char *c;
616 long long *l;
617
618 if( ( p != NULL ) && zero ) {
619 for( i = 0, l = (long long *) p; i < s
620 for( i *= sizeof( long long ), c = (ch
621 }
622
623 return( p );
624 }
625 /*
626 ==============================================
627 */
628 void *smr_realloc( statusMessageReporting *smr
629
630 void *p = realloc( pOld, size );
631
632 if( ( p == NULL ) && ( smr != NULL ) ) {
633 smr_setReportError( smr, NULL, file, l
634 }
635 return( p );
636 }
637 /*
638 ==============================================
639 */
640 void *smr_freeMemory( void **p ) {
641
642 if( p == NULL ) return( NULL );
643 if( *p != NULL ) {
644 free( *p );
645 *p = NULL;
646 }
647 return( *p );
648 }
649 /*
650 ==============================================
651 */
652 char *smr_allocateCopyString( statusMessageRep
653 /*
654 * User must free returned string.
655 */
656 char *c = strdup( s );
657
658 if( c == NULL ) smr_setReportError( smr, N
659 strlen( s ), forItem );
660 return( c );
661 }
662 /*
663 ==============================================
664 */
665 char *smr_allocateCopyStringN( statusMessageRe
666 /*
667 * User must free returned string.
668 */
669 size_t l = strlen( s );
670 char *c;
671
672 if( l > n ) l = n;
673 if( ( c = (char *) smr_malloc( smr, l + 1,
674 strncpy( c, s, n );
675 c[l] = 0;
676 }
677 /*
678 c = strndup( s, l ); # Not standard
679 if( c != NULL ) {
680 c[l] = 0; }
681 else {
682 smr_setReportError( smr, NULL, file,
683 strlen( s ), forItem );
684 }
685 */
686 return( c );
687 }
688
689 #if defined __cplusplus
690 }
691 #endif
692