[apple/icu.git] / icuSources / tools / toolutil / udbgutil.cpp

/********************************************************************
 * COPYRIGHT:
 * Copyright (c) 2007-2010, International Business Machines Corporation and
 * others. All Rights Reserved.
 ********************************************************************/

#include "udbgutil.h"
#include <string.h>

/*
To add a new enum type 
      (For example: UShoeSize  with values USHOE_WIDE=0, USHOE_REGULAR, USHOE_NARROW, USHOE_COUNT)

    1. udbgutil.h:  add  UDBG_UShoeSize to the UDebugEnumType enum before UDBG_ENUM_COUNT
      ( The subsequent steps involve this file, udbgutil.cpp )
    2. Find the marker "Add new enum types above this line"
    3. Before that marker, add a #include of any header file you need.
    4. Each enum type has three things in this section:  a #define, a count_, and an array of Fields. 
       It may help to copy and paste a previous definition.
    5. In the case of the USHOE_... strings above, "USHOE_" is common to all values- six characters
         " #define LEN_USHOE 6 "   
       6 characters will strip off "USHOE_" leaving enum values of WIDE, REGULAR, and NARROW.
    6. Define the 'count_' variable, with the number of enum values. If the enum has a _MAX or _COUNT value, 
        that can be helpful for automatically defining the count. Otherwise define it manually.
        " static const int32_t count_UShoeSize = USHOE_COUNT; "
    7. Define the field names, in order.
        " static const Field names_UShoeSize[] =  {
        "  FIELD_NAME_STR( LEN_USHOE, USHOE_WIDE ), 
        "  FIELD_NAME_STR( LEN_USHOE, USHOE_REGULAR ), 
        "  FIELD_NAME_STR( LEN_USHOE, USHOE_NARROW ), 
        " };
      ( The following command  was usedfor converting ucol.h into partially correct entities )
      grep "^[  ]*UCOL" < unicode/ucol.h  | 
         sed -e 's%^[  ]*\([A-Z]*\)_\([A-Z_]*\).*%   FIELD_NAME_STR( LEN_\1, \1_\2 ),%g' 
    8. Now, a bit farther down, add the name of the enum itself to the end of names_UDebugEnumType
          ( UDebugEnumType is an enum, too!)
        names_UDebugEnumType[] { ...  
            " FIELD_NAME_STR( LEN_UDBG, UDBG_UShoeSize ),   "
    9. Find the function _udbg_enumCount  and add the count macro:
            " COUNT_CASE(UShoeSize)
   10. Find the function _udbg_enumFields  and add the field macro:
            " FIELD_CASE(UShoeSize)
   11. verify that your test code, and Java data generation, works properly.
*/

/**
 * Structure representing an enum value
 */
struct Field {
    int32_t prefix;   /**< how many characters to remove in the prefix - i.e. UCHAR_ = 5 */
	const char *str;  /**< The actual string value */
	int32_t num;      /**< The numeric value */
};

/**
 * Calculate the size of an array.
 */
#define DBG_ARRAY_COUNT(x) (sizeof(x)/sizeof(x[0]))

/**
 * Define another field name. Used in an array of Field s
 * @param y the common prefix length (i.e. 6 for "USHOE_" )
 * @param x the actual enum value - it will be copied in both string and symbolic form.
 * @see Field
 */
#define FIELD_NAME_STR(y,x)  { y, #x, x }


// TODO: Currently, this whole functionality goes away with UCONFIG_NO_FORMATTING. Should be split up.
#if !UCONFIG_NO_FORMATTING

// Calendar
#include "unicode/ucal.h"

