ecosconfig-imx 200910-0ubuntu4 / usr / include / cyg / infra / cyg_trac.h

#ifndef CYGONCE_INFRA_CYG_TRAC_H
#define CYGONCE_INFRA_CYG_TRAC_H

//==========================================================================
//
//      cyg_trac.h
//
//      Macros and prototypes for the tracing system
//
//==========================================================================
//####COPYRIGHTBEGIN####
//                                                                          
// ----------------------------------------------------------------------------
// Copyright (C) 2002 Bart Veer
// Copyright (C) 1998, 1999, 2000, 2001 Red Hat, Inc.
//
// This file is part of the eCos host tools.
//
// This program is free software; you can redistribute it and/or modify it 
// under the terms of the GNU General Public License as published by the Free 
// Software Foundation; either version 2 of the License, or (at your option) 
// any later version.
// 
// This program is distributed in the hope that it will be useful, but WITHOUT 
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 
// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for 
// more details.
// 
// You should have received a copy of the GNU General Public License along with
// this program; if not, write to the Free Software Foundation, Inc., 
// 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
//
// ----------------------------------------------------------------------------
//                                                                          
//####COPYRIGHTEND####
//==========================================================================
//#####DESCRIPTIONBEGIN####
//
// Author(s):   nickg from an original by hmt
// Contributors:        nickg
// Date:        1998-04-23
// Purpose:     Use traces to log procedure entry, and "print" stuff
// Description: Runtime logging messages that compile to nothing in
//              release versions of the code, to allow
//              as-you-go tracing of alternate builds.
// Usage:       #include <cyg/infra/cyg_trac.h>
//              ...
//              CYG_TRACE2( PIPE_TRACE, "pipe %x, data %d", ppipe, oword );
//
//      which can result, for example, in a message of the form:
//      "TRACE: pipemgr.cxx:1340, write_pipe(): pipe 0x8004c, data 17"
//
//####DESCRIPTIONEND####
//

/****************************************************************************

Explicit tracing
================

CYG_TRACE0( bool, msg );
CYG_TRACE1( bool, msg, arg1 );
CYG_TRACE2( bool, msg, arg1, arg2 );
....
CYG_TRACE8( bool, msg, .... [with 8 args] );

In general, the bool controls whether or not the tracing occurs for a
particular invocation of the macro.  The msg is a printf-style string,
though exactly which formats are supported depends on the underlying
implementation.  Typically, at least %d, %x, %08x, %c and %s will be
supported.  Of course a most compact implementation might print

  TRACE:z1dbuff.c[92]get_nextdata(): data pointer %x offset %d: 42BD8 1C

or some such, leaving you to work it out for yourself.

It is expected that the boolean would rarely actually be a complex
expression; it is more likely that it would either be "1", tracing being
controlled for the whole compilation unit or subsystem by means of the
CYGDBG_USE_TRACING symbol, or a local symbol for tracing over the whole
file, defined to 0 or to 1.  For runtime control of tracing in a debugging
session, it is typical to use symbols defined to expressions such as:

    static int xxx_trace = 0;
    #define TL1 (0 < xxx_trace)
    #define TL2 (1 < xxx_trace)

so you set xxx_trace to 1 to enable those messages conditioned by TL1
(trace level 1) and so on.

    CYG_TRACE1( TL1, "Major argument is %d", zz );
    CYG_TRACE4( TL2, "...minor details %d %d %d %d", m1, m2, m3 ,m4 );

To assist with the case where the same symbol or expression is used
throughout a compilation unit, the programmer can define the symbol
CYG_TRACE_USER_BOOL as they choose and then use convenience macros with the
suffix 'B' in the obvious manner:

    #define CYG_TRACE_USER_BOOL (xxx_trace > 0)
    CYG_TRACE2B( "Counters are %d, %d", countlo, counthi );

For the case where you just want to print a load of numbers in hex, or
decimal, convenience suffices X, D and Y are provided.  X uses %08x, D %d
and Y an unadorned %x for each argument.

    CYG_TRACE3D( TL2, m1, m2, d );
   
If you want to do something similar but with a little more comment, the
names (strictly spellings) of the variables you are printing can be used by
appending a V to the X, D or Y.

    CYG_TRACE3DV( TL2, m1, m2, d );

might output:

  TRACE:z1dbuff.c[92]get_nextdata(): m1=23 m2=-4 d=55

These conveniences can be combined, and they apply equally to tracing with
up to 8 variables; the B for Bool goes last:

     CYG_TRACE4DVB( i, i*i, i*i*i, i*i*i*i );

might output:

  TRACE:table.c[12]main(): i=3 i*i=9 i*i*i=27 i*i*i*i=81


Function Tracing
================

There are also facities for easily reporting function entry and exit,
printing the function arguments, and detecting returns without logging (or
without a value!).

The basic facility is

        CYG_REPORT_FUNCTION();

In C, place this between the local variable declarations and the first
statement or errors will ensue.  C++ is more flexible; place the macro as
the first line of all functions you wish to trace.  The following
variations are also provided:

  CYG_REPORT_FUNCTYPE( exitmsg )  provide a printf string for the type
                                  of the returned value
  CYG_REPORT_FUNCNAME( name )     supply a function name explicitly, for
                                  if __FUNCTION__ is not supported
  CYG_REPORT_FUNCNAMETYPE( name, exitmsg ) both of the above extensions

These are unconditional; the assumption is that if function reporting is
used at all it will be used for all functions within a compilation unit.
However, it is useful to be able to control function reporting at finer
grain without editing the source files concerned, at compile time or at
runtime.  To support this, conditioned versions (with suffix 'C') are
provided for the above four macros, which only procduce trace output if the
macro CYG_REPORT_USER_BOOL evaluates true.

  CYG_REPORT_FUNCTIONC()
  CYG_REPORT_FUNCNAMEC( name )
  CYG_REPORT_FUNCTYPEC( exitmsg )
  CYG_REPORT_FUNCNAMETYPEC( name, exitmsg )

You can define CYG_REPORT_USER_BOOL to anything you like before invoking
these macros; using a simple -DCYG_REPORT_USER_BOOL=0 or ...=1 on the
compiler command line would do the trick, but there is more flexibility to
be gained by something like:

  #define CYG_REPORT_USER_BOOL (reporting_bool_FOO)
  #ifdef TRACE_FOO
  int reporting_bool_FOO = 1;
  #else
  int reporting_bool_FOO = 0;
  #endif

where FOO relates to the module name.  Thus an external symbol sets the
default, but it can be overridden in a debugging session by setting the
variable reporting_bool_FOO.

Note that the condition applied to the initial CYG_REPORT_FUNC...() macro
controls all function-related reporting (not tracing) from that function;
the underlying mechanisms still operate even if no output is created.  Thus
no conditioned variants of CYG_REPORT_FUNCARG[s] nor of CYG_REPORT_RETURN
are needed.

Examples:
    int myfunction()
    {
        CYG_REPORT_FUNCTYPE( "recode is %d" );

A function return is traced using

    CYG_REPORT_RETURN()         a void return
    CYG_REPORT_RETVAL( value )  returning a value

With the CYG_REPORT_FUNCTYPE example, the latter might produce a message
like:

  TRACE:myprog.c[40]fact(): enter
  TRACE:myprog.c[53]fact(): retcode is 24

It is also useful to trace the values of the arguments to a function:
        CYG_REPORT_FUNCARGVOID          confirms that the function is void
        CYG_REPORT_FUNCARG1( format, arg )              printf-style
                to
        CYG_REPORT_FUNCARG8( format, arg1...arg8 )      printf-style

The CYG_REPORT_FUNCARG[1-8] macros are also offered with the convenience
extensions: D, X, or Y, and V like the explicit tracing macros.  For
example:

    int fact( int number )
    {
        CYG_REPORT_FUNCTYPE( "recode is %d" );
        CYG_REPORT_FUNCARG1DV( number );
        int result = number;
        while ( --number > 1 )  result *= number
        CYG_REPORT_RETVAL( result );
        return result;
    }

might produce:

  TRACE:myprog.c[40]fact(): enter
  TRACE:myprog.c[40]fact(): number=4
  TRACE:myprog.c[53]fact(): retcode is 24

If no exit message is provided, a default of %08x is used.


General Configury
=================

If CYGDBG_INFRA_DEBUG_FUNCTION_PSEUDOMACRO is *not* defined, it is assumed
that __PRETTY_FUNCTION__ or equivalents do not exist, so no function name
tracing is possible; only file and line number.

If CYGDBG_INFRA_DEBUG_TRACE_MESSAGE is *not* defined, the message and
arguments to all tracing macros are not used; only "execution was here"
type information, by file, function and line number, is available.  This
can greatly reduce the size of an image with tracing disabled, which may be
crucial in debugging on actual shipped hardware with limited memory.

If configured for buffered tracing then CYG_TRACE_PRINT() can be used to
output the contents of the trace buffer on demand.

CYG_TRACE_DUMP() outputs a form of "core dump" containing info on the
scheduler and threads at the time. This information will be invalid if
the kernel is not running.

C/C++: in C++ the function reporting is implemented using a class object
with a destructor; this allows reporting of a return which has not been
explicitly reported, and detection of accidental multiple return reports.
This helps you write the function reporting correctly.  In C it is not
possible to be so sophisticated, so the implementation is not so helpful in
detecting errors in the use of the tracing system.

Note that for all of the above variations, the internal API to the
functions which are called in consequence of tracing remains the same, so
these variations can be mixed in the same executable, by configuring the
tracing macros differently in different compilation units or subsystems.


Summary
=======

Explicit tracing
----------------

CYG_TRACE0( bool, msg )                         if bool, print msg
CYG_TRACE1( bool, msg, arg )                    if bool, printf-style
        to
CYG_TRACE8( bool, msg, arg1...arg8 )            if bool, printf-style

CYG_TRACE0B( msg, args... ) to CYG_TRACE8B()    use CYG_TRACE_USER_BOOL

CYG_TRACE1X( bool, args... ) to CYG_TRACE8X()   print args using %08x
CYG_TRACE1Y( bool, args... ) to CYG_TRACE8Y()   print args using %x
CYG_TRACE1D( bool, args... ) to CYG_TRACE8D()   print args using %d

CYG_TRACE1XV( bool, args... ) to CYG_TRACE8XV() print args using "arg=%08x"
CYG_TRACE1YV( bool, args... ) to CYG_TRACE8YV() print args using "arg=%x"
CYG_TRACE1DV( bool, args... ) to CYG_TRACE8DV() print args using "arg=%d"

CYG_TRACE1XB( args... ) to CYG_TRACE8XB()       print using %08x, no bool
CYG_TRACE1YB( args... ) to CYG_TRACE8YB()       print using %x, no bool
CYG_TRACE1DB( args... ) to CYG_TRACE8DB()       print using %d, no bool

CYG_TRACE1XVB( args... ) to CYG_TRACE8XVB()     use "arg=%08x", no bool
CYG_TRACE1YVB( args... ) to CYG_TRACE8YVB()     use "arg=%x", no bool
CYG_TRACE1DVB( args... ) to CYG_TRACE8DVB()     use "arg=%d", no bool

Function tracing
----------------

CYG_REPORT_FUNCTION()                           default function entry
CYG_REPORT_FUNCNAME( name )                     name the function
CYG_REPORT_FUNCTYPE( exitmsg )                  printf for retval
CYG_REPORT_FUNCNAMETYPE( name, exitmsg )        both

CYG_REPORT_FUNCTIONC()                          as above, but conditional
CYG_REPORT_FUNCNAMEC( name )                    on CYG_REPORT_USER_BOOL
CYG_REPORT_FUNCTYPEC( exitmsg )                 however it is defined
CYG_REPORT_FUNCNAMETYPEC( name, exitmsg )       ...

CYG_REPORT_RETURN()                             void function exit
CYG_REPORT_RETVAL( value )                      returning value

CYG_REPORT_FUNCARGVOID()                        void function entry
CYG_REPORT_FUNCARG1( format, arg )              printf-style
        to
CYG_REPORT_FUNCARG8( format, arg1...arg8 )      printf-style

CYG_REPORT_FUNCARG1X( arg )
        to
CYG_REPORT_FUNCARG8X( arg1...arg8 )             use %08x
CYG_REPORT_FUNCARG1Y...                         use %x
CYG_REPORT_FUNCARG1D...                         use %d

CYG_REPORT_FUNCARG1XV...                        use "arg=%08x"
CYG_REPORT_FUNCARG1YV...                        use "arg=%x"
CYG_REPORT_FUNCARG1DV...                        use "arg=%d"

Other
-----

CYG_TRACE_DUMP()                                dumps kernel state
CYG_TRACE_PRINT()                               prints buffered tracing


---------------------------------------------------------------------------

Internal Documentation
======================

The required functions which are used by the tracing macros are

    externC void
    cyg_tracenomsg( const char *psz_func, const char *psz_file, cyg_uint32 linenum );
    
    externC void
    cyg_tracemsg( cyg_uint32 what, 
                  const char *psz_func, const char *psz_file, cyg_uint32 linenum, 
                  const char *psz_msg );
    
    externC void
    cyg_tracemsg2( cyg_uint32 what, 
                   const char *psz_func, const char *psz_file, cyg_uint32 linenum, 
                   const char *psz_msg,
                   CYG_ADDRWORD arg0,  CYG_ADDRWORD arg1 );
    // extended in the obvious way for 4,6,8 arguments

These functions should expect psz_func and psz_file to possibly be NULL in
case those facilities are not available in the compilation environment, and
do something safe in such cases.  A NULL message should really be dealt
with safely also, just logging "execution here" info like cyg_tracenomsg().

Discussion of possible underlying implementations
-------------------------------------------------

It is intended that the functions that get called can simply print the info
they are given in as fancy a format as you like, or they could do the
printf-type formatting and log the resulting text in a buffer.  They get
told the type of event (function-entry, function-arguments, function-exit
or plain tracing info) and so can perform fancy indenting, for example, to
make call stack inspection more obvious to humans.  It is also intended
that a more compact logging arrangement be possible, for example one which
records, in 32-bit words (CYG_ADDRWORDs), the addresses of the file,
function and msg strings, the line number and the arguments.  This has the
implication that the msg string should not be constructed dynamically but
be static ie. a plain quoted C string.  The number of arguments also must
be recorded, and if it is chosen to save string arguments in the buffer
rather than just their addresses (which could be invalid by the time the
logged information is processed) some flagging of which arguments are
strings must be provided.  The system could also be extended to deal with
floats of whichever size fir in a CYG_ADDRWORD; these would probably
require special treatment also.  With these considerations in mind, the
maximum number of parameters in a single trace message has been set to 8,
so that a byte bitset could be used to indicate which arguments are
strings, another for those which are floats, and the count of arguments
also fits in a byte as number or a bitset.


****************************************************************************/

