[apple/icu.git] / icuSources / common / utrace.cpp

// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
*******************************************************************************
*   Copyright (C) 2003-2014, International Business Machines
*   Corporation and others.  All Rights Reserved.
*******************************************************************************
*   file name:  utrace.c
*   encoding:   UTF-8
*   tab size:   8 (not used)
*   indentation:4
*/

#include "unicode/utrace.h"
#include "utracimp.h"
#include "cstring.h"
#include "uassert.h"
#include "ucln_cmn.h"


static UTraceEntry     *pTraceEntryFunc = NULL;
static UTraceExit      *pTraceExitFunc  = NULL;
static UTraceData      *pTraceDataFunc  = NULL;
static const void      *gTraceContext   = NULL;

/**
 * \var utrace_level
 * Trace level variable. Negative for "off".
 */
static int32_t
utrace_level = UTRACE_ERROR;

U_CAPI void U_EXPORT2
utrace_entry(int32_t fnNumber) {
    if (pTraceEntryFunc != NULL) {
        (*pTraceEntryFunc)(gTraceContext, fnNumber);
    }
}


static const char gExitFmt[]             = "Returns.";
static const char gExitFmtValue[]        = "Returns %d.";
static const char gExitFmtStatus[]       = "Returns.  Status = %d.";
static const char gExitFmtValueStatus[]  = "Returns %d.  Status = %d.";
static const char gExitFmtPtrStatus[]    = "Returns %d.  Status = %p.";

U_CAPI void U_EXPORT2
utrace_exit(int32_t fnNumber, int32_t returnType, ...) {
    if (pTraceExitFunc != NULL) {
        va_list     args;
        const char *fmt;

        switch (returnType) {
        case 0:
            fmt = gExitFmt;
            break;
        case UTRACE_EXITV_I32:
            fmt = gExitFmtValue;
            break;
        case UTRACE_EXITV_STATUS:
            fmt = gExitFmtStatus;
            break;
        case UTRACE_EXITV_I32 | UTRACE_EXITV_STATUS:
            fmt = gExitFmtValueStatus;
            break;
        case UTRACE_EXITV_PTR | UTRACE_EXITV_STATUS:
            fmt = gExitFmtPtrStatus;
            break;
        default:
            UPRV_UNREACHABLE;
        }

        va_start(args, returnType);
        (*pTraceExitFunc)(gTraceContext, fnNumber, fmt, args);
        va_end(args);
    }
}
 

U_CAPI void U_EXPORT2 
utrace_data(int32_t fnNumber, int32_t level, const char *fmt, ...) {
    if (pTraceDataFunc != NULL) {
           va_list args;
           va_start(args, fmt ); 
           (*pTraceDataFunc)(gTraceContext, fnNumber, level, fmt, args);
           va_end(args);
    }
}


static void outputChar(char c, char *outBuf, int32_t *outIx, int32_t capacity, int32_t indent) {
    int32_t i;
    /* Check whether a start of line indenting is needed.  Three cases:
     *   1.  At the start of the first line  (output index == 0).
     *   2.  At the start of subsequent lines  (preceeding char in buffer == '\n')
     *   3.  When preflighting buffer len (buffer capacity is exceeded), when
     *       a \n is output.  Ideally we wouldn't do the indent until the following char
     *       is received, but that won't work because there's no place to remember that
     *       the preceding char was \n.  Meaning that we may overstimate the
     *       buffer size needed.  No harm done.
     */
    if (*outIx==0 ||   /* case 1. */
        (c!='\n' && c!=0 && *outIx < capacity && outBuf[(*outIx)-1]=='\n') ||  /* case 2. */
        (c=='\n' && *outIx>=capacity))    /* case 3 */
    {
        /* At the start of a line.  Indent. */
        for(i=0; i<indent; i++) {
            if (*outIx < capacity) {
                outBuf[*outIx] = ' ';
            }
            (*outIx)++;
        }
    }

    if (*outIx < capacity) {
        outBuf[*outIx] = c;
    }
    if (c != 0) {
        /* Nulls only appear as end-of-string terminators.  Move them to the output
         *  buffer, but do not update the length of the buffer, so that any
         *  following output will overwrite the null. */
        (*outIx)++;
    }
}

