// NOTE: Function returns allocated memory, caller must free it! static char const * __kmp_pragma( int ct, ident_t const * ident ) { char const * cons = NULL; // Construct name. char * file = NULL; // File name. char * func = NULL; // Function (routine) name. char * line = NULL; // Line number. kmp_str_buf_t buffer; kmp_msg_t prgm; __kmp_str_buf_init( & buffer ); if ( 0 < ct && ct < cons_text_c_num ) { cons = cons_text_c[ ct ]; } else { KMP_DEBUG_ASSERT( 0 ); }; if ( ident != NULL && ident->psource != NULL ) { char * tail = NULL; __kmp_str_buf_print( & buffer, "%s", ident->psource ); // Copy source to buffer. // Split string in buffer to file, func, and line. tail = buffer.str; __kmp_str_split( tail, ';', NULL, & tail ); __kmp_str_split( tail, ';', & file, & tail ); __kmp_str_split( tail, ';', & func, & tail ); __kmp_str_split( tail, ';', & line, & tail ); }; // if prgm = __kmp_msg_format( kmp_i18n_fmt_Pragma, cons, file, func, line ); __kmp_str_buf_free( & buffer ); return prgm.str; } // __kmp_pragma
kmp_str_loc_t __kmp_str_loc_init( char const * psource, int init_fname ) { kmp_str_loc_t loc; loc._bulk = NULL; loc.file = NULL; loc.func = NULL; loc.line = 0; loc.col = 0; if ( psource != NULL ) { char * str = NULL; char * dummy = NULL; char * line = NULL; char * col = NULL; // Copy psource to keep it intact. loc._bulk = __kmp_str_format( "%s", psource ); // Parse psource string: ";file;func;line;col;;" str = loc._bulk; __kmp_str_split( str, ';', & dummy, & str ); __kmp_str_split( str, ';', & loc.file, & str ); __kmp_str_split( str, ';', & loc.func, & str ); __kmp_str_split( str, ';', & line, & str ); __kmp_str_split( str, ';', & col, & str ); // Convert line and col into numberic values. if ( line != NULL ) { loc.line = atoi( line ); if ( loc.line < 0 ) { loc.line = 0; }; // if }; // if if ( col != NULL ) { loc.col = atoi( col ); if ( loc.col < 0 ) { loc.col = 0; }; // if }; // if }; // if __kmp_str_fname_init( & loc.fname, init_fname ? loc.file : NULL ); return loc; } // kmp_str_loc_init
static void ___kmp_env_blk_parse_string( kmp_env_blk_t * block, // M: Env block to fill. char const * env // I: String to parse. ) { char const chr_delimiter = '|'; char const str_delimiter[] = { chr_delimiter, 0 }; char * bulk = NULL; kmp_env_var_t * vars = NULL; int count = 0; // Number of used elements in vars array. int delimiters = 0; // Number of delimiters in input string. // Copy original string, we will modify the copy. bulk = __kmp_str_format( "%s", env ); // Loop thru all the vars in environment block. Count delimiters (maximum number of variables // is number of delimiters plus one). { char const * ptr = bulk; for ( ; ; ) { ptr = strchr( ptr, chr_delimiter ); if ( ptr == NULL ) { break; }; // if ++ delimiters; ptr += 1; }; // forever } // Allocate vars array. vars = (kmp_env_var_t *) allocate( ( delimiters + 1 ) * sizeof( kmp_env_var_t ) ); // Loop thru all the variables. { char * var; // Pointer to variable (both name and value). char * name; // Pointer to name of variable. char * value; // Pointer to value. char * buf; // Buffer for __kmp_str_token() function. var = __kmp_str_token( bulk, str_delimiter, & buf ); // Get the first var. while ( var != NULL ) { // Save found variable in vars array. __kmp_str_split( var, '=', & name, & value ); KMP_DEBUG_ASSERT( count < delimiters + 1 ); vars[ count ].name = name; vars[ count ].value = value; ++ count; // Get the next var. var = __kmp_str_token( NULL, str_delimiter, & buf ); }; // while } // Fill out result. block->bulk = bulk; block->vars = vars; block->count = count; }; // ___kmp_env_blk_parse_string
static void ___kmp_env_blk_parse_unix( kmp_env_blk_t * block, // M: Env block to fill. char * * env // I: Unix environment to parse. ) { char * bulk = NULL; kmp_env_var_t * vars = NULL; int count = 0; int size = 0; // Size of bulk. // Count number of variables and length of required bulk. { count = 0; size = 0; while ( env[ count ] != NULL ) { size += KMP_STRLEN( env[ count ] ) + 1; ++ count; }; // while } // Allocate memory. bulk = (char *) allocate( size ); vars = (kmp_env_var_t *) allocate( count * sizeof( kmp_env_var_t ) ); // Loop thru all the vars. { char * var; // Pointer to beginning of var. char * name; // Pointer to name of variable. char * value; // Pointer to value. int len; // Length of variable. int i; var = bulk; for ( i = 0; i < count; ++ i ) { // Copy variable to bulk. len = KMP_STRLEN( env[ i ] ); KMP_MEMCPY_S( var, size, env[ i ], len + 1 ); // Save found variable in vars array. __kmp_str_split( var, '=', & name, & value ); vars[ i ].name = name; vars[ i ].value = value; // Move pointer. var += len + 1; }; // for } // Fill out result. block->bulk = bulk; block->vars = vars; block->count = count; }; // ___kmp_env_blk_parse_unix
static void ___kmp_env_blk_parse_windows( kmp_env_blk_t *block, // M: Env block to fill. char const *env // I: Pointer to Windows* OS (DOS) environment block. ) { char *bulk = NULL; kmp_env_var_t *vars = NULL; int count = 0; // Number of used elements in vars array. int size = 0; // Size of bulk. char *name; // Pointer to name of variable. char *value; // Pointer to value. if (env != NULL) { // Loop thru all the vars in environment block. Count variables, find size // of block. { char const *var; // Pointer to beginning of var. int len; // Length of variable. count = 0; var = env; // The first variable starts and beginning of environment block. len = KMP_STRLEN(var); while (len != 0) { ++count; size = size + len + 1; var = var + len + 1; // Move pointer to the beginning of the next variable. len = KMP_STRLEN(var); } size = size + 1; // Total size of env block, including terminating zero byte. } // Copy original block to bulk, we will modify bulk, not original block. bulk = (char *)allocate(size); KMP_MEMCPY_S(bulk, size, env, size); // Allocate vars array. vars = (kmp_env_var_t *)allocate(count * sizeof(kmp_env_var_t)); // Loop thru all the vars, now in bulk. { char *var; // Pointer to beginning of var. int len; // Length of variable. count = 0; var = bulk; len = KMP_STRLEN(var); while (len != 0) { // Save variable in vars array. __kmp_str_split(var, '=', &name, &value); vars[count].name = name; vars[count].value = value; ++count; // Get the next var. var = var + len + 1; len = KMP_STRLEN(var); } } } // Fill out result. block->bulk = bulk; block->vars = vars; block->count = count; }
void __kmp_i18n_do_catopen( ) { int english = 0; char * lang = __kmp_env_get( "LANG" ); // TODO: What about LC_ALL or LC_MESSAGES? KMP_DEBUG_ASSERT( status == KMP_I18N_CLOSED ); KMP_DEBUG_ASSERT( cat == KMP_I18N_NULLCAT ); english = lang == NULL || // In all these cases English language is used. strcmp( lang, "" ) == 0 || strcmp( lang, " " ) == 0 || // Workaround for Fortran RTL bug DPD200137873 "Fortran runtime resets LANG env var // to space if it is not set". strcmp( lang, "C" ) == 0 || strcmp( lang, "POSIX" ) == 0; if ( ! english ) { // English language is not yet detected, let us continue. // Format of LANG is: [language[_territory][.codeset][@modifier]] // Strip all parts except language. char * tail = NULL; __kmp_str_split( lang, '@', & lang, & tail ); __kmp_str_split( lang, '.', & lang, & tail ); __kmp_str_split( lang, '_', & lang, & tail ); english = ( strcmp( lang, "en" ) == 0 ); }; // if KMP_INTERNAL_FREE( lang ); // Do not try to open English catalog because internal messages are // exact copy of messages in English catalog. if ( english ) { status = KMP_I18N_ABSENT; // mark catalog as absent so it will not be re-opened. return; } cat = catopen( name, 0 ); // TODO: Why do we pass 0 in flags? status = ( cat == KMP_I18N_NULLCAT ? KMP_I18N_ABSENT : KMP_I18N_OPENED ); if ( status == KMP_I18N_ABSENT ) { if (__kmp_generate_warnings > kmp_warnings_low) { // AC: only issue warning in case explicitly asked to int error = errno; // Save errno immediately. char * nlspath = __kmp_env_get( "NLSPATH" ); char * lang = __kmp_env_get( "LANG" ); // Infinite recursion will not occur -- status is KMP_I18N_ABSENT now, so // __kmp_i18n_catgets() will not try to open catalog, but will return default message. __kmp_msg( kmp_ms_warning, KMP_MSG( CantOpenMessageCatalog, name ), KMP_ERR( error ), KMP_HNT( CheckEnvVar, "NLSPATH", nlspath ), KMP_HNT( CheckEnvVar, "LANG", lang ), __kmp_msg_null ); KMP_INFORM( WillUseDefaultMessages ); KMP_INTERNAL_FREE( nlspath ); KMP_INTERNAL_FREE( lang ); } } else { // status == KMP_I18N_OPENED int section = get_section( kmp_i18n_prp_Version ); int number = get_number( kmp_i18n_prp_Version ); char const * expected = __kmp_i18n_default_table.sect[ section ].str[ number ]; // Expected version of the catalog. kmp_str_buf_t version; // Actual version of the catalog. __kmp_str_buf_init( & version ); __kmp_str_buf_print( & version, "%s", catgets( cat, section, number, NULL ) ); // String returned by catgets is invalid after closing the catalog, so copy it. if ( strcmp( version.str, expected ) != 0 ) { __kmp_i18n_catclose(); // Close bad catalog. status = KMP_I18N_ABSENT; // And mark it as absent. if (__kmp_generate_warnings > kmp_warnings_low) { // AC: only issue warning in case explicitly asked to // And now print a warning using default messages. char const * name = "NLSPATH"; char const * nlspath = __kmp_env_get( name ); __kmp_msg( kmp_ms_warning, KMP_MSG( WrongMessageCatalog, name, version.str, expected ), KMP_HNT( CheckEnvVar, name, nlspath ), __kmp_msg_null ); KMP_INFORM( WillUseDefaultMessages ); KMP_INTERNAL_FREE( (void *) nlspath ); } // __kmp_generate_warnings }; // if __kmp_str_buf_free( & version ); }; // if } // func __kmp_i18n_do_catopen