// 'UCAL_' = 5
#define LEN_UCAL 5 /* UCAL_ */
static const int32_t count_UCalendarDateFields = UCAL_FIELD_COUNT;
static const Field names_UCalendarDateFields[] = 
{
    FIELD_NAME_STR( LEN_UCAL, UCAL_ERA ),
    FIELD_NAME_STR( LEN_UCAL, UCAL_YEAR ),
    FIELD_NAME_STR( LEN_UCAL, UCAL_MONTH ),
    FIELD_NAME_STR( LEN_UCAL, UCAL_WEEK_OF_YEAR ),
    FIELD_NAME_STR( LEN_UCAL, UCAL_WEEK_OF_MONTH ),
    FIELD_NAME_STR( LEN_UCAL, UCAL_DATE ),
    FIELD_NAME_STR( LEN_UCAL, UCAL_DAY_OF_YEAR ),
    FIELD_NAME_STR( LEN_UCAL, UCAL_DAY_OF_WEEK ),
    FIELD_NAME_STR( LEN_UCAL, UCAL_DAY_OF_WEEK_IN_MONTH ),
    FIELD_NAME_STR( LEN_UCAL, UCAL_AM_PM ),
    FIELD_NAME_STR( LEN_UCAL, UCAL_HOUR ),
    FIELD_NAME_STR( LEN_UCAL, UCAL_HOUR_OF_DAY ),
    FIELD_NAME_STR( LEN_UCAL, UCAL_MINUTE ),
    FIELD_NAME_STR( LEN_UCAL, UCAL_SECOND ),
    FIELD_NAME_STR( LEN_UCAL, UCAL_MILLISECOND ),
    FIELD_NAME_STR( LEN_UCAL, UCAL_ZONE_OFFSET ),
    FIELD_NAME_STR( LEN_UCAL, UCAL_DST_OFFSET ),
    FIELD_NAME_STR( LEN_UCAL, UCAL_YEAR_WOY ),
    FIELD_NAME_STR( LEN_UCAL, UCAL_DOW_LOCAL ),
    FIELD_NAME_STR( LEN_UCAL, UCAL_EXTENDED_YEAR ),
    FIELD_NAME_STR( LEN_UCAL, UCAL_JULIAN_DAY ),
    FIELD_NAME_STR( LEN_UCAL, UCAL_MILLISECONDS_IN_DAY ),
    FIELD_NAME_STR( LEN_UCAL, UCAL_IS_LEAP_MONTH ),
};


static const int32_t count_UCalendarMonths = UCAL_UNDECIMBER+1;
static const Field names_UCalendarMonths[] = 
{
  FIELD_NAME_STR( LEN_UCAL, UCAL_JANUARY ),
  FIELD_NAME_STR( LEN_UCAL, UCAL_FEBRUARY ),
  FIELD_NAME_STR( LEN_UCAL, UCAL_MARCH ),
  FIELD_NAME_STR( LEN_UCAL, UCAL_APRIL ),
  FIELD_NAME_STR( LEN_UCAL, UCAL_MAY ),
  FIELD_NAME_STR( LEN_UCAL, UCAL_JUNE ),
  FIELD_NAME_STR( LEN_UCAL, UCAL_JULY ),
  FIELD_NAME_STR( LEN_UCAL, UCAL_AUGUST ),
  FIELD_NAME_STR( LEN_UCAL, UCAL_SEPTEMBER ),
  FIELD_NAME_STR( LEN_UCAL, UCAL_OCTOBER ),
  FIELD_NAME_STR( LEN_UCAL, UCAL_NOVEMBER ),
  FIELD_NAME_STR( LEN_UCAL, UCAL_DECEMBER ),
  FIELD_NAME_STR( LEN_UCAL, UCAL_UNDECIMBER)
};

#include "unicode/udat.h"

#define LEN_UDAT 5 /* "UDAT_" */
static const int32_t count_UDateFormatStyle = UDAT_SHORT+1;
static const Field names_UDateFormatStyle[] = 
{
        FIELD_NAME_STR( LEN_UDAT, UDAT_FULL ),
        FIELD_NAME_STR( LEN_UDAT, UDAT_LONG ),
        FIELD_NAME_STR( LEN_UDAT, UDAT_MEDIUM ),
        FIELD_NAME_STR( LEN_UDAT, UDAT_SHORT ),
        /* end regular */
    /*
     *  negative enums.. leave out for now.
        FIELD_NAME_STR( LEN_UDAT, UDAT_NONE ),
        FIELD_NAME_STR( LEN_UDAT, UDAT_IGNORE ),
     */
};

#endif
 
#include "unicode/uloc.h"