static void outputHexBytes(int64_t val, int32_t charsToOutput,
                           char *outBuf, int32_t *outIx, int32_t capacity) {
    static const char gHexChars[] = "0123456789abcdef";
    int32_t shiftCount;
    for  (shiftCount=(charsToOutput-1)*4; shiftCount >= 0; shiftCount-=4) {
        char c = gHexChars[(val >> shiftCount) & 0xf];
        outputChar(c, outBuf, outIx, capacity, 0);
    }
}

/* Output a pointer value in hex.  Work with any size of pointer   */
static void outputPtrBytes(void *val, char *outBuf, int32_t *outIx, int32_t capacity) {
    uint32_t  i;
    int32_t  incVal = 1;              /* +1 for big endian, -1 for little endian          */
    char     *p     = (char *)&val;   /* point to current byte to output in the ptr val  */

#if !U_IS_BIG_ENDIAN
    /* Little Endian.  Move p to most significant end of the value      */
    incVal = -1;
    p += sizeof(void *) - 1;
#endif

    /* Loop through the bytes of the ptr as it sits in memory, from 
     * most significant to least significant end                    */
    for (i=0; i<sizeof(void *); i++) {
        outputHexBytes(*p, 2, outBuf, outIx, capacity);
        p += incVal;
    }
}

static void outputString(const char *s, char *outBuf, int32_t *outIx, int32_t capacity, int32_t indent) {
    int32_t i = 0;
    char    c;
    if (s==NULL) {
        s = "*NULL*";
    }
    do {
        c = s[i++];
        outputChar(c, outBuf, outIx, capacity, indent);
    } while (c != 0);
}
        

static void outputUString(const UChar *s, int32_t len, 
                          char *outBuf, int32_t *outIx, int32_t capacity, int32_t indent) {
    int32_t i = 0;
    UChar   c;
    if (s==NULL) {
        outputString(NULL, outBuf, outIx, capacity, indent);
        return;
    }

    for (i=0; i<len || len==-1; i++) {
        c = s[i];
        outputHexBytes(c, 4, outBuf, outIx, capacity);
        outputChar(' ', outBuf, outIx, capacity, indent);
        if (len == -1 && c==0) {
            break;
        }
    }
}
        
