organicmaps/icu
13
Fork 0
mirror of https://github.com/unicode-org/icu.git synced 2025-04-06 05:55:35 +00:00
Code Issues 1 Projects Releases Wiki Activity Actions 11

ICU-2403 tracing, split header file in two, misc. review fixes. Work in process.

Browse source 
X-SVN-Rev: 13539
This commit is contained in:
Andy Heninger 2003-10-31 02:19:42 +00:00
parent a4d1270530
commit d6f2e2319e
7 changed files with 452 additions and 312 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
icu4c/source/common/common.dsp
View file

@ -1859,6 +1859,10 @@ InputPath=.\unicode\uidna.h
!ENDIF
# End Source File
# Begin Source File
SOURCE=.\utracimp.h
# End Source File
# End Group
# Begin Group "locales & resources"

2
icu4c/source/common/ucln_cmn.c
View file

@ -16,7 +16,7 @@
#include "unicode/utypes.h"
#include "unicode/uclean.h"
#include "unicode/utrace.h"
#include "utracimp.h"
#include "ustr_imp.h"
#include "unormimp.h"
#include "ucln_cmn.h"

401
icu4c/source/common/unicode/utrace.h
View file

@ -15,33 +15,6 @@
*
* Definitions for ICU tracing/logging.
*
* Public API header.
*
* This is currently a design document.
* Latest Version: http://oss.software.ibm.com/cvs/icu/~checkout~/icuhtml/design/utrace.h
* CVS: http://oss.software.ibm.com/cvs/icu/icuhtml/design/utrace.h
*
* Various notes:
* - using a trace level variable to only call trace functions
* when the level is sufficient
* - using the same variable for tracing on/off to never make a function
* call when off
* - the function number is put into a local variable by the entry macro
* and used implicitly to avoid copy&paste/typing mistakes by the developer
* - the application must call utrace_setFunctions() and pass in
* implementations for the trace functions
* - ICU trace macros call ICU functions that route through the function
* pointers if they have been set;
* this avoids an indirection at the call site
* (which would cost more code for another check and for the indirection)
*
* ### TODO Issues:
* - Verify that va_list is portable among compilers for the same platform.
* va_list should be portable because printf() would fail otherwise!
* - Should enum values like UTraceLevel be passed into int32_t-type arguments,
* or should enum types be used?
* We use enum types in all public APIs, so they should be safe and more
* descriptive/type-safe. (Search case-insensitive for "level".)
*/
#ifndef __UTRACE_H__
@ -62,33 +35,6 @@ enum UTraceLevel {
};
typedef enum UTraceLevel UTraceLevel;
/**
* \var utrace_level
* Trace level variable. Negative for "off".
* Use only via UTRACE_ macros.
* @internal
*/
#ifdef UTRACE_IMPL
U_EXPORT int32_t
#elif U_COMMON_IMPLEMENTATION
U_CFUNC int32_t
#else
U_CFUNC U_IMPORT int32_t
#endif
utrace_level;
/**
* Boolean expression to see if ICU tracing is turned on.
* @draft ICU 2.8
*/
#define UTRACE_IS_ON (utrace_level>=UTRACE_ERROR)
/**
* Boolean expression to see if ICU tracing is turned on
* to at least the specified level.
* @draft ICU 2.8
*/
#define UTRACE_LEVEL(level) (utrace_level>=(level))
/**
* Setter for the trace level.
@ -98,109 +44,63 @@ utrace_level;
U_CAPI void U_EXPORT2
utrace_setLevel(int32_t traceLevel);
/**
* Trace statement for the entry point of a function.
* Stores the function number in a local variable.
* In C code, must be placed immediately after the last variable declaration.
* Must be matched with UTRACE_EXIT() at all function exit points.
*
* Tracing should start with UTRACE_ENTRY after checking for
* U_FAILURE at function entry, so that if a function returns immediately
* because of a pre-existing error condition, it does not show up in the trace,
* consistent with ICU's error handling model.
*
* @param fnNumber The UTraceFunctionNumber for the current function.
* @draft ICU 2.8
*/
#define UTRACE_ENTRY(fnNumber) \
int32_t utraceFnNumber=(fnNumber); \
if(UTRACE_IS_ON) { \
utrace_entry(fnNumber); \
}
/* Trace function pointers types ----------------------------- */
/* Function Exit return types. Internal
* Bits 0-3: The function return type. First variable param.
* Bit 4: Flag for presence of U_ErrorCode status param.
*/
enum UTraceExitVal {
UTRACE_EXITV_NONE = 0,
UTRACE_EXITV_I32 = 1,
UTRACE_EXITV_PTR = 2,
UTRACE_EXITV_BOOL = 3,
UTRACE_EXITV_MASK = 0xf,
UTRACE_EXITV_STATUS = 0x10
};
typedef enum UTraceExitVal UTraceExitVal;
typedef void U_CALLCONV
UTraceEntry(const void *context, int32_t fnNumber);
typedef void U_CALLCONV
UTraceExit(const void *context, int32_t fnNumber,
int32_t retType, va_list args);
typedef void U_CALLCONV
UTraceData(const void *context, int32_t fnNumber, int32_t level,
const char *fmt, va_list args);
/**
* Trace statement for each exit point of a function that has a UTRACE_ENTRY()
* statement.
*
* @param errorCode The function's ICU UErrorCode value at function exit,
* or U_ZERO_ERROR if the function does not use a UErrorCode.
* 0==U_ZERO_ERROR indicates success,
* positive values an error (see u_errorName()),
* negative values an informational status.
*
* @draft ICU 2.8
*/
#define UTRACE_EXIT() \
{if(UTRACE_IS_ON) { \
utrace_exit(utraceFnNumber, UTRACE_EXITV_NONE); \
}}
/**
* Trace statement for each exit point of a function that has a UTRACE_ENTRY()
* statement, and that returns a value.
*
* @param val The function's return value, int32_t or comatible type.
*
* @draft ICU 2.8
*/
#define UTRACE_EXIT_D(val) \
{if(UTRACE_IS_ON) { \
utrace_exit(utraceFnNumber, UTRACE_EXITV_I32, val); \
}}
#define UTRACE_EXIT_S(status) \
{if(UTRACE_IS_ON) { \
utrace_exit(utraceFnNumber, UTRACE_EXITV_STATUS, status); \
}}
#define UTRACE_EXIT_DS(val, status) \
{if(UTRACE_IS_ON) { \
utrace_exit(utraceFnNumber, (UTRACE_EXITV_I32 | UTRACE_EXITV_STATUS), val, status); \
}}
/**
* Trace function for the entry point of a function.
* Do not use directly, use UTRACE_ENTRY instead.
* @param fnNumber The UTraceFunctionNumber for the current function.
* @internal
*/
* Set ICU Tracing functions. Installs application-provided tracing
* functions into ICU. After doing this, subsequent ICU operations
* will call back to the installed functions, providing a trace
* of the use of ICU.
* @param context an uninterpretted pointer. Whatever is passed in
* here will in turn be passed to each of the tracing
* functions UTraceEntry, UTraceExit and UTraceData.
* ICU does not use or alter this pointer.
* @param e Callback function to be called on entry to a
* a traced ICU function.
* @param x Callback function to be called on exit from a
* traced ICU function.
* @param d Callback function to be called from within a
* traced ICU function, for the purpose of providing
* data to the trace.
* @param traceLevel Specify the level, or degree of verbosity,
* of the trace output.
* @param pErrorCode Receives error if the trace functions could
* not be set.
*/
U_CAPI void U_EXPORT2
utrace_entry(int32_t fnNumber);
utrace_setFunctions(const void *context,
UTraceEntry *e, UTraceExit *x, UTraceData *d,
int32_t traceLevel,
UErrorCode *pErrorCode);
/**
* Trace function for each exit point of a function.
* Do not use directly, use UTRACE_EXIT* instead.
* @param fnNumber The UTraceFunctionNumber for the current function.
* @param returnType The type of the value returned by the function.
* @param errorCode The UErrorCode value at function exit. See UTRACE_EXIT.
* @internal
*/
U_CAPI void U_EXPORT2
utrace_exit(int32_t fnNumber, int32_t returnType, ...);
/**
* Trace function used inside functions that have a UTRACE_ENTRY() statement.
* Do not use directly, use UTRACE_DATAX() macros instead.
*
* ICU trace format string syntax
*
* Goals
* Format Strings are passed to UTraceData functions, and define the
* number and types of the trace data being passed on each call.
*
* The UTraceData function, which is supplied by the application,
* not by ICU, can either pass the trace data (passed via
* varargs) and the format string back to ICU for formatting into
* a displayable string, or it can interpret the format itself,
* and do as it wishes with the trace data.
*
*
* Goals for the format string
* - basic data output
* - easy to use for trace programmer
* - sufficient provision for data types for trace output readability
@ -230,10 +130,11 @@ utrace_exit(int32_t fnNumber, int32_t returnType, ...);
*
* Type characters:
* - c A char character in the default codepage.
* - s A NUL-terminated char * string in the default codepage.
* - s A NULL-terminated char * string in the default codepage.
* - S A NULL-terminated UChar * string
* - b A byte (8-bit integer).
* - h A 16-bit integer.
* - d A 32-bit integer.
* - h A 16-bit integer. Also a 16 bit Unicode code unit.
* - d A 32-bit integer. Also a 20 bit Unicode code point value.
* - l A 64-bit integer.
* - p A data pointer.
*
@ -263,169 +164,17 @@ utrace_exit(int32_t fnNumber, int32_t returnType, ...);
* -> Info: An int32_t -5=0xfffffffb and a whole bunch of them
* fffffffb 00000005 0000010a [3]
*
* @param utraceFnNumber The number of the current function, from the local
* variable of the same name.
* @param level The trace level for this message.
* @param fmt The trace format string.
*
* @internal
*/
U_CAPI void U_EXPORT2
utrace_data(int32_t utraceFnNumber, int32_t level, const char *fmt, ...);
/**
* Trace statement used inside functions that have a UTRACE_ENTRY() statement.
* Takes no data arguments.
* The number of arguments for this macro must match the number of inserts
* in the format string. Vector inserts count as two arguments.
* Calls utrace_data() if the level is high enough.
* @draft ICU 2.8
*/
#define UTRACE_DATA0(level, fmt) \
if(UTRACE_LEVEL(level)) { \
utrace_data(utraceFnNumber, (level), (fmt)); \
}
/**
* Trace statement used inside functions that have a UTRACE_ENTRY() statement.
* Takes one data argument.
* The number of arguments for this macro must match the number of inserts
* in the format string. Vector inserts count as two arguments.
* Calls utrace_data() if the level is high enough.
* @draft ICU 2.8
*/
#define UTRACE_DATA1(level, fmt, a) \
if(UTRACE_LEVEL(level)) { \
utrace_data(utraceFnNumber, (level), (fmt), (a)); \
}
/**
* Trace statement used inside functions that have a UTRACE_ENTRY() statement.
* Takes two data arguments.
* The number of arguments for this macro must match the number of inserts
* in the format string. Vector inserts count as two arguments.
* Calls utrace_data() if the level is high enough.
* @draft ICU 2.8
*/
#define UTRACE_DATA2(level, fmt, a, b) \
if(UTRACE_LEVEL(level)) { \
utrace_data(utraceFnNumber, (level), (fmt), (a), (b)); \
}
/**
* Trace statement used inside functions that have a UTRACE_ENTRY() statement.
* Takes three data arguments.
* The number of arguments for this macro must match the number of inserts
* in the format string. Vector inserts count as two arguments.
* Calls utrace_data() if the level is high enough.
* @draft ICU 2.8
*/
#define UTRACE_DATA3(level, fmt, a, b, c) \
if(UTRACE_LEVEL(level)) { \
utrace_data(utraceFnNumber, (level), (fmt), (a), (b), (c)); \
}
/**
* Trace statement used inside functions that have a UTRACE_ENTRY() statement.
* Takes four data arguments.
* The number of arguments for this macro must match the number of inserts
* in the format string. Vector inserts count as two arguments.
* Calls utrace_data() if the level is high enough.
* @draft ICU 2.8
*/
#define UTRACE_DATA4(level, fmt, a, b, c, d) \
if(UTRACE_LEVEL(level)) { \
utrace_data(utraceFnNumber, (level), (fmt), (a), (b), (c), (d)); \
}
/**
* Trace statement used inside functions that have a UTRACE_ENTRY() statement.
* Takes five data arguments.
* The number of arguments for this macro must match the number of inserts
* in the format string. Vector inserts count as two arguments.
* Calls utrace_data() if the level is high enough.
* @draft ICU 2.8
*/
#define UTRACE_DATA5(level, fmt, a, b, c, d, e) \
if(UTRACE_LEVEL(level)) { \
utrace_data(utraceFnNumber, (level), (fmt), (a), (b), (c), (d), (e)); \
}
/**
* Trace statement used inside functions that have a UTRACE_ENTRY() statement.
* Takes six data arguments.
* The number of arguments for this macro must match the number of inserts
* in the format string. Vector inserts count as two arguments.
* Calls utrace_data() if the level is high enough.
* @draft ICU 2.8
*/
#define UTRACE_DATA6(level, fmt, a, b, c, d, e, f) \
if(UTRACE_LEVEL(level)) { \
utrace_data(utraceFnNumber, (level), (fmt), (a), (b), (c), (d), (e), (f)); \
}
/**
* Trace statement used inside functions that have a UTRACE_ENTRY() statement.
* Takes seven data arguments.
* The number of arguments for this macro must match the number of inserts
* in the format string. Vector inserts count as two arguments.
* Calls utrace_data() if the level is high enough.
* @draft ICU 2.8
*/
#define UTRACE_DATA7(level, fmt, a, b, c, d, e, f, g) \
if(UTRACE_LEVEL(level)) { \
utrace_data(utraceFnNumber, (level), (fmt), (a), (b), (c), (d), (e), (f), (g)); \
}
/**
* Trace statement used inside functions that have a UTRACE_ENTRY() statement.
* Takes eight data arguments.
* The number of arguments for this macro must match the number of inserts
* in the format string. Vector inserts count as two arguments.
* Calls utrace_data() if the level is high enough.
* @draft ICU 2.8
*/
#define UTRACE_DATA8(level, fmt, a, b, c, d, e, f, g, h) \
if(UTRACE_LEVEL(level)) { \
utrace_data(utraceFnNumber, (level), (fmt), (a), (b), (c), (d), (e), (f), (g), (h)); \
}
/**
* Trace statement used inside functions that have a UTRACE_ENTRY() statement.
* Takes nine data arguments.
* The number of arguments for this macro must match the number of inserts
* in the format string. Vector inserts count as two arguments.
* Calls utrace_data() if the level is high enough.
* @draft ICU 2.8
*/
#define UTRACE_DATA9(level, fmt, a, b, c, d, e, f, g, h, i) \
if(UTRACE_LEVEL(level)) { \
utrace_data(utraceFnNumber, (level), (fmt), (a), (b), (c), (d), (e), (f), (g), (h), (i)); \
}
/* Trace function pointers from the application ----------------------------- */
typedef void U_CALLCONV
UTraceEntry(const void *context, int32_t fnNumber);
typedef void U_CALLCONV
UTraceExit(const void *context, int32_t fnNumber,
UTraceExitVal retType, va_list args);
typedef void U_CALLCONV
UTraceData(const void *context, int32_t fnNumber, int32_t level,
const char *fmt, va_list args);
U_CAPI void U_EXPORT2
utrace_setFunctions(const void *context,
UTraceEntry *e, UTraceExit *x, UTraceData *d,
int32_t traceLevel,
UErrorCode *pErrorCode);
/**
* Trace output Formatter. Application tracing functions may call
* back to this function to format the trace output.
* Trace output Formatter. An application's UTraceData tracing functions may call
* back to this function to format the trace output in a
* human readable form. Note that a UTraceData function is not
* required to format the data; it could, for example, save it in
* in the raw form it was received (more compact), leaving
* formatting for a later trace analyis tool.
* @param outBuf pointer to a buffer to receive the formatted output. Output
* will be null terminated if there is space in the buffer -
* if the length of the requested output < the output buffer size.
@ -436,12 +185,50 @@ utrace_setFunctions(const void *context,
* @param args Data to be formatted.
* @return Length of formatted output, including the terminating NULL.
* If buffer capacity is insufficient, the required capacity is returned.
* @draft ICU 2.8
*/
U_CAPI int32_t U_EXPORT2
utrace_format(char *outBuf, int32_t capacity,
int32_t indent, const char *fmt, va_list args);
/**
* Traced Function Exit return types.
* Flags indicating the number and types of varargs included in a call
* to a UTraceExit function.
* Bits 0-3: The function return type. First variable param.
* Bit 4: Flag for presence of U_ErrorCode status param.
* @draft ICU 2.8
*/
enum UTraceExitVal {
UTRACE_EXITV_NONE = 0,
UTRACE_EXITV_I32 = 1,
UTRACE_EXITV_PTR = 2,
UTRACE_EXITV_BOOL = 3,
UTRACE_EXITV_MASK = 0xf,
UTRACE_EXITV_STATUS = 0x10
};
typedef enum UTraceExitVal UTraceExitVal;
/**
* Trace formatter for UTraceExit, function exit tracing.
* UTraceExit may optionally receive two data items: a function return value
* and a UErrorCode status value.
*
* @param outBuf pointer to a buffer to receive the formatted output.Output
* will be null terminated if there is space in the buffer -
* if the length of the requested output < the output buffer size.
* @param capacity Length of the output buffer.
* @param indent Number of spaces to indent the output. Intended to allow
* data displayed from nested functions to be indented for readability.
* @param fnNumber An index specifying the function that is exiting.
* @param argType Flags specifying the number and types of data values.
* @param args Data to be formatted.
* @return Length of formatted output, including the terminating NULL.
* If buffer capacity is insufficient, the required capacity is returned.
*/
U_CAPI void U_EXPORT2
utrace_formatExit(char *outBuf, int32_t capacity, int32_t indent,
int32_t fnNumber, int32_t argtype, va_list args);

