Geant4 Cross Reference |
>> 1 /* >> 2 # <<BEGIN-copyright>> >> 3 # Copyright (c) 2010, Lawrence Livermore National Security, LLC. >> 4 # Produced at the Lawrence Livermore National Laboratory >> 5 # Written by Bret R. Beck, beck6@llnl.gov. >> 6 # CODE-461393 >> 7 # All rights reserved. >> 8 # >> 9 # This file is part of GIDI. For details, see nuclear.llnl.gov. >> 10 # Please also read the "Additional BSD Notice" at nuclear.llnl.gov. >> 11 # >> 12 # Redistribution and use in source and binary forms, with or without modification, >> 13 # are permitted provided that the following conditions are met: >> 14 # >> 15 # 1) Redistributions of source code must retain the above copyright notice, >> 16 # this list of conditions and the disclaimer below. >> 17 # 2) Redistributions in binary form must reproduce the above copyright notice, >> 18 # this list of conditions and the disclaimer (as noted below) in the >> 19 # documentation and/or other materials provided with the distribution. >> 20 # 3) Neither the name of the LLNS/LLNL nor the names of its contributors may be >> 21 # used to endorse or promote products derived from this software without >> 22 # specific prior written permission. >> 23 # >> 24 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY >> 25 # EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES >> 26 # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT >> 27 # SHALL LAWRENCE LIVERMORE NATIONAL SECURITY, LLC, THE U.S. DEPARTMENT OF ENERGY OR >> 28 # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >> 29 # CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS >> 30 # OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED >> 31 # AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT >> 32 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, >> 33 # EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. >> 34 # <<END-copyright>> >> 35 */ 1 #include <stdio.h> 36 #include <stdio.h> 2 #include <stdlib.h> 37 #include <stdlib.h> 3 #include <string.h> 38 #include <string.h> 4 #include <stdarg.h> 39 #include <stdarg.h> 5 40 6 #ifdef WIN32 << 7 /*#define va_copy(dst, src) ((dst) = (src))*/ << 8 #endif << 9 << 10 #include "statusMessageReporting.h" 41 #include "statusMessageReporting.h" 11 42 12 #if defined __cplusplus 43 #if defined __cplusplus 13 namespace GIDI { 44 namespace GIDI { 14 using namespace GIDI; 45 using namespace GIDI; 15 #endif 46 #endif 16 47 17 #define SMR_InitialMessageSize 1024 << 48 static const char smr_mallocFailed[] = "statusMessageReporting could not allocate memory for message"; 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 49 113 if( ( new_SMR = (statusMessageReporting *) << 50 static int smr_setAllocationFailure( statusMessageReporting *smr, const char *fmt, va_list *args ); 114 smr_initialize( new_SMR, verbosity, append << 51 static int smr_setMessage( statusMessageReporting *smr, void *userInterface, const char *file, int line, int code, 115 return( new_SMR ); << 52 enum smr_status status, const char *fmt, va_list *args ); 116 } << 53 static char *smr_getFullMessage2( char const *fmt, ... ); 117 /* << 54 /* 118 ============================================== << 55 ************************************************************ 119 */ << 56 */ 120 int smr_initialize( statusMessageReporting *sm << 57 int smr_initialize( statusMessageReporting *smr ) { 121 << 58 122 if( smr == NULL ) return( 0 ); << 59 smr->status = smr_status_Ok; 123 smr->verbosity = verbosity; << 60 smr->packageName[0] = 0; 124 smr->append = append; << 61 smr->line= -1; 125 smr_reportInitialize( &(smr->report) ); << 62 smr->code = 0; 126 return( 0 ); << 63 smr->message = NULL; 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 ); 64 return( 0 ); 188 } 65 } 189 /* 66 /* 190 ============================================== << 67 ************************************************************ 191 */ 68 */ 192 static void smr_reportRelease( statusMessageRe << 69 int smr_release( statusMessageReporting *smr ) { 193 70 194 if( report->message != NULL ) { << 71 if( smr->message != NULL ) { 195 if( report->message != smr_mallocFaile << 72 if( smr->message != smr_mallocFailed ) free( smr->message ); 196 } 73 } 197 smr_reportInitialize( report ); << 74 return( smr_initialize( smr ) ); 198 } 75 } 199 /* 76 /* 200 ============================================== << 77 ************************************************************ 201 */ 78 */ 202 static int smr_setReport( statusMessageReporti << 79 int smr_setMessageInfo( statusMessageReporting *smr, void *userInterface, const char *file, int line, int code, const char *fmt, ... ) { 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 80 264 int status; 81 int status; 265 va_list args; 82 va_list args; 266 83 267 va_start( args, fmt ); 84 va_start( args, fmt ); 268 status = smr_setReport( smr, userInterface << 85 status = smr_setMessage( smr, userInterface, file, line, code, smr_status_Info, fmt, &args ); 269 va_end( args ); 86 va_end( args ); 270 return( status ); 87 return( status ); 271 } 88 } 272 /* 89 /* 273 ============================================== << 90 ************************************************************ 274 */ 91 */ 275 int smr_vsetReportInfo( statusMessageReporting << 92 int smr_vsetMessageInfo( statusMessageReporting *smr, void *userInterface, const char *file, int line, int code, const char *fmt, va_list *args ) { 276 93 277 return( smr_setReport( smr, userInterface, << 94 int status = smr_setMessage( smr, userInterface, file, line, code, smr_status_Info, fmt, args ); >> 95 return( status ); 278 } 96 } 279 /* 97 /* 280 ============================================== << 98 ************************************************************ 281 */ 99 */ 282 int smr_setReportWarning( statusMessageReporti << 100 int smr_setMessageError( statusMessageReporting *smr, void *userInterface, const char *file, int line, int code, const char *fmt, ... ) { 283 101 284 int status; 102 int status; 285 va_list args; 103 va_list args; 286 104 287 va_start( args, fmt ); 105 va_start( args, fmt ); 288 status = smr_setReport( smr, userInterface << 106 status = smr_setMessage( smr, userInterface, file, line, code, smr_status_Error, fmt, &args ); 289 va_end( args ); 107 va_end( args ); 290 return( status ); 108 return( status ); 291 } 109 } 292 /* 110 /* 293 ============================================== << 111 ************************************************************ 294 */ 112 */ 295 int smr_vsetReportWarning( statusMessageReport << 113 int smr_vsetMessageError( statusMessageReporting *smr, void *userInterface, const char *file, int line, int code, const char *fmt, va_list *args ) { 296 114 297 return( smr_setReport( smr, userInterface, << 115 int status = smr_setMessage( smr, userInterface, file, line, code, smr_status_Error, fmt, args ); >> 116 return( status ); 298 } 117 } 299 /* 118 /* 300 ============================================== << 119 ************************************************************ 301 */ 120 */ 302 int smr_setReportError( statusMessageReporting << 121 char *smr_allocateFormatMessage( const char *fmt, ... ) { 303 122 304 int status; << 123 char *s; 305 va_list args; 124 va_list args; 306 125 307 va_start( args, fmt ); 126 va_start( args, fmt ); 308 status = smr_setReport( smr, userInterface << 127 s = smr_vallocateFormatMessage( fmt, &args ); 309 va_end( args ); 128 va_end( args ); 310 return( status ); << 129 return( s ); 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 } 130 } 421 /* 131 /* 422 ============================================== << 132 ************************************************************ 423 */ 133 */ 424 statusMessageReport *smr_firstReport( statusMe << 134 char *smr_vallocateFormatMessage( const char *fmt, va_list *args ) { 425 135 426 if( smr == NULL ) return( NULL ); << 136 int n, size = 128; 427 if( smr->report.status == smr_status_Ok ) << 137 char *message = NULL; 428 return( &(smr->report) ); << 138 va_list args_; 429 } << 430 /* << 431 ============================================== << 432 */ << 433 statusMessageReport *smr_nextReport( statusMes << 434 139 435 if( report == NULL ) return( NULL ); << 140 while( 1 ) { 436 return( report->next ); << 141 if( ( message = (char *) realloc( message, size ) ) == NULL ) return( NULL ); >> 142 //TK110426 >> 143 #ifndef WIN32 >> 144 __va_copy( args_, *args ); >> 145 #endif >> 146 #ifdef WIN32 >> 147 args_ = *args; >> 148 #endif >> 149 n = vsnprintf( message, size, fmt, args_ ); >> 150 va_end( args_ ); >> 151 if( ( n > -1 ) && ( n < size ) ) break; >> 152 if( n > -1 ) { /* glibc 2.1 */ >> 153 size = n + 3; } >> 154 else { /* glibc 2.0 */ >> 155 size += 128; >> 156 } >> 157 } >> 158 return( message ); 437 } 159 } 438 /* 160 /* 439 ============================================== << 161 ************************************************************ 440 */ 162 */ 441 enum smr_status smr_getVerbosity( statusMessag << 163 static int smr_setMessage( statusMessageReporting *smr, void *userInterface, const char *file, int line, int code, >> 164 enum smr_status status, const char *fmt, va_list *args ) { 442 165 443 if( smr == NULL ) return( smr_status_Ok ); << 166 char *userMsg = NULL; 444 return( smr->verbosity ); << 167 int userSize; 445 } << 446 /* << 447 ============================================== << 448 */ << 449 int smr_getAppend( statusMessageReporting *smr << 450 168 451 if( smr == NULL ) return( 0 ); 169 if( smr == NULL ) return( 0 ); 452 return( smr->append ); << 170 smr_release( smr ); 453 } << 171 smr->status = status; 454 /* << 172 if( file != NULL ) strncpy( smr->packageName, file, smr_maximumPackageNameSize ); 455 ============================================== << 173 smr->packageName[smr_maximumPackageNameSize-1] = 0; 456 */ << 174 smr->line= line; 457 int smr_getLibraryID( statusMessageReport *rep << 175 smr->code = code; 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 176 491 if( report == NULL ) return( NULL ); << 177 if( ( smr->message = smr_vallocateFormatMessage( fmt, args ) ) == NULL ) return( smr_setAllocationFailure( smr, fmt, args ) ); 492 return( report->function ); << 178 if( userInterface != NULL ) { 493 } << 179 if( ( userSize = (*(smr_userInterface *) userInterface)( (void *) userInterface, NULL ) ) > 0 ) { 494 /* << 180 //if( (smr->message = realloc(smr->message, strlen( smr->message ) + userSize + 2)) == NULL ) return( smr_setAllocationFailure( smr, fmt, args ) ); 495 ============================================== << 181 if( (smr->message = (char*) realloc(smr->message, strlen( smr->message ) + userSize + 2)) == NULL ) return( smr_setAllocationFailure( smr, fmt, args ) ); 496 */ << 182 strcat( smr->message, "\n" ); 497 char const *smr_getMessage( statusMessageRepor << 183 userSize = (*(smr_userInterface *) userInterface)( (void *) userInterface, &userMsg ); 498 << 184 if( userSize < 0 ) return( smr_setAllocationFailure( smr, fmt, args ) ); 499 if( report == NULL ) return( NULL ); << 185 if( userSize > 0 ) { 500 return( report->message ); << 186 strcat( smr->message, userMsg ); >> 187 free( userMsg ); >> 188 } >> 189 } >> 190 } >> 191 return( 0 ); 501 } 192 } 502 /* 193 /* 503 ============================================== << 194 ************************************************************ 504 */ 195 */ 505 char *smr_copyMessage( statusMessageReport *re << 196 static int smr_setAllocationFailure( statusMessageReporting *smr, const char *fmt, va_list *args ) { 506 197 507 if( report == NULL ) return( NULL ); << 198 vfprintf( stderr, fmt, *args ); /* Assume calling routine calls va_end( args ). */ 508 if( report->status == smr_status_Ok ) retu << 199 fprintf( stderr, "\nAt line %d of %s\n", smr->line, smr->packageName ); 509 return( smr_allocateFormatMessage( report- << 200 smr->status = smr_status_Fatal; >> 201 smr->message = (char *) smr_mallocFailed; >> 202 return( 1 ); 510 } 203 } 511 /* 204 /* 512 ============================================== << 205 ************************************************************ 513 */ 206 */ 514 char *smr_copyFullMessage( statusMessageReport << 207 int smr_isOk( statusMessageReporting *smr ) { 515 208 516 if( report == NULL ) return( NULL ); << 209 if( smr == NULL ) return( 1 ); 517 if( report->status == smr_status_Ok ) retu << 210 return( smr->status == smr_status_Ok ); 518 return( smr_allocateFormatMessage( "%s\nAt << 519 } 211 } 520 /* 212 /* 521 ============================================== << 213 ************************************************************ 522 */ 214 */ 523 void smr_print( statusMessageReporting *smr, i << 215 int smr_isInfo( statusMessageReporting *smr ) { 524 216 525 smr_write( smr, stdout, clear ); << 217 if( smr == NULL ) return( 1 ); >> 218 return( smr->status == smr_status_Info ); 526 } 219 } 527 /* 220 /* 528 ============================================== << 221 ************************************************************ 529 */ 222 */ 530 void smr_write( statusMessageReporting *smr, F << 223 int smr_isError( statusMessageReporting *smr ) { 531 << 532 statusMessageReport *report; << 533 224 534 if( smr == NULL ) return; << 225 if( smr == NULL ) return( 1 ); 535 for( report = smr_firstReport( smr ); repo << 226 return( ( smr->status == smr_status_Error ) || ( smr->status == smr_status_Fatal ) ); 536 if( clear ) smr_release( smr ); << 537 } 227 } 538 /* 228 /* 539 ============================================== << 229 ************************************************************ 540 */ 230 */ 541 void smr_reportPrint( statusMessageReport *rep << 231 int smr_isFatal( statusMessageReporting *smr ) { 542 232 543 smr_reportWrite( report, stderr ); << 233 if( smr == NULL ) return( 1 ); >> 234 return( smr->status == smr_status_Fatal ); 544 } 235 } 545 /* 236 /* 546 ============================================== << 237 ************************************************************ 547 */ 238 */ 548 void smr_reportWrite( statusMessageReport *rep << 239 const char *smr_getMessage( statusMessageReporting *smr ) { 549 240 550 if( report->message != NULL ) fprintf( f, << 241 return( smr->message ); 551 } 242 } 552 /* 243 /* 553 ============================================== << 244 ************************************************************ 554 */ 245 */ 555 char const *smr_statusToString( enum smr_statu << 246 char *smr_getFullMessage( statusMessageReporting *smr ) { 556 247 557 switch( status ) { << 248 return( smr_getFullMessage2( "%s\nAt line %d of %s", smr->message, smr->line, smr->packageName ) ); 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 } 249 } 565 /* 250 /* 566 ============================================== << 251 ************************************************************ 567 */ 252 */ 568 char *smr_allocateFormatMessage( char const *f << 253 static char *smr_getFullMessage2( char const *fmt, ... ) { 569 254 570 char *s; << 571 va_list args; 255 va_list args; >> 256 char *message; 572 257 573 va_start( args, fmt ); 258 va_start( args, fmt ); 574 s = smr_vallocateFormatMessage( fmt, &args << 259 message = smr_vallocateFormatMessage( fmt, &args ); 575 va_end( args ); 260 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 ); 261 return( message ); 607 } 262 } 608 /* 263 /* 609 ============================================== << 264 ************************************************************ 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 */ 265 */ 640 void *smr_freeMemory( void **p ) { << 266 void smr_print( statusMessageReporting *smr, FILE *f, int clear ) { 641 267 642 if( p == NULL ) return( NULL ); << 268 if( smr->message != NULL ) fprintf( f, "%s\nAt line %d of %s\n", smr->message, smr->line, smr->packageName ); 643 if( *p != NULL ) { << 269 if( clear ) smr_release( smr ); 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 } 270 } 688 271 689 #if defined __cplusplus 272 #if defined __cplusplus 690 } 273 } 691 #endif 274 #endif 692 275