#define LEN_UAR 12 /* "ULOC_ACCEPT_" */
static const int32_t count_UAcceptResult = 3;
static const Field names_UAcceptResult[] = 
{
        FIELD_NAME_STR( LEN_UAR, ULOC_ACCEPT_FAILED ),
        FIELD_NAME_STR( LEN_UAR, ULOC_ACCEPT_VALID ),
        FIELD_NAME_STR( LEN_UAR, ULOC_ACCEPT_FALLBACK ),
};

#if !UCONFIG_NO_COLLATION
#include "unicode/ucol.h"
#define LEN_UCOL 5 /* UCOL_ */
static const int32_t count_UColAttributeValue = UCOL_ATTRIBUTE_VALUE_COUNT;
static const Field names_UColAttributeValue[]  = {
   FIELD_NAME_STR( LEN_UCOL, UCOL_PRIMARY ),
   FIELD_NAME_STR( LEN_UCOL, UCOL_SECONDARY ),
   FIELD_NAME_STR( LEN_UCOL, UCOL_TERTIARY ),
//   FIELD_NAME_STR( LEN_UCOL, UCOL_CE_STRENGTH_LIMIT ),
   FIELD_NAME_STR( LEN_UCOL, UCOL_QUATERNARY ),
   // gap
   FIELD_NAME_STR( LEN_UCOL, UCOL_IDENTICAL ),
//   FIELD_NAME_STR( LEN_UCOL, UCOL_STRENGTH_LIMIT ),
   FIELD_NAME_STR( LEN_UCOL, UCOL_OFF ),
   FIELD_NAME_STR( LEN_UCOL, UCOL_ON ),
   // gap
   FIELD_NAME_STR( LEN_UCOL, UCOL_SHIFTED ),
   FIELD_NAME_STR( LEN_UCOL, UCOL_NON_IGNORABLE ),
   // gap
   FIELD_NAME_STR( LEN_UCOL, UCOL_LOWER_FIRST ),
   FIELD_NAME_STR( LEN_UCOL, UCOL_UPPER_FIRST ),
};

#endif


#include "unicode/icuplug.h"

#define LEN_UPLUG_REASON 13 /* UPLUG_REASON_ */
static const int32_t count_UPlugReason = UPLUG_REASON_COUNT;
static const Field names_UPlugReason[]  = {
   FIELD_NAME_STR( LEN_UPLUG_REASON, UPLUG_REASON_QUERY ),
   FIELD_NAME_STR( LEN_UPLUG_REASON, UPLUG_REASON_LOAD ),
   FIELD_NAME_STR( LEN_UPLUG_REASON, UPLUG_REASON_UNLOAD ),
};

#define LEN_UPLUG_LEVEL 12 /* UPLUG_LEVEL_ */
static const int32_t count_UPlugLevel = UPLUG_LEVEL_COUNT;
static const Field names_UPlugLevel[]  = {
   FIELD_NAME_STR( LEN_UPLUG_LEVEL, UPLUG_LEVEL_INVALID ),
   FIELD_NAME_STR( LEN_UPLUG_LEVEL, UPLUG_LEVEL_UNKNOWN ),
   FIELD_NAME_STR( LEN_UPLUG_LEVEL, UPLUG_LEVEL_LOW ),
   FIELD_NAME_STR( LEN_UPLUG_LEVEL, UPLUG_LEVEL_HIGH ),
};

#define LEN_UDBG 5 /* "UDBG_" */
static const int32_t count_UDebugEnumType = UDBG_ENUM_COUNT;
static const Field names_UDebugEnumType[] = 
{
    FIELD_NAME_STR( LEN_UDBG, UDBG_UDebugEnumType ),
#if !UCONFIG_NO_FORMATTING
    FIELD_NAME_STR( LEN_UDBG, UDBG_UCalendarDateFields ),
    FIELD_NAME_STR( LEN_UDBG, UDBG_UCalendarMonths ),
    FIELD_NAME_STR( LEN_UDBG, UDBG_UDateFormatStyle ),
#endif
    FIELD_NAME_STR( LEN_UDBG, UDBG_UPlugReason ),
    FIELD_NAME_STR( LEN_UDBG, UDBG_UPlugLevel ),
    FIELD_NAME_STR( LEN_UDBG, UDBG_UAcceptResult ),
#if !UCONFIG_NO_COLLATION
    FIELD_NAME_STR( LEN_UDBG, UDBG_UColAttributeValue ),
#endif
};


