icuSources/tools/toolutil/udbgutil.cpp

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