#include <pkgconf/infra.h>

#include <cyg/infra/cyg_ass.h>

// -------------------------------------------------------------------------
// CYGDBG_INFRA_DEBUG_FUNCTION_PSEUDOMACRO is dealt with in cyg_ass.h.
// -------------------------------------------------------------------------

#ifdef CYGDBG_USE_TRACING

// -------------------------------------------------------------------------
// We define macros and appropriate prototypes for the trace/fail
// system.  These are:
//      CYG_TRACE0..8     - trace if boolean
//      CYG_TRACEPROC     - default no comment proc entry
//      CYG_TRACEPROCOUT  - default no comment proc exit
//      CYG_TRACE_DUMP    - outputs a form of "core dump", including the state
//                          of the kernel scheduler, threads, etc.
//      CYG_TRACE_PRINT   - Forces manual output of any trace info that has
//                          been buffered up.

// these are executed to deal with tracing - breakpoint?

externC void
cyg_tracenomsg( const char *psz_func, const char *psz_file, cyg_uint32 linenum );

externC void
cyg_trace_dump(void);

#define CYG_TRACE_DUMP() cyg_trace_dump()

#ifdef CYGDBG_INFRA_DEBUG_TRACE_ASSERT_BUFFER

externC void
cyg_trace_print(void);

#define CYG_TRACE_PRINT() cyg_trace_print()

#else
#define CYG_TRACE_PRINT() CYG_EMPTY_STATEMENT
#endif

// provide every other one of these as a space/caller bloat compromise.

# ifdef CYGDBG_INFRA_DEBUG_TRACE_MESSAGE

enum cyg_trace_what{
    cyg_trace_trace = 0,
    cyg_trace_enter,
    cyg_trace_args,
    cyg_trace_return,
//    cyg_trace_,
//    cyg_trace_,
};

externC void
cyg_tracemsg( cyg_uint32 what, 
              const char *psz_func, const char *psz_file, cyg_uint32 linenum, 
              const char *psz_msg );

externC void
cyg_tracemsg2( cyg_uint32 what, 
               const char *psz_func, const char *psz_file, cyg_uint32 linenum, 
               const char *psz_msg,
               CYG_ADDRWORD arg0,  CYG_ADDRWORD arg1 );
externC void
cyg_tracemsg4( cyg_uint32 what, 
               const char *psz_func, const char *psz_file, cyg_uint32 linenum, 
               const char *psz_msg,
               CYG_ADDRWORD arg0,  CYG_ADDRWORD arg1,
               CYG_ADDRWORD arg2,  CYG_ADDRWORD arg3 );
externC void
cyg_tracemsg6( cyg_uint32 what, 
               const char *psz_func, const char *psz_file, cyg_uint32 linenum, 
               const char *psz_msg,
               CYG_ADDRWORD arg0,  CYG_ADDRWORD arg1,
               CYG_ADDRWORD arg2,  CYG_ADDRWORD arg3,
               CYG_ADDRWORD arg4,  CYG_ADDRWORD arg5 );
externC void
cyg_tracemsg8( cyg_uint32 what, 
               const char *psz_func, const char *psz_file, cyg_uint32 linenum, 
               const char *psz_msg,
               CYG_ADDRWORD arg0,  CYG_ADDRWORD arg1,
               CYG_ADDRWORD arg2,  CYG_ADDRWORD arg3,
               CYG_ADDRWORD arg4,  CYG_ADDRWORD arg5,
               CYG_ADDRWORD arg6,  CYG_ADDRWORD arg7 );

#endif // CYGDBG_INFRA_DEBUG_TRACE_MESSAGE

// -------------------------------------------------------------------------

# ifdef CYGDBG_INFRA_DEBUG_TRACE_MESSAGE

#  define CYG_TRACE_docall0( _msg_ )                                    \
    cyg_tracemsg( cyg_trace_trace,                                      \
                  __PRETTY_FUNCTION__, __FILE__, __LINE__, _msg_ );

#  define CYG_TRACE_docall2( _msg_, _arg0_, _arg1_ )                    \
    cyg_tracemsg2( cyg_trace_trace,                                     \
                   __PRETTY_FUNCTION__, __FILE__, __LINE__, _msg_,      \
                 (CYG_ADDRWORD)_arg0_, (CYG_ADDRWORD)_arg1_ );

#  define CYG_TRACE_docall4( _msg_, _arg0_, _arg1_ , _arg2_, _arg3_  )  \
    cyg_tracemsg4( cyg_trace_trace,                                     \
                   __PRETTY_FUNCTION__, __FILE__, __LINE__, _msg_,      \
                 (CYG_ADDRWORD)_arg0_, (CYG_ADDRWORD)_arg1_,            \
                 (CYG_ADDRWORD)_arg2_, (CYG_ADDRWORD)_arg3_ );

#  define CYG_TRACE_docall6( _msg_, _arg0_, _arg1_ , _arg2_, _arg3_,    \
                                    _arg4_, _arg5_                   )  \
    cyg_tracemsg6( cyg_trace_trace,                                     \
                   __PRETTY_FUNCTION__, __FILE__, __LINE__, _msg_,      \
                 (CYG_ADDRWORD)_arg0_, (CYG_ADDRWORD)_arg1_,            \
                 (CYG_ADDRWORD)_arg2_, (CYG_ADDRWORD)_arg3_,            \
                 (CYG_ADDRWORD)_arg4_, (CYG_ADDRWORD)_arg5_ );

#  define CYG_TRACE_docall8( _msg_, _arg0_, _arg1_ , _arg2_, _arg3_,    \
                                    _arg4_,  _arg5_, _arg6_, _arg7_ )   \
    cyg_tracemsg8( cyg_trace_trace,                                     \
                   __PRETTY_FUNCTION__, __FILE__, __LINE__, _msg_,      \
                 (CYG_ADDRWORD)_arg0_, (CYG_ADDRWORD)_arg1_,            \
                 (CYG_ADDRWORD)_arg2_, (CYG_ADDRWORD)_arg3_,            \
                 (CYG_ADDRWORD)_arg4_, (CYG_ADDRWORD)_arg5_,            \
                 (CYG_ADDRWORD)_arg6_, (CYG_ADDRWORD)_arg7_ );

# else // do not CYGDBG_INFRA_DEBUG_TRACE_MESSAGE

#  define CYG_TRACE_docall0( _msg_ )                                    \
    cyg_tracenomsg( __PRETTY_FUNCTION__, __FILE__, __LINE__ );

#  define CYG_TRACE_docall2( _msg_, _arg0_, _arg1_ )                    \
    cyg_tracenomsg( __PRETTY_FUNCTION__, __FILE__, __LINE__ );

#  define CYG_TRACE_docall4( _msg_, _arg0_, _arg1_ , _arg2_, _arg3_  )  \
    cyg_tracenomsg( __PRETTY_FUNCTION__, __FILE__, __LINE__ );

#  define CYG_TRACE_docall6( _msg_, _arg0_, _arg1_ , _arg2_, _arg3_,    \
                                    _arg4_, _arg5_                   )  \
    cyg_tracenomsg( __PRETTY_FUNCTION__, __FILE__, __LINE__ );