// --- Add new enum types above this line ---

#define COUNT_CASE(x)  case UDBG_##x: return (actual?count_##x:DBG_ARRAY_COUNT(names_##x));
#define COUNT_FAIL_CASE(x) case UDBG_##x: return -1;

#define FIELD_CASE(x)  case UDBG_##x: return names_##x;
#define FIELD_FAIL_CASE(x) case UDBG_##x: return NULL;

// low level

/**
 * @param type type of item
 * @param actual TRUE: for the actual enum's type (UCAL_FIELD_COUNT, etc), or FALSE for the string count
 */
static int32_t _udbg_enumCount(UDebugEnumType type, UBool actual) {
	switch(type) {
		COUNT_CASE(UDebugEnumType)
#if !UCONFIG_NO_FORMATTING
		COUNT_CASE(UCalendarDateFields)
		COUNT_CASE(UCalendarMonths)
		COUNT_CASE(UDateFormatStyle)
#endif
        COUNT_CASE(UPlugReason)
        COUNT_CASE(UPlugLevel)
        COUNT_CASE(UAcceptResult)
#if !UCONFIG_NO_COLLATION
        COUNT_CASE(UColAttributeValue)
#endif
		// COUNT_FAIL_CASE(UNonExistentEnum)
	default:
		return -1;
	}
}

static const Field* _udbg_enumFields(UDebugEnumType type) {
	switch(type) {
		FIELD_CASE(UDebugEnumType)
#if !UCONFIG_NO_FORMATTING
		FIELD_CASE(UCalendarDateFields)
		FIELD_CASE(UCalendarMonths)
		FIELD_CASE(UDateFormatStyle)
#endif
        FIELD_CASE(UPlugReason)
        FIELD_CASE(UPlugLevel)
        FIELD_CASE(UAcceptResult)
		// FIELD_FAIL_CASE(UNonExistentEnum)
#if !UCONFIG_NO_COLLATION
        FIELD_CASE(UColAttributeValue)
#endif
	default:
		return NULL;
	}
}

// implementation

int32_t  udbg_enumCount(UDebugEnumType type) {
	return _udbg_enumCount(type, FALSE);
}

int32_t  udbg_enumExpectedCount(UDebugEnumType type) {
	return _udbg_enumCount(type, TRUE);
}

const char *  udbg_enumName(UDebugEnumType type, int32_t field) {
	if(field<0 || 
				field>=_udbg_enumCount(type,FALSE)) { // also will catch unsupported items
		return NULL;
	} else {
		const Field *fields = _udbg_enumFields(type);
		if(fields == NULL) {
			return NULL;
		} else {
			return fields[field].str + fields[field].prefix;
		}
	}
}

int32_t  udbg_enumArrayValue(UDebugEnumType type, int32_t field) {
	if(field<0 || 
				field>=_udbg_enumCount(type,FALSE)) { // also will catch unsupported items
		return -1;
	} else {
		const Field *fields = _udbg_enumFields(type);
		if(fields == NULL) {
			return -1;
		} else {
			return fields[field].num;
		}
	}    
}

int32_t udbg_enumByName(UDebugEnumType type, const char *value) {
    if(type<0||type>=_udbg_enumCount(UDBG_UDebugEnumType, TRUE)) {
        return -1; // type out of range
    }
	const Field *fields = _udbg_enumFields(type);
    for(int32_t field = 0;field<_udbg_enumCount(type, FALSE);field++) {
        if(!strcmp(value, fields[field].str + fields[field].prefix)) {
            return fields[field].num;
        }        
    }
    // try with the prefix
    for(int32_t field = 0;field<_udbg_enumCount(type, FALSE);field++) {
        if(!strcmp(value, fields[field].str)) {
            return fields[field].num;
        }        
    }
    // fail
    return -1;
}
Commit	Line	Data
729e4ab9 A	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	}