U_CAPI int32_t U_EXPORT2
utrace_vformat(char *outBuf, int32_t capacity, int32_t indent, const char *fmt, va_list args) {
    int32_t   outIx  = 0;
    int32_t   fmtIx  = 0;
    char      fmtC;
    char      c;
    int32_t   intArg;
    int64_t   longArg = 0;
    char      *ptrArg;

    /*   Loop runs once for each character in the format string.
     */
    for (;;) {
        fmtC = fmt[fmtIx++];
        if (fmtC != '%') {
            /* Literal character, not part of a %sequence.  Just copy it to the output. */
            outputChar(fmtC, outBuf, &outIx, capacity, indent);
            if (fmtC == 0) {
                /* We hit the null that terminates the format string.
                 * This is the normal (and only) exit from the loop that
                 * interprets the format
                 */
                break;
            }
            continue;
        }

        /* We encountered a '%'.  Pick up the following format char */
        fmtC = fmt[fmtIx++];

        switch (fmtC) {
        case 'c':
            /* single 8 bit char   */
            c = (char)va_arg(args, int32_t);
            outputChar(c, outBuf, &outIx, capacity, indent);
            break;

        case 's':
            /* char * string, null terminated.  */
            ptrArg = va_arg(args, char *);
            outputString((const char *)ptrArg, outBuf, &outIx, capacity, indent);
            break;

        case 'S':
            /* UChar * string, with length, len==-1 for null terminated. */
            ptrArg = va_arg(args, char *);             /* Ptr    */
            intArg =(int32_t)va_arg(args, int32_t);    /* Length */
            outputUString((const UChar *)ptrArg, intArg, outBuf, &outIx, capacity, indent);
            break;

        case 'b':
            /*  8 bit int  */
            intArg = va_arg(args, int);
            outputHexBytes(intArg, 2, outBuf, &outIx, capacity);
            break;

        case 'h':
            /*  16 bit int  */
            intArg = va_arg(args, int);
            outputHexBytes(intArg, 4, outBuf, &outIx, capacity);
            break;

        case 'd':
            /*  32 bit int  */
            intArg = va_arg(args, int);
            outputHexBytes(intArg, 8, outBuf, &outIx, capacity);
            break;

        case 'l':
            /*  64 bit long  */
            longArg = va_arg(args, int64_t);
            outputHexBytes(longArg, 16, outBuf, &outIx, capacity);
            break;
            
        case 'p':
            /*  Pointers.   */
            ptrArg = va_arg(args, char *);
            outputPtrBytes(ptrArg, outBuf, &outIx, capacity);
            break;

        case 0:
            /* Single '%' at end of fmt string.  Output as literal '%'.   
             * Back up index into format string so that the terminating null will be
             * re-fetched in the outer loop, causing it to terminate.
             */
            outputChar('%', outBuf, &outIx, capacity, indent);
            fmtIx--;
            break;

        case 'v':
            {
                /* Vector of values, e.g. %vh */
                char     vectorType;
                int32_t  vectorLen;
                const char   *i8Ptr;
                int16_t  *i16Ptr;
                int32_t  *i32Ptr;
                int64_t  *i64Ptr;
                void     **ptrPtr;
                int32_t   charsToOutput = 0;
                int32_t   i;
                
                vectorType = fmt[fmtIx];    /* b, h, d, l, p, etc. */
                if (vectorType != 0) {
                    fmtIx++;
                }
                i8Ptr = (const char *)va_arg(args, void*);
                i16Ptr = (int16_t *)i8Ptr;
                i32Ptr = (int32_t *)i8Ptr;
                i64Ptr = (int64_t *)i8Ptr;
                ptrPtr = (void **)i8Ptr;
                vectorLen =(int32_t)va_arg(args, int32_t);
                if (ptrPtr == NULL) {
                    outputString("*NULL* ", outBuf, &outIx, capacity, indent);
                } else {
                    for (i=0; i<vectorLen || vectorLen==-1; i++) { 
                        switch (vectorType) {
                        case 'b':
                            charsToOutput = 2;
                            longArg = *i8Ptr++;
                            break;
                        case 'h':
                            charsToOutput = 4;
                            longArg = *i16Ptr++;
                            break;
                        case 'd':
                            charsToOutput = 8;
                            longArg = *i32Ptr++;
                            break;
                        case 'l':
                            charsToOutput = 16;
                            longArg = *i64Ptr++;
                            break;
                        case 'p':
                            charsToOutput = 0;
                            outputPtrBytes(*ptrPtr, outBuf, &outIx, capacity);
                            longArg = *ptrPtr==NULL? 0: 1;    /* test for null terminated array. */
                            ptrPtr++;
                            break;
                        case 'c':
                            charsToOutput = 0;
                            outputChar(*i8Ptr, outBuf, &outIx, capacity, indent);
                            longArg = *i8Ptr;    /* for test for null terminated array. */
                            i8Ptr++;
                            break;
                        case 's':
                            charsToOutput = 0;
                            outputString((const char *)*ptrPtr, outBuf, &outIx, capacity, indent);
                            outputChar('\n', outBuf, &outIx, capacity, indent);
                            longArg = *ptrPtr==NULL? 0: 1;   /* for test for null term. array. */
                            ptrPtr++;
                            break;

                        case 'S':
                            charsToOutput = 0;
                            outputUString((const UChar *)*ptrPtr, -1, outBuf, &outIx, capacity, indent);
                            outputChar('\n', outBuf, &outIx, capacity, indent);
                            longArg = *ptrPtr==NULL? 0: 1;   /* for test for null term. array. */
                            ptrPtr++;
                            break;

                            
                        }
                        if (charsToOutput > 0) {
                            outputHexBytes(longArg, charsToOutput, outBuf, &outIx, capacity);
                            outputChar(' ', outBuf, &outIx, capacity, indent);
                        }
                        if (vectorLen == -1 && longArg == 0) {
                            break;
                        }
                    }
                }
                outputChar('[', outBuf, &outIx, capacity, indent);
                outputHexBytes(vectorLen, 8, outBuf, &outIx, capacity);
                outputChar(']', outBuf, &outIx, capacity, indent);
            }
            break;


        default:
            /* %. in format string, where . is some character not in the set
             *    of recognized format chars.  Just output it as if % wasn't there.
             *    (Covers "%%" outputing a single '%')
             */
             outputChar(fmtC, outBuf, &outIx, capacity, indent);
        }
    }
    outputChar(0, outBuf, &outIx, capacity, indent);  /* Make sure that output is null terminated  */
    return outIx + 1;     /* outIx + 1 because outIx does not increment when outputing final null. */
}


