89 #define KMP_STR_BUF_INVARIANT( b ) \
91 KMP_DEBUG_ASSERT( (b)->str != NULL ); \
92 KMP_DEBUG_ASSERT( (b)->size >= sizeof( (b)->bulk ) ); \
93 KMP_DEBUG_ASSERT( (b)->size % sizeof( (b)->bulk ) == 0 ); \
94 KMP_DEBUG_ASSERT( (unsigned)(b)->used < (b)->size ); \
95 KMP_DEBUG_ASSERT( (b)->size == sizeof( (b)->bulk ) ? (b)->str == & (b)->bulk[ 0 ] : 1 ); \
96 KMP_DEBUG_ASSERT( (b)->size > sizeof( (b)->bulk ) ? (b)->str != & (b)->bulk[ 0 ] : 1 ); \
101 kmp_str_buf_t * buffer
103 KMP_STR_BUF_INVARIANT( buffer );
104 if ( buffer->used > 0 ) {
106 buffer->str[ 0 ] = 0;
108 KMP_STR_BUF_INVARIANT( buffer );
113 __kmp_str_buf_reserve(
114 kmp_str_buf_t * buffer,
118 KMP_STR_BUF_INVARIANT( buffer );
119 KMP_DEBUG_ASSERT( size >= 0 );
121 if ( buffer->size < (
unsigned int)size ) {
126 }
while ( buffer->size < (
unsigned int)size );
129 if ( buffer->str == & buffer->bulk[ 0 ] ) {
130 buffer->str = (
char *) KMP_INTERNAL_MALLOC( buffer->size );
131 if ( buffer->str == NULL ) {
132 KMP_FATAL( MemoryAllocFailed );
134 KMP_MEMCPY_S( buffer->str, buffer->size, buffer->bulk, buffer->used + 1 );
136 buffer->str = (
char *) KMP_INTERNAL_REALLOC( buffer->str, buffer->size );
137 if ( buffer->str == NULL ) {
138 KMP_FATAL( MemoryAllocFailed );
144 KMP_DEBUG_ASSERT( buffer->size > 0 );
145 KMP_DEBUG_ASSERT( buffer->size >= (
unsigned)size );
146 KMP_STR_BUF_INVARIANT( buffer );
152 __kmp_str_buf_detach(
153 kmp_str_buf_t * buffer
156 KMP_STR_BUF_INVARIANT( buffer );
159 if ( buffer->size <=
sizeof( buffer->bulk ) ) {
160 buffer->str = (
char *) KMP_INTERNAL_MALLOC( buffer->size );
161 if ( buffer->str == NULL ) {
162 KMP_FATAL( MemoryAllocFailed );
164 KMP_MEMCPY_S( buffer->str, buffer->size, buffer->bulk, buffer->used + 1 );
172 kmp_str_buf_t * buffer
174 KMP_STR_BUF_INVARIANT( buffer );
175 if ( buffer->size >
sizeof( buffer->bulk ) ) {
176 KMP_INTERNAL_FREE( buffer->str );
178 buffer->str = buffer->bulk;
179 buffer->size =
sizeof( buffer->bulk );
181 KMP_STR_BUF_INVARIANT( buffer );
187 kmp_str_buf_t * buffer,
191 KMP_STR_BUF_INVARIANT( buffer );
192 KMP_DEBUG_ASSERT( str != NULL );
193 KMP_DEBUG_ASSERT( len >= 0 );
194 __kmp_str_buf_reserve( buffer, buffer->used + len + 1 );
195 KMP_MEMCPY( buffer->str + buffer->used, str, len );
196 buffer->str[ buffer->used + len ] = 0;
198 KMP_STR_BUF_INVARIANT( buffer );
203 __kmp_str_buf_vprint(
204 kmp_str_buf_t * buffer,
209 KMP_STR_BUF_INVARIANT( buffer );
213 int const free = buffer->size - buffer->used;
230 __va_copy( _args, args );
231 #define args _args // Substitute args with its copy, _args.
232 #endif // KMP_OS_WINDOWS
233 rc = KMP_VSNPRINTF( buffer->str + buffer->used, free, format, args );
235 #undef args // Remove substitution.
237 #endif // KMP_OS_WINDOWS
241 if ( rc >= 0 && rc < free ) {
249 size = buffer->used + rc + 1;
252 size = buffer->size * 2;
256 __kmp_str_buf_reserve( buffer, size );
262 KMP_DEBUG_ASSERT( buffer->size > 0 );
263 KMP_STR_BUF_INVARIANT( buffer );
270 kmp_str_buf_t * buffer,
276 va_start( args, format );
277 __kmp_str_buf_vprint( buffer, format, args );
289 __kmp_str_buf_print_size(
294 char const * names[] = {
"",
"k",
"M",
"G",
"T",
"P",
"E",
"Z",
"Y" };
295 int const units =
sizeof( names ) /
sizeof(
char const * );
299 while ( ( size % 1024 == 0 ) && ( u + 1 < units ) ) {
305 __kmp_str_buf_print( buf,
"%" KMP_SIZE_T_SPEC
"%s", size, names[ u ] );
311 __kmp_str_fname_init(
312 kmp_str_fname_t * fname,
320 if ( path != NULL ) {
323 fname->path = __kmp_str_format(
"%s", path );
326 if ( KMP_OS_WINDOWS ) {
327 __kmp_str_replace( fname->path,
'\\',
'/' );
329 fname->dir = __kmp_str_format(
"%s", fname->path );
330 slash = strrchr( fname->dir,
'/' );
331 if ( KMP_OS_WINDOWS && slash == NULL ) {
332 char first = TOLOWER( fname->dir[ 0 ] );
333 if (
'a' <= first && first <= 'z' && fname->dir[ 1 ] ==
':' ) {
334 slash = & fname->dir[ 1 ];
337 base = ( slash == NULL ? fname->dir : slash + 1 );
338 fname->base = __kmp_str_format(
"%s", base );
346 __kmp_str_fname_free(
347 kmp_str_fname_t * fname
349 __kmp_str_free( (
char const **)( & fname->path ) );
350 __kmp_str_free( (
char const **)( & fname->dir ) );
351 __kmp_str_free( (
char const **)( & fname->base ) );
356 __kmp_str_fname_match(
357 kmp_str_fname_t
const * fname,
364 if ( pattern != NULL ) {
365 kmp_str_fname_t ptrn;
366 __kmp_str_fname_init( & ptrn, pattern );
368 strcmp( ptrn.dir,
"*/" ) == 0
370 ( fname->dir != NULL && __kmp_str_eqf( fname->dir, ptrn.dir ) );
372 strcmp( ptrn.base,
"*" ) == 0
374 ( fname->base != NULL && __kmp_str_eqf( fname->base, ptrn.base ) );
375 __kmp_str_fname_free( & ptrn );
378 return dir_match && base_match;
385 char const * psource,
397 if ( psource != NULL ) {
405 loc._bulk = __kmp_str_format(
"%s", psource );
409 __kmp_str_split( str,
';', & dummy, & str );
410 __kmp_str_split( str,
';', & loc.file, & str );
411 __kmp_str_split( str,
';', & loc.func, & str );
412 __kmp_str_split( str,
';', & line, & str );
413 __kmp_str_split( str,
';', & col, & str );
416 if ( line != NULL ) {
417 loc.line = atoi( line );
418 if ( loc.line < 0 ) {
423 loc.col = atoi( col );
431 __kmp_str_fname_init( & loc.fname, init_fname ? loc.file : NULL );
442 __kmp_str_fname_free( & loc->fname );
443 KMP_INTERNAL_FREE( loc->_bulk );
465 result = ( _stricmp( lhs, rhs ) == 0 );
467 result = ( strcmp( lhs, rhs ) == 0 );
511 char * buffer = NULL;
515 buffer = (
char *) KMP_INTERNAL_MALLOC( size );
516 if ( buffer == NULL ) {
517 KMP_FATAL( MemoryAllocFailed );
523 va_start( args, format );
524 rc = KMP_VSNPRINTF( buffer, size, format, args );
528 if ( rc >= 0 && rc < size ) {
542 buffer = (
char *) KMP_INTERNAL_REALLOC( buffer, size );
543 if ( buffer == NULL ) {
544 KMP_FATAL( MemoryAllocFailed );
558 KMP_DEBUG_ASSERT( str != NULL );
559 KMP_INTERNAL_FREE( (
void *) * str );
576 if ( target == NULL || data == NULL ) {
579 for ( i = 0; target[i] && data[i]; ++ i ) {
580 if ( TOLOWER( target[i] ) != TOLOWER( data[i] ) ) {
584 return ( ( len > 0 ) ? i >= len : ( ! target[i] && ( len || ! data[i] ) ) );
589 __kmp_str_match_false(
char const * data ) {
591 __kmp_str_match(
"false", 1, data ) ||
592 __kmp_str_match(
"off", 2, data ) ||
593 __kmp_str_match(
"0", 1, data ) ||
594 __kmp_str_match(
".false.", 2, data ) ||
595 __kmp_str_match(
".f.", 2, data ) ||
596 __kmp_str_match(
"no", 1, data );
602 __kmp_str_match_true(
char const * data ) {
604 __kmp_str_match(
"true", 1, data ) ||
605 __kmp_str_match(
"on", 2, data ) ||
606 __kmp_str_match(
"1", 1, data ) ||
607 __kmp_str_match(
".true.", 2, data ) ||
608 __kmp_str_match(
".t.", 2, data ) ||
609 __kmp_str_match(
"yes", 1, data );
622 found = strchr( str, search_for );
624 * found = replace_with;
625 found = strchr( found + 1, search_for );
641 char * ptr = strchr( str, delim );
647 if ( head != NULL ) {
650 if ( tail != NULL ) {
670 * buf += strspn( * buf, delim );
673 * buf += strcspn( * buf, delim );
681 token = strtok_r( str, delim, buf );
697 for (t = str; *t !=
'\0'; ++t) {
698 if (*t < '0' || *t >
'9')
700 result = (result * 10) + (*t -
'0');
717 factor = (1024 * 1024);
726 if (result > (INT_MAX / factor))
731 return (*t != 0 ? 0 : result);
760 KMP_DEBUG_ASSERT( str != NULL );
763 while ( str[ i ] ==
' ' || str[ i ] ==
'\t') {
768 if ( str[ i ] <
'0' || str[ i ] >
'9' ) {
769 * error = KMP_I18N_STR( NotANumber );
773 digit = str[ i ] -
'0';
774 overflow = overflow || ( value > ( KMP_SIZE_T_MAX - digit ) / 10 );
775 value = ( value * 10 ) + digit;
777 }
while ( str[ i ] >=
'0' && str[ i ] <=
'9' );
780 while ( str[ i ] ==
' ' || str[ i ] ==
'\t' ) {
785 #define _case( ch, exp ) \
787 case ch - ( 'a' - 'A' ) : { \
788 size_t shift = (exp) * 10; \
790 if ( shift < sizeof( size_t ) * 8 ) { \
791 factor = (size_t)( 1 ) << shift; \
796 switch ( str[ i ] ) {
808 if ( str[ i ] ==
'b' || str[ i ] ==
'B' ) {
814 if ( ! ( str[ i ] ==
' ' || str[ i ] ==
'\t' || str[ i ] == 0 ) ) {
815 * error = KMP_I18N_STR( BadUnit );
824 overflow = overflow || ( value > ( KMP_SIZE_T_MAX / factor ) );
828 while ( str[ i ] ==
' ' || str[ i ] ==
'\t' ) {
832 if ( str[ i ] != 0 ) {
833 * error = KMP_I18N_STR( IllegalCharacters );
838 * error = KMP_I18N_STR( ValueTooLarge );
839 * out = KMP_SIZE_T_MAX;
862 KMP_DEBUG_ASSERT( str != NULL );
865 while ( str[ i ] ==
' ' || str[ i ] ==
'\t' ) {
870 if ( str[ i ] <
'0' || str[ i ] >
'9' ) {
871 * error = KMP_I18N_STR( NotANumber );
875 digit = str[ i ] -
'0';
876 overflow = overflow || ( value > ( KMP_SIZE_T_MAX - digit ) / 10 );
877 value = ( value * 10 ) + digit;
879 }
while ( str[ i ] >=
'0' && str[ i ] <=
'9' );
882 while ( str[ i ] ==
' ' || str[ i ] ==
'\t' ) {
886 if ( str[ i ] != 0 ) {
887 * error = KMP_I18N_STR( IllegalCharacters );
892 * error = KMP_I18N_STR( ValueTooLarge );
893 * out = (kmp_uint64) -1;