#  define CYG_TRACE_docall8( _msg_, _arg0_, _arg1_, _arg2_, _arg3_,     \
                                    _arg4_, _arg5_, _arg6_, _arg7_   )  \
    cyg_tracenomsg( __PRETTY_FUNCTION__, __FILE__, __LINE__ );

#endif

// -------------------------------------------------------------------------
// Conditioned trace; if the condition is false, fail.

#define CYG_TRACE0( _bool_, _msg_ )                             \
    CYG_MACRO_START                                             \
    if ( ( _bool_ ) )                                           \
        CYG_TRACE_docall0( _msg_ );                             \
    CYG_MACRO_END

#define CYG_TRACE1( _bool_, _msg_, a )                          \
    CYG_MACRO_START                                             \
    if ( ( _bool_ ) )                                           \
        CYG_TRACE_docall2( _msg_, a, 0 );                       \
    CYG_MACRO_END
 
#define CYG_TRACE2( _bool_, _msg_, a, b )                       \
    CYG_MACRO_START                                             \
    if ( ( _bool_ ) )                                           \
        CYG_TRACE_docall2( _msg_, a, b );                       \
    CYG_MACRO_END

#define CYG_TRACE3( _bool_, _msg_, a, b, c )                    \
    CYG_MACRO_START                                             \
    if ( ( _bool_ ) )                                           \
        CYG_TRACE_docall4( _msg_, a, b, c, 0 );                 \
    CYG_MACRO_END
 
#define CYG_TRACE4( _bool_, _msg_, a, b, c, d )                 \
    CYG_MACRO_START                                             \
    if ( ( _bool_ ) )                                           \
        CYG_TRACE_docall4( _msg_, a, b, c, d );                 \
    CYG_MACRO_END

#define CYG_TRACE5( _bool_, _msg_, a, b, c, d, e )              \
    CYG_MACRO_START                                             \
    if ( ( _bool_ ) )                                           \
        CYG_TRACE_docall6( _msg_, a, b, c, d, e, 0 );           \
    CYG_MACRO_END
 
#define CYG_TRACE6( _bool_, _msg_, a, b, c, d, e, f )           \
    CYG_MACRO_START                                             \
    if ( ( _bool_ ) )                                           \
        CYG_TRACE_docall6( _msg_, a, b, c, d, e, f );           \
    CYG_MACRO_END

#define CYG_TRACE7( _bool_, _msg_, a, b, c, d, e, f, g )        \
    CYG_MACRO_START                                             \
    if ( ( _bool_ ) )                                           \
        CYG_TRACE_docall8( _msg_, a, b, c, d, e, f, g, 0 );     \
    CYG_MACRO_END
 
#define CYG_TRACE8( _bool_, _msg_, a, b, c, d, e, f, g, h )     \
    CYG_MACRO_START                                             \
    if ( ( _bool_ ) )                                           \
        CYG_TRACE_docall8( _msg_, a, b, c, d, e, f, g, h );     \
    CYG_MACRO_END

// -------------------------------------------------------------------------
// Report function entry and exit.
// In C++ the macro CYG_REPORT_FUNCTION should appear as the first line of
// any function. It will generate a message whenever the function is entered
// and when it is exited.
// In C the macro should appear as the first statement after any local variable
// definitions. No exit message will be generated unless CYG_REPORT_RETURN is
// placed just before each return.
// Where a piece of code is to be compiled with both C and C++, the above
// rules for C should be followed.

#ifdef CYGDBG_INFRA_DEBUG_FUNCTION_REPORTS
        
#ifdef __cplusplus

class Cyg_TraceFunction_Report_
{
public:
    int   cond;
    const char *func;
    const char *file;
    cyg_uint32 lnum;
#ifdef CYGDBG_INFRA_DEBUG_TRACE_MESSAGE
    const char *exitmsg;
    CYG_ADDRWORD exitvalue;
    enum { UNSET = 0, SET, VOID } exitset;
#endif

    Cyg_TraceFunction_Report_(
        int condition, const char *psz_func, const char *psz_file,
        cyg_uint32 linenum)
    {
        cond = condition;
        func = psz_func;
        file = psz_file;
        lnum = linenum;
        
#ifdef CYGDBG_INFRA_DEBUG_TRACE_MESSAGE
        exitmsg = NULL;
        exitset  = UNSET;
        if ( cond )
            cyg_tracemsg( cyg_trace_enter, func, file, lnum, "enter");
#else
        if ( cond )
            cyg_tracenomsg( func, file, lnum );
#endif
    };

    Cyg_TraceFunction_Report_(
        int condition, const char *psz_func, const char *psz_file, 
        cyg_uint32 linenum, const char *psz_exitmsg )
    {
        cond = condition;
        func = psz_func;
        file = psz_file;
        lnum = linenum;
#ifdef CYGDBG_INFRA_DEBUG_TRACE_MESSAGE
        exitmsg = psz_exitmsg;
        exitset  = UNSET;
        if ( cond )
            cyg_tracemsg( cyg_trace_enter, func, file, lnum, "enter");
#else
        CYG_UNUSED_PARAM( const char *, psz_exitmsg );
        if ( cond )
            cyg_tracenomsg( func, file, lnum );
#endif
    };

    inline void set_exitvoid( cyg_uint32 linenum )
    {
        lnum = linenum;
#ifdef CYGDBG_INFRA_DEBUG_TRACE_MESSAGE
        CYG_ASSERT( NULL == exitmsg, "exitvoid used in typed function" );
        CYG_ASSERT( UNSET == exitset, "exitvoid used when arg already set" );
        exitset = VOID;
#endif
    }

    inline void set_exitvalue( cyg_uint32 linenum, CYG_ADDRWORD retcode )
    {
        lnum = linenum;
#ifdef CYGDBG_INFRA_DEBUG_TRACE_MESSAGE
        CYG_ASSERT( UNSET == exitset, "exitvalue used when arg already set" );
        exitvalue = retcode;
        exitset = SET;
#else
        CYG_UNUSED_PARAM( CYG_ADDRWORD, retcode );
#endif
    }

    ~Cyg_TraceFunction_Report_()
    {
        if ( cond ) {
#ifdef CYGDBG_INFRA_DEBUG_TRACE_MESSAGE
            if ( VOID == exitset )
                cyg_tracemsg( cyg_trace_return, func, file, lnum,
                              "return void");
            else if ( UNSET == exitset )
                cyg_tracemsg( cyg_trace_return, func, file, lnum,
                              "RETURNING UNSET!");
            else if ( NULL == exitmsg )
                cyg_tracemsg2( cyg_trace_return, func, file, lnum,
                               "return %08x", exitvalue, 0 );
            else
                cyg_tracemsg2( cyg_trace_return, func, file, lnum,
                               exitmsg, exitvalue, 0 );
#else
            cyg_tracenomsg( func, file, lnum );
#endif
        }
    }
};

// These have no CYG_MACRO_START,END around because it is required
// that the scope of the object be the whole function body.  Get it?

// These are the unconditional versions:
#define CYG_REPORT_FUNCTION()                           \
  Cyg_TraceFunction_Report_ cyg_tracefunction_report_(  \
        1, __PRETTY_FUNCTION__,                         \
        __FILE__, __LINE__ )

#define CYG_REPORT_FUNCTYPE( _exitmsg_ )                \
  Cyg_TraceFunction_Report_ cyg_tracefunction_report_(  \
        1, __PRETTY_FUNCTION__,                         \
        __FILE__, __LINE__, _exitmsg_ )

#define CYG_REPORT_FUNCNAME( _name_ )                   \
  Cyg_TraceFunction_Report_ cyg_tracefunction_report_(  \
        1, _name_,                                      \
        __FILE__, __LINE__ )

#define CYG_REPORT_FUNCNAMETYPE( _name_, _exitmsg_  )   \
  Cyg_TraceFunction_Report_ cyg_tracefunction_report_(  \
        1, _name_,                                      \
        __FILE__, __LINE__, _exitmsg_ )

// These are conditioned on macro CYG_REPORT_USER_BOOL
// (which you better have defined)
#define CYG_REPORT_FUNCTIONC()                          \
  Cyg_TraceFunction_Report_ cyg_tracefunction_report_(  \
        CYG_REPORT_USER_BOOL, __PRETTY_FUNCTION__,      \
        __FILE__, __LINE__ )

#define CYG_REPORT_FUNCTYPEC( _exitmsg_ )               \
  Cyg_TraceFunction_Report_ cyg_tracefunction_report_(  \
        CYG_REPORT_USER_BOOL, __PRETTY_FUNCTION__,      \
        __FILE__, __LINE__, _exitmsg_ )

#define CYG_REPORT_FUNCNAMEC( _name_ )                  \
  Cyg_TraceFunction_Report_ cyg_tracefunction_report_(  \
        CYG_REPORT_USER_BOOL, _name_,                   \
        __FILE__, __LINE__ )

#define CYG_REPORT_FUNCNAMETYPEC( _name_, _exitmsg_  )  \
  Cyg_TraceFunction_Report_ cyg_tracefunction_report_(  \
        CYG_REPORT_USER_BOOL, _name_,                   \
        __FILE__, __LINE__, _exitmsg_ )


#define CYG_REPORT_RETURN() CYG_MACRO_START             \
    cyg_tracefunction_report_.set_exitvoid( __LINE__ ); \
CYG_MACRO_END

#define CYG_REPORT_RETVAL( _value_) CYG_MACRO_START     \
    cyg_tracefunction_report_.set_exitvalue(            \
        __LINE__, (CYG_ADDRWORD)(_value_) );            \
CYG_MACRO_END


#else   // not __cplusplus


struct Cyg_TraceFunction_Report_
{
    int   cond;
    const char *func;
    const char *file; /* not strictly needed in plain 'C' */
    cyg_uint32 lnum; /* nor this */
#ifdef CYGDBG_INFRA_DEBUG_TRACE_MESSAGE
    const char *exitmsg;
    CYG_ADDRWORD exitvalue;
    int exitset;
#endif

};

#ifdef CYGDBG_INFRA_DEBUG_TRACE_MESSAGE

#define CYG_REPORT_FUNCTION_ENTER_INTERNAL() CYG_MACRO_START            \
  if ( cyg_tracefunction_report_.cond )                                 \
    cyg_tracemsg( cyg_trace_enter,                                      \
                  cyg_tracefunction_report_.func,                       \
                  cyg_tracefunction_report_.file,                       \
                  cyg_tracefunction_report_.lnum,                       \
                  "enter" );                                            \
CYG_MACRO_END

#define CYG_REPORT_FUNCTION_CONSTRUCT( _c_, _fn_,_fl_,_l_,_xm_,_xv_,_xs_ ) \
        { _c_, _fn_, _fl_, _l_, _xm_, _xv_, _xs_ }

#else // do not CYGDBG_INFRA_DEBUG_TRACE_MESSAGE

