michael@0: /*
michael@0: *******************************************************************************
michael@0: *   Copyright (C) 2003-2008, International Business Machines
michael@0: *   Corporation and others.  All Rights Reserved.
michael@0: *******************************************************************************
michael@0: *   file name:  utrace.c
michael@0: *   encoding:   US-ASCII
michael@0: *   tab size:   8 (not used)
michael@0: *   indentation:4
michael@0: */
michael@0: 
michael@0: #define   UTRACE_IMPL
michael@0: #include "unicode/utrace.h"
michael@0: #include "utracimp.h"
michael@0: #include "cstring.h"
michael@0: #include "uassert.h"
michael@0: #include "ucln_cmn.h"
michael@0: 
michael@0: 
michael@0: static UTraceEntry     *pTraceEntryFunc = NULL;
michael@0: static UTraceExit      *pTraceExitFunc  = NULL;
michael@0: static UTraceData      *pTraceDataFunc  = NULL;
michael@0: static const void      *gTraceContext   = NULL;
michael@0: 
michael@0: U_EXPORT int32_t
michael@0: utrace_level = UTRACE_ERROR;
michael@0: 
michael@0: U_CAPI void U_EXPORT2
michael@0: utrace_entry(int32_t fnNumber) {
michael@0:     if (pTraceEntryFunc != NULL) {
michael@0:         (*pTraceEntryFunc)(gTraceContext, fnNumber);
michael@0:     }
michael@0: }
michael@0: 
michael@0: 
michael@0: static const char gExitFmt[]             = "Returns.";
michael@0: static const char gExitFmtValue[]        = "Returns %d.";
michael@0: static const char gExitFmtStatus[]       = "Returns.  Status = %d.";
michael@0: static const char gExitFmtValueStatus[]  = "Returns %d.  Status = %d.";
michael@0: static const char gExitFmtPtrStatus[]    = "Returns %d.  Status = %p.";
michael@0: 
michael@0: U_CAPI void U_EXPORT2
michael@0: utrace_exit(int32_t fnNumber, int32_t returnType, ...) {
michael@0:     if (pTraceExitFunc != NULL) {
michael@0:         va_list     args;
michael@0:         const char *fmt;
michael@0: 
michael@0:         switch (returnType) {
michael@0:         case 0:
michael@0:             fmt = gExitFmt;
michael@0:             break;
michael@0:         case UTRACE_EXITV_I32:
michael@0:             fmt = gExitFmtValue;
michael@0:             break;
michael@0:         case UTRACE_EXITV_STATUS:
michael@0:             fmt = gExitFmtStatus;
michael@0:             break;
michael@0:         case UTRACE_EXITV_I32 | UTRACE_EXITV_STATUS:
michael@0:             fmt = gExitFmtValueStatus;
michael@0:             break;
michael@0:         case UTRACE_EXITV_PTR | UTRACE_EXITV_STATUS:
michael@0:             fmt = gExitFmtPtrStatus;
michael@0:             break;
michael@0:         default:
michael@0:             U_ASSERT(FALSE);
michael@0:             fmt = gExitFmt;
michael@0:         }
michael@0: 
michael@0:         va_start(args, returnType);
michael@0:         (*pTraceExitFunc)(gTraceContext, fnNumber, fmt, args);
michael@0:         va_end(args);
michael@0:     }
michael@0: }
michael@0:  
michael@0: 
michael@0:  
michael@0: U_CAPI void U_EXPORT2 
michael@0: utrace_data(int32_t fnNumber, int32_t level, const char *fmt, ...) {
michael@0:     if (pTraceDataFunc != NULL) {
michael@0:            va_list args;
michael@0:            va_start(args, fmt ); 
michael@0:            (*pTraceDataFunc)(gTraceContext, fnNumber, level, fmt, args);
michael@0:            va_end(args);
michael@0:     }
michael@0: }
michael@0: 
michael@0: 
michael@0: static void outputChar(char c, char *outBuf, int32_t *outIx, int32_t capacity, int32_t indent) {
michael@0:     int32_t i;
michael@0:     /* Check whether a start of line indenting is needed.  Three cases:
michael@0:      *   1.  At the start of the first line  (output index == 0).
michael@0:      *   2.  At the start of subsequent lines  (preceeding char in buffer == '\n')
michael@0:      *   3.  When preflighting buffer len (buffer capacity is exceeded), when
michael@0:      *       a \n is output.  Ideally we wouldn't do the indent until the following char
michael@0:      *       is received, but that won't work because there's no place to remember that
michael@0:      *       the preceding char was \n.  Meaning that we may overstimate the
michael@0:      *       buffer size needed.  No harm done.
michael@0:      */
michael@0:     if (*outIx==0 ||   /* case 1. */
michael@0:         (c!='\n' && c!=0 && *outIx < capacity && outBuf[(*outIx)-1]=='\n') ||  /* case 2. */
michael@0:         (c=='\n' && *outIx>=capacity))    /* case 3 */
michael@0:     {
michael@0:         /* At the start of a line.  Indent. */
michael@0:         for(i=0; i<indent; i++) {
michael@0:             if (*outIx < capacity) {
michael@0:                 outBuf[*outIx] = ' ';
michael@0:             }
michael@0:             (*outIx)++;
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     if (*outIx < capacity) {
michael@0:         outBuf[*outIx] = c;
michael@0:     }
michael@0:     if (c != 0) {
michael@0:         /* Nulls only appear as end-of-string terminators.  Move them to the output
michael@0:          *  buffer, but do not update the length of the buffer, so that any
michael@0:          *  following output will overwrite the null. */
michael@0:         (*outIx)++;
michael@0:     }
michael@0: }
michael@0: 
michael@0: static void outputHexBytes(int64_t val, int32_t charsToOutput,
michael@0:                            char *outBuf, int32_t *outIx, int32_t capacity) {
michael@0:     static const char gHexChars[] = "0123456789abcdef";
michael@0:     int32_t shiftCount;
michael@0:     for  (shiftCount=(charsToOutput-1)*4; shiftCount >= 0; shiftCount-=4) {
michael@0:         char c = gHexChars[(val >> shiftCount) & 0xf];
michael@0:         outputChar(c, outBuf, outIx, capacity, 0);
michael@0:     }
michael@0: }
michael@0: 
michael@0: /* Output a pointer value in hex.  Work with any size of pointer   */
michael@0: static void outputPtrBytes(void *val, char *outBuf, int32_t *outIx, int32_t capacity) {
michael@0:     int32_t  i;
michael@0:     int32_t  incVal = 1;              /* +1 for big endian, -1 for little endian          */
michael@0:     char     *p     = (char *)&val;   /* point to current byte to output in the ptr val  */
michael@0: 
michael@0: #if !U_IS_BIG_ENDIAN
michael@0:     /* Little Endian.  Move p to most significant end of the value      */
michael@0:     incVal = -1;
michael@0:     p += sizeof(void *) - 1;
michael@0: #endif
michael@0: 
michael@0:     /* Loop through the bytes of the ptr as it sits in memory, from 
michael@0:      * most significant to least significant end                    */
michael@0:     for (i=0; i<sizeof(void *); i++) {
michael@0:         outputHexBytes(*p, 2, outBuf, outIx, capacity);
michael@0:         p += incVal;
michael@0:     }
michael@0: }
michael@0: 
michael@0: static void outputString(const char *s, char *outBuf, int32_t *outIx, int32_t capacity, int32_t indent) {
michael@0:     int32_t i = 0;
michael@0:     char    c;
michael@0:     if (s==NULL) {
michael@0:         s = "*NULL*";
michael@0:     }
michael@0:     do {
michael@0:         c = s[i++];
michael@0:         outputChar(c, outBuf, outIx, capacity, indent);
michael@0:     } while (c != 0);
michael@0: }
michael@0:         
michael@0: 
michael@0: 
michael@0: static void outputUString(const UChar *s, int32_t len, 
michael@0:                           char *outBuf, int32_t *outIx, int32_t capacity, int32_t indent) {
michael@0:     int32_t i = 0;
michael@0:     UChar   c;
michael@0:     if (s==NULL) {
michael@0:         outputString(NULL, outBuf, outIx, capacity, indent);
michael@0:         return;
michael@0:     }
michael@0: 
michael@0:     for (i=0; i<len || len==-1; i++) {
michael@0:         c = s[i];
michael@0:         outputHexBytes(c, 4, outBuf, outIx, capacity);
michael@0:         outputChar(' ', outBuf, outIx, capacity, indent);
michael@0:         if (len == -1 && c==0) {
michael@0:             break;
michael@0:         }
michael@0:     }
michael@0: }
michael@0:         
michael@0: U_CAPI int32_t U_EXPORT2
michael@0: utrace_vformat(char *outBuf, int32_t capacity, int32_t indent, const char *fmt, va_list args) {
michael@0:     int32_t   outIx  = 0;
michael@0:     int32_t   fmtIx  = 0;
michael@0:     char      fmtC;
michael@0:     char      c;
michael@0:     int32_t   intArg;
michael@0:     int64_t   longArg = 0;
michael@0:     char      *ptrArg;
michael@0: 
michael@0:     /*   Loop runs once for each character in the format string.
michael@0:      */
michael@0:     for (;;) {
michael@0:         fmtC = fmt[fmtIx++];
michael@0:         if (fmtC != '%') {
michael@0:             /* Literal character, not part of a %sequence.  Just copy it to the output. */
michael@0:             outputChar(fmtC, outBuf, &outIx, capacity, indent);
michael@0:             if (fmtC == 0) {
michael@0:                 /* We hit the null that terminates the format string.
michael@0:                  * This is the normal (and only) exit from the loop that
michael@0:                  * interprets the format
michael@0:                  */
michael@0:                 break;
michael@0:             }
michael@0:             continue;
michael@0:         }
michael@0: 
michael@0:         /* We encountered a '%'.  Pick up the following format char */
michael@0:         fmtC = fmt[fmtIx++];
michael@0: 
michael@0:         switch (fmtC) {
michael@0:         case 'c':
michael@0:             /* single 8 bit char   */
michael@0:             c = (char)va_arg(args, int32_t);
michael@0:             outputChar(c, outBuf, &outIx, capacity, indent);
michael@0:             break;
michael@0: 
michael@0:         case 's':
michael@0:             /* char * string, null terminated.  */
michael@0:             ptrArg = va_arg(args, char *);
michael@0:             outputString((const char *)ptrArg, outBuf, &outIx, capacity, indent);
michael@0:             break;
michael@0: 
michael@0:         case 'S':
michael@0:             /* UChar * string, with length, len==-1 for null terminated. */
michael@0:             ptrArg = va_arg(args, void *);             /* Ptr    */
michael@0:             intArg =(int32_t)va_arg(args, int32_t);    /* Length */
michael@0:             outputUString((const UChar *)ptrArg, intArg, outBuf, &outIx, capacity, indent);
michael@0:             break;
michael@0: 
michael@0:         case 'b':
michael@0:             /*  8 bit int  */
michael@0:             intArg = va_arg(args, int);
michael@0:             outputHexBytes(intArg, 2, outBuf, &outIx, capacity);
michael@0:             break;
michael@0: 
michael@0:         case 'h':
michael@0:             /*  16 bit int  */
michael@0:             intArg = va_arg(args, int);
michael@0:             outputHexBytes(intArg, 4, outBuf, &outIx, capacity);
michael@0:             break;
michael@0: 
michael@0:         case 'd':
michael@0:             /*  32 bit int  */
michael@0:             intArg = va_arg(args, int);
michael@0:             outputHexBytes(intArg, 8, outBuf, &outIx, capacity);
michael@0:             break;
michael@0: 
michael@0:         case 'l':
michael@0:             /*  64 bit long  */
michael@0:             longArg = va_arg(args, int64_t);
michael@0:             outputHexBytes(longArg, 16, outBuf, &outIx, capacity);
michael@0:             break;
michael@0:             
michael@0:         case 'p':
michael@0:             /*  Pointers.   */
michael@0:             ptrArg = va_arg(args, void *);
michael@0:             outputPtrBytes(ptrArg, outBuf, &outIx, capacity);
michael@0:             break;
michael@0: 
michael@0:         case 0:
michael@0:             /* Single '%' at end of fmt string.  Output as literal '%'.   
michael@0:              * Back up index into format string so that the terminating null will be
michael@0:              * re-fetched in the outer loop, causing it to terminate.
michael@0:              */
michael@0:             outputChar('%', outBuf, &outIx, capacity, indent);
michael@0:             fmtIx--;
michael@0:             break;
michael@0: 
michael@0:         case 'v':
michael@0:             {
michael@0:                 /* Vector of values, e.g. %vh */
michael@0:                 char     vectorType;
michael@0:                 int32_t  vectorLen;
michael@0:                 const char   *i8Ptr;
michael@0:                 int16_t  *i16Ptr;
michael@0:                 int32_t  *i32Ptr;
michael@0:                 int64_t  *i64Ptr;
michael@0:                 void     **ptrPtr;
michael@0:                 int32_t   charsToOutput = 0;
michael@0:                 int32_t   i;
michael@0:                 
michael@0:                 vectorType = fmt[fmtIx];    /* b, h, d, l, p, etc. */
michael@0:                 if (vectorType != 0) {
michael@0:                     fmtIx++;
michael@0:                 }
michael@0:                 i8Ptr = (const char *)va_arg(args, void*);
michael@0:                 i16Ptr = (int16_t *)i8Ptr;
michael@0:                 i32Ptr = (int32_t *)i8Ptr;
michael@0:                 i64Ptr = (int64_t *)i8Ptr;
michael@0:                 ptrPtr = (void **)i8Ptr;
michael@0:                 vectorLen =(int32_t)va_arg(args, int32_t);
michael@0:                 if (ptrPtr == NULL) {
michael@0:                     outputString("*NULL* ", outBuf, &outIx, capacity, indent);
michael@0:                 } else {
michael@0:                     for (i=0; i<vectorLen || vectorLen==-1; i++) { 
michael@0:                         switch (vectorType) {
michael@0:                         case 'b':
michael@0:                             charsToOutput = 2;
michael@0:                             longArg = *i8Ptr++;
michael@0:                             break;
michael@0:                         case 'h':
michael@0:                             charsToOutput = 4;
michael@0:                             longArg = *i16Ptr++;
michael@0:                             break;
michael@0:                         case 'd':
michael@0:                             charsToOutput = 8;
michael@0:                             longArg = *i32Ptr++;
michael@0:                             break;
michael@0:                         case 'l':
michael@0:                             charsToOutput = 16;
michael@0:                             longArg = *i64Ptr++;
michael@0:                             break;
michael@0:                         case 'p':
michael@0:                             charsToOutput = 0;
michael@0:                             outputPtrBytes(*ptrPtr, outBuf, &outIx, capacity);
michael@0:                             longArg = *ptrPtr==NULL? 0: 1;    /* test for null terminated array. */
michael@0:                             ptrPtr++;
michael@0:                             break;
michael@0:                         case 'c':
michael@0:                             charsToOutput = 0;
michael@0:                             outputChar(*i8Ptr, outBuf, &outIx, capacity, indent);
michael@0:                             longArg = *i8Ptr;    /* for test for null terminated array. */
michael@0:                             i8Ptr++;
michael@0:                             break;
michael@0:                         case 's':
michael@0:                             charsToOutput = 0;
michael@0:                             outputString(*ptrPtr, outBuf, &outIx, capacity, indent);
michael@0:                             outputChar('\n', outBuf, &outIx, capacity, indent);
michael@0:                             longArg = *ptrPtr==NULL? 0: 1;   /* for test for null term. array. */
michael@0:                             ptrPtr++;
michael@0:                             break;
michael@0: 
michael@0:                         case 'S':
michael@0:                             charsToOutput = 0;
michael@0:                             outputUString((const UChar *)*ptrPtr, -1, outBuf, &outIx, capacity, indent);
michael@0:                             outputChar('\n', outBuf, &outIx, capacity, indent);
michael@0:                             longArg = *ptrPtr==NULL? 0: 1;   /* for test for null term. array. */
michael@0:                             ptrPtr++;
michael@0:                             break;
michael@0: 
michael@0:                             
michael@0:                         }
michael@0:                         if (charsToOutput > 0) {
michael@0:                             outputHexBytes(longArg, charsToOutput, outBuf, &outIx, capacity);
michael@0:                             outputChar(' ', outBuf, &outIx, capacity, indent);
michael@0:                         }
michael@0:                         if (vectorLen == -1 && longArg == 0) {
michael@0:                             break;
michael@0:                         }
michael@0:                     }
michael@0:                 }
michael@0:                 outputChar('[', outBuf, &outIx, capacity, indent);
michael@0:                 outputHexBytes(vectorLen, 8, outBuf, &outIx, capacity);
michael@0:                 outputChar(']', outBuf, &outIx, capacity, indent);
michael@0:             }
michael@0:             break;
michael@0: 
michael@0: 
michael@0:         default:
michael@0:             /* %. in format string, where . is some character not in the set
michael@0:              *    of recognized format chars.  Just output it as if % wasn't there.
michael@0:              *    (Covers "%%" outputing a single '%')
michael@0:              */
michael@0:              outputChar(fmtC, outBuf, &outIx, capacity, indent);
michael@0:         }
michael@0:     }
michael@0:     outputChar(0, outBuf, &outIx, capacity, indent);  /* Make sure that output is null terminated  */
michael@0:     return outIx + 1;     /* outIx + 1 because outIx does not increment when outputing final null. */
michael@0: }
michael@0: 
michael@0: 
michael@0: 
michael@0: 
michael@0: U_CAPI int32_t U_EXPORT2
michael@0: utrace_format(char *outBuf, int32_t capacity,
michael@0:                 int32_t indent, const char *fmt,  ...) {
michael@0:     int32_t retVal;
michael@0:     va_list args;
michael@0:     va_start(args, fmt ); 
michael@0:     retVal = utrace_vformat(outBuf, capacity, indent, fmt, args);
michael@0:     va_end(args);
michael@0:     return retVal;
michael@0: }
michael@0: 
michael@0: 
michael@0: U_CAPI void U_EXPORT2
michael@0: utrace_setFunctions(const void *context,
michael@0:                     UTraceEntry *e, UTraceExit *x, UTraceData *d) {
michael@0:     pTraceEntryFunc = e;
michael@0:     pTraceExitFunc  = x;
michael@0:     pTraceDataFunc  = d;
michael@0:     gTraceContext   = context;
michael@0: }
michael@0: 
michael@0: 
michael@0: U_CAPI void U_EXPORT2
michael@0: utrace_getFunctions(const void **context,
michael@0:                     UTraceEntry **e, UTraceExit **x, UTraceData **d) {
michael@0:     *e = pTraceEntryFunc;
michael@0:     *x = pTraceExitFunc;
michael@0:     *d = pTraceDataFunc;
michael@0:     *context = gTraceContext;
michael@0: }
michael@0: 
michael@0: U_CAPI void U_EXPORT2
michael@0: utrace_setLevel(int32_t level) {
michael@0:     if (level < UTRACE_OFF) {
michael@0:         level = UTRACE_OFF;
michael@0:     }
michael@0:     if (level > UTRACE_VERBOSE) {
michael@0:         level = UTRACE_VERBOSE;
michael@0:     }
michael@0:     utrace_level = level;
michael@0: }
michael@0: 
michael@0: U_CAPI int32_t U_EXPORT2
michael@0: utrace_getLevel() {
michael@0:     return utrace_level;
michael@0: }
michael@0: 
michael@0: 
michael@0: U_CFUNC UBool 
michael@0: utrace_cleanup() {
michael@0:     pTraceEntryFunc = NULL;
michael@0:     pTraceExitFunc  = NULL;
michael@0:     pTraceDataFunc  = NULL;
michael@0:     utrace_level    = UTRACE_OFF;
michael@0:     gTraceContext   = NULL;
michael@0:     return TRUE;
michael@0: }
michael@0: 
michael@0: 
michael@0: static const char * const
michael@0: trFnName[] = {
michael@0:     "u_init",
michael@0:     "u_cleanup",
michael@0:     NULL
michael@0: };
michael@0: 
michael@0: 
michael@0: static const char * const
michael@0: trConvNames[] = {
michael@0:     "ucnv_open",
michael@0:     "ucnv_openPackage",
michael@0:     "ucnv_openAlgorithmic",
michael@0:     "ucnv_clone",
michael@0:     "ucnv_close",
michael@0:     "ucnv_flushCache",
michael@0:     "ucnv_load",
michael@0:     "ucnv_unload",
michael@0:     NULL
michael@0: };
michael@0: 
michael@0:     
michael@0: static const char * const
michael@0: trCollNames[] = {
michael@0:     "ucol_open",
michael@0:     "ucol_close",
michael@0:     "ucol_strcoll",
michael@0:     "ucol_getSortKey",
michael@0:     "ucol_getLocale",
michael@0:     "ucol_nextSortKeyPart",
michael@0:     "ucol_strcollIter",
michael@0:     NULL
michael@0: };
michael@0: 
michael@0:                 
michael@0: U_CAPI const char * U_EXPORT2
michael@0: utrace_functionName(int32_t fnNumber) {
michael@0:     if(UTRACE_FUNCTION_START <= fnNumber && fnNumber < UTRACE_FUNCTION_LIMIT) {
michael@0:         return trFnName[fnNumber];
michael@0:     } else if(UTRACE_CONVERSION_START <= fnNumber && fnNumber < UTRACE_CONVERSION_LIMIT) {
michael@0:         return trConvNames[fnNumber - UTRACE_CONVERSION_START];
michael@0:     } else if(UTRACE_COLLATION_START <= fnNumber && fnNumber < UTRACE_COLLATION_LIMIT){
michael@0:         return trCollNames[fnNumber - UTRACE_COLLATION_START];
michael@0:     } else {
michael@0:         return "[BOGUS Trace Function Number]";
michael@0:     }
michael@0: }
michael@0: