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_INTERNAL_FREE( loc->_bulk );
445 result = ( _stricmp( lhs, rhs ) == 0 );
447 result = ( strcmp( lhs, rhs ) == 0 );
491 char * buffer = NULL;
495 buffer = (
char *) KMP_INTERNAL_MALLOC( size );
496 if ( buffer == NULL ) {
497 KMP_FATAL( MemoryAllocFailed );
503 va_start( args, format );
504 rc = KMP_VSNPRINTF( buffer, size, format, args );
508 if ( rc >= 0 && rc < size ) {
522 buffer = (
char *) KMP_INTERNAL_REALLOC( buffer, size );
523 if ( buffer == NULL ) {
524 KMP_FATAL( MemoryAllocFailed );
538 KMP_DEBUG_ASSERT( str != NULL );
539 KMP_INTERNAL_FREE( (
void *) * str );
556 if ( target == NULL || data == NULL ) {
559 for ( i = 0; target[i] && data[i]; ++ i ) {
560 if ( TOLOWER( target[i] ) != TOLOWER( data[i] ) ) {
564 return ( ( len > 0 ) ? i >= len : ( ! target[i] && ( len || ! data[i] ) ) );
569 __kmp_str_match_false(
char const * data ) {
571 __kmp_str_match(
"false", 1, data ) ||
572 __kmp_str_match(
"off", 2, data ) ||
573 __kmp_str_match(
"0", 1, data ) ||
574 __kmp_str_match(
".false.", 2, data ) ||
575 __kmp_str_match(
".f.", 2, data ) ||
576 __kmp_str_match(
"no", 1, data );
582 __kmp_str_match_true(
char const * data ) {
584 __kmp_str_match(
"true", 1, data ) ||
585 __kmp_str_match(
"on", 2, data ) ||
586 __kmp_str_match(
"1", 1, data ) ||
587 __kmp_str_match(
".true.", 2, data ) ||
588 __kmp_str_match(
".t.", 2, data ) ||
589 __kmp_str_match(
"yes", 1, data );
602 found = strchr( str, search_for );
604 * found = replace_with;
605 found = strchr( found + 1, search_for );
621 char * ptr = strchr( str, delim );
627 if ( head != NULL ) {
630 if ( tail != NULL ) {
650 * buf += strspn( * buf, delim );
653 * buf += strcspn( * buf, delim );
661 token = strtok_r( str, delim, buf );
677 for (t = str; *t !=
'\0'; ++t) {
678 if (*t < '0' || *t >
'9')
680 result = (result * 10) + (*t -
'0');
697 factor = (1024 * 1024);
706 if (result > (INT_MAX / factor))
711 return (*t != 0 ? 0 : result);
739 KMP_DEBUG_ASSERT( str != NULL );
742 while ( str[ i ] ==
' ' || str[ i ] ==
'\t') {
747 if ( str[ i ] <
'0' || str[ i ] >
'9' ) {
748 * error = KMP_I18N_STR( NotANumber );
752 digit = str[ i ] -
'0';
753 overflow = overflow || ( value > ( KMP_SIZE_T_MAX - digit ) / 10 );
754 value = ( value * 10 ) + digit;
756 }
while ( str[ i ] >=
'0' && str[ i ] <=
'9' );
759 while ( str[ i ] ==
' ' || str[ i ] ==
'\t' ) {
764 #define _case( ch, exp ) \
766 case ch - ( 'a' - 'A' ) : { \
767 size_t shift = (exp) * 10; \
769 if ( shift < sizeof( size_t ) * 8 ) { \
770 factor = (size_t)( 1 ) << shift; \
775 switch ( str[ i ] ) {
787 if ( str[ i ] ==
'b' || str[ i ] ==
'B' ) {
793 if ( ! ( str[ i ] ==
' ' || str[ i ] ==
'\t' || str[ i ] == 0 ) ) {
794 * error = KMP_I18N_STR( BadUnit );
803 overflow = overflow || ( value > ( KMP_SIZE_T_MAX / factor ) );
807 while ( str[ i ] ==
' ' || str[ i ] ==
'\t' ) {
811 if ( str[ i ] != 0 ) {
812 * error = KMP_I18N_STR( IllegalCharacters );
817 * error = KMP_I18N_STR( ValueTooLarge );
818 * out = KMP_SIZE_T_MAX;
841 KMP_DEBUG_ASSERT( str != NULL );
844 while ( str[ i ] ==
' ' || str[ i ] ==
'\t' ) {
849 if ( str[ i ] <
'0' || str[ i ] >
'9' ) {
850 * error = KMP_I18N_STR( NotANumber );
854 digit = str[ i ] -
'0';
855 overflow = overflow || ( value > ( KMP_SIZE_T_MAX - digit ) / 10 );
856 value = ( value * 10 ) + digit;
858 }
while ( str[ i ] >=
'0' && str[ i ] <=
'9' );
861 while ( str[ i ] ==
' ' || str[ i ] ==
'\t' ) {
865 if ( str[ i ] != 0 ) {
866 * error = KMP_I18N_STR( IllegalCharacters );
871 * error = KMP_I18N_STR( ValueTooLarge );
872 * out = (kmp_uint64) -1;