#define CYG_REPORT_FUNCTION_ENTER_INTERNAL() CYG_MACRO_START            \
  if ( cyg_tracefunction_report_.cond )                                 \
    cyg_tracenomsg( cyg_tracefunction_report_.func,                     \
                    cyg_tracefunction_report_.file,                     \
                    cyg_tracefunction_report_.lnum );                   \
CYG_MACRO_END

#define CYG_REPORT_FUNCTION_CONSTRUCT( _c_, _fn_,_fl_,_l_,_xm_,_xv_,_xs_ ) \
        { _c_, _fn_, _fl_, _l_ }

#endif // not CYGDBG_INFRA_DEBUG_TRACE_MESSAGE

// These have no CYG_MACRO_START,END around because it is required
// that the scope of the object be the whole function body.  Get it?

// These are the unconditional versions:
#define CYG_REPORT_FUNCTION()                                           \
    struct Cyg_TraceFunction_Report_ cyg_tracefunction_report_ =        \
    CYG_REPORT_FUNCTION_CONSTRUCT(                                      \
        1, __PRETTY_FUNCTION__, __FILE__, __LINE__, NULL, 0, 0 );       \
    CYG_REPORT_FUNCTION_ENTER_INTERNAL()

#define CYG_REPORT_FUNCTYPE( _exitmsg_ )                                \
    struct Cyg_TraceFunction_Report_ cyg_tracefunction_report_ =        \
    CYG_REPORT_FUNCTION_CONSTRUCT(                                      \
        1, __PRETTY_FUNCTION__, __FILE__, __LINE__, _exitmsg_, 0, 0 );  \
    CYG_REPORT_FUNCTION_ENTER_INTERNAL()

#define CYG_REPORT_FUNCNAME( _name_ )                                   \
    struct Cyg_TraceFunction_Report_ cyg_tracefunction_report_ =        \
    CYG_REPORT_FUNCTION_CONSTRUCT(                                      \
        1, _name_, __FILE__, __LINE__, NULL, 0, 0 );                    \
    CYG_REPORT_FUNCTION_ENTER_INTERNAL()

#define CYG_REPORT_FUNCNAMETYPE( _name_, _exitmsg_  )                   \
    struct Cyg_TraceFunction_Report_ cyg_tracefunction_report_ =        \
    CYG_REPORT_FUNCTION_CONSTRUCT(                                      \
        1, _name_, __FILE__, __LINE__, _exitmsg_, 0, 0 );               \
    CYG_REPORT_FUNCTION_ENTER_INTERNAL()

// These are conditioned on macro CYG_REPORT_USER_BOOL
// (which you better have defined)
#define CYG_REPORT_FUNCTIONC()                                          \
    struct Cyg_TraceFunction_Report_ cyg_tracefunction_report_ =        \
    CYG_REPORT_FUNCTION_CONSTRUCT(                                      \
        CYG_REPORT_USER_BOOL,                                           \
        __PRETTY_FUNCTION__, __FILE__, __LINE__, NULL, 0, 0 );          \
    CYG_REPORT_FUNCTION_ENTER_INTERNAL()

#define CYG_REPORT_FUNCTYPEC( _exitmsg_ )                               \
    struct Cyg_TraceFunction_Report_ cyg_tracefunction_report_ =        \
    CYG_REPORT_FUNCTION_CONSTRUCT(                                      \
        CYG_REPORT_USER_BOOL,                                           \
        __PRETTY_FUNCTION__, __FILE__, __LINE__, _exitmsg_, 0, 0 );     \
    CYG_REPORT_FUNCTION_ENTER_INTERNAL()

#define CYG_REPORT_FUNCNAMEC( _name_ )                                  \
    struct Cyg_TraceFunction_Report_ cyg_tracefunction_report_ =        \
    CYG_REPORT_FUNCTION_CONSTRUCT(                                      \
        CYG_REPORT_USER_BOOL,                                           \
        _name_, __FILE__, __LINE__, NULL, 0, 0 );                       \
    CYG_REPORT_FUNCTION_ENTER_INTERNAL()

#define CYG_REPORT_FUNCNAMETYPEC( _name_, _exitmsg_  )                  \
    struct Cyg_TraceFunction_Report_ cyg_tracefunction_report_ =        \
    CYG_REPORT_FUNCTION_CONSTRUCT(                                      \
        CYG_REPORT_USER_BOOL,                                           \
        _name_, __FILE__, __LINE__, _exitmsg_, 0, 0 );                  \
    CYG_REPORT_FUNCTION_ENTER_INTERNAL()

#ifdef CYGDBG_INFRA_DEBUG_TRACE_MESSAGE

#define CYG_REPORT_RETURN() CYG_MACRO_START                             \
    CYG_ASSERT( NULL == cyg_tracefunction_report_.exitmsg,              \
                "exitvoid used in typed function" );                    \
    CYG_ASSERT( 0 == cyg_tracefunction_report_.exitset,                 \
                "exitvoid used when arg already set" );                 \
    cyg_tracefunction_report_.lnum = __LINE__;                          \
    cyg_tracefunction_report_.exitset = 2;                              \
    if ( cyg_tracefunction_report_.cond )                               \
      cyg_tracemsg( cyg_trace_return,                                   \
                    cyg_tracefunction_report_.func,                     \
                    cyg_tracefunction_report_.file,                     \
                    cyg_tracefunction_report_.lnum,                     \
                    "return void" );                                    \
CYG_MACRO_END

#define CYG_REPORT_RETVAL( _value_ ) CYG_MACRO_START                    \
    CYG_ASSERT( 0 == cyg_tracefunction_report_.exitset,                 \
                "exitvalue used when arg already set" );                \
    cyg_tracefunction_report_.lnum = __LINE__;                          \
    cyg_tracefunction_report_.exitvalue = (CYG_ADDRWORD)(_value_);      \
    cyg_tracefunction_report_.exitset = 1;                              \
    if ( cyg_tracefunction_report_.cond )                               \
      cyg_tracemsg2( cyg_trace_return,                                  \
                     cyg_tracefunction_report_.func,                    \
                     cyg_tracefunction_report_.file,                    \
                     cyg_tracefunction_report_.lnum,                    \
                     cyg_tracefunction_report_.exitmsg ?                \
                        cyg_tracefunction_report_.exitmsg :             \
                        "return %08x",                                  \
                     cyg_tracefunction_report_.exitvalue, 0 );          \
CYG_MACRO_END

#else // do not CYGDBG_INFRA_DEBUG_TRACE_MESSAGE

#define CYG_REPORT_RETURN() CYG_MACRO_START                             \
    cyg_tracefunction_report_.lnum = __LINE__;                          \
    if ( cyg_tracefunction_report_.cond )                               \
      cyg_tracenomsg( cyg_tracefunction_report_.func,                   \
                      cyg_tracefunction_report_.file,                   \
                      cyg_tracefunction_report_.lnum );                 \
CYG_MACRO_END

#define CYG_REPORT_RETVAL( _value_ ) CYG_MACRO_START                    \
    CYG_REPORT_RETURN();                                                \
CYG_MACRO_END

#endif // not CYGDBG_INFRA_DEBUG_TRACE_MESSAGE

#endif // not __cplusplus

#ifdef CYGDBG_INFRA_DEBUG_TRACE_MESSAGE

#define CYG_REPORT_FUNCARGVOID() CYG_MACRO_START                        \
  if ( cyg_tracefunction_report_.cond )                                 \
    cyg_tracemsg(  cyg_trace_args,                                      \
                   cyg_tracefunction_report_.func,                      \
                   cyg_tracefunction_report_.file,                      \
                   cyg_tracefunction_report_.lnum,                      \
                   "(void)"                                             \
                   );                                                   \
CYG_MACRO_END

#define CYG_REPORT_FUNCARG1( _format_, a ) CYG_MACRO_START              \
  if ( cyg_tracefunction_report_.cond )                                 \
    cyg_tracemsg2( cyg_trace_args,                                      \
                   cyg_tracefunction_report_.func,                      \
                   cyg_tracefunction_report_.file,                      \
                   cyg_tracefunction_report_.lnum,                      \
                   (_format_),                                          \
                   (CYG_ADDRWORD)a      , 0                             \
                   );                                                   \
CYG_MACRO_END
    
#define CYG_REPORT_FUNCARG2( _format_, a,b ) CYG_MACRO_START            \
  if ( cyg_tracefunction_report_.cond )                                 \
    cyg_tracemsg2( cyg_trace_args,                                      \
                   cyg_tracefunction_report_.func,                      \
                   cyg_tracefunction_report_.file,                      \
                   cyg_tracefunction_report_.lnum,                      \
                   (_format_),                                          \
                   (CYG_ADDRWORD)a, (CYG_ADDRWORD)b                     \
                   );                                                   \
CYG_MACRO_END

#define CYG_REPORT_FUNCARG3( _format_, a,b,c ) CYG_MACRO_START          \
  if ( cyg_tracefunction_report_.cond )                                 \
    cyg_tracemsg4( cyg_trace_args,                                      \
                   cyg_tracefunction_report_.func,                      \
                   cyg_tracefunction_report_.file,                      \
                   cyg_tracefunction_report_.lnum,                      \
                   (_format_),                                          \
                   (CYG_ADDRWORD)a, (CYG_ADDRWORD)b,                    \
                   (CYG_ADDRWORD)c      , 0                             \
                   );                                                   \
CYG_MACRO_END

#define CYG_REPORT_FUNCARG4( _format_, a,b,c,d ) CYG_MACRO_START        \
  if ( cyg_tracefunction_report_.cond )                                 \
    cyg_tracemsg4( cyg_trace_args,                                      \
                   cyg_tracefunction_report_.func,                      \
                   cyg_tracefunction_report_.file,                      \
                   cyg_tracefunction_report_.lnum,                      \
                   (_format_),                                          \
                   (CYG_ADDRWORD)a, (CYG_ADDRWORD)b,                    \
                   (CYG_ADDRWORD)c, (CYG_ADDRWORD)d                     \
                   );                                                   \
CYG_MACRO_END

#define CYG_REPORT_FUNCARG5( _format_, a,b,c,d,e ) CYG_MACRO_START      \
  if ( cyg_tracefunction_report_.cond )                                 \
    cyg_tracemsg6( cyg_trace_args,                                      \
                   cyg_tracefunction_report_.func,                      \
                   cyg_tracefunction_report_.file,                      \
                   cyg_tracefunction_report_.lnum,                      \
                   (_format_),                                          \
                   (CYG_ADDRWORD)a, (CYG_ADDRWORD)b,                    \
                   (CYG_ADDRWORD)c, (CYG_ADDRWORD)d,                    \
                   (CYG_ADDRWORD)e      , 0                             \
                   );                                                   \
CYG_MACRO_END

#define CYG_REPORT_FUNCARG6( _format_, a,b,c,d,e,f ) CYG_MACRO_START    \
  if ( cyg_tracefunction_report_.cond )                                 \
    cyg_tracemsg6( cyg_trace_args,                                      \
                   cyg_tracefunction_report_.func,                      \
                   cyg_tracefunction_report_.file,                      \
                   cyg_tracefunction_report_.lnum,                      \
                   (_format_),                                          \
                   (CYG_ADDRWORD)a, (CYG_ADDRWORD)b,                    \
                   (CYG_ADDRWORD)c, (CYG_ADDRWORD)d,                    \
                   (CYG_ADDRWORD)e, (CYG_ADDRWORD)f                     \
                   );                                                   \