U_CAPI int32_t U_EXPORT2
utrace_format(char *outBuf, int32_t capacity,
                int32_t indent, const char *fmt,  ...) {
    int32_t retVal;
    va_list args;
    va_start(args, fmt ); 
    retVal = utrace_vformat(outBuf, capacity, indent, fmt, args);
    va_end(args);
    return retVal;
}


U_CAPI void U_EXPORT2
utrace_setFunctions(const void *context,
                    UTraceEntry *e, UTraceExit *x, UTraceData *d) {
    pTraceEntryFunc = e;
    pTraceExitFunc  = x;
    pTraceDataFunc  = d;
    gTraceContext   = context;
}


U_CAPI void U_EXPORT2
utrace_getFunctions(const void **context,
                    UTraceEntry **e, UTraceExit **x, UTraceData **d) {
    *e = pTraceEntryFunc;
    *x = pTraceExitFunc;
    *d = pTraceDataFunc;
    *context = gTraceContext;
}

U_CAPI void U_EXPORT2
utrace_setLevel(int32_t level) {
    if (level < UTRACE_OFF) {
        level = UTRACE_OFF;
    }
    if (level > UTRACE_VERBOSE) {
        level = UTRACE_VERBOSE;
    }
    utrace_level = level;
}

U_CAPI int32_t U_EXPORT2
utrace_getLevel() {
    return utrace_level;
}


U_CFUNC UBool 
utrace_cleanup() {
    pTraceEntryFunc = NULL;
    pTraceExitFunc  = NULL;
    pTraceDataFunc  = NULL;
    utrace_level    = UTRACE_OFF;
    gTraceContext   = NULL;
    return TRUE;
}


static const char * const
trFnName[] = {
    "u_init",
    "u_cleanup",
    NULL
};


static const char * const
trConvNames[] = {
    "ucnv_open",
    "ucnv_openPackage",
    "ucnv_openAlgorithmic",
    "ucnv_clone",
    "ucnv_close",
    "ucnv_flushCache",
    "ucnv_load",
    "ucnv_unload",
    NULL
};

    
static const char * const
trCollNames[] = {
    "ucol_open",
    "ucol_close",
    "ucol_strcoll",
    "ucol_getSortKey",
    "ucol_getLocale",
    "ucol_nextSortKeyPart",
    "ucol_strcollIter",
    "ucol_openFromShortString",
    "ucol_strcollUTF8",
    NULL
};

                
U_CAPI const char * U_EXPORT2
utrace_functionName(int32_t fnNumber) {
    if(UTRACE_FUNCTION_START <= fnNumber && fnNumber < UTRACE_FUNCTION_LIMIT) {
        return trFnName[fnNumber];
    } else if(UTRACE_CONVERSION_START <= fnNumber && fnNumber < UTRACE_CONVERSION_LIMIT) {
        return trConvNames[fnNumber - UTRACE_CONVERSION_START];
    } else if(UTRACE_COLLATION_START <= fnNumber && fnNumber < UTRACE_COLLATION_LIMIT){
        return trCollNames[fnNumber - UTRACE_COLLATION_START];
    } else {
        return "[BOGUS Trace Function Number]";
    }
}
Commit	Line	Data
f3c0d7a5 A	1	// © 2016 and later: Unicode, Inc. and others.
f3c0d7a5 A	2	// License & terms of use: http://www.unicode.org/copyright.html
374ca955 A	3	/*
374ca955 A	4	*******************************************************************************
57a6839d	5	* Copyright (C) 2003-2014, International Business Machines
374ca955 A	6	* Corporation and others. All Rights Reserved.
	7	*******************************************************************************
	8	* file name: utrace.c
f3c0d7a5	9	* encoding: UTF-8
374ca955 A	10	* tab size: 8 (not used)
	11	* indentation:4
	12	*/
	13
374ca955 A	14	#include "unicode/utrace.h"
	15	#include "utracimp.h"
	16	#include "cstring.h"
	17	#include "uassert.h"
	18	#include "ucln_cmn.h"
	19
	20
	21	static UTraceEntry *pTraceEntryFunc = NULL;
	22	static UTraceExit *pTraceExitFunc = NULL;
	23	static UTraceData *pTraceDataFunc = NULL;
	24	static const void *gTraceContext = NULL;
	25
f3c0d7a5 A	26	/**
	27	* \var utrace_level
	28	* Trace level variable. Negative for "off".
	29	*/
	30	static int32_t
