1 /******************************************************************** 2 * COPYRIGHT: 3 * Copyright (c) 2007-2012, International Business Machines Corporation and 4 * others. All Rights Reserved. 5 ********************************************************************/ 6 7 #include "udbgutil.h" 8 #include <string.h> 9 #include "ustr_imp.h" 10 #include "cstring.h" 11 #include "putilimp.h" 12 #include "unicode/ulocdata.h" 13 #include "unicode/ucnv.h" 14 15 /* 16 To add a new enum type 17 (For example: UShoeSize with values USHOE_WIDE=0, USHOE_REGULAR, USHOE_NARROW, USHOE_COUNT) 18 19 1. udbgutil.h: add UDBG_UShoeSize to the UDebugEnumType enum before UDBG_ENUM_COUNT 20 ( The subsequent steps involve this file, udbgutil.cpp ) 21 2. Find the marker "Add new enum types above this line" 22 3. Before that marker, add a #include of any header file you need. 23 4. Each enum type has three things in this section: a #define, a count_, and an array of Fields. 24 It may help to copy and paste a previous definition. 25 5. In the case of the USHOE_... strings above, "USHOE_" is common to all values- six characters 26 " #define LEN_USHOE 6 " 27 6 characters will strip off "USHOE_" leaving enum values of WIDE, REGULAR, and NARROW. 28 6. Define the 'count_' variable, with the number of enum values. If the enum has a _MAX or _COUNT value, 29 that can be helpful for automatically defining the count. Otherwise define it manually. 30 " static const int32_t count_UShoeSize = USHOE_COUNT; " 31 7. Define the field names, in order. 32 " static const Field names_UShoeSize[] = { 33 " FIELD_NAME_STR( LEN_USHOE, USHOE_WIDE ), 34 " FIELD_NAME_STR( LEN_USHOE, USHOE_REGULAR ), 35 " FIELD_NAME_STR( LEN_USHOE, USHOE_NARROW ), 36 " }; 37 ( The following command was usedfor converting ucol.h into partially correct entities ) 38 grep "^[ ]*UCOL" < unicode/ucol.h | 39 sed -e 's%^[ ]*\([A-Z]*\)_\([A-Z_]*\).*% FIELD_NAME_STR( LEN_\1, \1_\2 ),%g' 40 8. Now, a bit farther down, add the name of the enum itself to the end of names_UDebugEnumType 41 ( UDebugEnumType is an enum, too!) 42 names_UDebugEnumType[] { ... 43 " FIELD_NAME_STR( LEN_UDBG, UDBG_UShoeSize ), " 44 9. Find the function _udbg_enumCount and add the count macro: 45 " COUNT_CASE(UShoeSize) 46 10. Find the function _udbg_enumFields and add the field macro: 47 " FIELD_CASE(UShoeSize) 48 11. verify that your test code, and Java data generation, works properly. 49 */ 50 51 /** 52 * Structure representing an enum value 53 */ 54 struct Field { 55 int32_t prefix; /**< how many characters to remove in the prefix - i.e. UCHAR_ = 5 */ 56 const char *str; /**< The actual string value */ 57 int32_t num; /**< The numeric value */ 58 }; 59 60 /** 61 * Calculate the size of an array. 62 */ 63 #define DBG_ARRAY_COUNT(x) (sizeof(x)/sizeof(x[0])) 64 65 /** 66 * Define another field name. Used in an array of Field s 67 * @param y the common prefix length (i.e. 6 for "USHOE_" ) 68 * @param x the actual enum value - it will be copied in both string and symbolic form. 69 * @see Field 70 */ 71 #define FIELD_NAME_STR(y,x) { y, #x, x } 72 73 74 // TODO: Currently, this whole functionality goes away with UCONFIG_NO_FORMATTING. Should be split up. 75 #if !UCONFIG_NO_FORMATTING 76 77 // Calendar 78 #include "unicode/ucal.h" 79 80 // 'UCAL_' = 5 81 #define LEN_UCAL 5 /* UCAL_ */ 82 static const int32_t count_UCalendarDateFields = UCAL_FIELD_COUNT; 83 static const Field names_UCalendarDateFields[] = 84 { 85 FIELD_NAME_STR( LEN_UCAL, UCAL_ERA ), 86 FIELD_NAME_STR( LEN_UCAL, UCAL_YEAR ), 87 FIELD_NAME_STR( LEN_UCAL, UCAL_MONTH ), 88 FIELD_NAME_STR( LEN_UCAL, UCAL_WEEK_OF_YEAR ), 89 FIELD_NAME_STR( LEN_UCAL, UCAL_WEEK_OF_MONTH ), 90 FIELD_NAME_STR( LEN_UCAL, UCAL_DATE ), 91 FIELD_NAME_STR( LEN_UCAL, UCAL_DAY_OF_YEAR ), 92 FIELD_NAME_STR( LEN_UCAL, UCAL_DAY_OF_WEEK ), 93 FIELD_NAME_STR( LEN_UCAL, UCAL_DAY_OF_WEEK_IN_MONTH ), 94 FIELD_NAME_STR( LEN_UCAL, UCAL_AM_PM ), 95 FIELD_NAME_STR( LEN_UCAL, UCAL_HOUR ), 96 FIELD_NAME_STR( LEN_UCAL, UCAL_HOUR_OF_DAY ), 97 FIELD_NAME_STR( LEN_UCAL, UCAL_MINUTE ), 98 FIELD_NAME_STR( LEN_UCAL, UCAL_SECOND ), 99 FIELD_NAME_STR( LEN_UCAL, UCAL_MILLISECOND ), 100 FIELD_NAME_STR( LEN_UCAL, UCAL_ZONE_OFFSET ), 101 FIELD_NAME_STR( LEN_UCAL, UCAL_DST_OFFSET ), 102 FIELD_NAME_STR( LEN_UCAL, UCAL_YEAR_WOY ), 103 FIELD_NAME_STR( LEN_UCAL, UCAL_DOW_LOCAL ), 104 FIELD_NAME_STR( LEN_UCAL, UCAL_EXTENDED_YEAR ), 105 FIELD_NAME_STR( LEN_UCAL, UCAL_JULIAN_DAY ), 106 FIELD_NAME_STR( LEN_UCAL, UCAL_MILLISECONDS_IN_DAY ), 107 FIELD_NAME_STR( LEN_UCAL, UCAL_IS_LEAP_MONTH ), 108 }; 109 110 111 static const int32_t count_UCalendarMonths = UCAL_UNDECIMBER+1; 112 static const Field names_UCalendarMonths[] = 113 { 114 FIELD_NAME_STR( LEN_UCAL, UCAL_JANUARY ), 115 FIELD_NAME_STR( LEN_UCAL, UCAL_FEBRUARY ), 116 FIELD_NAME_STR( LEN_UCAL, UCAL_MARCH ), 117 FIELD_NAME_STR( LEN_UCAL, UCAL_APRIL ), 118 FIELD_NAME_STR( LEN_UCAL, UCAL_MAY ), 119 FIELD_NAME_STR( LEN_UCAL, UCAL_JUNE ), 120 FIELD_NAME_STR( LEN_UCAL, UCAL_JULY ), 121 FIELD_NAME_STR( LEN_UCAL, UCAL_AUGUST ), 122 FIELD_NAME_STR( LEN_UCAL, UCAL_SEPTEMBER ), 123 FIELD_NAME_STR( LEN_UCAL, UCAL_OCTOBER ), 124 FIELD_NAME_STR( LEN_UCAL, UCAL_NOVEMBER ), 125 FIELD_NAME_STR( LEN_UCAL, UCAL_DECEMBER ), 126 FIELD_NAME_STR( LEN_UCAL, UCAL_UNDECIMBER) 127 }; 128 129 #include "unicode/udat.h" 130 131 #define LEN_UDAT 5 /* "UDAT_" */ 132 static const int32_t count_UDateFormatStyle = UDAT_SHORT+1; 133 static const Field names_UDateFormatStyle[] = 134 { 135 FIELD_NAME_STR( LEN_UDAT, UDAT_FULL ), 136 FIELD_NAME_STR( LEN_UDAT, UDAT_LONG ), 137 FIELD_NAME_STR( LEN_UDAT, UDAT_MEDIUM ), 138 FIELD_NAME_STR( LEN_UDAT, UDAT_SHORT ), 139 /* end regular */ 140 /* 141 * negative enums.. leave out for now. 142 FIELD_NAME_STR( LEN_UDAT, UDAT_NONE ), 143 FIELD_NAME_STR( LEN_UDAT, UDAT_PATTERN ), 144 */ 145 }; 146 147 #endif 148 149 #include "unicode/uloc.h" 150 151 #define LEN_UAR 12 /* "ULOC_ACCEPT_" */ 152 static const int32_t count_UAcceptResult = 3; 153 static const Field names_UAcceptResult[] = 154 { 155 FIELD_NAME_STR( LEN_UAR, ULOC_ACCEPT_FAILED ), 156 FIELD_NAME_STR( LEN_UAR, ULOC_ACCEPT_VALID ), 157 FIELD_NAME_STR( LEN_UAR, ULOC_ACCEPT_FALLBACK ), 158 }; 159 160 #if !UCONFIG_NO_COLLATION 161 #include "unicode/ucol.h" 162 #define LEN_UCOL 5 /* UCOL_ */ 163 static const int32_t count_UColAttributeValue = UCOL_ATTRIBUTE_VALUE_COUNT; 164 static const Field names_UColAttributeValue[] = { 165 FIELD_NAME_STR( LEN_UCOL, UCOL_PRIMARY ), 166 FIELD_NAME_STR( LEN_UCOL, UCOL_SECONDARY ), 167 FIELD_NAME_STR( LEN_UCOL, UCOL_TERTIARY ), 168 // FIELD_NAME_STR( LEN_UCOL, UCOL_CE_STRENGTH_LIMIT ), 169 FIELD_NAME_STR( LEN_UCOL, UCOL_QUATERNARY ), 170 // gap 171 FIELD_NAME_STR( LEN_UCOL, UCOL_IDENTICAL ), 172 // FIELD_NAME_STR( LEN_UCOL, UCOL_STRENGTH_LIMIT ), 173 FIELD_NAME_STR( LEN_UCOL, UCOL_OFF ), 174 FIELD_NAME_STR( LEN_UCOL, UCOL_ON ), 175 // gap 176 FIELD_NAME_STR( LEN_UCOL, UCOL_SHIFTED ), 177 FIELD_NAME_STR( LEN_UCOL, UCOL_NON_IGNORABLE ), 178 // gap 179 FIELD_NAME_STR( LEN_UCOL, UCOL_LOWER_FIRST ), 180 FIELD_NAME_STR( LEN_UCOL, UCOL_UPPER_FIRST ), 181 }; 182 183 #endif 184 185 186 #include "unicode/icuplug.h" 187 188 #define LEN_UPLUG_REASON 13 /* UPLUG_REASON_ */ 189 static const int32_t count_UPlugReason = UPLUG_REASON_COUNT; 190 static const Field names_UPlugReason[] = { 191 FIELD_NAME_STR( LEN_UPLUG_REASON, UPLUG_REASON_QUERY ), 192 FIELD_NAME_STR( LEN_UPLUG_REASON, UPLUG_REASON_LOAD ), 193 FIELD_NAME_STR( LEN_UPLUG_REASON, UPLUG_REASON_UNLOAD ), 194 }; 195 196 #define LEN_UPLUG_LEVEL 12 /* UPLUG_LEVEL_ */ 197 static const int32_t count_UPlugLevel = UPLUG_LEVEL_COUNT; 198 static const Field names_UPlugLevel[] = { 199 FIELD_NAME_STR( LEN_UPLUG_LEVEL, UPLUG_LEVEL_INVALID ), 200 FIELD_NAME_STR( LEN_UPLUG_LEVEL, UPLUG_LEVEL_UNKNOWN ), 201 FIELD_NAME_STR( LEN_UPLUG_LEVEL, UPLUG_LEVEL_LOW ), 202 FIELD_NAME_STR( LEN_UPLUG_LEVEL, UPLUG_LEVEL_HIGH ), 203 }; 204 205 #define LEN_UDBG 5 /* "UDBG_" */ 206 static const int32_t count_UDebugEnumType = UDBG_ENUM_COUNT; 207 static const Field names_UDebugEnumType[] = 208 { 209 FIELD_NAME_STR( LEN_UDBG, UDBG_UDebugEnumType ), 210 #if !UCONFIG_NO_FORMATTING 211 FIELD_NAME_STR( LEN_UDBG, UDBG_UCalendarDateFields ), 212 FIELD_NAME_STR( LEN_UDBG, UDBG_UCalendarMonths ), 213 FIELD_NAME_STR( LEN_UDBG, UDBG_UDateFormatStyle ), 214 #endif 215 FIELD_NAME_STR( LEN_UDBG, UDBG_UPlugReason ), 216 FIELD_NAME_STR( LEN_UDBG, UDBG_UPlugLevel ), 217 FIELD_NAME_STR( LEN_UDBG, UDBG_UAcceptResult ), 218 #if !UCONFIG_NO_COLLATION 219 FIELD_NAME_STR( LEN_UDBG, UDBG_UColAttributeValue ), 220 #endif 221 }; 222 223 224 // --- Add new enum types above this line --- 225 226 #define COUNT_CASE(x) case UDBG_##x: return (actual?count_##x:DBG_ARRAY_COUNT(names_##x)); 227 #define COUNT_FAIL_CASE(x) case UDBG_##x: return -1; 228 229 #define FIELD_CASE(x) case UDBG_##x: return names_##x; 230 #define FIELD_FAIL_CASE(x) case UDBG_##x: return NULL; 231 232 // low level 233 234 /** 235 * @param type type of item 236 * @param actual TRUE: for the actual enum's type (UCAL_FIELD_COUNT, etc), or FALSE for the string count 237 */ 238 static int32_t _udbg_enumCount(UDebugEnumType type, UBool actual) { 239 switch(type) { 240 COUNT_CASE(UDebugEnumType) 241 #if !UCONFIG_NO_FORMATTING 242 COUNT_CASE(UCalendarDateFields) 243 COUNT_CASE(UCalendarMonths) 244 COUNT_CASE(UDateFormatStyle) 245 #endif 246 COUNT_CASE(UPlugReason) 247 COUNT_CASE(UPlugLevel) 248 COUNT_CASE(UAcceptResult) 249 #if !UCONFIG_NO_COLLATION 250 COUNT_CASE(UColAttributeValue) 251 #endif 252 // COUNT_FAIL_CASE(UNonExistentEnum) 253 default: 254 return -1; 255 } 256 } 257 258 static const Field* _udbg_enumFields(UDebugEnumType type) { 259 switch(type) { 260 FIELD_CASE(UDebugEnumType) 261 #if !UCONFIG_NO_FORMATTING 262 FIELD_CASE(UCalendarDateFields) 263 FIELD_CASE(UCalendarMonths) 264 FIELD_CASE(UDateFormatStyle) 265 #endif 266 FIELD_CASE(UPlugReason) 267 FIELD_CASE(UPlugLevel) 268 FIELD_CASE(UAcceptResult) 269 // FIELD_FAIL_CASE(UNonExistentEnum) 270 #if !UCONFIG_NO_COLLATION 271 FIELD_CASE(UColAttributeValue) 272 #endif 273 default: 274 return NULL; 275 } 276 } 277 278 // implementation 279 280 int32_t udbg_enumCount(UDebugEnumType type) { 281 return _udbg_enumCount(type, FALSE); 282 } 283 284 int32_t udbg_enumExpectedCount(UDebugEnumType type) { 285 return _udbg_enumCount(type, TRUE); 286 } 287 288 const char * udbg_enumName(UDebugEnumType type, int32_t field) { 289 if(field<0 || 290 field>=_udbg_enumCount(type,FALSE)) { // also will catch unsupported items 291 return NULL; 292 } else { 293 const Field *fields = _udbg_enumFields(type); 294 if(fields == NULL) { 295 return NULL; 296 } else { 297 return fields[field].str + fields[field].prefix; 298 } 299 } 300 } 301 302 int32_t udbg_enumArrayValue(UDebugEnumType type, int32_t field) { 303 if(field<0 || 304 field>=_udbg_enumCount(type,FALSE)) { // also will catch unsupported items 305 return -1; 306 } else { 307 const Field *fields = _udbg_enumFields(type); 308 if(fields == NULL) { 309 return -1; 310 } else { 311 return fields[field].num; 312 } 313 } 314 } 315 316 int32_t udbg_enumByName(UDebugEnumType type, const char *value) { 317 if(type<0||type>=_udbg_enumCount(UDBG_UDebugEnumType, TRUE)) { 318 return -1; // type out of range 319 } 320 const Field *fields = _udbg_enumFields(type); 321 for(int32_t field = 0;field<_udbg_enumCount(type, FALSE);field++) { 322 if(!strcmp(value, fields[field].str + fields[field].prefix)) { 323 return fields[field].num; 324 } 325 } 326 // try with the prefix 327 for(int32_t field = 0;field<_udbg_enumCount(type, FALSE);field++) { 328 if(!strcmp(value, fields[field].str)) { 329 return fields[field].num; 330 } 331 } 332 // fail 333 return -1; 334 } 335 336 /* platform info */ 337 /** 338 * Print the current platform 339 */ 340 U_CAPI const char *udbg_getPlatform(void) 341 { 342 #if U_PLATFORM_HAS_WIN32_API 343 return "Windows"; 344 #elif U_PLATFORM == U_PF_UNKNOWN 345 return "unknown"; 346 #elif U_PLATFORM == U_PF_DARWIN 347 return "Darwin"; 348 #elif U_PLATFORM == U_PF_QNX 349 return "QNX"; 350 #elif U_PLATFORM == U_PF_LINUX 351 return "Linux"; 352 #elif U_PLATFORM == U_PF_ANDROID 353 return "Android"; 354 #elif U_PLATFORM == U_PF_CLASSIC_MACOS 355 return "MacOS (Classic)"; 356 #elif U_PLATFORM == U_PF_OS390 357 return "IBM z"; 358 #elif U_PLATFORM == U_PF_OS400 359 return "IBM i"; 360 #else 361 return "Other (POSIX-like)"; 362 #endif 363 } 364 365 struct USystemParams; 366 367 typedef int32_t U_CALLCONV USystemParameterCallback(const USystemParams *param, char *target, int32_t targetCapacity, UErrorCode *status); 368 369 struct USystemParams { 370 const char *paramName; 371 USystemParameterCallback *paramFunction; 372 const char *paramStr; 373 int32_t paramInt; 374 }; 375 376 /* parameter types */ 377 U_CAPI int32_t 378 paramEmpty(const USystemParams * /* param */, char *target, int32_t targetCapacity, UErrorCode *status) { 379 if(U_FAILURE(*status))return 0; 380 return u_terminateChars(target, targetCapacity, 0, status); 381 } 382 383 U_CAPI int32_t 384 paramStatic(const USystemParams *param, char *target, int32_t targetCapacity, UErrorCode *status) { 385 if(param->paramStr==NULL) return paramEmpty(param,target,targetCapacity,status); 386 if(U_FAILURE(*status))return 0; 387 int32_t len = uprv_strlen(param->paramStr); 388 if(target!=NULL) { 389 uprv_strncpy(target,param->paramStr,uprv_min(len,targetCapacity)); 390 } 391 return u_terminateChars(target, targetCapacity, len, status); 392 } 393 394 static const char *nullString = "(null)"; 395 396 static int32_t stringToStringBuffer(char *target, int32_t targetCapacity, const char *str, UErrorCode *status) { 397 if(str==NULL) str=nullString; 398 399 int32_t len = uprv_strlen(str); 400 if (U_SUCCESS(*status)) { 401 if(target!=NULL) { 402 uprv_strncpy(target,str,uprv_min(len,targetCapacity)); 403 } 404 } else { 405 const char *s = u_errorName(*status); 406 len = uprv_strlen(s); 407 if(target!=NULL) { 408 uprv_strncpy(target,s,uprv_min(len,targetCapacity)); 409 } 410 } 411 return u_terminateChars(target, targetCapacity, len, status); 412 } 413 414 static int32_t integerToStringBuffer(char *target, int32_t targetCapacity, int32_t n, int32_t radix, UErrorCode *status) { 415 if(U_FAILURE(*status)) return 0; 416 char str[300]; 417 T_CString_integerToString(str,n,radix); 418 return stringToStringBuffer(target,targetCapacity,str,status); 419 } 420 421 U_CAPI int32_t 422 paramInteger(const USystemParams *param, char *target, int32_t targetCapacity, UErrorCode *status) { 423 if(U_FAILURE(*status))return 0; 424 if(param->paramStr==NULL || param->paramStr[0]=='d') { 425 return integerToStringBuffer(target,targetCapacity,param->paramInt, 10,status); 426 } else if(param->paramStr[0]=='x') { 427 return integerToStringBuffer(target,targetCapacity,param->paramInt, 16,status); 428 } else if(param->paramStr[0]=='o') { 429 return integerToStringBuffer(target,targetCapacity,param->paramInt, 8,status); 430 } else if(param->paramStr[0]=='b') { 431 return integerToStringBuffer(target,targetCapacity,param->paramInt, 2,status); 432 } else { 433 *status = U_INTERNAL_PROGRAM_ERROR; 434 return 0; 435 } 436 } 437 438 439 U_CAPI int32_t 440 paramCldrVersion(const USystemParams * /* param */, char *target, int32_t targetCapacity, UErrorCode *status) { 441 if(U_FAILURE(*status))return 0; 442 char str[200]=""; 443 UVersionInfo icu; 444 445 ulocdata_getCLDRVersion(icu, status); 446 if(U_SUCCESS(*status)) { 447 u_versionToString(icu, str); 448 return stringToStringBuffer(target,targetCapacity,str,status); 449 } else { 450 return 0; 451 } 452 } 453 454 455 #if !UCONFIG_NO_FORMATTING 456 U_CAPI int32_t 457 paramTimezoneDefault(const USystemParams * /* param */, char *target, int32_t targetCapacity, UErrorCode *status) { 458 if(U_FAILURE(*status))return 0; 459 UChar buf[100]; 460 char buf2[100]; 461 int32_t len; 462 463 len = ucal_getDefaultTimeZone(buf, 100, status); 464 if(U_SUCCESS(*status)&&len>0) { 465 u_UCharsToChars(buf, buf2, len+1); 466 return stringToStringBuffer(target,targetCapacity, buf2,status); 467 } else { 468 return 0; 469 } 470 } 471 #endif 472 473 U_CAPI int32_t 474 paramLocaleDefaultBcp47(const USystemParams * /* param */, char *target, int32_t targetCapacity, UErrorCode *status) { 475 if(U_FAILURE(*status))return 0; 476 const char *def = uloc_getDefault(); 477 return uloc_toLanguageTag(def,target,targetCapacity,FALSE,status); 478 } 479 480 481 /* simple 1-liner param functions */ 482 #define STRING_PARAM(func, str) U_CAPI int32_t \ 483 func(const USystemParams *, char *target, int32_t targetCapacity, UErrorCode *status) \ 484 { return stringToStringBuffer(target,targetCapacity,(str),status); } 485 486 STRING_PARAM(paramIcudataPath, u_getDataDirectory()) 487 STRING_PARAM(paramPlatform, udbg_getPlatform()) 488 STRING_PARAM(paramLocaleDefault, uloc_getDefault()) 489 #if !UCONFIG_NO_CONVERSION 490 STRING_PARAM(paramConverterDefault, ucnv_getDefaultName()) 491 #endif 492 493 #if !UCONFIG_NO_FORMATTING 494 STRING_PARAM(paramTimezoneVersion, ucal_getTZDataVersion(status)) 495 #endif 496 497 static const USystemParams systemParams[] = { 498 { "copyright", paramStatic, U_COPYRIGHT_STRING,0 }, 499 { "product", paramStatic, "icu4c",0 }, 500 { "product.full", paramStatic, "International Components for Unicode for C/C++",0 }, 501 { "version", paramStatic, U_ICU_VERSION,0 }, 502 { "version.unicode", paramStatic, U_UNICODE_VERSION,0 }, 503 { "platform.number", paramInteger, "d",U_PLATFORM}, 504 { "platform.type", paramPlatform, NULL ,0}, 505 { "locale.default", paramLocaleDefault, NULL, 0}, 506 { "locale.default.bcp47", paramLocaleDefaultBcp47, NULL, 0}, 507 #if !UCONFIG_NO_CONVERSION 508 { "converter.default", paramConverterDefault, NULL, 0}, 509 #endif 510 { "icudata.name", paramStatic, U_ICUDATA_NAME, 0}, 511 { "icudata.path", paramIcudataPath, NULL, 0}, 512 513 { "cldr.version", paramCldrVersion, NULL, 0}, 514 515 #if !UCONFIG_NO_FORMATTING 516 { "tz.version", paramTimezoneVersion, NULL, 0}, 517 { "tz.default", paramTimezoneDefault, NULL, 0}, 518 #endif 519 520 { "cpu.bits", paramInteger, "d", (sizeof(void*))*8}, 521 { "cpu.big_endian", paramInteger, "b", U_IS_BIG_ENDIAN}, 522 { "os.wchar_width", paramInteger, "d", U_SIZEOF_WCHAR_T}, 523 { "os.charset_family", paramInteger, "d", U_CHARSET_FAMILY}, 524 #if defined (U_HOST) 525 { "os.host", paramStatic, U_HOST, 0}, 526 #endif 527 #if defined (U_BUILD) 528 { "build.build", paramStatic, U_BUILD, 0}, 529 #endif 530 #if defined (U_CC) 531 { "build.cc", paramStatic, U_CC, 0}, 532 #endif 533 #if defined (U_CXX) 534 { "build.cxx", paramStatic, U_CXX, 0}, 535 #endif 536 #if defined (CYGWINMSVC) 537 { "build.cygwinmsvc", paramInteger, "b", 1}, 538 #endif 539 { "uconfig.internal_digitlist", paramInteger, "b", 1}, /* always 1 */ 540 { "uconfig.have_parseallinput", paramInteger, "b", UCONFIG_HAVE_PARSEALLINPUT}, 541 { "uconfig.format_fastpaths_49",paramInteger, "b", UCONFIG_FORMAT_FASTPATHS_49}, 542 543 544 }; 545 546 #define U_SYSPARAM_COUNT (sizeof(systemParams)/sizeof(systemParams[0])) 547 548 U_CAPI const char *udbg_getSystemParameterNameByIndex(int32_t i) { 549 if(i>=0 && i < (int32_t)U_SYSPARAM_COUNT) { 550 return systemParams[i].paramName; 551 } else { 552 return NULL; 553 } 554 } 555 556 557 U_CAPI int32_t udbg_getSystemParameterValueByIndex(int32_t i, char *buffer, int32_t bufferCapacity, UErrorCode *status) { 558 if(i>=0 && i< (int32_t)U_SYSPARAM_COUNT) { 559 return systemParams[i].paramFunction(&(systemParams[i]),buffer,bufferCapacity,status); 560 } else { 561 return 0; 562 } 563 } 564 565 U_CAPI void udbg_writeIcuInfo(FILE *out) { 566 char str[2000]; 567 /* todo: API for writing DTD? */ 568 fprintf(out, " <icuSystemParams type=\"icu4c\">\n"); 569 const char *paramName; 570 for(int32_t i=0;(paramName=udbg_getSystemParameterNameByIndex(i))!=NULL;i++) { 571 UErrorCode status2 = U_ZERO_ERROR; 572 udbg_getSystemParameterValueByIndex(i, str,2000,&status2); 573 if(U_SUCCESS(status2)) { 574 fprintf(out," <param name=\"%s\">%s</param>\n", paramName,str); 575 } else { 576 fprintf(out," <!-- n=\"%s\" ERROR: %s -->\n", paramName, u_errorName(status2)); 577 } 578 } 579 fprintf(out, " </icuSystemParams>\n"); 580 } 581