CYG_MACRO_END

#define CYG_REPORT_FUNCARG7( _format_, a,b,c,d,e,f,g ) CYG_MACRO_START  \
  if ( cyg_tracefunction_report_.cond )                                 \
    cyg_tracemsg8( cyg_trace_args,                                      \
                   cyg_tracefunction_report_.func,                      \
                   cyg_tracefunction_report_.file,                      \
                   cyg_tracefunction_report_.lnum,                      \
                   (_format_),                                          \
                   (CYG_ADDRWORD)a, (CYG_ADDRWORD)b,                    \
                   (CYG_ADDRWORD)c, (CYG_ADDRWORD)d,                    \
                   (CYG_ADDRWORD)e, (CYG_ADDRWORD)f,                    \
                   (CYG_ADDRWORD)g      , 0                             \
                   );                                                   \
CYG_MACRO_END

#define CYG_REPORT_FUNCARG8( _format_, a,b,c,d,e,f,g,h ) CYG_MACRO_START\
  if ( cyg_tracefunction_report_.cond )                                 \
    cyg_tracemsg8( cyg_trace_args,                                      \
                   cyg_tracefunction_report_.func,                      \
                   cyg_tracefunction_report_.file,                      \
                   cyg_tracefunction_report_.lnum,                      \
                   (_format_),                                          \
                   (CYG_ADDRWORD)a, (CYG_ADDRWORD)b,                    \
                   (CYG_ADDRWORD)c, (CYG_ADDRWORD)d,                    \
                   (CYG_ADDRWORD)e, (CYG_ADDRWORD)f,                    \
                   (CYG_ADDRWORD)g, (CYG_ADDRWORD)h                     \
                   );                                                   \
CYG_MACRO_END


#else // do not CYGDBG_INFRA_DEBUG_TRACE_MESSAGE

#define CYG_REPORT_FUNCARGVOID() CYG_EMPTY_STATEMENT
#define CYG_REPORT_FUNCARG1( _format_, a ) CYG_EMPTY_STATEMENT
#define CYG_REPORT_FUNCARG2( _format_, a,b ) CYG_EMPTY_STATEMENT
#define CYG_REPORT_FUNCARG3( _format_, a,b,c ) CYG_EMPTY_STATEMENT
#define CYG_REPORT_FUNCARG4( _format_, a,b,c,d ) CYG_EMPTY_STATEMENT
#define CYG_REPORT_FUNCARG5( _format_, a,b,c,d,e ) CYG_EMPTY_STATEMENT
#define CYG_REPORT_FUNCARG6( _format_, a,b,c,d,e,f ) CYG_EMPTY_STATEMENT
#define CYG_REPORT_FUNCARG7( _format_, a,b,c,d,e,f,g ) CYG_EMPTY_STATEMENT
#define CYG_REPORT_FUNCARG8( _format_, a,b,c,d,e,f,g,h ) CYG_EMPTY_STATEMENT

#endif  // not CYGDBG_INFRA_DEBUG_TRACE_MESSAGE

#else   // no CYGDBG_INFRA_DEBUG_FUNCTION_REPORTS

#define CYG_REPORT_FUNCTION()                           CYG_EMPTY_STATEMENT
#define CYG_REPORT_FUNCTYPE( _exitmsg_ )                CYG_EMPTY_STATEMENT
#define CYG_REPORT_FUNCNAME( _name_ )                   CYG_EMPTY_STATEMENT
#define CYG_REPORT_FUNCNAMETYPE( _name_, _exitmsg_  )   CYG_EMPTY_STATEMENT

#define CYG_REPORT_FUNCTIONC()                          CYG_EMPTY_STATEMENT
#define CYG_REPORT_FUNCTYPEC( _exitmsg_ )               CYG_EMPTY_STATEMENT
#define CYG_REPORT_FUNCNAMEC( _name_ )                  CYG_EMPTY_STATEMENT
#define CYG_REPORT_FUNCNAMETYPEC( _name_, _exitmsg_  )  CYG_EMPTY_STATEMENT

#define CYG_REPORT_FUNCARGVOID() CYG_EMPTY_STATEMENT
#define CYG_REPORT_FUNCARG1( _format_, a ) CYG_EMPTY_STATEMENT
#define CYG_REPORT_FUNCARG2( _format_, a,b ) CYG_EMPTY_STATEMENT
#define CYG_REPORT_FUNCARG3( _format_, a,b,c ) CYG_EMPTY_STATEMENT
#define CYG_REPORT_FUNCARG4( _format_, a,b,c,d ) CYG_EMPTY_STATEMENT
#define CYG_REPORT_FUNCARG5( _format_, a,b,c,d,e ) CYG_EMPTY_STATEMENT
#define CYG_REPORT_FUNCARG6( _format_, a,b,c,d,e,f ) CYG_EMPTY_STATEMENT
#define CYG_REPORT_FUNCARG7( _format_, a,b,c,d,e,f,g ) CYG_EMPTY_STATEMENT
#define CYG_REPORT_FUNCARG8( _format_, a,b,c,d,e,f,g,h ) CYG_EMPTY_STATEMENT

#define CYG_REPORT_RETURN()                             CYG_EMPTY_STATEMENT
#define CYG_REPORT_RETVAL( _value_ )                    CYG_EMPTY_STATEMENT
    
#endif  // CYGDBG_INFRA_DEBUG_FUNCTION_REPORTS
    
#else   // ! CYGDBG_USE_TRACING

// -------------------------------------------------------------------------
// No traces: we define empty statements for trace macros.

#define CYG_TRACE0( _bool_, _msg_  ) CYG_EMPTY_STATEMENT
#define CYG_TRACE1( _bool_, _msg_, a ) CYG_EMPTY_STATEMENT
#define CYG_TRACE2( _bool_, _msg_, a,b ) CYG_EMPTY_STATEMENT
#define CYG_TRACE3( _bool_, _msg_, a,b,c ) CYG_EMPTY_STATEMENT
#define CYG_TRACE4( _bool_, _msg_, a,b,c,d ) CYG_EMPTY_STATEMENT
#define CYG_TRACE5( _bool_, _msg_, a,b,c,d,e ) CYG_EMPTY_STATEMENT
#define CYG_TRACE6( _bool_, _msg_, a,b,c,d,e,f ) CYG_EMPTY_STATEMENT
#define CYG_TRACE7( _bool_, _msg_, a,b,c,d,e,f,g ) CYG_EMPTY_STATEMENT
#define CYG_TRACE8( _bool_, _msg_, a,b,c,d,e,f,g,h ) CYG_EMPTY_STATEMENT

#define CYG_REPORT_FUNCTION()                           CYG_EMPTY_STATEMENT
#define CYG_REPORT_FUNCTYPE( _exitmsg_ )                CYG_EMPTY_STATEMENT
#define CYG_REPORT_FUNCNAME( _name_ )                   CYG_EMPTY_STATEMENT
#define CYG_REPORT_FUNCNAMETYPE( _name_, _exitmsg_  )   CYG_EMPTY_STATEMENT

#define CYG_REPORT_FUNCTIONC()                          CYG_EMPTY_STATEMENT
#define CYG_REPORT_FUNCTYPEC( _exitmsg_ )               CYG_EMPTY_STATEMENT
#define CYG_REPORT_FUNCNAMEC( _name_ )                  CYG_EMPTY_STATEMENT
#define CYG_REPORT_FUNCNAMETYPEC( _name_, _exitmsg_  )  CYG_EMPTY_STATEMENT

#define CYG_REPORT_FUNCARGVOID() CYG_EMPTY_STATEMENT
#define CYG_REPORT_FUNCARG1( _format_, a ) CYG_EMPTY_STATEMENT
#define CYG_REPORT_FUNCARG2( _format_, a,b ) CYG_EMPTY_STATEMENT
#define CYG_REPORT_FUNCARG3( _format_, a,b,c ) CYG_EMPTY_STATEMENT
#define CYG_REPORT_FUNCARG4( _format_, a,b,c,d ) CYG_EMPTY_STATEMENT
#define CYG_REPORT_FUNCARG5( _format_, a,b,c,d,e ) CYG_EMPTY_STATEMENT
#define CYG_REPORT_FUNCARG6( _format_, a,b,c,d,e,f ) CYG_EMPTY_STATEMENT
#define CYG_REPORT_FUNCARG7( _format_, a,b,c,d,e,f,g ) CYG_EMPTY_STATEMENT
#define CYG_REPORT_FUNCARG8( _format_, a,b,c,d,e,f,g,h ) CYG_EMPTY_STATEMENT

#define CYG_REPORT_RETURN()                             CYG_EMPTY_STATEMENT
#define CYG_REPORT_RETVAL( _value_ )                    CYG_EMPTY_STATEMENT

#define CYG_TRACE_PRINT() CYG_EMPTY_STATEMENT
#define CYG_TRACE_DUMP()  CYG_EMPTY_STATEMENT

#endif // ! CYGDBG_USE_TRACING

// -------------------------------------------------------------------------
//
// CYG_TRACEn{[XDY]{V}}{B}
//
// Convenience macros: these fall into a few dimensions, with suffix letters:
// First option:
//     X: user need not supply a format string, %08x is used
//     D: ditto but signed decimal, %d
//     Y: ditto but just plain %x
// Second option, only meaningful with one of XDY:
//     V: "<var> = %..." is used, by stringifying the argument
// Third option:
//     B: user need not supply a bool; the symbol CYG_TRACE_USER_BOOL is
//        used (which we do not define, user must do this)

#define CYG_TRACE0B( _msg_  ) \
        CYG_TRACE0( CYG_TRACE_USER_BOOL, _msg_  ) 
#define CYG_TRACE1B( _msg_, a ) \
        CYG_TRACE1( CYG_TRACE_USER_BOOL, _msg_, a ) 
#define CYG_TRACE2B( _msg_, a,b ) \
        CYG_TRACE2( CYG_TRACE_USER_BOOL, _msg_, a,b ) 
#define CYG_TRACE3B( _msg_, a,b,c ) \
        CYG_TRACE3( CYG_TRACE_USER_BOOL, _msg_, a,b,c ) 
#define CYG_TRACE4B( _msg_, a,b,c,d ) \
        CYG_TRACE4( CYG_TRACE_USER_BOOL, _msg_, a,b,c,d ) 
#define CYG_TRACE5B( _msg_, a,b,c,d,e ) \
        CYG_TRACE5( CYG_TRACE_USER_BOOL, _msg_, a,b,c,d,e ) 
#define CYG_TRACE6B( _msg_, a,b,c,d,e,f ) \
        CYG_TRACE6( CYG_TRACE_USER_BOOL, _msg_, a,b,c,d,e,f ) 
