70 #define KMP_STR_BUF_INVARIANT( b ) \ 72 KMP_DEBUG_ASSERT( (b)->str != NULL ); \ 73 KMP_DEBUG_ASSERT( (b)->size >= sizeof( (b)->bulk ) ); \ 74 KMP_DEBUG_ASSERT( (b)->size % sizeof( (b)->bulk ) == 0 ); \ 75 KMP_DEBUG_ASSERT( (unsigned)(b)->used < (b)->size ); \ 76 KMP_DEBUG_ASSERT( (b)->size == sizeof( (b)->bulk ) ? (b)->str == & (b)->bulk[ 0 ] : 1 ); \ 77 KMP_DEBUG_ASSERT( (b)->size > sizeof( (b)->bulk ) ? (b)->str != & (b)->bulk[ 0 ] : 1 ); \ 82 kmp_str_buf_t * buffer
84 KMP_STR_BUF_INVARIANT( buffer );
85 if ( buffer->used > 0 ) {
89 KMP_STR_BUF_INVARIANT( buffer );
94 __kmp_str_buf_reserve(
95 kmp_str_buf_t * buffer,
99 KMP_STR_BUF_INVARIANT( buffer );
100 KMP_DEBUG_ASSERT( size >= 0 );
102 if ( buffer->size < (
unsigned int)size ) {
107 }
while ( buffer->size < (
unsigned int)size );
110 if ( buffer->str == & buffer->bulk[ 0 ] ) {
111 buffer->str = (
char *) KMP_INTERNAL_MALLOC( buffer->size );
112 if ( buffer->str == NULL ) {
113 KMP_FATAL( MemoryAllocFailed );
115 KMP_MEMCPY_S( buffer->str, buffer->size, buffer->bulk, buffer->used + 1 );
117 buffer->str = (
char *) KMP_INTERNAL_REALLOC( buffer->str, buffer->size );
118 if ( buffer->str == NULL ) {
119 KMP_FATAL( MemoryAllocFailed );
125 KMP_DEBUG_ASSERT( buffer->size > 0 );
126 KMP_DEBUG_ASSERT( buffer->size >= (
unsigned)size );
127 KMP_STR_BUF_INVARIANT( buffer );
133 __kmp_str_buf_detach(
134 kmp_str_buf_t * buffer
137 KMP_STR_BUF_INVARIANT( buffer );
140 if ( buffer->size <=
sizeof( buffer->bulk ) ) {
141 buffer->str = (
char *) KMP_INTERNAL_MALLOC( buffer->size );
142 if ( buffer->str == NULL ) {
143 KMP_FATAL( MemoryAllocFailed );
145 KMP_MEMCPY_S( buffer->str, buffer->size, buffer->bulk, buffer->used + 1 );
153 kmp_str_buf_t * buffer
155 KMP_STR_BUF_INVARIANT( buffer );
156 if ( buffer->size >
sizeof( buffer->bulk ) ) {
157 KMP_INTERNAL_FREE( buffer->str );
159 buffer->str = buffer->bulk;
160 buffer->size =
sizeof( buffer->bulk );
162 KMP_STR_BUF_INVARIANT( buffer );
168 kmp_str_buf_t * buffer,
172 KMP_STR_BUF_INVARIANT( buffer );
173 KMP_DEBUG_ASSERT( str != NULL );
174 KMP_DEBUG_ASSERT( len >= 0 );
175 __kmp_str_buf_reserve( buffer, buffer->used + len + 1 );
176 KMP_MEMCPY( buffer->str + buffer->used, str, len );
177 buffer->str[ buffer->used + len ] = 0;
179 KMP_STR_BUF_INVARIANT( buffer );
184 __kmp_str_buf_vprint(
185 kmp_str_buf_t * buffer,
190 KMP_STR_BUF_INVARIANT( buffer );
194 int const free = buffer->size - buffer->used;
211 __va_copy( _args, args );
212 #define args _args // Substitute args with its copy, _args. 213 #endif // KMP_OS_WINDOWS 214 rc = KMP_VSNPRINTF( buffer->str + buffer->used, free, format, args );
216 #undef args // Remove substitution. 218 #endif // KMP_OS_WINDOWS 222 if ( rc >= 0 && rc < free ) {
230 size = buffer->used + rc + 1;
233 size = buffer->size * 2;
237 __kmp_str_buf_reserve( buffer, size );
243 KMP_DEBUG_ASSERT( buffer->size > 0 );
244 KMP_STR_BUF_INVARIANT( buffer );
251 kmp_str_buf_t * buffer,
257 va_start( args, format );
258 __kmp_str_buf_vprint( buffer, format, args );
270 __kmp_str_buf_print_size(
275 char const * names[] = {
"",
"k",
"M",
"G",
"T",
"P",
"E",
"Z",
"Y" };
276 int const units =
sizeof( names ) /
sizeof(
char const * );
279 while ( ( size % 1024 == 0 ) && ( u + 1 < units ) ) {
285 __kmp_str_buf_print( buf,
"%" KMP_SIZE_T_SPEC
"%s", size, names[ u ] );
291 __kmp_str_fname_init(
292 kmp_str_fname_t * fname,
300 if ( path != NULL ) {
303 fname->path = __kmp_str_format(
"%s", path );
306 if ( KMP_OS_WINDOWS ) {
307 __kmp_str_replace( fname->path,
'\\',
'/' );
309 fname->dir = __kmp_str_format(
"%s", fname->path );
310 slash = strrchr( fname->dir,
'/' );
311 if ( KMP_OS_WINDOWS && slash == NULL ) {
312 char first = TOLOWER( fname->dir[ 0 ] );
313 if (
'a' <= first && first <= 'z' && fname->dir[ 1 ] ==
':' ) {
314 slash = & fname->dir[ 1 ];
317 base = ( slash == NULL ? fname->dir : slash + 1 );
318 fname->base = __kmp_str_format(
"%s", base );
326 __kmp_str_fname_free(
327 kmp_str_fname_t * fname
329 __kmp_str_free( (
char const **)( & fname->path ) );
330 __kmp_str_free( (
char const **)( & fname->dir ) );
331 __kmp_str_free( (
char const **)( & fname->base ) );
336 __kmp_str_fname_match(
337 kmp_str_fname_t
const * fname,
344 if ( pattern != NULL ) {
345 kmp_str_fname_t ptrn;
346 __kmp_str_fname_init( & ptrn, pattern );
348 strcmp( ptrn.dir,
"*/" ) == 0
350 ( fname->dir != NULL && __kmp_str_eqf( fname->dir, ptrn.dir ) );
352 strcmp( ptrn.base,
"*" ) == 0
354 ( fname->base != NULL && __kmp_str_eqf( fname->base, ptrn.base ) );
355 __kmp_str_fname_free( & ptrn );
358 return dir_match && base_match;
365 char const * psource,
377 if ( psource != NULL ) {
385 loc._bulk = __kmp_str_format(
"%s", psource );
389 __kmp_str_split( str,
';', & dummy, & str );
390 __kmp_str_split( str,
';', & loc.file, & str );
391 __kmp_str_split( str,
';', & loc.func, & str );
392 __kmp_str_split( str,
';', & line, & str );
393 __kmp_str_split( str,
';', & col, & str );
396 if ( line != NULL ) {
397 loc.line = atoi( line );
398 if ( loc.line < 0 ) {
403 loc.col = atoi( col );
411 __kmp_str_fname_init( & loc.fname, init_fname ? loc.file : NULL );
422 __kmp_str_fname_free( & loc->fname );
423 __kmp_str_free((
const char **) &(loc->_bulk));
444 result = ( _stricmp( lhs, rhs ) == 0 );
446 result = ( strcmp( lhs, rhs ) == 0 );
488 char * buffer = NULL;
492 buffer = (
char *) KMP_INTERNAL_MALLOC( size );
493 if ( buffer == NULL ) {
494 KMP_FATAL( MemoryAllocFailed );
500 va_start( args, format );
501 rc = KMP_VSNPRINTF( buffer, size, format, args );
505 if ( rc >= 0 && rc < size ) {
519 buffer = (
char *) KMP_INTERNAL_REALLOC( buffer, size );
520 if ( buffer == NULL ) {
521 KMP_FATAL( MemoryAllocFailed );
535 KMP_DEBUG_ASSERT( str != NULL );
536 KMP_INTERNAL_FREE( (
void *) * str );
553 if ( target == NULL || data == NULL ) {
556 for ( i = 0; target[i] && data[i]; ++ i ) {
557 if ( TOLOWER( target[i] ) != TOLOWER( data[i] ) ) {
561 return ( ( len > 0 ) ? i >= len : ( ! target[i] && ( len || ! data[i] ) ) );
566 __kmp_str_match_false(
char const * data ) {
568 __kmp_str_match(
"false", 1, data ) ||
569 __kmp_str_match(
"off", 2, data ) ||
570 __kmp_str_match(
"0", 1, data ) ||
571 __kmp_str_match(
".false.", 2, data ) ||
572 __kmp_str_match(
".f.", 2, data ) ||
573 __kmp_str_match(
"no", 1, data );
579 __kmp_str_match_true(
char const * data ) {
581 __kmp_str_match(
"true", 1, data ) ||
582 __kmp_str_match(
"on", 2, data ) ||
583 __kmp_str_match(
"1", 1, data ) ||
584 __kmp_str_match(
".true.", 2, data ) ||
585 __kmp_str_match(
".t.", 2, data ) ||
586 __kmp_str_match(
"yes", 1, data );
599 found = strchr( str, search_for );
601 * found = replace_with;
602 found = strchr( found + 1, search_for );
618 char * ptr = strchr( str, delim );
624 if ( head != NULL ) {
627 if ( tail != NULL ) {
647 * buf += strspn( * buf, delim );
650 * buf += strcspn( * buf, delim );
658 token = strtok_r( str, delim, buf );
674 for (t = str; *t !=
'\0'; ++t) {
675 if (*t < '0' || *t >
'9')
677 result = (result * 10) + (*t -
'0');
694 factor = (1024 * 1024);
703 if (result > (INT_MAX / factor))
708 return (*t != 0 ? 0 : result);
736 KMP_DEBUG_ASSERT( str != NULL );
739 while ( str[ i ] ==
' ' || str[ i ] ==
'\t') {
744 if ( str[ i ] <
'0' || str[ i ] >
'9' ) {
745 * error = KMP_I18N_STR( NotANumber );
749 digit = str[ i ] -
'0';
750 overflow = overflow || ( value > ( KMP_SIZE_T_MAX - digit ) / 10 );
751 value = ( value * 10 ) + digit;
753 }
while ( str[ i ] >=
'0' && str[ i ] <=
'9' );
756 while ( str[ i ] ==
' ' || str[ i ] ==
'\t' ) {
761 #define _case( ch, exp ) \ 763 case ch - ( 'a' - 'A' ) : { \ 764 size_t shift = (exp) * 10; \ 766 if ( shift < sizeof( size_t ) * 8 ) { \ 767 factor = (size_t)( 1 ) << shift; \ 772 switch ( str[ i ] ) {
784 if ( str[ i ] ==
'b' || str[ i ] ==
'B' ) {
790 if ( ! ( str[ i ] ==
' ' || str[ i ] ==
'\t' || str[ i ] == 0 ) ) {
791 * error = KMP_I18N_STR( BadUnit );
800 overflow = overflow || ( value > ( KMP_SIZE_T_MAX / factor ) );
804 while ( str[ i ] ==
' ' || str[ i ] ==
'\t' ) {
808 if ( str[ i ] != 0 ) {
809 * error = KMP_I18N_STR( IllegalCharacters );
814 * error = KMP_I18N_STR( ValueTooLarge );
815 * out = KMP_SIZE_T_MAX;
838 KMP_DEBUG_ASSERT( str != NULL );
841 while ( str[ i ] ==
' ' || str[ i ] ==
'\t' ) {
846 if ( str[ i ] <
'0' || str[ i ] >
'9' ) {
847 * error = KMP_I18N_STR( NotANumber );
851 digit = str[ i ] -
'0';
852 overflow = overflow || ( value > ( KMP_SIZE_T_MAX - digit ) / 10 );
853 value = ( value * 10 ) + digit;
855 }
while ( str[ i ] >=
'0' && str[ i ] <=
'9' );
858 while ( str[ i ] ==
' ' || str[ i ] ==
'\t' ) {
862 if ( str[ i ] != 0 ) {
863 * error = KMP_I18N_STR( IllegalCharacters );
868 * error = KMP_I18N_STR( ValueTooLarge );
869 * out = (kmp_uint64) -1;