91 #define KMP_STR_BUF_INVARIANT( b ) \
93 KMP_DEBUG_ASSERT( (b)->str != NULL ); \
94 KMP_DEBUG_ASSERT( (b)->size >= sizeof( (b)->bulk ) ); \
95 KMP_DEBUG_ASSERT( (b)->size % sizeof( (b)->bulk ) == 0 ); \
96 KMP_DEBUG_ASSERT( (unsigned)(b)->used < (b)->size ); \
97 KMP_DEBUG_ASSERT( (b)->size == sizeof( (b)->bulk ) ? (b)->str == & (b)->bulk[ 0 ] : 1 ); \
98 KMP_DEBUG_ASSERT( (b)->size > sizeof( (b)->bulk ) ? (b)->str != & (b)->bulk[ 0 ] : 1 ); \
103 kmp_str_buf_t * buffer
105 KMP_STR_BUF_INVARIANT( buffer );
106 if ( buffer->used > 0 ) {
108 buffer->str[ 0 ] = 0;
110 KMP_STR_BUF_INVARIANT( buffer );
115 __kmp_str_buf_reserve(
116 kmp_str_buf_t * buffer,
120 KMP_STR_BUF_INVARIANT( buffer );
121 KMP_DEBUG_ASSERT( size >= 0 );
123 if ( buffer->size < (
unsigned int)size ) {
128 }
while ( buffer->size < (
unsigned int)size );
131 if ( buffer->str == & buffer->bulk[ 0 ] ) {
132 buffer->str = (
char *) KMP_INTERNAL_MALLOC( buffer->size );
133 if ( buffer->str == NULL ) {
134 KMP_FATAL( MemoryAllocFailed );
136 memcpy( buffer->str, buffer->bulk, buffer->used + 1 );
138 buffer->str = (
char *) KMP_INTERNAL_REALLOC( buffer->str, buffer->size );
139 if ( buffer->str == NULL ) {
140 KMP_FATAL( MemoryAllocFailed );
146 KMP_DEBUG_ASSERT( buffer->size > 0 );
147 KMP_DEBUG_ASSERT( buffer->size >= (
unsigned)size );
148 KMP_STR_BUF_INVARIANT( buffer );
154 __kmp_str_buf_detach(
155 kmp_str_buf_t * buffer
158 KMP_STR_BUF_INVARIANT( buffer );
161 if ( buffer->size <=
sizeof( buffer->bulk ) ) {
162 buffer->str = (
char *) KMP_INTERNAL_MALLOC( buffer->size );
163 if ( buffer->str == NULL ) {
164 KMP_FATAL( MemoryAllocFailed );
166 memcpy( buffer->str, buffer->bulk, buffer->used + 1 );
174 kmp_str_buf_t * buffer
176 KMP_STR_BUF_INVARIANT( buffer );
177 if ( buffer->size >
sizeof( buffer->bulk ) ) {
178 KMP_INTERNAL_FREE( buffer->str );
180 buffer->str = buffer->bulk;
181 buffer->size =
sizeof( buffer->bulk );
183 KMP_STR_BUF_INVARIANT( buffer );
189 kmp_str_buf_t * buffer,
193 KMP_STR_BUF_INVARIANT( buffer );
194 KMP_DEBUG_ASSERT( str != NULL );
195 KMP_DEBUG_ASSERT( len >= 0 );
196 __kmp_str_buf_reserve( buffer, buffer->used + len + 1 );
197 memcpy( buffer->str + buffer->used, str, len );
198 buffer->str[ buffer->used + len ] = 0;
200 KMP_STR_BUF_INVARIANT( buffer );
205 __kmp_str_buf_vprint(
206 kmp_str_buf_t * buffer,
211 KMP_STR_BUF_INVARIANT( buffer );
215 int const free = buffer->size - buffer->used;
232 __va_copy( _args, args );
233 #define args _args // Substitute args with its copy, _args.
234 #endif // KMP_OS_WINDOWS
235 rc = vsnprintf( buffer->str + buffer->used, free, format, args );
237 #undef args // Remove substitution.
239 #endif // KMP_OS_WINDOWS
243 if ( rc >= 0 && rc < free ) {
251 size = buffer->used + rc + 1;
254 size = buffer->size * 2;
258 __kmp_str_buf_reserve( buffer, size );
264 KMP_DEBUG_ASSERT( buffer->size > 0 );
265 KMP_STR_BUF_INVARIANT( buffer );
272 kmp_str_buf_t * buffer,
278 va_start( args, format );
279 __kmp_str_buf_vprint( buffer, format, args );
291 __kmp_str_buf_print_size(
296 char const * names[] = {
"",
"k",
"M",
"G",
"T",
"P",
"E",
"Z",
"Y" };
297 int const units =
sizeof( names ) /
sizeof(
char const * );
301 while ( ( size % 1024 == 0 ) && ( u + 1 < units ) ) {
307 __kmp_str_buf_print( buf,
"%" KMP_SIZE_T_SPEC
"%s", size, names[ u ] );
313 __kmp_str_fname_init(
314 kmp_str_fname_t * fname,
322 if ( path != NULL ) {
325 fname->path = __kmp_str_format(
"%s", path );
328 if ( KMP_OS_WINDOWS ) {
329 __kmp_str_replace( fname->path,
'\\',
'/' );
331 fname->dir = __kmp_str_format(
"%s", fname->path );
332 slash = strrchr( fname->dir,
'/' );
333 if ( KMP_OS_WINDOWS && slash == NULL ) {
334 char first = TOLOWER( fname->dir[ 0 ] );
335 if (
'a' <= first && first <= 'z' && fname->dir[ 1 ] ==
':' ) {
336 slash = & fname->dir[ 1 ];
339 base = ( slash == NULL ? fname->dir : slash + 1 );
340 fname->base = __kmp_str_format(
"%s", base );
348 __kmp_str_fname_free(
349 kmp_str_fname_t * fname
351 __kmp_str_free( const_cast< char const ** >( & fname->path ) );
352 __kmp_str_free( const_cast< char const ** >( & fname->dir ) );
353 __kmp_str_free( const_cast< char const ** >( & fname->base ) );
358 __kmp_str_fname_match(
359 kmp_str_fname_t
const * fname,
366 if ( pattern != NULL ) {
367 kmp_str_fname_t ptrn;
368 __kmp_str_fname_init( & ptrn, pattern );
370 strcmp( ptrn.dir,
"*/" ) == 0
372 ( fname->dir != NULL && __kmp_str_eqf( fname->dir, ptrn.dir ) );
374 strcmp( ptrn.base,
"*" ) == 0
376 ( fname->base != NULL && __kmp_str_eqf( fname->base, ptrn.base ) );
377 __kmp_str_fname_free( & ptrn );
380 return dir_match && base_match;
387 char const * psource,
399 if ( psource != NULL ) {
407 loc._bulk = __kmp_str_format(
"%s", psource );
411 __kmp_str_split( str,
';', & dummy, & str );
412 __kmp_str_split( str,
';', & loc.file, & str );
413 __kmp_str_split( str,
';', & loc.func, & str );
414 __kmp_str_split( str,
';', & line, & str );
415 __kmp_str_split( str,
';', & col, & str );
418 if ( line != NULL ) {
419 loc.line = atoi( line );
420 if ( loc.line < 0 ) {
425 loc.col = atoi( col );
433 __kmp_str_fname_init( & loc.fname, init_fname ? loc.file : NULL );
444 __kmp_str_fname_free( & loc->fname );
445 KMP_INTERNAL_FREE( loc->_bulk );
467 result = ( _stricmp( lhs, rhs ) == 0 );
469 result = ( strcmp( lhs, rhs ) == 0 );
513 char * buffer = NULL;
517 buffer = (
char *) KMP_INTERNAL_MALLOC( size );
518 if ( buffer == NULL ) {
519 KMP_FATAL( MemoryAllocFailed );
525 va_start( args, format );
526 rc = vsnprintf( buffer, size, format, args );
530 if ( rc >= 0 && rc < size ) {
544 buffer = (
char *) KMP_INTERNAL_REALLOC( buffer, size );
545 if ( buffer == NULL ) {
546 KMP_FATAL( MemoryAllocFailed );
560 KMP_DEBUG_ASSERT( str != NULL );
561 KMP_INTERNAL_FREE( (
void *) * str );
578 if ( target == NULL || data == NULL ) {
581 for ( i = 0; target[i] && data[i]; ++ i ) {
582 if ( TOLOWER( target[i] ) != TOLOWER( data[i] ) ) {
586 return ( ( len > 0 ) ? i >= len : ( ! target[i] && ( len || ! data[i] ) ) );
591 __kmp_str_match_false(
char const * data ) {
593 __kmp_str_match(
"false", 1, data ) ||
594 __kmp_str_match(
"off", 2, data ) ||
595 __kmp_str_match(
"0", 1, data ) ||
596 __kmp_str_match(
".false.", 2, data ) ||
597 __kmp_str_match(
".f.", 2, data ) ||
598 __kmp_str_match(
"no", 1, data );
604 __kmp_str_match_true(
char const * data ) {
606 __kmp_str_match(
"true", 1, data ) ||
607 __kmp_str_match(
"on", 2, data ) ||
608 __kmp_str_match(
"1", 1, data ) ||
609 __kmp_str_match(
".true.", 2, data ) ||
610 __kmp_str_match(
".t.", 2, data ) ||
611 __kmp_str_match(
"yes", 1, data );
624 found = strchr( str, search_for );
626 * found = replace_with;
627 found = strchr( found + 1, search_for );
643 char * ptr = strchr( str, delim );
649 if ( head != NULL ) {
652 if ( tail != NULL ) {
672 * buf += strspn( * buf, delim );
675 * buf += strcspn( * buf, delim );
683 token = strtok_r( str, delim, buf );
699 for (t = str; *t !=
'\0'; ++t) {
700 if (*t < '0' || *t >
'9')
702 result = (result * 10) + (*t -
'0');
719 factor = (1024 * 1024);
728 if (result > (INT_MAX / factor))
733 return (*t != 0 ? 0 : result);
762 KMP_DEBUG_ASSERT( str != NULL );
765 while ( str[ i ] ==
' ' || str[ i ] ==
'\t') {
770 if ( str[ i ] <
'0' || str[ i ] >
'9' ) {
771 * error = KMP_I18N_STR( NotANumber );
775 digit = str[ i ] -
'0';
776 overflow = overflow || ( value > ( KMP_SIZE_T_MAX - digit ) / 10 );
777 value = ( value * 10 ) + digit;
779 }
while ( str[ i ] >=
'0' && str[ i ] <=
'9' );
782 while ( str[ i ] ==
' ' || str[ i ] ==
'\t' ) {
787 #define _case( ch, exp ) \
789 case ch - ( 'a' - 'A' ) : { \
790 size_t shift = (exp) * 10; \
792 if ( shift < sizeof( size_t ) * 8 ) { \
793 factor = (size_t)( 1 ) << shift; \
798 switch ( str[ i ] ) {
810 if ( str[ i ] ==
'b' || str[ i ] ==
'B' ) {
816 if ( ! ( str[ i ] ==
' ' || str[ i ] ==
'\t' || str[ i ] == 0 ) ) {
817 * error = KMP_I18N_STR( BadUnit );
826 overflow = overflow || ( value > ( KMP_SIZE_T_MAX / factor ) );
830 while ( str[ i ] ==
' ' || str[ i ] ==
'\t' ) {
834 if ( str[ i ] != 0 ) {
835 * error = KMP_I18N_STR( IllegalCharacters );
840 * error = KMP_I18N_STR( ValueTooLarge );
841 * out = KMP_SIZE_T_MAX;
864 KMP_DEBUG_ASSERT( str != NULL );
867 while ( str[ i ] ==
' ' || str[ i ] ==
'\t' ) {
872 if ( str[ i ] <
'0' || str[ i ] >
'9' ) {
873 * error = KMP_I18N_STR( NotANumber );
877 digit = str[ i ] -
'0';
878 overflow = overflow || ( value > ( KMP_SIZE_T_MAX - digit ) / 10 );
879 value = ( value * 10 ) + digit;
881 }
while ( str[ i ] >=
'0' && str[ i ] <=
'9' );
884 while ( str[ i ] ==
' ' || str[ i ] ==
'\t' ) {
888 if ( str[ i ] != 0 ) {
889 * error = KMP_I18N_STR( IllegalCharacters );
894 * error = KMP_I18N_STR( ValueTooLarge );
895 * out = (kmp_uint64) -1;