#define CYG_TRACE7B( _msg_, a,b,c,d,e,f,g ) \
        CYG_TRACE7( CYG_TRACE_USER_BOOL, _msg_, a,b,c,d,e,f,g ) 
#define CYG_TRACE8B( _msg_, a,b,c,d,e,f,g,h ) \
        CYG_TRACE8( CYG_TRACE_USER_BOOL, _msg_, a,b,c,d,e,f,g,h ) 

// long hex versions

#define CYG_TRACE1X( _bool_, a ) \
        CYG_TRACE1( _bool_, "%08x", a ) 
#define CYG_TRACE2X( _bool_, a,b ) \
        CYG_TRACE2( _bool_, "%08x %08x", a,b ) 
#define CYG_TRACE3X( _bool_, a,b,c ) \
        CYG_TRACE3( _bool_, "%08x %08x %08x", a,b,c ) 
#define CYG_TRACE4X( _bool_, a,b,c,d ) \
        CYG_TRACE4( _bool_, "%08x %08x %08x %08x", a,b,c,d ) 
#define CYG_TRACE5X( _bool_, a,b,c,d,e ) \
        CYG_TRACE5( _bool_, "%08x %08x %08x %08x %08x", a,b,c,d,e ) 
#define CYG_TRACE6X( _bool_, a,b,c,d,e,f ) \
        CYG_TRACE6( _bool_, "%08x %08x %08x %08x %08x %08x", \
                    a,b,c,d,e,f ) 
#define CYG_TRACE7X( _bool_, a,b,c,d,e,f,g ) \
        CYG_TRACE7( _bool_, "%08x %08x %08x %08x %08x %08x %08x", \
                    a,b,c,d,e,f,g ) 
#define CYG_TRACE8X( _bool_, a,b,c,d,e,f,g,h ) \
        CYG_TRACE8( _bool_, "%08x %08x %08x %08x %08x %08x %08x %08x", \
                    a,b,c,d,e,f,g,h )