40
icu4c/source/common/utrace.c
View file

@ -121,6 +121,25 @@ static void outputString(const char *s, char *outBuf, int32_t *outIx, int32_t ca
} 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, 2, outBuf, outIx, capacity);
outputChar(' ', outBuf, outIx, capacity, indent);
if (len == -1 && c==0) {
break;
}
}
}
U_CAPI int32_t U_EXPORT2
utrace_format(char *outBuf, int32_t capacity, int32_t indent, const char *fmt, va_list args) {
int32_t outIx = 0;
@ -170,6 +189,14 @@ utrace_format(char *outBuf, int32_t capacity, int32_t indent, const char *fmt, v
outputString((const char *)ptrArg, outBuf, &outIx, capacity, indent);
break;
case 'S':
/* UChar * string, null terminated. */
ptrArg = va_arg(args, void *);
intArg =(int32_t)va_arg(args, int32_t);
outputUString((const unsigned short *)ptrArg, intArg, outBuf, &outIx, capacity, indent);
break;
case 'b':
/* 8 bit int */
intArg = va_arg(args, int);
@ -235,7 +262,7 @@ utrace_format(char *outBuf, int32_t capacity, int32_t indent, const char *fmt, v
if (ptrPtr == NULL) {
outputString("NULL", outBuf, &outIx, capacity, indent);
} else {
for (i=0; i<vectorLen; i++) {
for (i=0; i<vectorLen || vectorLen==-1; i++) {
switch (vectorType) {
case 'b':
charsToOutput = 2;
@ -256,23 +283,32 @@ utrace_format(char *outBuf, int32_t capacity, int32_t indent, const char *fmt, v
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(i8Ptr, outBuf, &outIx, capacity, indent);
outputString(*ptrPtr, 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);

313
icu4c/source/common/utracimp.h Normal file
View file

@ -0,0 +1,313 @@
/*
*******************************************************************************
*
* Copyright (C) 2003, International Business Machines
* Corporation and others. All Rights Reserved.
*
*******************************************************************************
* file name: utracimp.h
* encoding: US-ASCII
* tab size: 8 (not used)
* indentation:4
*
* created on: 2003aug06
* created by: Markus W. Scherer
*
* Internal header for ICU tracing/logging.
*
* This is currently a design document.
* Latest Version: http://oss.software.ibm.com/cvs/icu/~checkout~/icuhtml/design/utrace.h
* CVS: http://oss.software.ibm.com/cvs/icu/icuhtml/design/utrace.h
*
* Various notes:
* - using a trace level variable to only call trace functions
* when the level is sufficient
* - using the same variable for tracing on/off to never make a function
* call when off
* - the function number is put into a local variable by the entry macro
* and used implicitly to avoid copy&paste/typing mistakes by the developer
* - the application must call utrace_setFunctions() and pass in
* implementations for the trace functions
* - ICU trace macros call ICU functions that route through the function
* pointers if they have been set;
* this avoids an indirection at the call site
* (which would cost more code for another check and for the indirection)
*
* ### TODO Issues:
* - Verify that va_list is portable among compilers for the same platform.
* va_list should be portable because printf() would fail otherwise!
* - Should enum values like UTraceLevel be passed into int32_t-type arguments,
* or should enum types be used?
* We use enum types in all public APIs, so they should be safe and more
* descriptive/type-safe. (Search case-insensitive for "level".)
*/
#ifndef __UTRACIMP_H__
#define __UTRACIMP_H__
#include <stdarg.h>
#include "unicode/utrace.h"
#include "unicode/utypes.h"
U_CDECL_BEGIN
/**
* \var utrace_level
* Trace level variable. Negative for "off".
* Use only via UTRACE_ macros.
* @internal
*/
#ifdef UTRACE_IMPL
U_EXPORT int32_t
#elif U_COMMON_IMPLEMENTATION
U_CFUNC int32_t
#else
U_CFUNC U_IMPORT int32_t
#endif
utrace_level;
/**
* Boolean expression to see if ICU tracing is turned on.
* @draft ICU 2.8
*/
#define UTRACE_IS_ON (utrace_level>=UTRACE_ERROR)
/**
* Boolean expression to see if ICU tracing is turned on
* to at least the specified level.
* @draft ICU 2.8
*/
#define UTRACE_LEVEL(level) (utrace_level>=(level))
/**
* Trace statement for the entry point of a function.
* Stores the function number in a local variable.
* In C code, must be placed immediately after the last variable declaration.
* Must be matched with UTRACE_EXIT() at all function exit points.
*
* Tracing should start with UTRACE_ENTRY after checking for
* U_FAILURE at function entry, so that if a function returns immediately
* because of a pre-existing error condition, it does not show up in the trace,
* consistent with ICU's error handling model.
*
* @param fnNumber The UTraceFunctionNumber for the current function.
* @draft ICU 2.8
*/
#define UTRACE_ENTRY(fnNumber) \
int32_t utraceFnNumber=(fnNumber); \
if(UTRACE_IS_ON) { \
utrace_entry(fnNumber); \
}
/**
* Trace statement for each exit point of a function that has a UTRACE_ENTRY()
* statement.
*
* @param errorCode The function's ICU UErrorCode value at function exit,
* or U_ZERO_ERROR if the function does not use a UErrorCode.
* 0==U_ZERO_ERROR indicates success,
* positive values an error (see u_errorName()),
* negative values an informational status.
*
* @draft ICU 2.8
*/
#define UTRACE_EXIT() \
{if(UTRACE_IS_ON) { \
utrace_exit(utraceFnNumber, UTRACE_EXITV_NONE); \
}}
/**
* Trace statement for each exit point of a function that has a UTRACE_ENTRY()
* statement, and that returns a value.
*
* @param val The function's return value, int32_t or comatible type.
*
* @draft ICU 2.8
*/
#define UTRACE_EXIT_D(val) \
{if(UTRACE_IS_ON) { \
utrace_exit(utraceFnNumber, UTRACE_EXITV_I32, val); \
}}
#define UTRACE_EXIT_S(status) \
{if(UTRACE_IS_ON) { \
utrace_exit(utraceFnNumber, UTRACE_EXITV_STATUS, status); \
}}
#define UTRACE_EXIT_DS(val, status) \
{if(UTRACE_IS_ON) { \
utrace_exit(utraceFnNumber, (UTRACE_EXITV_I32 | UTRACE_EXITV_STATUS), val, status); \
}}
/**
* Trace function for the entry point of a function.
* Do not use directly, use UTRACE_ENTRY instead.
* @param fnNumber The UTraceFunctionNumber for the current function.
* @internal
*/
U_CAPI void U_EXPORT2
utrace_entry(int32_t fnNumber);
/**
* Trace function for each exit point of a function.
* Do not use directly, use UTRACE_EXIT* instead.
* @param fnNumber The UTraceFunctionNumber for the current function.
* @param returnType The type of the value returned by the function.
* @param errorCode The UErrorCode value at function exit. See UTRACE_EXIT.
* @internal
*/
U_CAPI void U_EXPORT2
utrace_exit(int32_t fnNumber, int32_t returnType, ...);
/**
* Trace function used inside functions that have a UTRACE_ENTRY() statement.
* Do not use directly, use UTRACE_DATAX() macros instead.
*
* @param utraceFnNumber The number of the current function, from the local
* variable of the same name.
* @param level The trace level for this message.
* @param fmt The trace format string.
*
* @internal
*/
U_CAPI void U_EXPORT2
utrace_data(int32_t utraceFnNumber, int32_t level, const char *fmt, ...);
/**
* Trace statement used inside functions that have a UTRACE_ENTRY() statement.
* Takes no data arguments.
* The number of arguments for this macro must match the number of inserts
* in the format string. Vector inserts count as two arguments.
* Calls utrace_data() if the level is high enough.
* @internal
*/
#define UTRACE_DATA0(level, fmt) \
if(UTRACE_LEVEL(level)) { \
utrace_data(utraceFnNumber, (level), (fmt)); \
}
/**
* Trace statement used inside functions that have a UTRACE_ENTRY() statement.
* Takes one data argument.
* The number of arguments for this macro must match the number of inserts
* in the format string. Vector inserts count as two arguments.
* Calls utrace_data() if the level is high enough.
* @internal
*/
#define UTRACE_DATA1(level, fmt, a) \
if(UTRACE_LEVEL(level)) { \
utrace_data(utraceFnNumber, (level), (fmt), (a)); \
}
/**
* Trace statement used inside functions that have a UTRACE_ENTRY() statement.
* Takes two data arguments.
* The number of arguments for this macro must match the number of inserts
* in the format string. Vector inserts count as two arguments.
* Calls utrace_data() if the level is high enough.
* @internal
*/
#define UTRACE_DATA2(level, fmt, a, b) \
if(UTRACE_LEVEL(level)) { \
utrace_data(utraceFnNumber, (level), (fmt), (a), (b)); \
}
/**
* Trace statement used inside functions that have a UTRACE_ENTRY() statement.
* Takes three data arguments.
* The number of arguments for this macro must match the number of inserts
* in the format string. Vector inserts count as two arguments.
* Calls utrace_data() if the level is high enough.
* @internal
*/
#define UTRACE_DATA3(level, fmt, a, b, c) \
if(UTRACE_LEVEL(level)) { \
utrace_data(utraceFnNumber, (level), (fmt), (a), (b), (c)); \
}
/**
* Trace statement used inside functions that have a UTRACE_ENTRY() statement.
* Takes four data arguments.
* The number of arguments for this macro must match the number of inserts
* in the format string. Vector inserts count as two arguments.
* Calls utrace_data() if the level is high enough.
* @internal
*/
#define UTRACE_DATA4(level, fmt, a, b, c, d) \
if(UTRACE_LEVEL(level)) { \
utrace_data(utraceFnNumber, (level), (fmt), (a), (b), (c), (d)); \
}
/**
* Trace statement used inside functions that have a UTRACE_ENTRY() statement.
* Takes five data arguments.
* The number of arguments for this macro must match the number of inserts
* in the format string. Vector inserts count as two arguments.
* Calls utrace_data() if the level is high enough.
* @internal
*/
#define UTRACE_DATA5(level, fmt, a, b, c, d, e) \
if(UTRACE_LEVEL(level)) { \
utrace_data(utraceFnNumber, (level), (fmt), (a), (b), (c), (d), (e)); \
}
/**
* Trace statement used inside functions that have a UTRACE_ENTRY() statement.
* Takes six data arguments.
* The number of arguments for this macro must match the number of inserts
* in the format string. Vector inserts count as two arguments.
* Calls utrace_data() if the level is high enough.
* @internal
*/
#define UTRACE_DATA6(level, fmt, a, b, c, d, e, f) \
if(UTRACE_LEVEL(level)) { \
utrace_data(utraceFnNumber, (level), (fmt), (a), (b), (c), (d), (e), (f)); \
}
/**
* Trace statement used inside functions that have a UTRACE_ENTRY() statement.
* Takes seven data arguments.
* The number of arguments for this macro must match the number of inserts
* in the format string. Vector inserts count as two arguments.
* Calls utrace_data() if the level is high enough.
* @internal
*/
#define UTRACE_DATA7(level, fmt, a, b, c, d, e, f, g) \
if(UTRACE_LEVEL(level)) { \
utrace_data(utraceFnNumber, (level), (fmt), (a), (b), (c), (d), (e), (f), (g)); \
}
/**
* Trace statement used inside functions that have a UTRACE_ENTRY() statement.
* Takes eight data arguments.
* The number of arguments for this macro must match the number of inserts
* in the format string. Vector inserts count as two arguments.
* Calls utrace_data() if the level is high enough.
* @internal
*/
#define UTRACE_DATA8(level, fmt, a, b, c, d, e, f, g, h) \
if(UTRACE_LEVEL(level)) { \
utrace_data(utraceFnNumber, (level), (fmt), (a), (b), (c), (d), (e), (f), (g), (h)); \
}
/**
* Trace statement used inside functions that have a UTRACE_ENTRY() statement.
* Takes nine data arguments.
* The number of arguments for this macro must match the number of inserts
* in the format string. Vector inserts count as two arguments.
* Calls utrace_data() if the level is high enough.
* @internal
*/
#define UTRACE_DATA9(level, fmt, a, b, c, d, e, f, g, h, i) \
if(UTRACE_LEVEL(level)) { \
utrace_data(utraceFnNumber, (level), (fmt), (a), (b), (c), (d), (e), (f), (g), (h), (i)); \
}
U_CDECL_END
#endif

2
icu4c/source/i18n/ucol.cpp
View file

@ -29,7 +29,6 @@
#include "unicode/udata.h"
#include "unicode/uchar.h"
#include "unicode/caniter.h"
#include "unicode/utrace.h"
#include "ucol_bld.h"
#include "ucol_imp.h"
@ -44,6 +43,7 @@
#include "uhash.h"
#include "ucln_in.h"
#include "cstring.h"
#include "utracimp.h"
#ifdef UCOL_DEBUG
#include <stdio.h>

2
icu4c/source/test/cintltst/cintltst.c
View file

@ -68,7 +68,7 @@ void U_CALLCONV TraceEntry(const void *context, int32_t fnNumber) {
traceFnNestingDepth++;
}
void U_CALLCONV TraceExit(const void *context, int32_t fnNumber, UTraceExitVal type, va_list args) {
void U_CALLCONV TraceExit(const void *context, int32_t fnNumber, int32_t type, va_list args) {
char buf[2000];
if (traceFnNestingDepth>0) {
traceFnNestingDepth--;