46f4442e	31	utrace_level = UTRACE_ERROR;
374ca955 A	32
	33	U_CAPI void U_EXPORT2
	34	utrace_entry(int32_t fnNumber) {
	35	if (pTraceEntryFunc != NULL) {
	36	(*pTraceEntryFunc)(gTraceContext, fnNumber);
	37	}
	38	}
	39
	40
	41	static const char gExitFmt[] = "Returns.";
	42	static const char gExitFmtValue[] = "Returns %d.";
	43	static const char gExitFmtStatus[] = "Returns. Status = %d.";
	44	static const char gExitFmtValueStatus[] = "Returns %d. Status = %d.";
	45	static const char gExitFmtPtrStatus[] = "Returns %d. Status = %p.";
	46
	47	U_CAPI void U_EXPORT2
	48	utrace_exit(int32_t fnNumber, int32_t returnType, ...) {
	49	if (pTraceExitFunc != NULL) {
	50	va_list args;
	51	const char *fmt;
	52
	53	switch (returnType) {
	54	case 0:
	55	fmt = gExitFmt;
	56	break;
	57	case UTRACE_EXITV_I32:
	58	fmt = gExitFmtValue;
	59	break;
	60	case UTRACE_EXITV_STATUS:
	61	fmt = gExitFmtStatus;
	62	break;
	63	case UTRACE_EXITV_I32 \| UTRACE_EXITV_STATUS:
	64	fmt = gExitFmtValueStatus;
	65	break;
	66	case UTRACE_EXITV_PTR \| UTRACE_EXITV_STATUS:
	67	fmt = gExitFmtPtrStatus;
	68	break;
	69	default:
3d1f044b	70	UPRV_UNREACHABLE;
374ca955 A	71	}
	72
	73	va_start(args, returnType);
	74	(*pTraceExitFunc)(gTraceContext, fnNumber, fmt, args);
	75	va_end(args);
	76	}
	77	}
	78
	79
	80
	81	U_CAPI void U_EXPORT2
	82	utrace_data(int32_t fnNumber, int32_t level, const char *fmt, ...) {
	83	if (pTraceDataFunc != NULL) {
	84	va_list args;
	85	va_start(args, fmt );
	86	(*pTraceDataFunc)(gTraceContext, fnNumber, level, fmt, args);
	87	va_end(args);
	88	}
	89	}
	90
	91
	92	static void outputChar(char c, char outBuf, int32_t outIx, int32_t capacity, int32_t indent) {
	93	int32_t i;
	94	/* Check whether a start of line indenting is needed. Three cases:
	95	* 1. At the start of the first line (output index == 0).
	96	* 2. At the start of subsequent lines (preceeding char in buffer == '\n')
	97	* 3. When preflighting buffer len (buffer capacity is exceeded), when
	98	* a \n is output. Ideally we wouldn't do the indent until the following char
	99	* is received, but that won't work because there's no place to remember that
	100	* the preceding char was \n. Meaning that we may overstimate the
	101	* buffer size needed. No harm done.
	102	*/
	103	if (outIx==0 \|\| / case 1. */
	104	(c!='\n' && c!=0 && outIx < capacity && outBuf[(outIx)-1]=='\n') \|\| /* case 2. */
	105	(c=='\n' && outIx>=capacity)) / case 3 */
	106	{
	107	/* At the start of a line. Indent. */
	108	for(i=0; i<indent; i++) {
	109	if (*outIx < capacity) {
	110	outBuf[*outIx] = ' ';
	111	}
	112	(*outIx)++;
	113	}
	114	}
	115
	116	if (*outIx < capacity) {
	117	outBuf[*outIx] = c;
	118	}
	119	if (c != 0) {
	120	/* Nulls only appear as end-of-string terminators. Move them to the output
	121	* buffer, but do not update the length of the buffer, so that any
	122	* following output will overwrite the null. */
	123	(*outIx)++;
	124	}
	125	}
	126
	127	static void outputHexBytes(int64_t val, int32_t charsToOutput,
	128	char outBuf, int32_t outIx, int32_t capacity) {
	129	static const char gHexChars[] = "0123456789abcdef";
	130	int32_t shiftCount;
	131	for (shiftCount=(charsToOutput-1)*4; shiftCount >= 0; shiftCount-=4) {
	132	char c = gHexChars[(val >> shiftCount) & 0xf];
	133	outputChar(c, outBuf, outIx, capacity, 0);
	134	}
135	}
136
137	/* Output a pointer value in hex. Work with any size of pointer */
138	static void outputPtrBytes(void val, char outBuf, int32_t *outIx, int32_t capacity) {
f3c0d7a5	139	uint32_t i;
374ca955 A	140	int32_t incVal = 1; /* +1 for big endian, -1 for little endian */
	141	char p = (char )&val; /* point to current byte to output in the ptr val */
	142
	143	#if !U_IS_BIG_ENDIAN
	144	/* Little Endian. Move p to most significant end of the value */
	145	incVal = -1;
	146	p += sizeof(void *) - 1;
	147	#endif
	148
	149	/* Loop through the bytes of the ptr as it sits in memory, from
	150	* most significant to least significant end */
	151	for (i=0; i<sizeof(void *); i++) {
	152	outputHexBytes(*p, 2, outBuf, outIx, capacity);
	153	p += incVal;
	154	}
	155	}
	156
	157	static void outputString(const char s, char outBuf, int32_t *outIx, int32_t capacity, int32_t indent) {
	158	int32_t i = 0;
	159	char c;
	160	if (s==NULL) {
	161	s = "NULL";
	162	}
	163	do {
	164	c = s[i++];
	165	outputChar(c, outBuf, outIx, capacity, indent);
	166	} while (c != 0);
	167	}
	168
	169
	170
	171	static void outputUString(const UChar *s, int32_t len,
	172	char outBuf, int32_t outIx, int32_t capacity, int32_t indent) {
	173	int32_t i = 0;
	174	UChar c;
	175	if (s==NULL) {
	176	outputString(NULL, outBuf, outIx, capacity, indent);
	177	return;
	178	}
	179
	180	for (i=0; i<len \|\| len==-1; i++) {
	181	c = s[i];
	182	outputHexBytes(c, 4, outBuf, outIx, capacity);
	183	outputChar(' ', outBuf, outIx, capacity, indent);
	184	if (len == -1 && c==0) {
	185	break;
	186	}
	187	}
	188	}
	189
	190	U_CAPI int32_t U_EXPORT2
	191	utrace_vformat(char outBuf, int32_t capacity, int32_t indent, const char fmt, va_list args) {
	192	int32_t outIx = 0;
	193	int32_t fmtIx = 0;
	194	char fmtC;
	195	char c;
	196	int32_t intArg;
	197	int64_t longArg = 0;
	198	char *ptrArg;
	199
	200	/* Loop runs once for each character in the format string.
	201	*/
	202	for (;;) {
	203	fmtC = fmt[fmtIx++];
204	if (fmtC != '%') {
205	/* Literal character, not part of a %sequence. Just copy it to the output. */
206	outputChar(fmtC, outBuf, &outIx, capacity, indent);
207	if (fmtC == 0) {
208	/* We hit the null that terminates the format string.
209	* This is the normal (and only) exit from the loop that
210	* interprets the format
211	*/
212	break;
213	}
214	continue;
215	}
216
217	/* We encountered a '%'. Pick up the following format char */
218	fmtC = fmt[fmtIx++];
219
220	switch (fmtC) {
221	case 'c':
222	/* single 8 bit char */
223	c = (char)va_arg(args, int32_t);
224	outputChar(c, outBuf, &outIx, capacity, indent);
225	break;
226
227	case 's':
228	/* char * string, null terminated. */
229	ptrArg = va_arg(args, char *);
230	outputString((const char *)ptrArg, outBuf, &outIx, capacity, indent);
231	break;
232
233	case 'S':
234	/* UChar * string, with length, len==-1 for null terminated. */
f3c0d7a5	235	ptrArg = va_arg(args, char ); / Ptr */
374ca955	236	intArg =(int32_t)va_arg(args, int32_t); /* Length */
73c04bcf	237	outputUString((const UChar *)ptrArg, intArg, outBuf, &outIx, capacity, indent);
374ca955 A	238	break;
	239
	240	case 'b':
	241	/* 8 bit int */
	242	intArg = va_arg(args, int);
	243	outputHexBytes(intArg, 2, outBuf, &outIx, capacity);
	244	break;
	245
	246	case 'h':
	247	/* 16 bit int */
	248	intArg = va_arg(args, int);
	249	outputHexBytes(intArg, 4, outBuf, &outIx, capacity);
	250	break;
	251
	252	case 'd':
	253	/* 32 bit int */
	254	intArg = va_arg(args, int);
	255	outputHexBytes(intArg, 8, outBuf, &outIx, capacity);
	256	break;
	257
	258	case 'l':
	259	/* 64 bit long */
	260	longArg = va_arg(args, int64_t);
	261	outputHexBytes(longArg, 16, outBuf, &outIx, capacity);
	262	break;
	263
	264	case 'p':
	265	/* Pointers. */
f3c0d7a5	266	ptrArg = va_arg(args, char *);
374ca955 A	267	outputPtrBytes(ptrArg, outBuf, &outIx, capacity);
	268	break;
	269
	270	case 0:
	271	/* Single '%' at end of fmt string. Output as literal '%'.
	272	* Back up index into format string so that the terminating null will be
	273	* re-fetched in the outer loop, causing it to terminate.
	274	*/
	275	outputChar('%', outBuf, &outIx, capacity, indent);
	276	fmtIx--;
	277	break;
	278
	279	case 'v':
	280	{
	281	/* Vector of values, e.g. %vh */
	282	char vectorType;
	283	int32_t vectorLen;
	284	const char *i8Ptr;
	285	int16_t *i16Ptr;
	286	int32_t *i32Ptr;
	287	int64_t *i64Ptr;
	288	void **ptrPtr;
	289	int32_t charsToOutput = 0;
	290	int32_t i;
	291
	292	vectorType = fmt[fmtIx]; /* b, h, d, l, p, etc. */
	293	if (vectorType != 0) {
	294	fmtIx++;
	295	}
	296	i8Ptr = (const char )va_arg(args, void);
	297	i16Ptr = (int16_t *)i8Ptr;
	298	i32Ptr = (int32_t *)i8Ptr;
	299	i64Ptr = (int64_t *)i8Ptr;
	300	ptrPtr = (void **)i8Ptr;
	301	vectorLen =(int32_t)va_arg(args, int32_t);
	302	if (ptrPtr == NULL) {
	303	outputString("NULL ", outBuf, &outIx, capacity, indent);
	304	} else {
	305	for (i=0; i<vectorLen \|\| vectorLen==-1; i++) {
	306	switch (vectorType) {
	307	case 'b':
	308	charsToOutput = 2;
	309	longArg = *i8Ptr++;
	310	break;
	311	case 'h':
	312	charsToOutput = 4;
	313	longArg = *i16Ptr++;
	314	break;
	315	case 'd':
	316	charsToOutput = 8;
	317	longArg = *i32Ptr++;
	318	break;
	319	case 'l':
	320	charsToOutput = 16;
	321	longArg = *i64Ptr++;
	322	break;
	323	case 'p':
	324	charsToOutput = 0;
	325	outputPtrBytes(*ptrPtr, outBuf, &outIx, capacity);
	326	longArg = ptrPtr==NULL? 0: 1; / test for null terminated array. */
	327	ptrPtr++;
	328	break;
	329	case 'c':
	330	charsToOutput = 0;
331	outputChar(*i8Ptr, outBuf, &outIx, capacity, indent);
332	longArg = i8Ptr; / for test for null terminated array. */
333	i8Ptr++;
334	break;
335	case 's':
336	charsToOutput = 0;
f3c0d7a5	337	outputString((const char )ptrPtr, outBuf, &outIx, capacity, indent);
374ca955 A	338	outputChar('\n', outBuf, &outIx, capacity, indent);
	339	longArg = ptrPtr==NULL? 0: 1; / for test for null term. array. */
	340	ptrPtr++;
	341	break;
	342
	343	case 'S':
	344	charsToOutput = 0;
73c04bcf	345	outputUString((const UChar )ptrPtr, -1, outBuf, &outIx, capacity, indent);
374ca955 A	346	outputChar('\n', outBuf, &outIx, capacity, indent);
	347	longArg = ptrPtr==NULL? 0: 1; / for test for null term. array. */
	348	ptrPtr++;
	349	break;
	350
	351
	352	}
	353	if (charsToOutput > 0) {
	354	outputHexBytes(longArg, charsToOutput, outBuf, &outIx, capacity);
	355	outputChar(' ', outBuf, &outIx, capacity, indent);
	356	}
	357	if (vectorLen == -1 && longArg == 0) {
	358	break;
	359	}
	360	}
	361	}
	362	outputChar('[', outBuf, &outIx, capacity, indent);
	363	outputHexBytes(vectorLen, 8, outBuf, &outIx, capacity);
	364	outputChar(']', outBuf, &outIx, capacity, indent);
	365	}
	366	break;
	367
	368
	369	default:
	370	/* %. in format string, where . is some character not in the set
	371	* of recognized format chars. Just output it as if % wasn't there.
	372	* (Covers "%%" outputing a single '%')
	373	*/
	374	outputChar(fmtC, outBuf, &outIx, capacity, indent);
	375	}
	376	}
	377	outputChar(0, outBuf, &outIx, capacity, indent); /* Make sure that output is null terminated */
	378	return outIx + 1; /* outIx + 1 because outIx does not increment when outputing final null. */
	379	}
	380
	381
	382
	383
	384	U_CAPI int32_t U_EXPORT2
	385	utrace_format(char *outBuf, int32_t capacity,
	386	int32_t indent, const char *fmt, ...) {
	387	int32_t retVal;
	388	va_list args;
	389	va_start(args, fmt );
	390	retVal = utrace_vformat(outBuf, capacity, indent, fmt, args);
	391	va_end(args);
	392	return retVal;
	393	}
	394
	395
	396	U_CAPI void U_EXPORT2
	397	utrace_setFunctions(const void *context,
	398	UTraceEntry e, UTraceExit x, UTraceData *d) {
	399	pTraceEntryFunc = e;
	400	pTraceExitFunc = x;
	401	pTraceDataFunc = d;
	402	gTraceContext = context;
	403	}
	404
	405
	406	U_CAPI void U_EXPORT2
	407	utrace_getFunctions(const void **context,
	408	UTraceEntry e, UTraceExit x, UTraceData **d) {
	409	*e = pTraceEntryFunc;
410	*x = pTraceExitFunc;
411	*d = pTraceDataFunc;
412	*context = gTraceContext;
413	}
414
415	U_CAPI void U_EXPORT2
416	utrace_setLevel(int32_t level) {
417	if (level < UTRACE_OFF) {
418	level = UTRACE_OFF;
419	}
420	if (level > UTRACE_VERBOSE) {
421	level = UTRACE_VERBOSE;
422	}
423	utrace_level = level;
424	}
425
426	U_CAPI int32_t U_EXPORT2
427	utrace_getLevel() {
428	return utrace_level;
429	}
430
431
432	U_CFUNC UBool
433	utrace_cleanup() {
434	pTraceEntryFunc = NULL;
435	pTraceExitFunc = NULL;
436	pTraceDataFunc = NULL;
437	utrace_level = UTRACE_OFF;
438	gTraceContext = NULL;
439	return TRUE;
440	}
441
442
443	static const char * const
444	trFnName[] = {
445	"u_init",
446	"u_cleanup",
447	NULL
448	};
449
450
451	static const char * const
452	trConvNames[] = {
453	"ucnv_open",
454	"ucnv_openPackage",
455	"ucnv_openAlgorithmic",
456	"ucnv_clone",
457	"ucnv_close",
458	"ucnv_flushCache",
459	"ucnv_load",
460	"ucnv_unload",
461	NULL
462	};
463
464
465	static const char * const
466	trCollNames[] = {
467	"ucol_open",
468	"ucol_close",
469	"ucol_strcoll",
470	"ucol_getSortKey",
471	"ucol_getLocale",
472	"ucol_nextSortKeyPart",
473	"ucol_strcollIter",
57a6839d A	474	"ucol_openFromShortString",
57a6839d A	475	"ucol_strcollUTF8",
374ca955 A	476	NULL
	477	};
	478
	479
	480	U_CAPI const char * U_EXPORT2
	481	utrace_functionName(int32_t fnNumber) {
	482	if(UTRACE_FUNCTION_START <= fnNumber && fnNumber < UTRACE_FUNCTION_LIMIT) {
	483	return trFnName[fnNumber];
	484	} else if(UTRACE_CONVERSION_START <= fnNumber && fnNumber < UTRACE_CONVERSION_LIMIT) {
	485	return trConvNames[fnNumber - UTRACE_CONVERSION_START];
	486	} else if(UTRACE_COLLATION_START <= fnNumber && fnNumber < UTRACE_COLLATION_LIMIT){
	487	return trCollNames[fnNumber - UTRACE_COLLATION_START];
	488	} else {
	489	return "[BOGUS Trace Function Number]";
	490	}
	491	}
	492