| // © 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 | |
| */ | |
| #if defined(STARBOARD) | |
| #include "starboard/client_porting/poem/assert_poem.h" | |
| #endif // defined(STARBOARD) | |
| #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 | |
| }; | |
| static const char* const | |
| trResDataNames[] = { | |
| "resc", | |
| "bundle-open", | |
| "file-open", | |
| "res-open", | |
| 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 if(UTRACE_UDATA_START <= fnNumber && fnNumber < UTRACE_RES_DATA_LIMIT){ | |
| return trResDataNames[fnNumber - UTRACE_UDATA_START]; | |
| } else { | |
| return "[BOGUS Trace Function Number]"; | |
| } | |
| } | |