icuSources/tools/toolutil/udbgutil.cpp

   1 /********************************************************************
   2  * COPYRIGHT:
   3  * Copyright (c) 2007-2010, International Business Machines Corporation and
   4  * others. All Rights Reserved.
   5  ********************************************************************/
   6
   7 #include "udbgutil.h"
   8 #include <string.h>
   9
  10 /*
  11 To add a new enum type
  12       (For example: UShoeSize  with values USHOE_WIDE=0, USHOE_REGULAR, USHOE_NARROW, USHOE_COUNT)
  13
  14     1. udbgutil.h:  add  UDBG_UShoeSize to the UDebugEnumType enum before UDBG_ENUM_COUNT
  15       ( The subsequent steps involve this file, udbgutil.cpp )
  16     2. Find the marker "Add new enum types above this line"
  17     3. Before that marker, add a #include of any header file you need.
  18     4. Each enum type has three things in this section:  a #define, a count_, and an array of Fields.
  19        It may help to copy and paste a previous definition.
  20     5. In the case of the USHOE_... strings above, "USHOE_" is common to all values- six characters
  21          " #define LEN_USHOE 6 "
  22        6 characters will strip off "USHOE_" leaving enum values of WIDE, REGULAR, and NARROW.
  23     6. Define the 'count_' variable, with the number of enum values. If the enum has a _MAX or _COUNT value,
  24         that can be helpful for automatically defining the count. Otherwise define it manually.
  25         " static const int32_t count_UShoeSize = USHOE_COUNT; "
  26     7. Define the field names, in order.
  27         " static const Field names_UShoeSize[] =  {
  28         "  FIELD_NAME_STR( LEN_USHOE, USHOE_WIDE ),
  29         "  FIELD_NAME_STR( LEN_USHOE, USHOE_REGULAR ),
  30         "  FIELD_NAME_STR( LEN_USHOE, USHOE_NARROW ),
  31         " };
  32       ( The following command  was usedfor converting ucol.h into partially correct entities )
  33       grep "^[  ]*UCOL" < unicode/ucol.h  |
  34          sed -e 's%^[  ]*\([A-Z]*\)_\([A-Z_]*\).*%   FIELD_NAME_STR( LEN_\1, \1_\2 ),%g'
  35     8. Now, a bit farther down, add the name of the enum itself to the end of names_UDebugEnumType
  36           ( UDebugEnumType is an enum, too!)
  37         names_UDebugEnumType[] { ...
  38             " FIELD_NAME_STR( LEN_UDBG, UDBG_UShoeSize ),   "
  39     9. Find the function _udbg_enumCount  and add the count macro:
  40             " COUNT_CASE(UShoeSize)
  41    10. Find the function _udbg_enumFields  and add the field macro:
  42             " FIELD_CASE(UShoeSize)
  43    11. verify that your test code, and Java data generation, works properly.
  44 */
  45
  46 /**
  47  * Structure representing an enum value
  48  */
  49 struct Field {
  50     int32_t prefix;   /**< how many characters to remove in the prefix - i.e. UCHAR_ = 5 */
  51         const char *str;  /**< The actual string value */
  52         int32_t num;      /**< The numeric value */
  53 };
  54
  55 /**
  56  * Calculate the size of an array.
  57  */
  58 #define DBG_ARRAY_COUNT(x) (sizeof(x)/sizeof(x[0]))
  59
  60 /**
  61  * Define another field name. Used in an array of Field s
  62  * @param y the common prefix length (i.e. 6 for "USHOE_" )
  63  * @param x the actual enum value - it will be copied in both string and symbolic form.
  64  * @see Field
  65  */
  66 #define FIELD_NAME_STR(y,x)  { y, #x, x }
  67
  68
  69 // TODO: Currently, this whole functionality goes away with UCONFIG_NO_FORMATTING. Should be split up.
  70 #if !UCONFIG_NO_FORMATTING
  71
  72 // Calendar
  73 #include "unicode/ucal.h"
  74
  75 // 'UCAL_' = 5
  76 #define LEN_UCAL 5 /* UCAL_ */
  77 static const int32_t count_UCalendarDateFields = UCAL_FIELD_COUNT;
  78 static const Field names_UCalendarDateFields[] =
  79 {
  80     FIELD_NAME_STR( LEN_UCAL, UCAL_ERA ),
  81     FIELD_NAME_STR( LEN_UCAL, UCAL_YEAR ),
  82     FIELD_NAME_STR( LEN_UCAL, UCAL_MONTH ),
  83     FIELD_NAME_STR( LEN_UCAL, UCAL_WEEK_OF_YEAR ),
  84     FIELD_NAME_STR( LEN_UCAL, UCAL_WEEK_OF_MONTH ),
  85     FIELD_NAME_STR( LEN_UCAL, UCAL_DATE ),
  86     FIELD_NAME_STR( LEN_UCAL, UCAL_DAY_OF_YEAR ),
  87     FIELD_NAME_STR( LEN_UCAL, UCAL_DAY_OF_WEEK ),
  88     FIELD_NAME_STR( LEN_UCAL, UCAL_DAY_OF_WEEK_IN_MONTH ),
  89     FIELD_NAME_STR( LEN_UCAL, UCAL_AM_PM ),
  90     FIELD_NAME_STR( LEN_UCAL, UCAL_HOUR ),
  91     FIELD_NAME_STR( LEN_UCAL, UCAL_HOUR_OF_DAY ),
  92     FIELD_NAME_STR( LEN_UCAL, UCAL_MINUTE ),
  93     FIELD_NAME_STR( LEN_UCAL, UCAL_SECOND ),
  94     FIELD_NAME_STR( LEN_UCAL, UCAL_MILLISECOND ),
  95     FIELD_NAME_STR( LEN_UCAL, UCAL_ZONE_OFFSET ),
  96     FIELD_NAME_STR( LEN_UCAL, UCAL_DST_OFFSET ),
  97     FIELD_NAME_STR( LEN_UCAL, UCAL_YEAR_WOY ),
  98     FIELD_NAME_STR( LEN_UCAL, UCAL_DOW_LOCAL ),
  99     FIELD_NAME_STR( LEN_UCAL, UCAL_EXTENDED_YEAR ),
 100     FIELD_NAME_STR( LEN_UCAL, UCAL_JULIAN_DAY ),
 101     FIELD_NAME_STR( LEN_UCAL, UCAL_MILLISECONDS_IN_DAY ),
 102     FIELD_NAME_STR( LEN_UCAL, UCAL_IS_LEAP_MONTH ),
 103 };
 104
 105
 106 static const int32_t count_UCalendarMonths = UCAL_UNDECIMBER+1;
 107 static const Field names_UCalendarMonths[] =
 108 {
 109   FIELD_NAME_STR( LEN_UCAL, UCAL_JANUARY ),
 110   FIELD_NAME_STR( LEN_UCAL, UCAL_FEBRUARY ),
 111   FIELD_NAME_STR( LEN_UCAL, UCAL_MARCH ),
 112   FIELD_NAME_STR( LEN_UCAL, UCAL_APRIL ),
 113   FIELD_NAME_STR( LEN_UCAL, UCAL_MAY ),
 114   FIELD_NAME_STR( LEN_UCAL, UCAL_JUNE ),
 115   FIELD_NAME_STR( LEN_UCAL, UCAL_JULY ),
 116   FIELD_NAME_STR( LEN_UCAL, UCAL_AUGUST ),
 117   FIELD_NAME_STR( LEN_UCAL, UCAL_SEPTEMBER ),
 118   FIELD_NAME_STR( LEN_UCAL, UCAL_OCTOBER ),
 119   FIELD_NAME_STR( LEN_UCAL, UCAL_NOVEMBER ),
 120   FIELD_NAME_STR( LEN_UCAL, UCAL_DECEMBER ),
 121   FIELD_NAME_STR( LEN_UCAL, UCAL_UNDECIMBER)
 122 };
 123
 124 #include "unicode/udat.h"
 125
 126 #define LEN_UDAT 5 /* "UDAT_" */
 127 static const int32_t count_UDateFormatStyle = UDAT_SHORT+1;
 128 static const Field names_UDateFormatStyle[] =
 129 {
 130         FIELD_NAME_STR( LEN_UDAT, UDAT_FULL ),
 131         FIELD_NAME_STR( LEN_UDAT, UDAT_LONG ),
 132         FIELD_NAME_STR( LEN_UDAT, UDAT_MEDIUM ),
 133         FIELD_NAME_STR( LEN_UDAT, UDAT_SHORT ),
 134         /* end regular */
 135     /*
 136      *  negative enums.. leave out for now.
 137         FIELD_NAME_STR( LEN_UDAT, UDAT_NONE ),
 138         FIELD_NAME_STR( LEN_UDAT, UDAT_IGNORE ),
 139      */
 140 };
 141
 142 #endif
 143
 144 #include "unicode/uloc.h"
 145
 146 #define LEN_UAR 12 /* "ULOC_ACCEPT_" */
 147 static const int32_t count_UAcceptResult = 3;
 148 static const Field names_UAcceptResult[] =
 149 {
 150         FIELD_NAME_STR( LEN_UAR, ULOC_ACCEPT_FAILED ),
 151         FIELD_NAME_STR( LEN_UAR, ULOC_ACCEPT_VALID ),
 152         FIELD_NAME_STR( LEN_UAR, ULOC_ACCEPT_FALLBACK ),
 153 };
 154
 155 #if !UCONFIG_NO_COLLATION
 156 #include "unicode/ucol.h"
 157 #define LEN_UCOL 5 /* UCOL_ */
 158 static const int32_t count_UColAttributeValue = UCOL_ATTRIBUTE_VALUE_COUNT;
 159 static const Field names_UColAttributeValue[]  = {
 160    FIELD_NAME_STR( LEN_UCOL, UCOL_PRIMARY ),
 161    FIELD_NAME_STR( LEN_UCOL, UCOL_SECONDARY ),
 162    FIELD_NAME_STR( LEN_UCOL, UCOL_TERTIARY ),
 163 //   FIELD_NAME_STR( LEN_UCOL, UCOL_CE_STRENGTH_LIMIT ),
 164    FIELD_NAME_STR( LEN_UCOL, UCOL_QUATERNARY ),
 165    // gap
 166    FIELD_NAME_STR( LEN_UCOL, UCOL_IDENTICAL ),
 167 //   FIELD_NAME_STR( LEN_UCOL, UCOL_STRENGTH_LIMIT ),
 168    FIELD_NAME_STR( LEN_UCOL, UCOL_OFF ),
 169    FIELD_NAME_STR( LEN_UCOL, UCOL_ON ),
 170    // gap
 171    FIELD_NAME_STR( LEN_UCOL, UCOL_SHIFTED ),
 172    FIELD_NAME_STR( LEN_UCOL, UCOL_NON_IGNORABLE ),
 173    // gap
 174    FIELD_NAME_STR( LEN_UCOL, UCOL_LOWER_FIRST ),
 175    FIELD_NAME_STR( LEN_UCOL, UCOL_UPPER_FIRST ),
 176 };
 177
 178 #endif
 179
 180
 181 #include "unicode/icuplug.h"
 182
 183 #define LEN_UPLUG_REASON 13 /* UPLUG_REASON_ */
 184 static const int32_t count_UPlugReason = UPLUG_REASON_COUNT;
 185 static const Field names_UPlugReason[]  = {
 186    FIELD_NAME_STR( LEN_UPLUG_REASON, UPLUG_REASON_QUERY ),
 187    FIELD_NAME_STR( LEN_UPLUG_REASON, UPLUG_REASON_LOAD ),
 188    FIELD_NAME_STR( LEN_UPLUG_REASON, UPLUG_REASON_UNLOAD ),
 189 };
 190
 191 #define LEN_UPLUG_LEVEL 12 /* UPLUG_LEVEL_ */
 192 static const int32_t count_UPlugLevel = UPLUG_LEVEL_COUNT;
 193 static const Field names_UPlugLevel[]  = {
 194    FIELD_NAME_STR( LEN_UPLUG_LEVEL, UPLUG_LEVEL_INVALID ),
 195    FIELD_NAME_STR( LEN_UPLUG_LEVEL, UPLUG_LEVEL_UNKNOWN ),
 196    FIELD_NAME_STR( LEN_UPLUG_LEVEL, UPLUG_LEVEL_LOW ),
 197    FIELD_NAME_STR( LEN_UPLUG_LEVEL, UPLUG_LEVEL_HIGH ),
 198 };
 199
 200 #define LEN_UDBG 5 /* "UDBG_" */
 201 static const int32_t count_UDebugEnumType = UDBG_ENUM_COUNT;
 202 static const Field names_UDebugEnumType[] =
 203 {
 204     FIELD_NAME_STR( LEN_UDBG, UDBG_UDebugEnumType ),
 205 #if !UCONFIG_NO_FORMATTING
 206     FIELD_NAME_STR( LEN_UDBG, UDBG_UCalendarDateFields ),
 207     FIELD_NAME_STR( LEN_UDBG, UDBG_UCalendarMonths ),
 208     FIELD_NAME_STR( LEN_UDBG, UDBG_UDateFormatStyle ),
 209 #endif
 210     FIELD_NAME_STR( LEN_UDBG, UDBG_UPlugReason ),
 211     FIELD_NAME_STR( LEN_UDBG, UDBG_UPlugLevel ),
 212     FIELD_NAME_STR( LEN_UDBG, UDBG_UAcceptResult ),
 213 #if !UCONFIG_NO_COLLATION
 214     FIELD_NAME_STR( LEN_UDBG, UDBG_UColAttributeValue ),
 215 #endif
 216 };
 217
 218
 219 // --- Add new enum types above this line ---
 220
 221 #define COUNT_CASE(x)  case UDBG_##x: return (actual?count_##x:DBG_ARRAY_COUNT(names_##x));
 222 #define COUNT_FAIL_CASE(x) case UDBG_##x: return -1;
 223
 224 #define FIELD_CASE(x)  case UDBG_##x: return names_##x;
 225 #define FIELD_FAIL_CASE(x) case UDBG_##x: return NULL;
 226
 227 // low level
 228
 229 /**
 230  * @param type type of item
 231  * @param actual TRUE: for the actual enum's type (UCAL_FIELD_COUNT, etc), or FALSE for the string count
 232  */
 233 static int32_t _udbg_enumCount(UDebugEnumType type, UBool actual) {
 234         switch(type) {
 235                 COUNT_CASE(UDebugEnumType)
 236 #if !UCONFIG_NO_FORMATTING
 237                 COUNT_CASE(UCalendarDateFields)
 238                 COUNT_CASE(UCalendarMonths)
 239                 COUNT_CASE(UDateFormatStyle)
 240 #endif
 241         COUNT_CASE(UPlugReason)
 242         COUNT_CASE(UPlugLevel)
 243         COUNT_CASE(UAcceptResult)
 244 #if !UCONFIG_NO_COLLATION
 245         COUNT_CASE(UColAttributeValue)
 246 #endif
 247                 // COUNT_FAIL_CASE(UNonExistentEnum)
 248         default:
 249                 return -1;
 250         }
 251 }
 252
 253 static const Field* _udbg_enumFields(UDebugEnumType type) {
 254         switch(type) {
 255                 FIELD_CASE(UDebugEnumType)
 256 #if !UCONFIG_NO_FORMATTING
 257                 FIELD_CASE(UCalendarDateFields)
 258                 FIELD_CASE(UCalendarMonths)
 259                 FIELD_CASE(UDateFormatStyle)
 260 #endif
 261         FIELD_CASE(UPlugReason)
 262         FIELD_CASE(UPlugLevel)
 263         FIELD_CASE(UAcceptResult)
 264                 // FIELD_FAIL_CASE(UNonExistentEnum)
 265 #if !UCONFIG_NO_COLLATION
 266         FIELD_CASE(UColAttributeValue)
 267 #endif
 268         default:
 269                 return NULL;
 270         }
 271 }
 272
 273 // implementation
 274
 275 int32_t  udbg_enumCount(UDebugEnumType type) {
 276         return _udbg_enumCount(type, FALSE);
 277 }
 278
 279 int32_t  udbg_enumExpectedCount(UDebugEnumType type) {
 280         return _udbg_enumCount(type, TRUE);
 281 }
 282
 283 const char *  udbg_enumName(UDebugEnumType type, int32_t field) {
 284         if(field<0 ||
 285                                 field>=_udbg_enumCount(type,FALSE)) { // also will catch unsupported items
 286                 return NULL;
 287         } else {
 288                 const Field *fields = _udbg_enumFields(type);
 289                 if(fields == NULL) {
 290                         return NULL;
 291                 } else {
 292                         return fields[field].str + fields[field].prefix;
 293                 }
 294         }
 295 }
 296
 297 int32_t  udbg_enumArrayValue(UDebugEnumType type, int32_t field) {
 298         if(field<0 ||
 299                                 field>=_udbg_enumCount(type,FALSE)) { // also will catch unsupported items
 300                 return -1;
 301         } else {
 302                 const Field *fields = _udbg_enumFields(type);
 303                 if(fields == NULL) {
 304                         return -1;
 305                 } else {
 306                         return fields[field].num;
 307                 }
 308         }
 309 }
 310
 311 int32_t udbg_enumByName(UDebugEnumType type, const char *value) {
 312     if(type<0||type>=_udbg_enumCount(UDBG_UDebugEnumType, TRUE)) {
 313         return -1; // type out of range
 314     }
 315         const Field *fields = _udbg_enumFields(type);
 316     for(int32_t field = 0;field<_udbg_enumCount(type, FALSE);field++) {
 317         if(!strcmp(value, fields[field].str + fields[field].prefix)) {
 318             return fields[field].num;
 319         }
 320     }
 321     // try with the prefix
 322     for(int32_t field = 0;field<_udbg_enumCount(type, FALSE);field++) {
 323         if(!strcmp(value, fields[field].str)) {
 324             return fields[field].num;
 325         }
 326     }
 327     // fail
 328     return -1;
 329 }