icuSources/common/utrace.cpp

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