#define CYG_TRACE1XV( _bool_, a ) \
        CYG_TRACE1( _bool_, # a "=%08x ", a ) 
#define CYG_TRACE2XV( _bool_, a,b ) \
        CYG_TRACE2( _bool_, \
                    # a "=%08x " # b "=%08x " , a,b )
#define CYG_TRACE3XV( _bool_, a,b,c ) \
        CYG_TRACE3( _bool_, \
                    # a "=%08x " # b "=%08x " # c "=%08x " , a,b,c )
#define CYG_TRACE4XV( _bool_, a,b,c,d ) \
        CYG_TRACE4( _bool_, \
                    # a "=%08x " # b "=%08x " # c "=%08x " # d "=%08x " \
                    , a,b,c,d )
#define CYG_TRACE5XV( _bool_, a,b,c,d,e ) \
        CYG_TRACE5( _bool_, \
                    # a "=%08x " # b "=%08x " # c "=%08x " # d "=%08x " \
                    # e "=%08x " \
                    , a,b,c,d,e )
#define CYG_TRACE6XV( _bool_, a,b,c,d,e,f ) \
        CYG_TRACE6( _bool_, \
                    # a "=%08x " # b "=%08x " # c "=%08x " # d "=%08x " \
                    # e "=%08x " # f "=%08x " \
                    , a,b,c,d,e,f ) 
#define CYG_TRACE7XV( _bool_, a,b,c,d,e,f,g ) \
        CYG_TRACE7( _bool_, \
                    # a "=%08x " # b "=%08x " # c "=%08x " # d "=%08x " \
                    # e "=%08x " # f "=%08x " # g "=%08x " \
                    , a,b,c,d,e,f,g ) 
#define CYG_TRACE8XV( _bool_, a,b,c,d,e,f,g,h ) \
        CYG_TRACE8( _bool_, \
                    # a "=%08x " # b "=%08x " # c "=%08x " # d "=%08x " \
                    # e "=%08x " # f "=%08x " # g "=%08x " # h "=%08x " \
                    , a,b,c,d,e,f,g,h )

#define CYG_TRACE1XB( a ) \
        CYG_TRACE1( CYG_TRACE_USER_BOOL, "%08x", a ) 
#define CYG_TRACE2XB( a,b ) \
        CYG_TRACE2( CYG_TRACE_USER_BOOL, "%08x %08x", a,b ) 
#define CYG_TRACE3XB( a,b,c ) \
        CYG_TRACE3( CYG_TRACE_USER_BOOL, "%08x %08x %08x", a,b,c ) 
#define CYG_TRACE4XB( a,b,c,d ) \
        CYG_TRACE4( CYG_TRACE_USER_BOOL, "%08x %08x %08x %08x", a,b,c,d ) 
#define CYG_TRACE5XB( a,b,c,d,e ) \
        CYG_TRACE5( CYG_TRACE_USER_BOOL, "%08x %08x %08x %08x %08x", a,b,c,d,e ) 
#define CYG_TRACE6XB( a,b,c,d,e,f ) \
        CYG_TRACE6( CYG_TRACE_USER_BOOL, "%08x %08x %08x %08x %08x %08x", \
                    a,b,c,d,e,f ) 
#define CYG_TRACE7XB( a,b,c,d,e,f,g ) \
        CYG_TRACE7( CYG_TRACE_USER_BOOL, "%08x %08x %08x %08x %08x %08x %08x", \
                    a,b,c,d,e,f,g ) 
#define CYG_TRACE8XB( a,b,c,d,e,f,g,h ) \
        CYG_TRACE8( CYG_TRACE_USER_BOOL, "%08x %08x %08x %08x %08x %08x %08x %08x", \
                    a,b,c,d,e,f,g,h )

#define CYG_TRACE1XVB( a ) \
        CYG_TRACE1( CYG_TRACE_USER_BOOL, # a "=%08x ", a ) 
#define CYG_TRACE2XVB( a,b ) \
        CYG_TRACE2( CYG_TRACE_USER_BOOL, \
                    # a "=%08x " # b "=%08x " , a,b )
#define CYG_TRACE3XVB( a,b,c ) \
        CYG_TRACE3( CYG_TRACE_USER_BOOL, \
                    # a "=%08x " # b "=%08x " # c "=%08x " , a,b,c )
#define CYG_TRACE4XVB( a,b,c,d ) \
        CYG_TRACE4( CYG_TRACE_USER_BOOL, \
                    # a "=%08x " # b "=%08x " # c "=%08x " # d "=%08x " \
                    , a,b,c,d )
#define CYG_TRACE5XVB( a,b,c,d,e ) \
        CYG_TRACE5( CYG_TRACE_USER_BOOL, \
                    # a "=%08x " # b "=%08x " # c "=%08x " # d "=%08x " \
                    # e "=%08x " \
                    , a,b,c,d,e )
#define CYG_TRACE6XVB( a,b,c,d,e,f ) \
        CYG_TRACE6( CYG_TRACE_USER_BOOL, \
                    # a "=%08x " # b "=%08x " # c "=%08x " # d "=%08x " \
                    # e "=%08x " # f "=%08x " \
                    , a,b,c,d,e,f ) 
#define CYG_TRACE7XVB( a,b,c,d,e,f,g ) \
        CYG_TRACE7( CYG_TRACE_USER_BOOL, \
                    # a "=%08x " # b "=%08x " # c "=%08x " # d "=%08x " \
                    # e "=%08x " # f "=%08x " # g "=%08x " \
                    , a,b,c,d,e,f,g ) 
#define CYG_TRACE8XVB( a,b,c,d,e,f,g,h ) \
        CYG_TRACE8( CYG_TRACE_USER_BOOL, \
                    # a "=%08x " # b "=%08x " # c "=%08x " # d "=%08x " \
                    # e "=%08x " # f "=%08x " # g "=%08x " # h "=%08x " \
                    , a,b,c,d,e,f,g,h )

// decimal versions

#define CYG_TRACE1D( _bool_, a ) \
        CYG_TRACE1( _bool_, "%d", a ) 
#define CYG_TRACE2D( _bool_, a,b ) \
        CYG_TRACE2( _bool_, "%d %d", a,b ) 
#define CYG_TRACE3D( _bool_, a,b,c ) \
        CYG_TRACE3( _bool_, "%d %d %d", a,b,c ) 
#define CYG_TRACE4D( _bool_, a,b,c,d ) \
        CYG_TRACE4( _bool_, "%d %d %d %d", a,b,c,d ) 
#define CYG_TRACE5D( _bool_, a,b,c,d,e ) \
        CYG_TRACE5( _bool_, "%d %d %d %d %d", a,b,c,d,e ) 
#define CYG_TRACE6D( _bool_, a,b,c,d,e,f ) \
        CYG_TRACE6( _bool_, "%d %d %d %d %d %d", \
                    a,b,c,d,e,f ) 
#define CYG_TRACE7D( _bool_, a,b,c,d,e,f,g ) \
        CYG_TRACE7( _bool_, "%d %d %d %d %d %d %d", \
                    a,b,c,d,e,f,g ) 
#define CYG_TRACE8D( _bool_, a,b,c,d,e,f,g,h ) \
        CYG_TRACE8( _bool_, "%d %d %d %d %d %d %d %d", \
                    a,b,c,d,e,f,g,h )

#define CYG_TRACE1DV( _bool_, a ) \
        CYG_TRACE1( _bool_, # a "=%d ", a ) 
#define CYG_TRACE2DV( _bool_, a,b ) \
        CYG_TRACE2( _bool_, \
                    # a "=%d " # b "=%d " , a,b )
#define CYG_TRACE3DV( _bool_, a,b,c ) \
        CYG_TRACE3( _bool_, \
                    # a "=%d " # b "=%d " # c "=%d " , a,b,c )
#define CYG_TRACE4DV( _bool_, a,b,c,d ) \
        CYG_TRACE4( _bool_, \
                    # a "=%d " # b "=%d " # c "=%d " # d "=%d " \
                    , a,b,c,d )
#define CYG_TRACE5DV( _bool_, a,b,c,d,e ) \
        CYG_TRACE5( _bool_, \
                    # a "=%d " # b "=%d " # c "=%d " # d "=%d " \
                    # e "=%d " \
                    , a,b,c,d,e )
#define CYG_TRACE6DV( _bool_, a,b,c,d,e,f ) \
        CYG_TRACE6( _bool_, \
                    # a "=%d " # b "=%d " # c "=%d " # d "=%d " \
                    # e "=%d " # f "=%d " \
                    , a,b,c,d,e,f ) 
#define CYG_TRACE7DV( _bool_, a,b,c,d,e,f,g ) \
        CYG_TRACE7( _bool_, \
                    # a "=%d " # b "=%d " # c "=%d " # d "=%d " \
                    # e "=%d " # f "=%d " # g "=%d " \
                    , a,b,c,d,e,f,g ) 
#define CYG_TRACE8DV( _bool_, a,b,c,d,e,f,g,h ) \
        CYG_TRACE8( _bool_, \
                    # a "=%d " # b "=%d " # c "=%d " # d "=%d " \
                    # e "=%d " # f "=%d " # g "=%d " # h "=%d " \
                    , a,b,c,d,e,f,g,h )

#define CYG_TRACE1DB( a ) \
        CYG_TRACE1( CYG_TRACE_USER_BOOL, "%d", a ) 
#define CYG_TRACE2DB( a,b ) \
        CYG_TRACE2( CYG_TRACE_USER_BOOL, "%d %d", a,b ) 
#define CYG_TRACE3DB( a,b,c ) \
        CYG_TRACE3( CYG_TRACE_USER_BOOL, "%d %d %d", a,b,c ) 
#define CYG_TRACE4DB( a,b,c,d ) \
        CYG_TRACE4( CYG_TRACE_USER_BOOL, "%d %d %d %d", a,b,c,d ) 
#define CYG_TRACE5DB( a,b,c,d,e ) \
        CYG_TRACE5( CYG_TRACE_USER_BOOL, "%d %d %d %d %d", a,b,c,d,e ) 
#define CYG_TRACE6DB( a,b,c,d,e,f ) \
        CYG_TRACE6( CYG_TRACE_USER_BOOL, "%d %d %d %d %d %d", \
                    a,b,c,d,e,f ) 
#define CYG_TRACE7DB( a,b,c,d,e,f,g ) \
        CYG_TRACE7( CYG_TRACE_USER_BOOL, "%d %d %d %d %d %d %d", \
                    a,b,c,d,e,f,g ) 
#define CYG_TRACE8DB( a,b,c,d,e,f,g,h ) \
        CYG_TRACE8( CYG_TRACE_USER_BOOL, "%d %d %d %d %d %d %d %d", \
                    a,b,c,d,e,f,g,h )

#define CYG_TRACE1DVB( a ) \
        CYG_TRACE1( CYG_TRACE_USER_BOOL, # a "=%d ", a ) 
#define CYG_TRACE2DVB( a,b ) \
        CYG_TRACE2( CYG_TRACE_USER_BOOL, \
                    # a "=%d " # b "=%d " , a,b )
#define CYG_TRACE3DVB( a,b,c ) \
        CYG_TRACE3( CYG_TRACE_USER_BOOL, \
                    # a "=%d " # b "=%d " # c "=%d " , a,b,c )
#define CYG_TRACE4DVB( a,b,c,d ) \
        CYG_TRACE4( CYG_TRACE_USER_BOOL, \
                    # a "=%d " # b "=%d " # c "=%d " # d "=%d " \
                    , a,b,c,d )
#define CYG_TRACE5DVB( a,b,c,d,e ) \
        CYG_TRACE5( CYG_TRACE_USER_BOOL, \
                    # a "=%d " # b "=%d " # c "=%d " # d "=%d " \
                    # e "=%d " \
                    , a,b,c,d,e )
#define CYG_TRACE6DVB( a,b,c,d,e,f ) \
        CYG_TRACE6( CYG_TRACE_USER_BOOL, \
                    # a "=%d " # b "=%d " # c "=%d " # d "=%d " \
                    # e "=%d " # f "=%d " \
                    , a,b,c,d,e,f ) 
#define CYG_TRACE7DVB( a,b,c,d,e,f,g ) \
        CYG_TRACE7( CYG_TRACE_USER_BOOL, \
                    # a "=%d " # b "=%d " # c "=%d " # d "=%d " \
                    # e "=%d " # f "=%d " # g "=%d " \
                    , a,b,c,d,e,f,g ) 
#define CYG_TRACE8DVB( a,b,c,d,e,f,g,h ) \
        CYG_TRACE8( CYG_TRACE_USER_BOOL, \
                    # a "=%d " # b "=%d " # c "=%d " # d "=%d " \
                    # e "=%d " # f "=%d " # g "=%d " # h "=%d " \
                    , a,b,c,d,e,f,g,h )

// short hex versions

#define CYG_TRACE1Y( _bool_, a ) \
        CYG_TRACE1( _bool_, "%x", a ) 
#define CYG_TRACE2Y( _bool_, a,b ) \
        CYG_TRACE2( _bool_, "%x %x", a,b ) 
#define CYG_TRACE3Y( _bool_, a,b,c ) \
        CYG_TRACE3( _bool_, "%x %x %x", a,b,c ) 
#define CYG_TRACE4Y( _bool_, a,b,c,d ) \
        CYG_TRACE4( _bool_, "%x %x %x %x", a,b,c,d ) 
#define CYG_TRACE5Y( _bool_, a,b,c,d,e ) \
        CYG_TRACE5( _bool_, "%x %x %x %x %x", a,b,c,d,e ) 
#define CYG_TRACE6Y( _bool_, a,b,c,d,e,f ) \
        CYG_TRACE6( _bool_, "%x %x %x %x %x %x", \
                    a,b,c,d,e,f ) 
#define CYG_TRACE7Y( _bool_, a,b,c,d,e,f,g ) \
        CYG_TRACE7( _bool_, "%x %x %x %x %x %x %x", \
                    a,b,c,d,e,f,g ) 
#define CYG_TRACE8Y( _bool_, a,b,c,d,e,f,g,h ) \
        CYG_TRACE8( _bool_, "%x %x %x %x %x %x %x %x", \
                    a,b,c,d,e,f,g,h )

#define CYG_TRACE1YV( _bool_, a ) \
        CYG_TRACE1( _bool_, # a "=%x ", a ) 
#define CYG_TRACE2YV( _bool_, a,b ) \
        CYG_TRACE2( _bool_, \
                    # a "=%x " # b "=%x " , a,b )
#define CYG_TRACE3YV( _bool_, a,b,c ) \
        CYG_TRACE3( _bool_, \
                    # a "=%x " # b "=%x " # c "=%x " , a,b,c )
#define CYG_TRACE4YV( _bool_, a,b,c,d ) \
        CYG_TRACE4( _bool_, \
                    # a "=%x " # b "=%x " # c "=%x " # d "=%x " \
                    , a,b,c,d )
#define CYG_TRACE5YV( _bool_, a,b,c,d,e ) \
        CYG_TRACE5( _bool_, \
                    # a "=%x " # b "=%x " # c "=%x " # d "=%x " \
                    # e "=%x " \
                    , a,b,c,d,e )
#define CYG_TRACE6YV( _bool_, a,b,c,d,e,f ) \
        CYG_TRACE6( _bool_, \
                    # a "=%x " # b "=%x " # c "=%x " # d "=%x " \
                    # e "=%x " # f "=%x " \
                    , a,b,c,d,e,f ) 
#define CYG_TRACE7YV( _bool_, a,b,c,d,e,f,g ) \
        CYG_TRACE7( _bool_, \
                    # a "=%x " # b "=%x " # c "=%x " # d "=%x " \
                    # e "=%x " # f "=%x " # g "=%x " \
                    , a,b,c,d,e,f,g ) 
#define CYG_TRACE8YV( _bool_, a,b,c,d,e,f,g,h ) \
        CYG_TRACE8( _bool_, \
                    # a "=%x " # b "=%x " # c "=%x " # d "=%x " \
                    # e "=%x " # f "=%x " # g "=%x " # h "=%x " \
                    , a,b,c,d,e,f,g,h )

#define CYG_TRACE1YB( a ) \
        CYG_TRACE1( CYG_TRACE_USER_BOOL, "%x", a ) 
#define CYG_TRACE2YB( a,b ) \
        CYG_TRACE2( CYG_TRACE_USER_BOOL, "%x %x", a,b ) 
#define CYG_TRACE3YB( a,b,c ) \
        CYG_TRACE3( CYG_TRACE_USER_BOOL, "%x %x %x", a,b,c ) 
#define CYG_TRACE4YB( a,b,c,d ) \
        CYG_TRACE4( CYG_TRACE_USER_BOOL, "%x %x %x %x", a,b,c,d ) 
#define CYG_TRACE5YB( a,b,c,d,e ) \
        CYG_TRACE5( CYG_TRACE_USER_BOOL, "%x %x %x %x %x", a,b,c,d,e ) 
#define CYG_TRACE6YB( a,b,c,d,e,f ) \
        CYG_TRACE6( CYG_TRACE_USER_BOOL, "%x %x %x %x %x %x", \
                    a,b,c,d,e,f ) 
#define CYG_TRACE7YB( a,b,c,d,e,f,g ) \
        CYG_TRACE7( CYG_TRACE_USER_BOOL, "%x %x %x %x %x %x %x", \
                    a,b,c,d,e,f,g ) 
#define CYG_TRACE8YB( a,b,c,d,e,f,g,h ) \
        CYG_TRACE8( CYG_TRACE_USER_BOOL, "%x %x %x %x %x %x %x %x", \
                    a,b,c,d,e,f,g,h )

#define CYG_TRACE1YVB( a ) \
        CYG_TRACE1( CYG_TRACE_USER_BOOL, # a "=%x ", a ) 
#define CYG_TRACE2YVB( a,b ) \
        CYG_TRACE2( CYG_TRACE_USER_BOOL, \
                    # a "=%x " # b "=%x " , a,b )
#define CYG_TRACE3YVB( a,b,c ) \
        CYG_TRACE3( CYG_TRACE_USER_BOOL, \
                    # a "=%x " # b "=%x " # c "=%x " , a,b,c )
#define CYG_TRACE4YVB( a,b,c,d ) \
        CYG_TRACE4( CYG_TRACE_USER_BOOL, \
                    # a "=%x " # b "=%x " # c "=%x " # d "=%x " \
                    , a,b,c,d )
#define CYG_TRACE5YVB( a,b,c,d,e ) \
        CYG_TRACE5( CYG_TRACE_USER_BOOL, \
                    # a "=%x " # b "=%x " # c "=%x " # d "=%x " \
                    # e "=%x " \
                    , a,b,c,d,e )
#define CYG_TRACE6YVB( a,b,c,d,e,f ) \
        CYG_TRACE6( CYG_TRACE_USER_BOOL, \
                    # a "=%x " # b "=%x " # c "=%x " # d "=%x " \
                    # e "=%x " # f "=%x " \
                    , a,b,c,d,e,f ) 
#define CYG_TRACE7YVB( a,b,c,d,e,f,g ) \
        CYG_TRACE7( CYG_TRACE_USER_BOOL, \
                    # a "=%x " # b "=%x " # c "=%x " # d "=%x " \
                    # e "=%x " # f "=%x " # g "=%x " \
                    , a,b,c,d,e,f,g ) 
#define CYG_TRACE8YVB( a,b,c,d,e,f,g,h ) \
        CYG_TRACE8( CYG_TRACE_USER_BOOL, \
                    # a "=%x " # b "=%x " # c "=%x " # d "=%x " \
                    # e "=%x " # f "=%x " # g "=%x " # h "=%x " \
                    , a,b,c,d,e,f,g,h )

// -------------------------------------------------------------------------
//
// CYG_REPORT_FUNCARGn{[XDY]{V}}
//
// Convenience macros two: these fall into a few dimensions, with suffix letters:
// First option:
//     X: user need not supply a format string, %08x is used
//     D: ditto but signed decimal, %d
//     Y: ditto but just plain %x
// Second option, only meaningful with one of XDY:
//     V: "<var> = %..." is used, by stringifying the argument

// long hex versions

#define CYG_REPORT_FUNCARG1X( a ) \
        CYG_REPORT_FUNCARG1( "%08x", a ) 
#define CYG_REPORT_FUNCARG2X( a,b ) \
        CYG_REPORT_FUNCARG2( "%08x %08x", a,b ) 
#define CYG_REPORT_FUNCARG3X( a,b,c ) \
        CYG_REPORT_FUNCARG3( "%08x %08x %08x", a,b,c ) 
#define CYG_REPORT_FUNCARG4X( a,b,c,d ) \
        CYG_REPORT_FUNCARG4( "%08x %08x %08x %08x", a,b,c,d ) 
#define CYG_REPORT_FUNCARG5X( a,b,c,d,e ) \
        CYG_REPORT_FUNCARG5( "%08x %08x %08x %08x %08x", a,b,c,d,e ) 
#define CYG_REPORT_FUNCARG6X( a,b,c,d,e,f ) \
        CYG_REPORT_FUNCARG6( "%08x %08x %08x %08x %08x %08x", \
                    a,b,c,d,e,f ) 
#define CYG_REPORT_FUNCARG7X( a,b,c,d,e,f,g ) \
        CYG_REPORT_FUNCARG7( "%08x %08x %08x %08x %08x %08x %08x", \
                    a,b,c,d,e,f,g ) 
#define CYG_REPORT_FUNCARG8X( a,b,c,d,e,f,g,h ) \
        CYG_REPORT_FUNCARG8( "%08x %08x %08x %08x %08x %08x %08x %08x", \
                    a,b,c,d,e,f,g,h )

#define CYG_REPORT_FUNCARG1XV( a ) \
        CYG_REPORT_FUNCARG1( # a "=%08x ", a ) 
#define CYG_REPORT_FUNCARG2XV( a,b ) \
        CYG_REPORT_FUNCARG2( \
                    # a "=%08x " # b "=%08x " , a,b )
#define CYG_REPORT_FUNCARG3XV( a,b,c ) \
        CYG_REPORT_FUNCARG3( \
                    # a "=%08x " # b "=%08x " # c "=%08x " , a,b,c )
#define CYG_REPORT_FUNCARG4XV( a,b,c,d ) \
        CYG_REPORT_FUNCARG4( \
                    # a "=%08x " # b "=%08x " # c "=%08x " # d "=%08x " \
                    , a,b,c,d )
#define CYG_REPORT_FUNCARG5XV( a,b,c,d,e ) \
        CYG_REPORT_FUNCARG5( \
                    # a "=%08x " # b "=%08x " # c "=%08x " # d "=%08x " \
                    # e "=%08x " \
                    , a,b,c,d,e )
#define CYG_REPORT_FUNCARG6XV( a,b,c,d,e,f ) \
        CYG_REPORT_FUNCARG6( \
                    # a "=%08x " # b "=%08x " # c "=%08x " # d "=%08x " \
                    # e "=%08x " # f "=%08x " \
                    , a,b,c,d,e,f ) 
#define CYG_REPORT_FUNCARG7XV( a,b,c,d,e,f,g ) \
        CYG_REPORT_FUNCARG7( \
                    # a "=%08x " # b "=%08x " # c "=%08x " # d "=%08x " \
                    # e "=%08x " # f "=%08x " # g "=%08x " \
                    , a,b,c,d,e,f,g ) 
#define CYG_REPORT_FUNCARG8XV( a,b,c,d,e,f,g,h ) \
        CYG_REPORT_FUNCARG8( \
                    # a "=%08x " # b "=%08x " # c "=%08x " # d "=%08x " \
                    # e "=%08x " # f "=%08x " # g "=%08x " # h "=%08x " \
                    , a,b,c,d,e,f,g,h )

// decimal versions


#define CYG_REPORT_FUNCARG1D( a ) \
        CYG_REPORT_FUNCARG1( "%d", a ) 
#define CYG_REPORT_FUNCARG2D( a,b ) \
        CYG_REPORT_FUNCARG2( "%d %d", a,b ) 
#define CYG_REPORT_FUNCARG3D( a,b,c ) \
        CYG_REPORT_FUNCARG3( "%d %d %d", a,b,c ) 
#define CYG_REPORT_FUNCARG4D( a,b,c,d ) \
        CYG_REPORT_FUNCARG4( "%d %d %d %d", a,b,c,d ) 
#define CYG_REPORT_FUNCARG5D( a,b,c,d,e ) \
        CYG_REPORT_FUNCARG5( "%d %d %d %d %d", a,b,c,d,e ) 
#define CYG_REPORT_FUNCARG6D( a,b,c,d,e,f ) \
        CYG_REPORT_FUNCARG6( "%d %d %d %d %d %d", \
                    a,b,c,d,e,f ) 
#define CYG_REPORT_FUNCARG7D( a,b,c,d,e,f,g ) \
        CYG_REPORT_FUNCARG7( "%d %d %d %d %d %d %d", \
                    a,b,c,d,e,f,g ) 
#define CYG_REPORT_FUNCARG8D( a,b,c,d,e,f,g,h ) \
        CYG_REPORT_FUNCARG8( "%d %d %d %d %d %d %d %d", \
                    a,b,c,d,e,f,g,h )

#define CYG_REPORT_FUNCARG1DV( a ) \
        CYG_REPORT_FUNCARG1( # a "=%d ", a ) 
#define CYG_REPORT_FUNCARG2DV( a,b ) \
        CYG_REPORT_FUNCARG2( \
                    # a "=%d " # b "=%d " , a,b )
#define CYG_REPORT_FUNCARG3DV( a,b,c ) \
        CYG_REPORT_FUNCARG3( \
                    # a "=%d " # b "=%d " # c "=%d " , a,b,c )
#define CYG_REPORT_FUNCARG4DV( a,b,c,d ) \
        CYG_REPORT_FUNCARG4( \
                    # a "=%d " # b "=%d " # c "=%d " # d "=%d " \
                    , a,b,c,d )
#define CYG_REPORT_FUNCARG5DV( a,b,c,d,e ) \
        CYG_REPORT_FUNCARG5( \
                    # a "=%d " # b "=%d " # c "=%d " # d "=%d " \
                    # e "=%d " \
                    , a,b,c,d,e )
#define CYG_REPORT_FUNCARG6DV( a,b,c,d,e,f ) \
        CYG_REPORT_FUNCARG6( \
                    # a "=%d " # b "=%d " # c "=%d " # d "=%d " \
                    # e "=%d " # f "=%d " \
                    , a,b,c,d,e,f ) 
#define CYG_REPORT_FUNCARG7DV( a,b,c,d,e,f,g ) \
        CYG_REPORT_FUNCARG7( \
                    # a "=%d " # b "=%d " # c "=%d " # d "=%d " \
                    # e "=%d " # f "=%d " # g "=%d " \
                    , a,b,c,d,e,f,g ) 
#define CYG_REPORT_FUNCARG8DV( a,b,c,d,e,f,g,h ) \
        CYG_REPORT_FUNCARG8( \
                    # a "=%d " # b "=%d " # c "=%d " # d "=%d " \
                    # e "=%d " # f "=%d " # g "=%d " # h "=%d " \
                    , a,b,c,d,e,f,g,h )

// short hex versions

#define CYG_REPORT_FUNCARG1Y( a ) \
        CYG_REPORT_FUNCARG1( "%x", a ) 
#define CYG_REPORT_FUNCARG2Y( a,b ) \
        CYG_REPORT_FUNCARG2( "%x %x", a,b ) 
#define CYG_REPORT_FUNCARG3Y( a,b,c ) \
        CYG_REPORT_FUNCARG3( "%x %x %x", a,b,c ) 
#define CYG_REPORT_FUNCARG4Y( a,b,c,d ) \
        CYG_REPORT_FUNCARG4( "%x %x %x %x", a,b,c,d ) 
#define CYG_REPORT_FUNCARG5Y( a,b,c,d,e ) \
        CYG_REPORT_FUNCARG5( "%x %x %x %x %x", a,b,c,d,e ) 
#define CYG_REPORT_FUNCARG6Y( a,b,c,d,e,f ) \
        CYG_REPORT_FUNCARG6( "%x %x %x %x %x %x", \
                    a,b,c,d,e,f ) 
#define CYG_REPORT_FUNCARG7Y( a,b,c,d,e,f,g ) \
        CYG_REPORT_FUNCARG7( "%x %x %x %x %x %x %x", \
                    a,b,c,d,e,f,g ) 
#define CYG_REPORT_FUNCARG8Y( a,b,c,d,e,f,g,h ) \
        CYG_REPORT_FUNCARG8( "%x %x %x %x %x %x %x %x", \
                    a,b,c,d,e,f,g,h )

#define CYG_REPORT_FUNCARG1YV( a ) \
        CYG_REPORT_FUNCARG1( # a "=%x ", a ) 
#define CYG_REPORT_FUNCARG2YV( a,b ) \
        CYG_REPORT_FUNCARG2( \
                    # a "=%x " # b "=%x " , a,b )
#define CYG_REPORT_FUNCARG3YV( a,b,c ) \
        CYG_REPORT_FUNCARG3( \
                    # a "=%x " # b "=%x " # c "=%x " , a,b,c )
#define CYG_REPORT_FUNCARG4YV( a,b,c,d ) \
        CYG_REPORT_FUNCARG4( \
                    # a "=%x " # b "=%x " # c "=%x " # d "=%x " \
                    , a,b,c,d )
#define CYG_REPORT_FUNCARG5YV( a,b,c,d,e ) \
        CYG_REPORT_FUNCARG5( \
                    # a "=%x " # b "=%x " # c "=%x " # d "=%x " \
                    # e "=%x " \
                    , a,b,c,d,e )
#define CYG_REPORT_FUNCARG6YV( a,b,c,d,e,f ) \
        CYG_REPORT_FUNCARG6( \
                    # a "=%x " # b "=%x " # c "=%x " # d "=%x " \
                    # e "=%x " # f "=%x " \
                    , a,b,c,d,e,f ) 
#define CYG_REPORT_FUNCARG7YV( a,b,c,d,e,f,g ) \
        CYG_REPORT_FUNCARG7( \
                    # a "=%x " # b "=%x " # c "=%x " # d "=%x " \
                    # e "=%x " # f "=%x " # g "=%x " \
                    , a,b,c,d,e,f,g ) 
#define CYG_REPORT_FUNCARG8YV( a,b,c,d,e,f,g,h ) \
        CYG_REPORT_FUNCARG8( \
                    # a "=%x " # b "=%x " # c "=%x " # d "=%x " \
                    # e "=%x " # f "=%x " # g "=%x " # h "=%x " \
                    , a,b,c,d,e,f,g,h )


#endif // CYGONCE_INFRA_CYG_TRAC_H multiple inclusion protection
// EOF cyg_trac.h