Added the OS files

7 files changed, 3594 insertions, 0 deletions

diff --git a/ecos/packages/infra/current/include/clist.hxx b/ecos/packages/infra/current/include/clist.hxx
new file mode 100644
index 0000000..d90428d
--- /dev/null
+++ b/ecos/packages/infra/current/include/clist.hxx
@@ -0,0 +1,364 @@
+#ifndef CYGONCE_INFRA_CLIST_HXX
+#define CYGONCE_INFRA_CLIST_HXX
+
+//==========================================================================
+//
+//      clist.hxx
+//
+//      Standard types, and some useful coding macros.
+//
+//==========================================================================
+// ####ECOSGPLCOPYRIGHTBEGIN####                                            
+// -------------------------------------------                              
+// This file is part of eCos, the Embedded Configurable Operating System.   
+// Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+//
+// eCos 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 or (at your option) any later      
+// version.                                                                 
+//
+// eCos 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 eCos; if not, write to the Free Software Foundation, Inc.,    
+// 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.            
+//
+// As a special exception, if other files instantiate templates or use      
+// macros or inline functions from this file, or you compile this file      
+// and link it with other works to produce a work based on this file,       
+// this file does not by itself cause the resulting work to be covered by   
+// the GNU General Public License. However the source code for this file    
+// must still be made available in accordance with section (3) of the GNU   
+// General Public License v2.                                               
+//
+// This exception does not invalidate any other reasons why a work based    
+// on this file might be covered by the GNU General Public License.         
+// -------------------------------------------                              
+// ####ECOSGPLCOPYRIGHTEND####                                              
+//==========================================================================
+//#####DESCRIPTIONBEGIN####
+//
+// Author(s):     nickg
+// Contributors:  nickg
+// Date:        2000-11-08
+// Purpose:     Simple circular list implementation
+// Description: A simple implementation of circular lists.
+// Usage:       #include "cyg/infra/clist.hxx"
+//              ...
+//              
+//####DESCRIPTIONEND####
+//
+//==========================================================================
+
+#include <cyg/infra/cyg_type.h>
+
+// -------------------------------------------------------------------------
+// Class and structure conversion macros.
+// CYG_CLASSFROMFIELD translates a pointer to a field of a struct or
+// class into a pointer to the class.
+// CYG_OFFSETOFBASE yields the offset of a base class of a derived
+// class.
+// CYG_CLASSFROMBASE translates a pointer to a base class into a pointer
+// to a selected derived class. The base class object _must_ be part of
+// the specified derived class. This is essentially a poor mans version
+// of the RTTI dynamic_cast operator.
+// Caveat: These macros do not work for virtual base classes.
+
+// Note: These definitions are exact duplicates of definitions in
+// ktypes.h. If either definition is changed, the other should be too
+// to avoid compiler messages.
+
+#define CYG_CLASSFROMFIELD(_type_,_member_,_ptr_)\
+    ((_type_ *)((char *)(_ptr_)-((char *)&(((_type_ *)0)->_member_))))
+
+#define CYG_OFFSETOFBASE(_type_,_base_)\
+    ((char *)((_base_ *)((_type_ *)4)) - (char *)4)
+
+# define CYG_CLASSFROMBASE(_class_,_base_,_ptr_)\
+    ((_class_ *)((char *)(_ptr_) - CYG_OFFSETOFBASE(_class_,_base_)))
+
+
+// -------------------------------------------------------------------------
+// Cyg_DNode class.
+// This simply represents a double linked node that is intended to
+// be a base member of the class that is being managed.
+
+class Cyg_DNode
+{
+    friend class Cyg_CList;
+    
+    Cyg_DNode   *next;
+    Cyg_DNode   *prev;
+
+public:
+
+    Cyg_DNode()
+    {
+        // Initialize pointers to point here
+        next = prev = this;
+    };
+
+    // Accessor and test functions
+    Cyg_DNode *get_next() { return next; };
+    Cyg_DNode *get_prev() { return prev; };
+    cyg_bool  in_list() { return next != this; };
+    
+    // Insert a node into the list before this one,
+    // so that it becomes this nodes predecessor in
+    // the list.
+    void insert( Cyg_DNode *node )
+    {
+        node->next = this;
+        node->prev = prev;
+        prev->next = node;
+        prev = node;
+    };
+
+    // Append a node after this one so that it become
+    // this nodes sucessor in the list.
+    void append( Cyg_DNode *node )
+    {
+        node->prev = this;
+        node->next = next;
+        next->prev = node;
+        next = node;
+    };
+
+    // Unlink this node from it's list. It is safe to apply this to an
+    // already unlinked node.
+    void unlink()
+    {
+        next->prev = prev;
+        prev->next = next;
+        next = prev = this;
+    };
+    
+    ~Cyg_DNode()
+    {
+        // If this node is still linked, unlink it.
+        if( next != this )
+            unlink();
+    };
+    
+};
+
+// -------------------------------------------------------------------------
+// Cyg_CList class.
+
+// This is a simple class that manages a circular list of DNodes. This
+// object points to the head of the list and provides functions to
+// manipulate the head and tail of the list.
+
+class Cyg_CList
+{
+    Cyg_DNode   *head;                  // list head pointer
+
+public:
+
+    Cyg_CList()
+    {
+        head = NULL;
+    };
+
+    // Accessor and test functions
+    Cyg_DNode *get_head() { return head; };
+    Cyg_DNode *get_tail() { return head?head->prev:NULL; };
+    cyg_bool empty() { return head == NULL; };
+    
+    // Add a node at the head of the list
+    void add_head( Cyg_DNode *node )
+    {
+        if( head == NULL )
+            head = node;
+        else
+        {
+            head->insert( node );
+            head = node;
+        }
+    };
+
+    // Remove the node at the head of the list
+    Cyg_DNode *rem_head()
+    {
+        Cyg_DNode *node = head;
+        if( node != NULL )
+        {
+            // There is a node available
+            Cyg_DNode *next = node->next;
+            if( next == node )
+            {
+                // Only node on list
+                head = NULL;
+            }
+            else
+            {
+                // remove head node and move head to next.
+                node->unlink();
+                head = next;
+            }
+        }
+        return node;
+    };
+
+
+    // Add a node at the tail of the list
+    void add_tail( Cyg_DNode *node )
+    {
+        if( head == NULL )
+            head = node;
+        else
+            head->insert( node );
+    };
+
+    // Remove the node at the tail of the list
+    Cyg_DNode *rem_tail()
+    {
+        if( head == NULL )
+            return NULL;
+
+        Cyg_DNode *node = head->prev;
+
+        if( node == head )
+            head = NULL;
+        else node->unlink();
+        
+        return node;
+    };
+
+    // Merge the supplied list into this one, at the tail.
+    void merge( Cyg_CList& list )
+    {
+        if( list.head == NULL )
+            return;                     // Nothing to do
+        else if( head == NULL )
+            head = list.head;           // this is empty, just move it
+        else
+        {
+            // We have a real merge to do. Adjust the pointers
+            // on the two lists so that they become one.
+
+            Cyg_DNode *lh = list.head;
+            Cyg_DNode *lt = lh->prev;
+            Cyg_DNode *tail = head->prev;
+
+            head->prev = lt;
+            lt->next = head;
+            tail->next = lh;
+            lh->prev = tail;
+        }
+        list.head = NULL;
+    };
+    
+    // General removal. Deals with what happend if this is only
+    // object on list, or is the head.
+    void remove( Cyg_DNode *node )
+    {
+        if( node == head )
+            rem_head();
+        else node->unlink();
+    };
+
+    // Rotation - move the head to the next node in the list.
+    void rotate()
+    {
+        if( head )
+            head = head->next;
+    };
+
+    // Move a node to the head of the list. Assumes that the
+    // node is in this list.
+    void to_head( Cyg_DNode *node )
+    {
+        head = node;
+    };
+
+    // Insert a node before one in this list, and deal with what
+    // happens if the node happens to be at the head of the list.
+    void insert( Cyg_DNode *list_node, Cyg_DNode *node )
+    {
+        if( list_node == head )
+        {
+            head->insert( node );
+            head = node;
+        }
+        else list_node->insert( node );
+    };
+    
+    ~Cyg_CList()
+    {
+        while( head != NULL )
+            rem_head();
+    };
+
+};
+
+// -------------------------------------------------------------------------
+// Cyg_CList_T
+// Template class that allows us to make use of the CList class in a
+// type-specific way.
+
+template <class T> class Cyg_CList_T
+    : public Cyg_CList
+{
+public:
+
+    Cyg_CList_T() {};
+    ~Cyg_CList_T() {};
+
+    T *get_head()
+    {
+        Cyg_DNode *node = Cyg_CList::get_head();
+        if( node ) return CYG_CLASSFROMBASE( T, Cyg_DNode, node );
+        return NULL;
+    };
+    T *get_tail()
+    {
+        Cyg_DNode *node = Cyg_CList::get_tail();
+        if( node ) return CYG_CLASSFROMBASE( T, Cyg_DNode, node );
+        return NULL;
+    };
+    
+    T *rem_head()
+    {
+        Cyg_DNode *node = Cyg_CList::rem_head();
+        if( node ) return CYG_CLASSFROMBASE( T, Cyg_DNode, node );
+        return NULL;
+    };
+
+    T *rem_tail()
+    {
+        Cyg_DNode *node = Cyg_CList::rem_tail();
+        if( node ) return CYG_CLASSFROMBASE( T, Cyg_DNode, node );
+        return NULL;
+    };
+
+    // The rest just default to the Cyg_CList class operations.
+};
+
+// -------------------------------------------------------------------------
+// Cyg_DNode_T
+// Template class that allows us to make use of the DNode class in a
+// type-specific way.
+
+template <class T> class Cyg_DNode_T
+    : public Cyg_DNode
+{
+public:
+
+    Cyg_DNode_T() {};
+    ~Cyg_DNode_T() {};
+
+    T *get_next() { return CYG_CLASSFROMBASE( T, Cyg_DNode, Cyg_DNode::get_next() ); };
+    T *get_prev() { return CYG_CLASSFROMBASE( T, Cyg_DNode, Cyg_DNode::get_prev() ); };
+
+    // The rest just default to the Cyg_DNode class operations.
+};
+
+// -------------------------------------------------------------------------
+#endif // CYGONCE_INFRA_CLIST_HXX multiple inclusion protection
+// EOF clist.hxx
+
diff --git a/ecos/packages/infra/current/include/cyg_ass.h b/ecos/packages/infra/current/include/cyg_ass.h
new file mode 100644
index 0000000..3517b21
--- /dev/null
+++ b/ecos/packages/infra/current/include/cyg_ass.h
@@ -0,0 +1,616 @@
+#ifndef CYGONCE_INFRA_CYG_ASS_H
+#define CYGONCE_INFRA_CYG_ASS_H
+
+//==========================================================================
+//
+//      assert.h
+//
+//      Macros and prototypes for the assert system
+//
+//==========================================================================
+// ####ECOSGPLCOPYRIGHTBEGIN####                                            
+// -------------------------------------------                              
+// This file is part of eCos, the Embedded Configurable Operating System.   
+// Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+//
+// eCos 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 or (at your option) any later      
+// version.                                                                 
+//
+// eCos 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 eCos; if not, write to the Free Software Foundation, Inc.,    
+// 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.            
+//
+// As a special exception, if other files instantiate templates or use      
+// macros or inline functions from this file, or you compile this file      
+// and link it with other works to produce a work based on this file,       
+// this file does not by itself cause the resulting work to be covered by   
+// the GNU General Public License. However the source code for this file    
+// must still be made available in accordance with section (3) of the GNU   
+// General Public License v2.                                               
+//
+// This exception does not invalidate any other reasons why a work based    
+// on this file might be covered by the GNU General Public License.         
+// -------------------------------------------                              
+// ####ECOSGPLCOPYRIGHTEND####                                              
+//==========================================================================
+//#####DESCRIPTIONBEGIN####
+//
+// Author(s):   nickg from an original by hmt
+// Contributors:        nickg
+// Date:        1997-09-08
+// Purpose:     Use asserts to avoid writing duff code.
+// Description: Runtime tests that compile to nothing in
+//              release versions of the code, to allow
+//              as-you-go testing of alternate builds.
+// Usage:       #include <cyg/infra/cyg_ass.h>
+//              ...
+//              CYG_ASSERT( pcount > 0, "Number of probes should be > 0!" );
+//
+//      which can result, for example, in a message of the form:
+//      ASSERT FAILED: probemgr.cxx:1340, scan_probes() :
+//                     number of probes should be > 0!
+//      if the boolean "pcount > 0" is false.
+//
+//####DESCRIPTIONEND####
+//
+//==========================================================================
+
+#include <pkgconf/infra.h>
+
+#include <cyg/infra/cyg_type.h>         // for CYGBLD_ATTRIB_NORET
+
+// -------------------------------------------------------------------------
+// If we do not have a function name macro, define it ourselves
+
+#ifndef CYGDBG_INFRA_DEBUG_FUNCTION_PSEUDOMACRO
+                                        // __PRETTY_FUNCTION__ does not work
+# ifndef __PRETTY_FUNCTION__            // And it is not already defined
+#  define __PRETTY_FUNCTION__ NULL
+# endif
+#endif
+
+// -------------------------------------------------------------------------
+// This is executed to deal with failure - breakpoint it first!
+// It is declared as a weak symbol to allow user code to override the
+// definition.
+
+externC void
+cyg_assert_fail( const char* /* psz_func */, const char* /* psz_file */,
+                 cyg_uint32 /* linenum */, const char* /* psz_msg */ )  __THROW
+    CYGBLD_ATTRIB_NORET CYGBLD_ATTRIB_WEAK;
+
+externC void
+cyg_assert_msg( const char *psz_func, const char *psz_file,
+                cyg_uint32 linenum, const char *psz_msg ) __THROW;
+
+// -------------------------------------------------------------------------
+
+#ifdef CYGDBG_USE_ASSERTS
+
+// -------------------------------------------------------------------------
+// We define macros and appropriate prototypes for the assert/fail
+// system.  These are:
+//      CYG_FAIL        - unconditional panic
+//      CYG_ASSERT      - panic if boolean expression is false
+//      CYG_ASSERTC     - compact version of CYG_ASSERT
+
+# ifdef CYGDBG_INFRA_DEBUG_ASSERT_MESSAGE
+#  define CYG_ASSERT_DOCALL( _msg_ )                                      \
+        CYG_MACRO_START                                                   \
+        /* Make sure we always get a pretty-printed message */            \
+        cyg_assert_msg( __PRETTY_FUNCTION__, __FILE__, __LINE__, _msg_ ); \
+        cyg_assert_fail( __PRETTY_FUNCTION__, __FILE__, __LINE__, _msg_ );\
+        CYG_MACRO_END
+# else
+#   define CYG_ASSERT_DOCALL( _msg_ )    \
+        CYG_MACRO_START                 \
+        const char* _tmp1_ = _msg_;     \
+        _tmp1_ = _tmp1_;                \
+        cyg_assert_fail( __PRETTY_FUNCTION__, __FILE__, __LINE__, NULL ); \
+        CYG_MACRO_END
+# endif
+
+// unconditional failure; use like panic(), coredump() &c.
+# define CYG_FAIL( _msg_ )              \
+        CYG_MACRO_START                 \
+        CYG_ASSERT_DOCALL( _msg_ );      \
+        CYG_MACRO_END
+
+// conditioned assert; if the condition is false, fail.
+# define CYG_ASSERT( _bool_, _msg_ )    \
+        CYG_MACRO_START                 \
+        if ( ! ( _bool_ ) )             \
+            CYG_ASSERT_DOCALL( _msg_ );  \
+        CYG_MACRO_END
+
+# define CYG_ASSERTC( _bool_ )          \
+       CYG_MACRO_START                  \
+       if ( ! ( _bool_ ) )              \
+           CYG_ASSERT_DOCALL( #_bool_ );\
+       CYG_MACRO_END
+
+#else // ! CYGDBG_USE_ASSERTS
+
+// -------------------------------------------------------------------------
+// No asserts: we define empty statements for assert & fail.
+
+# define CYG_FAIL( _msg_ )           CYG_EMPTY_STATEMENT
+# define CYG_ASSERT( _bool_, _msg_ ) CYG_EMPTY_STATEMENT
+# define CYG_ASSERTC( _bool_ )       CYG_EMPTY_STATEMENT
+
+#endif // ! CYGDBG_USE_ASSERTS
+
+// -------------------------------------------------------------------------
+// Pointer integrity checks.
+// These check not only for NULL pointer, but can also check for pointers
+// that are outside to defined memory areas of the platform or executable.
+// We differentiate between data and function pointers, so that we can cope
+// with different formats, and so we can check them against different memory
+// regions.
+
+externC cyg_bool cyg_check_data_ptr(const void *ptr);
+externC cyg_bool cyg_check_func_ptr(void (*ptr)(void));
+
+#ifdef CYGDBG_USE_ASSERTS
+
+# define CYG_CHECK_DATA_PTR( _ptr_, _msg_ )             \
+        CYG_MACRO_START                                 \
+        if( !cyg_check_data_ptr((const void *)(_ptr_)))       \
+           CYG_ASSERT_DOCALL( _msg_ );                   \
+        CYG_MACRO_END
+
+# define CYG_CHECK_FUNC_PTR( _ptr_, _msg_ )             \
+        CYG_MACRO_START                                 \
+        if( !cyg_check_func_ptr((void (*)(void))(_ptr_))) \
+           CYG_ASSERT_DOCALL( _msg_ );                   \
+        CYG_MACRO_END
+        
+# define CYG_CHECK_DATA_PTRC( _ptr_ )                   \
+         CYG_MACRO_START                                \
+         if ( !cyg_check_data_ptr((const void *)(_ptr_)))     \
+             CYG_ASSERT_DOCALL("data pointer (" #_ptr_ ") is valid");\
+         CYG_MACRO_END
+
+# define CYG_CHECK_FUNC_PTRC( _ptr_ )                       \
+         CYG_MACRO_START                                    \
+         if ( !cyg_check_func_ptr((void (*)(void))(_ptr_))) \
+             CYG_ASSERT_DOCALL("function pointer (" #_ptr_ ") is valid"); \
+         CYG_MACRO_END
+
+#else // CYGDBG_USE_ASSERTS
+
+# define CYG_CHECK_DATA_PTR( _ptr_, _msg_ ) CYG_EMPTY_STATEMENT
+# define CYG_CHECK_FUNC_PTR( _ptr_, _msg_ ) CYG_EMPTY_STATEMENT
+# define CYG_CHECK_DATA_PTRC( _ptr_ )       CYG_EMPTY_STATEMENT
+# define CYG_CHECK_FUNC_PTRC( _ptr_ )       CYG_EMPTY_STATEMENT
+
+#endif // CYGDBG_USE_ASSERTS
+            
+// -------------------------------------------------------------------------
+// Unconditional definitions:
+
+// Check an object for validity by calling its own checker.
+// Usage:
+//   ClassThing *p = &classobject;
+//   CYG_ASSERTCLASS( p, "Object at p is broken!" );
+
+// this enum gives some options as to how keenly to test; avoids cluttering
+// the member function declaration if the implementor wants to do more
+// zealous tests themselves.
+
+enum cyg_assert_class_zeal {
+  cyg_system_test       = -1,
+  cyg_none              = 0,
+  cyg_trivial,
+  cyg_quick,
+  cyg_thorough,
+  cyg_extreme
+};
+
+// -------------------------------------------------------------------------
+// Define macros for checking classes:
+//
+//      CYG_ASSERT_CLASS        - do proforma check on a class pointer
+//      CYG_ASSERT_CLASSO       - do proforma check on a class object
+//      CYG_ASSERT_ZERO_OR_CLASS- a class pointer is NULL or valid
+//      CYG_ASSERT_THIS         - "this" is valid
+//      + 3 compact variants and two aliases for backwards compatibility.
+//
+// All of these end up going via CYG_ASSERT(), which will be an empty
+// statement if CYGDBG_USE_ASSERTS is disabled. There is no need to
+// test CYGDBG_USE_ASSERTS again here.
+//
+// The idiom required is that a class have a member function called
+// "bool check_this( cyg_assert_class_zeal ) const" that returns true
+// iff the object is OK.  This need not be conditionally compiled against
+// CYGDBG_USE_ASSERTS but it can be if only this macro is used to
+// invoke it.  Alternatively it can be invoked by hand with other
+// choices from the above enum.
+
+// Assert the checker function of an object by pointer, or in hand.
+
+#ifdef __cplusplus
+
+# ifndef CYG_ASSERT_CLASS_ZEAL
+#  define CYG_ASSERT_CLASS_ZEAL (cyg_quick) // can be redefined locally
+# endif
+
+# define CYG_ASSERT_CLASS( _pobj_, _msg_ ) \
+    CYG_ASSERT( ((0 != (_pobj_)) &&        \
+                 (_pobj_)->check_this( CYG_ASSERT_CLASS_ZEAL )), _msg_ )
+
+# define CYG_ASSERTCLASS( _pobj_,_msg_) \
+    CYG_ASSERT_CLASS( (_pobj_), _msg_ )
+
+# define CYG_ASSERT_CLASSO( _obj_, _msg_ ) \
+    CYG_ASSERT( (_obj_).check_this( CYG_ASSERT_CLASS_ZEAL ), _msg_ )
+
+# define CYG_ASSERTCLASSO( _obj_, _msg_ ) \
+    CYG_ASSERT_CLASSO( (_obj_), _msg_ )
+
+# define CYG_ASSERT_ZERO_OR_CLASS( _pobj_, _msg_ ) \
+    CYG_ASSERT( ((0 == (_pobj_)) ||                \
+                 (_pobj_)->check_this( CYG_ASSERT_CLASS_ZEAL )), _msg_ )
+
+# define CYG_ASSERT_THIS( _msg_ ) \
+    CYG_ASSERT( this->check_this( CYG_ASSERT_CLASS_ZEAL ), _msg_ )
+
+# define CYG_ASSERT_CLASSC( _pobj_ ) \
+    CYG_ASSERT_CLASS( (_pobj_), "class pointer (" #_pobj_ ") is valid" )
+
+# define CYG_ASSERT_CLASSOC( _obj_ ) \
+    CYG_ASSERT_CLASSO( (_obj_), "object (" #_obj_ ") is valid" )
+
+# define CYG_ASSERT_ZERO_OR_CLASSC( _pobj_ ) \
+    CYG_ASSERT_ZERO_OR_CLASS((_pobj_),       \
+        "class pointer (" #_pobj_ ") is zero or valid")
+
+# define CYG_ASSERT_THISC( ) \
+    CYG_ASSERT_THIS( "\"this\" pointer is valid" )
+    
+#define CYGDBG_DEFINE_CHECK_THIS \
+    cyg_bool check_this( cyg_assert_class_zeal zeal ) const;
+
+#endif // __cplusplus
+
+// -------------------------------------------------------------------------
+// Some alternative names for basic assertions that we can disable
+// individually.
+//
+//      CYG_PRECONDITION        - argument checking etc
+//      CYG_POSTCONDITION       - results etc
+//      CYG_LOOP_INVARIANT      - for putting in loops
+//
+// C++ programmers have class-related variants of all of these.
+
+#ifdef CYGDBG_INFRA_DEBUG_PRECONDITIONS
+# define CYG_PRECONDITION( _bool_ , _msg_ ) CYG_ASSERT( _bool_, _msg_ )
+# define CYG_PRECONDITIONC( _bool_ ) \
+    CYG_ASSERT( _bool_, "precondition " #_bool_)
+#else
+# define CYG_PRECONDITION( _bool_ , _msg_ ) CYG_EMPTY_STATEMENT
+# define CYG_PRECONDITIONC( _bool_ )        CYG_EMPTY_STATEMENT
+#endif
+
+#ifdef CYGDBG_INFRA_DEBUG_POSTCONDITIONS
+# define CYG_POSTCONDITION( _bool_ , _msg_ ) CYG_ASSERT( _bool_, _msg_ )
+# define CYG_POSTCONDITIONC( _bool_ ) \
+    CYG_ASSERT( _bool_, "postcondition " #_bool_)
+#else
+# define CYG_POSTCONDITION( _bool_ , _msg_ ) CYG_EMPTY_STATEMENT
+# define CYG_POSTCONDITIONC( _bool_ )        CYG_EMPTY_STATEMENT
+#endif
+
+#ifdef CYGDBG_INFRA_DEBUG_LOOP_INVARIANTS
+# define CYG_LOOP_INVARIANT( _bool_ , _msg_ ) CYG_ASSERT( _bool_, _msg_ )
+# define CYG_LOOP_INVARIANTC( _bool_ ) \
+    CYG_ASSERT( _bool_, "loop invariant " #_bool_ )
+#else
+# define CYG_LOOP_INVARIANT( _bool_ , _msg_ ) CYG_EMPTY_STATEMENT
+# define CYG_LOOP_INVARIANTC( _bool_ )        CYG_EMPTY_STATEMENT
+#endif
+
+#ifdef __cplusplus
+
+// All variants of _CLASS
+# define CYG_PRECONDITION_CLASS( _pobj_, _msg_ )  \
+    CYG_PRECONDITION( ((0 != (_pobj_)) &&         \
+                       (_pobj_)->check_this(CYG_ASSERT_CLASS_ZEAL)), _msg_)
+
+# define CYG_PRECONDITION_CLASSC( _pobj_ )        \
+    CYG_PRECONDITION_CLASS( (_pobj_),             \
+       "precondition, class pointer (" #_pobj_ ") is valid" )
+    
+# define CYG_POSTCONDITION_CLASS( _pobj_, _msg_ ) \
+    CYG_POSTCONDITION( ((0 != (_pobj_)) &&        \
+                        (_pobj_)->check_this(CYG_ASSERT_CLASS_ZEAL)), _msg_)
+
+# define CYG_POSTCONDITION_CLASSC( _pobj_ )       \
+    CYG_POSTCONDITION_CLASS( (_pobj_),            \
+       "postcondition, class pointer (" #_pobj_ ") is valid" )
+
+# define CYG_LOOP_INVARIANT_CLASS( _pobj_, _msg_) \
+    CYG_LOOP_INVARIANT( ((0 != (_pobj_)) &&       \
+                         (_pobj_)->check_this(CYG_ASSERT_CLASS_ZEAL)), _msg_)
+        
+# define CYG_LOOP_INVARIANT_CLASSC( _pobj_ )      \
+    CYG_LOOP_INVARIANT_CLASS( (_pobj_),           \
+       "loop invariant, class pointer (" #_pobj_ ") is valid" )
+
+// All variants of _CLASSO
+# define CYG_PRECONDITION_CLASSO( _obj_, _msg_ )  \
+    CYG_PRECONDITION( (_obj_).check_this(CYG_ASSERT_CLASS_ZEAL), _msg_)
+    
+# define CYG_PRECONDITION_CLASSOC( _obj_ )        \
+    CYG_PRECONDITION_CLASSO( (_obj_),             \
+        "precondition, object (" #_obj_ ") is valid" )
+
+# define CYG_POSTCONDITION_CLASSO( _obj_, _msg_ ) \
+    CYG_POSTCONDITION( (_obj_).check_this(CYG_ASSERT_CLASS_ZEAL), _msg_)
+    
+# define CYG_POSTCONDITION_CLASSOC( _obj_ )       \
+    CYG_POSTCONDITION_CLASSO( (_obj_),            \
+       "postcondition, object (" #_obj_ ") is valid" )
+                             
+# define CYG_LOOP_INVARIANT_CLASSO( _obj_, _msg_) \
+    CYG_LOOP_INVARIANT( (_obj_).check_this(CYG_ASSERT_CLASS_ZEAL), _msg_)
+
+# define CYG_LOOP_INVARIANT_CLASSOC( _obj_ )      \
+    CYG_LOOP_INVARIANT_CLASSO( (_obj_),           \
+       "loop invariant, object (" #_obj_ ") is valid" )
+
+// All variants of _ZERO_OR_CLASS
+# define CYG_PRECONDITION_ZERO_OR_CLASS( _pobj_, _msg_ )  \
+    CYG_PRECONDITION( ((0 == (_pobj_)) ||                 \
+                       (_pobj_)->check_this(CYG_ASSERT_CLASS_ZEAL)), _msg_)
+    
+# define CYG_PRECONDITION_ZERO_OR_CLASSC( _pobj_ )        \
+    CYG_PRECONDITION_ZERO_OR_CLASS( (_pobj_),             \
+       "precondition, class pointer (" #_pobj_ ") is zero or valid" )
+    
+# define CYG_POSTCONDITION_ZERO_OR_CLASS( _pobj_, _msg_ ) \
+    CYG_POSTCONDITION( ((0 == (_pobj_)) ||                \
+                        (_pobj_)->check_this(CYG_ASSERT_CLASS_ZEAL)), _msg_)
+
+# define CYG_POSTCONDITION_ZERO_OR_CLASSC( _pobj_ )       \
+    CYG_POSTCONDITION_ZERO_OR_CLASS( (_pobj_),            \
+       "postcondition, class pointer (" #_pobj_ ") is zero or valid" )
+                             
+# define CYG_LOOP_INVARIANT_ZERO_OR_CLASS( _pobj_, _msg_) \
+    CYG_LOOP_INVARIANT( ((0 == (_pobj_)) ||               \
+                         (_pobj_)->check_this(CYG_ASSERT_CLASS_ZEAL)), _msg_)
+        
+# define CYG_LOOP_INVARIANT_ZERO_OR_CLASSC( _pobj_ )      \
+    CYG_LOOP_INVARIANT_ZERO_OR_CLASS( (_pobj_),           \
+       "loop invariant, class pointer (" #_pobj_ ") is zero or valid" )
+
+// All variants of _THIS
+# define CYG_PRECONDITION_THIS( _msg_ )  \
+    CYG_PRECONDITION( this->check_this(CYG_ASSERT_CLASS_ZEAL), _msg_)
+    
+# define CYG_PRECONDITION_THISC()        \
+    CYG_PRECONDITION_THIS( "precondition, \"this\"  is valid" )
+    
+# define CYG_POSTCONDITION_THIS( _msg_ ) \
+    CYG_POSTCONDITION( this->check_this(CYG_ASSERT_CLASS_ZEAL), _msg_)
+    
+# define CYG_POSTCONDITION_THISC()       \
+    CYG_POSTCONDITION_THIS( "postcondition, \"this\" is valid" )
+                             
+# define CYG_LOOP_INVARIANT_THIS( _msg_) \
+    CYG_LOOP_INVARIANT( this->check_this(CYG_ASSERT_CLASS_ZEAL), _msg_)
+        
+# define CYG_LOOP_INVARIANT_THISC()      \
+    CYG_LOOP_INVARIANT_THIS( "loop invariant, \"this\" is valid" )
+
+#endif // __cplusplus
+
+// -------------------------------------------------------------------------
+// Invariants. These are a bit more interesting. The ordinary invariants
+// take an arbitrary boolean expression, and C++ does not provide any way
+// of evaluating this expression automatically on entry and exit - any
+// attempt to use local objects leads to trying to evaluate the expression
+// when it is not in scope. This problem does not arise with objects.
+//
+// For C++ objects it is possible to do a bit better. A template can be
+// used to create a local object whose constructor will validate the
+// target object and whose destructor will validate the target object
+// again. Unfortunately it is necessary to pass the type as well as
+// the object: typeof() is a gcc extension, and RTTI's typeid facility
+// would provide the derived class and not what we actually want.            
+
+#ifdef CYGDBG_INFRA_DEBUG_INVARIANTS    
+
+# define CYG_INVARIANT( _bool_, _msg_ ) \
+        CYG_MACRO_START                 \
+        if ( ! ( _bool_ ) )             \
+            CYG_ASSERT_DOCALL( _msg_ ); \
+        CYG_MACRO_END
+
+# define CYG_INVARIANTC( _bool_ )       \
+        CYG_MACRO_START                 \
+        if ( ! ( _bool_ ) )             \
+            CYG_ASSERT_DOCALL( "invariant (" #_bool_ ")" ); \
+        CYG_MACRO_END
+
+# ifdef __cplusplus
+// NOTE: if the compiler does not manage to inline the appropriate
+// template functions then the impact on code size and performance becomes
+// rather large. But there are significant performance overheads anyway
+// simply because of the call to check_this()...            
+//
+template<class X> class __CygInvariantObject {
+
+    const X*  rep;
+
+  private:
+    // Prevent access to the default constructors.
+    __CygInvariantObject() { }
+    __CygInvariantObject( const __CygInvariantObject&  arg ) { }
+    __CygInvariantObject & operator=( const __CygInvariantObject & arg) { return *this; }
+    
+  public:
+    __CygInvariantObject( X* arg, const char* msg ) : rep(arg) {
+        if ( !rep->check_this( CYG_ASSERT_CLASS_ZEAL ) )
+            CYG_ASSERT_DOCALL( msg );
+    }
+    __CygInvariantObject( X& arg, const char* msg ) : rep(&arg) {
+        if ( !rep->check_this( CYG_ASSERT_CLASS_ZEAL ) )
+            CYG_ASSERT_DOCALL( msg );
+    }
+    __CygInvariantObject( const X* arg, const char* msg ) : rep(arg) {
+        if ( !rep->check_this( CYG_ASSERT_CLASS_ZEAL ) )
+            CYG_ASSERT_DOCALL( msg );
+    }
+    __CygInvariantObject( const X& arg, const char* msg ) : rep(&arg) {
+        if ( !rep->check_this( CYG_ASSERT_CLASS_ZEAL ) )
+            CYG_ASSERT_DOCALL( msg );
+    }
+    ~__CygInvariantObject( ) {
+        if ( !rep->check_this( CYG_ASSERT_CLASS_ZEAL ) )
+            CYG_ASSERT_DOCALL( "invariant, object valid on exit" );
+        rep = 0;
+    };
+};
+
+//
+// These macros provide sensible concatenation facilities at
+// the C preprocessor level, getting around complications in the
+// macro expansion rules related to __LINE__ and __FILE__.
+
+# define __CYG_INVARIANT_CLASSNAME_AUX( a, b) a ## b
+# define __CYG_INVARIANT_CLASSNAME( a, b ) \
+              __CYG_INVARIANT_CLASSNAME_AUX( a, b )
+
+
+// These macro definitions do not use CYG_MACRO_START because
+// I do not want the scope of the local objects to get confused.
+//
+// The first line of the macro expansion specifies the type of
+// the local object being created. The second line invents a
+// name for this object. The third line provides command-line
+// arguments.    
+
+# define CYG_INVARIANT_CLASS( _type_, _pobj_, _msg_ )          \
+     __CygInvariantObject<_type_>                              \
+     __CYG_INVARIANT_CLASSNAME( __invariant_class_, __LINE__ ) \
+              ( _pobj_, _msg_ )
+
+# define CYG_INVARIANT_CLASSC( _type_, _pobj_ )                \
+     __CygInvariantObject<_type_>                              \
+     __CYG_INVARIANT_CLASSNAME( __invariant_class_, __LINE__ ) \
+              ( _pobj_, "invariant, class pointer (" #_pobj_ ") is valid" )
+         
+# define CYG_INVARIANT_CLASSO( _type_, _obj_, _msg_ )          \
+     __CygInvariantObject<_type_>                              \
+     __CYG_INVARIANT_CLASSNAME( __invariant_class_, __LINE__ ) \
+              ( _obj_, _msg_ )
+
+# define CYG_INVARIANT_CLASSOC( _type_, _obj_ )                \
+     __CygInvariantObject<_type_>                              \
+     __CYG_INVARIANT_CLASSNAME( __invariant_class_, __LINE__ ) \
+              ( _obj_, "invariant, object (" #_obj_ ") is valid" )
+
+# define CYG_INVARIANT_THIS( _type_, _msg_ )                   \
+     __CygInvariantObject<_type_>                              \
+     __CYG_INVARIANT_CLASSNAME( __invariant_class_, __LINE__ ) \
+              ( this, _msg_ )
+         
+# define CYG_INVARIANT_THISC( _type_ )                         \
+     __CygInvariantObject<_type_>                              \
+     __CYG_INVARIANT_CLASSNAME( __invariant_class_, __LINE__ ) \
+              ( this, "invariant, \"this\" is valid" )
+
+# endif // __cplusplus
+
+#else  // !CYGDBG_INFRA_DEBUG_INVARIANTS
+
+# define CYG_INVARIANT( _bool_, _msg_ ) CYG_EMPTY_STATEMENT
+# define CYG_INVARIANTC( _bool_ )       CYG_EMPTY_STATEMENT
+
+# ifdef __cplusplus
+
+#  define CYG_INVARIANT_CLASS( _type_, _pobj_, _msg_ )
+#  define CYG_INVARIANT_CLASSC( _type_, _pobj_ )
+#  define CYG_INVARIANT_CLASSO( _type_, _obj_, _msg_ )
+#  define CYG_INVARIANT_CLASSOC( _type_, _obj_ )
+#  define CYG_INVARIANT_THIS( _type_, _msg_ )
+#  define CYG_INVARIANT_THISC( _type_ )
+
+# endif
+    
+#endif // CYGDBG_INFRA_DEBUG_INVARIANTS
+
+// -------------------------------------------------------------------------
+// Compile time failure; like #error but in a macro so we can use it in
+// other definitions.
+//
+// Usage:
+// #define new CYG_COMPILETIMEFAIL( "Do NOT use new!")
+
+#define CYG_COMPILETIMEFAIL( _msg_ ) !!!-- _msg_ --!!!
+
+
+// -------------------------------------------------------------------------
+// The host-side implementation of the infrastructure provides a number
+// of additional functions that allow applications to provide their own
+// implementation of cyg_assert_fail(). This is not strictly necessary
+// since the presence of cyg_assert_fail() in the application would
+// override the one in the library anyway, but it is useful to make
+// certain functionality more readily available.
+//
+// These declarations are only available if the symbol
+// CYG_DECLARE_HOST_ASSERTION_SUPPORT is defined.
+#ifdef CYG_DECLARE_HOST_ASSERTION_SUPPORT
+
+// The default assertion handler writes its output to a file and
+// if possible a suitable message to stdout. It is possible to
+// install an alternative handler. If this alternative returns false
+// then the default handler will be invoked instead, otherwise the
+// application will exit.
+externC void cyg_assert_install_failure_handler(
+                bool (*)(const char* /* psz_func */,
+                         const char* /* psz_file */,
+                         cyg_uint32  /* linenum */,
+                         const char* /* psz_msg */) );
+
+// Register a callback that should get invoked as part of handling an
+// assertion failure and that will typically produce some additional
+// output. For example the trace code will install a callback to output
+// trace information.
+//
+// The first argument is a string identifying the callback. The second
+// argument is a function pointer for the callback itself, whose
+// argument is another function that can be invoked for output.
+externC void cyg_assert_install_failure_callback(
+                const char* /* name */,
+                void (*)( void (*)(const char*) ));
+
+// This function can be called by assert failure handlers to invoke
+// the installed callbacks. The three arguments are function pointers
+// that get invoked prior to callback invocation, by the callback itself,
+// and after each callback. In the first case the argument will be the
+// callback name.
+externC void cyg_assert_failure_invoke_callbacks(
+                void (*)(const char* /* name */),
+                void (*)(const char* /* callback data */ ),
+                void (*)(void) );
+
+// This function is intended to be called from inside gdb instead of
+// cyg_assert_fail(),, without the need to specify a filename or
+// anything else.
+externC void cyg_assert_quickfail(void);
+
+#endif // CYG_DECLARE_HOST_ASSERTION_SUPPORT
+    
+// -------------------------------------------------------------------------
+
+#endif // CYGONCE_INFRA_CYG_ASS_H multiple inclusion protection
+// EOF cyg_ass.h
diff --git a/ecos/packages/infra/current/include/cyg_trac.h b/ecos/packages/infra/current/include/cyg_trac.h
new file mode 100644
index 0000000..07d62ef
--- /dev/null
+++ b/ecos/packages/infra/current/include/cyg_trac.h
@@ -0,0 +1,1654 @@
+#ifndef CYGONCE_INFRA_CYG_TRAC_H
+#define CYGONCE_INFRA_CYG_TRAC_H
+
+//==========================================================================
+//
+//      cyg_trac.h
+//
+//      Macros and prototypes for the tracing system
+//
+//==========================================================================
+// ####ECOSGPLCOPYRIGHTBEGIN####                                            
+// -------------------------------------------                              
+// This file is part of eCos, the Embedded Configurable Operating System.   
+// Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+//
+// eCos 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 or (at your option) any later      
+// version.                                                                 
+//
+// eCos 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 eCos; if not, write to the Free Software Foundation, Inc.,    
+// 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.            
+//
+// As a special exception, if other files instantiate templates or use      
+// macros or inline functions from this file, or you compile this file      
+// and link it with other works to produce a work based on this file,       
+// this file does not by itself cause the resulting work to be covered by   
+// the GNU General Public License. However the source code for this file    
+// must still be made available in accordance with section (3) of the GNU   
+// General Public License v2.                                               
+//
+// This exception does not invalidate any other reasons why a work based    
+// on this file might be covered by the GNU General Public License.         
+// -------------------------------------------                              
+// ####ECOSGPLCOPYRIGHTEND####                                              
+//==========================================================================
+//#####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
+    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, 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( 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;
+    char *func;
+    char *file; /* not strictly needed in plain 'C' */
+    cyg_uint32 lnum; /* nor this */
+#ifdef CYGDBG_INFRA_DEBUG_TRACE_MESSAGE
+    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
diff --git a/ecos/packages/infra/current/include/cyg_type.h b/ecos/packages/infra/current/include/cyg_type.h
new file mode 100644
index 0000000..5047493
--- /dev/null
+++ b/ecos/packages/infra/current/include/cyg_type.h
@@ -0,0 +1,559 @@
+#ifndef CYGONCE_INFRA_CYG_TYPE_H
+#define CYGONCE_INFRA_CYG_TYPE_H
+
+//==========================================================================
+//
+//      cyg_type.h
+//
+//      Standard types, and some useful coding macros.
+//
+//==========================================================================
+// ####ECOSGPLCOPYRIGHTBEGIN####                                            
+// -------------------------------------------                              
+// This file is part of eCos, the Embedded Configurable Operating System.   
+// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2009 Free Software Foundation, Inc.
+//
+// eCos 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 or (at your option) any later      
+// version.                                                                 
+//
+// eCos 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 eCos; if not, write to the Free Software Foundation, Inc.,    
+// 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.            
+//
+// As a special exception, if other files instantiate templates or use      
+// macros or inline functions from this file, or you compile this file      
+// and link it with other works to produce a work based on this file,       
+// this file does not by itself cause the resulting work to be covered by   
+// the GNU General Public License. However the source code for this file    
+// must still be made available in accordance with section (3) of the GNU   
+// General Public License v2.                                               
+//
+// This exception does not invalidate any other reasons why a work based    
+// on this file might be covered by the GNU General Public License.         
+// -------------------------------------------                              
+// ####ECOSGPLCOPYRIGHTEND####                                              
+//==========================================================================
+//#####DESCRIPTIONBEGIN####
+//
+// Author(s):   nickg from an original by hmt
+// Contributors:  nickg
+// Date:        1997-09-08
+// Purpose:     share unambiguously sized types.
+// Description: we typedef [cyg_][u]int8,16,32 &c for general use.
+// Usage:       #include "cyg/infra/cyg_type.h"
+//              ...
+//              cyg_int32 my_32bit_integer;
+//              
+//####DESCRIPTIONEND####
+//
+
+#include <stddef.h>           // Definition of NULL from the compiler
+
+// -------------------------------------------------------------------------
+// Some useful macros. These are defined here by default.
+
+// __externC is used in mixed C/C++ headers to force C linkage on an external
+// definition. It avoids having to put all sorts of ifdefs in.
+
+#ifdef __cplusplus
+# define __externC extern "C"
+#else
+# define __externC extern
+#endif
+// Also define externC for now - but it is deprecated
+#define externC __externC
+
+// Compiler version.
+#ifdef __GNUC__
+# if defined(__GNU_PATCHLEVEL__)
+#  define __GNUC_VERSION__ (__GNUC__ * 10000 \
+                             + __GNUC_MINOR__ * 100 \
+                             + __GNUC_PATCHLEVEL__)
+# else
+#  define __GNUC_VERSION__ (__GNUC__ * 10000 \
+                             + __GNUC_MINOR__ * 100)
+# endif
+#endif
+
+// -------------------------------------------------------------------------
+// The header <basetype.h> defines the base types used here. It is
+// supplied either by the target architecture HAL, or by the host
+// porting kit. They are all defined as macros, and only those that
+// make choices other than the defaults given below need be defined.
+
+#define CYG_LSBFIRST 1234
+#define CYG_MSBFIRST 4321
+
+#include <cyg/hal/basetype.h>
+
+#if (CYG_BYTEORDER != CYG_LSBFIRST) && (CYG_BYTEORDER != CYG_MSBFIRST)
+# error You must define CYG_BYTEORDER to equal CYG_LSBFIRST or CYG_MSBFIRST
+#endif
+
+#ifndef CYG_DOUBLE_BYTEORDER
+#define CYG_DOUBLE_BYTEORDER CYG_BYTEORDER
+#endif
+
+#ifndef cyg_halint8
+# define cyg_halint8 char
+#endif
+#ifndef cyg_halint16
+# define cyg_halint16 short
+#endif
+#ifndef cyg_halint32
+# define cyg_halint32 int
+#endif
+#ifndef cyg_halint64
+# define cyg_halint64 long long
+#endif
+
+#ifndef cyg_halcount8
+# define cyg_halcount8 int
+#endif
+#ifndef cyg_halcount16
+# define cyg_halcount16 int
+#endif
+#ifndef cyg_halcount32
+# define cyg_halcount32 int
+#endif
+#ifndef cyg_halcount64
+# define cyg_halcount64 long long
+#endif
+
+#ifndef cyg_haladdress
+# define cyg_haladdress cyg_uint32
+#endif
+#ifndef cyg_haladdrword
+# define cyg_haladdrword cyg_uint32
+#endif
+
+#ifndef cyg_halbool
+# define cyg_halbool int
+#endif
+
+#ifndef cyg_halatomic
+# define cyg_halatomic cyg_halint8
+#endif
+
+// -------------------------------------------------------------------------
+// Provide a default architecture alignment
+// This may be overridden in basetype.h if necessary.
+// These should be straightforward numbers to allow use in assembly.
+
+#ifndef CYGARC_ALIGNMENT
+# define CYGARC_ALIGNMENT 8
+#endif
+// And corresponding power of two alignment
+#ifndef CYGARC_P2ALIGNMENT
+# define CYGARC_P2ALIGNMENT 3
+#endif
+#if (CYGARC_ALIGNMENT) != (1 << CYGARC_P2ALIGNMENT)
+# error "Inconsistent CYGARC_ALIGNMENT and CYGARC_P2ALIGNMENT values"
+#endif
+
+// -------------------------------------------------------------------------
+// The obvious few that compilers may define for you.
+// But in case they don't:
+
+#ifndef NULL
+# define NULL 0
+#endif
+
+#ifndef __cplusplus
+
+typedef cyg_halbool bool;
+
+# ifndef false
+#  define false 0
+# endif
+
+# ifndef true
+#  define true (!false)
+# endif
+
+#endif
+
+// -------------------------------------------------------------------------
+// Allow creation of procedure-like macros that are a single statement,
+// and must be followed by a semi-colon
+
+#define CYG_MACRO_START do {
+#define CYG_MACRO_END   } while (0)
+
+#define CYG_EMPTY_STATEMENT CYG_MACRO_START CYG_MACRO_END
+
+#define CYG_UNUSED_PARAM( _type_, _name_ ) CYG_MACRO_START      \
+  _type_ __tmp1 = (_name_);                                     \
+  _type_ __tmp2 = __tmp1;                                       \
+  __tmp1 = __tmp2;                                              \
+CYG_MACRO_END
+
+
+//----------------------------------------------------------------------------
+// The unused attribute stops the compiler warning about the variable
+// not being used.
+// The used attribute prevents the compiler from optimizing it away.
+
+#define CYG_REFERENCE_OBJECT(__object__)                            \
+    CYG_MACRO_START                                                 \
+    static const void*  __cygvar_discard_me__                       \
+    __attribute__ ((unused, used)) = (const void*)&(__object__);    \
+    CYG_MACRO_END
+
+// -------------------------------------------------------------------------
+// Define basic types for using integers in memory and structures;
+// depends on compiler defaults and CPU type.
+
+typedef unsigned cyg_halint8    cyg_uint8  ;
+typedef   signed cyg_halint8    cyg_int8   ;
+
+typedef unsigned cyg_halint16   cyg_uint16 ;
+typedef   signed cyg_halint16   cyg_int16  ;
+
+typedef unsigned cyg_halint32   cyg_uint32 ;
+typedef   signed cyg_halint32   cyg_int32  ;
+
+typedef unsigned cyg_halint64   cyg_uint64 ;
+typedef   signed cyg_halint64   cyg_int64  ;
+
+typedef  cyg_halbool            cyg_bool   ;
+
+// -------------------------------------------------------------------------
+// Define types for using integers in registers for looping and the like;
+// depends on CPU type, choose what it is most comfortable with, with at
+// least the range required.
+
+typedef unsigned cyg_halcount8  cyg_ucount8  ;
+typedef   signed cyg_halcount8  cyg_count8   ;
+
+typedef unsigned cyg_halcount16 cyg_ucount16 ;
+typedef   signed cyg_halcount16 cyg_count16  ;
+
+typedef unsigned cyg_halcount32 cyg_ucount32 ;
+typedef   signed cyg_halcount32 cyg_count32  ;
+
+typedef unsigned cyg_halcount64 cyg_ucount64 ;
+typedef   signed cyg_halcount64 cyg_count64  ;
+
+// -------------------------------------------------------------------------
+// Define a type to be used for atomic accesses. This type is guaranteed
+// to be read or written in a single uninterruptible operation. This type
+// is at least a single byte.
+
+typedef volatile unsigned cyg_halatomic  cyg_atomic;
+typedef volatile unsigned cyg_halatomic  CYG_ATOMIC;
+
+// -------------------------------------------------------------------------
+// Define types for access plain, on-the-metal memory or devices.
+
+typedef cyg_uint32  CYG_WORD;
+typedef cyg_uint8   CYG_BYTE;
+typedef cyg_uint16  CYG_WORD16;
+typedef cyg_uint32  CYG_WORD32;
+typedef cyg_uint64  CYG_WORD64;
+
+typedef cyg_haladdress  CYG_ADDRESS;
+typedef cyg_haladdrword CYG_ADDRWORD;
+
+// -------------------------------------------------------------------------
+// Number of elements in a (statically allocated) array.
+
+#define CYG_NELEM(a) (sizeof(a) / sizeof((a)[0]))
+
+// -------------------------------------------------------------------------
+// Constructor ordering macros.  These are added as annotations to all
+// static objects to order the constuctors appropriately.
+
+#if defined(__cplusplus) && defined(__GNUC__) && \
+    !defined(CYGBLD_ATTRIB_INIT_PRI)
+# define CYGBLD_ATTRIB_INIT_PRI( _pri_ ) __attribute__((init_priority(_pri_)))
+#elif !defined(CYGBLD_ATTRIB_INIT_PRI)
+// FIXME: should maybe just bomb out if this is attempted anywhere else?
+// Not sure
+# define CYGBLD_ATTRIB_INIT_PRI( _pri_ )
+#endif
+    
+// The following will be removed eventually as it doesn't allow the use of
+// e.g. pri+5 format
+#define CYG_INIT_PRIORITY( _pri_ ) CYGBLD_ATTRIB_INIT_PRI( CYG_INIT_##_pri_ )
+
+#define CYGBLD_ATTRIB_INIT_BEFORE( _pri_ ) CYGBLD_ATTRIB_INIT_PRI(_pri_-100)
+#define CYGBLD_ATTRIB_INIT_AFTER( _pri_ )  CYGBLD_ATTRIB_INIT_PRI(_pri_+100)
+
+#if defined(__GNUC__) && !defined(__cplusplus) && (__GNUC_VERSION__ >= 40300)
+// Equivalents of the above for C functions, available from gcc 4.3 onwards.
+# define CYGBLD_ATTRIB_C_INIT_PRI( _pri_)       __attribute__((constructor (_pri_)))
+# define CYGBLD_ATTRIB_C_INIT_BEFORE( _pri_ )   __attribute__((constructor (_pri_-100)))
+# define CYGBLD_ATTRIB_C_INIT_AFTER( _pri_ )    __attribute__((constructor (_pri_+100)))
+#endif
+
+// Start with initializing everything inside the cpu and the main memory.
+#define CYG_INIT_HAL                    10000
+#define CYG_INIT_SCHEDULER              11000
+#define CYG_INIT_IDLE_THREAD            11100
+#define CYG_INIT_INTERRUPTS             12000
+#define CYG_INIT_CLOCK                  14000
+#define CYG_INIT_THREADS                16000
+#define CYG_INIT_KERNEL                 19000
+#define CYG_INIT_MEMALLOC               20000
+// Now move on to I/O subsystems and device drivers. These can make use of
+// kernel and HAL functionality, and can dynamically allocate memory if
+// absolutely needed. For now they can also assume that diag_printf()
+// functionality is available, but that may change in future.
+//
+// Primary buses are ones very closely tied to the processor, e.g. PCI.
+#define CYG_INIT_BUS_PRIMARY            30000
+// Not yet: on some targets cyg_pci_init() has to be called very early
+// on for HAL diagnostics to work.
+// #define CYG_INIT_BUS_PCI                CYG_INIT_BUS_PRIMARY
+//
+// Secondary buses may hang off primary buses, e.g. USB host.
+#define CYG_INIT_BUS_SECONDARY          31000
+// Tertiary buses are everything else.
+#define CYG_INIT_BUS_TERTIARY           32000
+#define CYG_INIT_BUS_I2C                CYG_INIT_BUS_TERTIARY
+#define CYG_INIT_BUS_SPI                CYG_INIT_BUS_TERTIARY
+//
+// In future HAL diag initialization may happen at this point.
+//
+// Watchdogs and wallclocks often hang off a tertiary bus but
+// have no dependencies
+#define CYG_INIT_DEV_WATCHDOG           35000
+#define CYG_INIT_DEV_WALLCLOCK          36000
+// A primary block configuration can be initialized with no need
+// for per-unit configuration information.
+#define CYG_INIT_DEV_BLOCK_PRIMARY      37000
+#define CYG_INIT_DEV_FLASH              CYG_INIT_DEV_BLOCK_PRIMARY
+// Per-unit configuration data extracted from primary storage.
+// NOTE: for future use, not implemented yet.
+#define CYG_INIT_CONFIG                 38000
+// Secondary block devices may use per-unit configuration data
+// for e.g. interpreting partition layout. Few devices are expected
+// to fall into this category. Note that these devices, as well as
+// some char devices, may not actually be usable until interrupts
+// are enabled.
+#define CYG_INIT_DEV_BLOCK_SECONDARY    40000
+// Char devices are everything else: serial, ethernet, CAN, ...
+#define CYG_INIT_DEV_CHAR               41000
+// For backwards compatibility. Subject to change in future so
+// a CYG_INIT_DEV_ priority should be used instead.
+#define CYG_INIT_DRIVERS                48000
+// CYG_INIT_IO and CYG_INIT_IO_FS are poorly defined at present,
+// and may get reorganized in future.
+#define CYG_INIT_IO                     49000
+#define CYG_INIT_IO_FS                  50000
+// The I/O subsystems and device drivers have been initialized.
+#define CYG_INIT_LIBC                   56000
+#define CYG_INIT_COMPAT                 58000
+#define CYG_INIT_APPLICATION            60000
+#define CYG_INIT_PREDEFAULT             65534
+#define CYG_INIT_DEFAULT                65535
+
+// -------------------------------------------------------------------------
+// Label name macros. Some toolsets generate labels with initial
+// underscores and others don't. CYG_LABEL_NAME should be used on
+// labels in C/C++ code that are defined in assembly code or linker
+// scripts. CYG_LABEL_DEFN is for use in assembly code and linker
+// scripts where we need to manufacture labels that can be used from
+// C/C++.
+// These are default implementations that should work for most targets.
+// They may be overridden in basetype.h if necessary.
+
+#ifndef CYG_LABEL_NAME
+
+#define CYG_LABEL_NAME(_name_) _name_
+
+#endif
+
+#ifndef CYG_LABEL_DEFN
+
+#define CYG_LABEL_DEFN(_label) _label
+
+#endif
+
+// -------------------------------------------------------------------------
+// COMPILER-SPECIFIC STUFF
+
+#ifdef __GNUC__
+// Force a 'C' routine to be called like a 'C++' contructor
+# if !defined(CYGBLD_ATTRIB_CONSTRUCTOR)
+#  define CYGBLD_ATTRIB_CONSTRUCTOR __attribute__((constructor))
+# endif
+
+// Define a compiler-specific rune for saying a function doesn't return
+# if !defined(CYGBLD_ATTRIB_NORET)
+#  define CYGBLD_ATTRIB_NORET __attribute__((noreturn))
+# endif
+
+// How to define weak symbols - this is only relevant for ELF and a.out,
+// but that won't be a problem for eCos
+# if !defined(CYGBLD_ATTRIB_WEAK)
+#  define CYGBLD_ATTRIB_WEAK __attribute__ ((weak))
+# endif
+
+// How to define alias to symbols. Just pass in the symbol itself, not
+// the string name of the symbol
+# if !defined(CYGBLD_ATTRIB_ALIAS)
+#  define CYGBLD_ATTRIB_ALIAS(__symbol__) \
+        __attribute__ ((alias (#__symbol__)))
+# endif
+
+// This effectively does the reverse of the previous macro. It defines
+// a name that the attributed variable or function will actually have
+// in assembler.
+# if !defined(CYGBLD_ATTRIB_ASM_ALIAS)
+#  define __Str(x) #x
+#  define __Xstr(x) __Str(x)
+#  define CYGBLD_ATTRIB_ASM_ALIAS(__symbol__) \
+             __asm__ ( __Xstr( CYG_LABEL_DEFN( __symbol__ ) ) )
+# endif
+
+// Shows that a function returns the same value when given the same args, but
+// note this can't be used if there are pointer args
+# if !defined(CYGBLD_ATTRIB_CONST)
+#  define CYGBLD_ATTRIB_CONST __attribute__((const))
+#endif
+
+// Assign a defined variable to a specific section
+# if !defined(CYGBLD_ATTRIB_SECTION)
+#  define CYGBLD_ATTRIB_SECTION(__sect__) __attribute__((section (__sect__)))
+# endif
+
+// Give a type or object explicit minimum alignment
+# if !defined(CYGBLD_ATTRIB_ALIGN)
+#  define CYGBLD_ATTRIB_ALIGN(__align__) __attribute__((aligned(__align__)))
+# endif
+
+# if !defined(CYGBLD_ATTRIB_ALIGN_MAX)
+#  define CYGBLD_ATTRIB_ALIGN_MAX __attribute__((aligned))
+# endif
+
+# if !defined(CYGBLD_ATTRIB_ALIGNOFTYPE)
+#  define CYGBLD_ATTRIB_ALIGNOFTYPE( _type_ ) \
+     __attribute__((aligned(__alignof__( _type_ ))))
+# endif
+
+// Teach compiler how to check format of printf-like functions
+# define CYGBLD_ATTRIB_PRINTF_FORMAT(__format__, __args__) \
+        __attribute__((format (printf, __format__, __args__)))
+
+// Teach compiler how to check format of scanf-like functions
+# define CYGBLD_ATTRIB_SCANF_FORMAT(__format__, __args__) \
+        __attribute__((format (scanf, __format__, __args__)))
+
+// Teach compiler how to check format of strftime-like functions
+# define CYGBLD_ATTRIB_STRFTIME_FORMAT(__format__, __args__) \
+        __attribute__((format (strftime, __format__, __args__)))
+
+// Tell compiler not to warn us about an unused variable -- generally
+// because it will be used when sources are build under certain
+// circumstances (e.g. with debugging or asserts enabled.
+# define CYGBLD_ATTRIB_UNUSED  __attribute__((unused))
+
+// Tell the compiler not to throw away a variable or function. Only known
+// available on 3.3.2 or above. Old version's didn't throw them away,
+// but using the unused attribute should stop warnings.
+# if !defined(CYGBLD_ATTRIB_USED)
+#  if __GNUC_VERSION__ >= 30302
+#   define CYGBLD_ATTRIB_USED __attribute__((used))
+#  else
+#   define CYGBLD_ATTRIB_USED __attribute__((unused))
+#  endif
+# endif 
+
+// Enforce inlining of a C function. GCC does not inline any C
+// function when not optimizing, unless you specify "always_inline" attribute.
+// Other attributes suppress generation of standalone function.
+# if !defined(CYGBLD_FORCE_INLINE)
+#  define CYGBLD_FORCE_INLINE __externC inline __attribute((gnu_inline)) __attribute((always_inline))
+# endif
+
+// Suppress function inlining
+#define CYGBLD_ATTRIB_NO_INLINE __attribute__((noinline))
+
+#else // non-GNU
+
+# define CYGBLD_ATTRIB_UNUSED  /* nothing */
+
+# define CYGBLD_ATTRIB_CONSTRUCTOR
+
+# define CYGBLD_ATTRIB_NORET
+    // This intentionally gives an error only if we actually try to
+    // use it.  #error would give an error if we simply can't.
+// FIXME: Had to disarm the bomb - the CYGBLD_ATTRIB_WEAK macro is now
+//        (indirectly) used in host tools.
+# define CYGBLD_ATTRIB_WEAK /* !!!-- Attribute weak not defined --!!! */
+
+# define CYGBLD_ATTRIB_ALIAS(__x__) !!!-- Attribute alias not defined --!!!
+
+# define CYGBLD_ATTRIB_ASM_ALIAS(__symbol__) !!!-- Asm alias not defined --!!!
+
+# define CYGBLD_ATTRIB_CONST
+
+# define CYGBLD_ATTRIB_ALIGN(__align__) !!!-- Alignment alias not defined --!!!
+
+# define CYGBLD_ATTRIB_ALIGN_MAX !!!-- Alignment alias not defined --!!!
+
+# define CYGBLD_ATTRIB_ALIGNOFTYPE( _type_ ) !!!-- Alignment alias not defined --!!!
+
+# define CYGBLD_ATTRIB_PRINTF_FORMAT(__format__, __args__)
+
+# define CYGBLD_ATTRIB_SCANF_FORMAT(__format__, __args__)
+
+# define CYGBLD_ATTRIB_STRFTIME_FORMAT(__format__, __args__)
+
+#define CYGBLD_FORCE_INLINE
+
+#define CYGBLD_ATTRIB_NO_INLINE
+
+#endif
+
+// How to define weak aliases. Currently this is simply a mixture of the
+// above
+
+# define CYGBLD_ATTRIB_WEAK_ALIAS(__symbol__) \
+        CYGBLD_ATTRIB_WEAK CYGBLD_ATTRIB_ALIAS(__symbol__)
+
+#ifdef __cplusplus
+# define __THROW throw()
+#else
+# define __THROW
+#endif
+
+// -------------------------------------------------------------------------
+// Variable annotations
+// These annotations may be added to various static variables in the
+// HAL and kernel to indicate which component they belong to. These
+// are used by some targets to optimize memory placement of these
+// variables.
+
+#ifndef CYGBLD_ANNOTATE_VARIABLE_HAL
+#define CYGBLD_ANNOTATE_VARIABLE_HAL
+#endif
+#ifndef CYGBLD_ANNOTATE_VARIABLE_SCHED
+#define CYGBLD_ANNOTATE_VARIABLE_SCHED
+#endif
+#ifndef CYGBLD_ANNOTATE_VARIABLE_CLOCK
+#define CYGBLD_ANNOTATE_VARIABLE_CLOCK
+#endif
+#ifndef CYGBLD_ANNOTATE_VARIABLE_INTR
+#define CYGBLD_ANNOTATE_VARIABLE_INTR
+#endif
+
+// -------------------------------------------------------------------------
+// Various "flavours" of memory regions that can be described by the 
+// Memory Layout Tool (MLT).
+
+#define CYGMEM_REGION_ATTR_R  0x01  // Region can be read
+#define CYGMEM_REGION_ATTR_W  0x02  // Region can be written
+
+// -------------------------------------------------------------------------
+#endif // CYGONCE_INFRA_CYG_TYPE_H multiple inclusion protection
+// EOF cyg_type.h
diff --git a/ecos/packages/infra/current/include/cyg_type.inc b/ecos/packages/infra/current/include/cyg_type.inc
new file mode 100644
index 0000000..724b318
--- /dev/null
+++ b/ecos/packages/infra/current/include/cyg_type.inc
@@ -0,0 +1,86 @@
+#ifndef CYGONCE_INFRA_CYG_TYPE_INC
+#define CYGONCE_INFRA_CYG_TYPE_INC
+
+//==========================================================================
+//
+//      cyg_type.inc
+//
+//      Standard types, and some useful coding macros.
+//
+//==========================================================================
+// ####ECOSGPLCOPYRIGHTBEGIN####                                            
+// -------------------------------------------                              
+// This file is part of eCos, the Embedded Configurable Operating System.   
+// Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+//
+// eCos 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 or (at your option) any later      
+// version.                                                                 
+//
+// eCos 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 eCos; if not, write to the Free Software Foundation, Inc.,    
+// 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.            
+//
+// As a special exception, if other files instantiate templates or use      
+// macros or inline functions from this file, or you compile this file      
+// and link it with other works to produce a work based on this file,       
+// this file does not by itself cause the resulting work to be covered by   
+// the GNU General Public License. However the source code for this file    
+// must still be made available in accordance with section (3) of the GNU   
+// General Public License v2.                                               
+//
+// This exception does not invalidate any other reasons why a work based    
+// on this file might be covered by the GNU General Public License.         
+// -------------------------------------------                              
+// ####ECOSGPLCOPYRIGHTEND####                                              
+//==========================================================================
+//#####DESCRIPTIONBEGIN####
+//
+// Author(s):    jlarmour
+// Contributors: 
+// Date:         2000-07-25
+// Purpose:      Define symbols for use in linker scripts and "generic" asm
+// Description:  This file should only use #defines - it should be safe
+//               to include from both linker scripts and assembler files
+// Usage:        #include <cyg/infra/cyg_type.inc>
+//
+//              
+//####DESCRIPTIONEND####
+
+#include <cyg/hal/basetype.h>
+
+// -------------------------------------------------------------------------
+// Label name macros. Some toolsets generate labels with initial
+// underscores and others don't. CYG_LABEL_NAME should be used on
+// labels in C/C++ code that are defined in assembly code or linker
+// scripts. CYG_LABEL_DEFN is for use in assembly code and linker
+// scripts where we need to manufacture labels that can be used from
+// C/C++.
+// These are default implementations that should work for most targets.
+// They may be overridden in basetype.h if necessary.
+
+#ifndef CYG_LABEL_DEFN
+# define CYG_LABEL_DEFN(_label) _label
+#endif
+
+// -------------------------------------------------------------------------
+// Provide a default architecture alignment.
+// This may be overridden in basetype.h if necessary.
+
+#ifndef CYGARC_ALIGNMENT
+# define CYGARC_ALIGNMENT 8
+#endif
+// And corresponding power of two alignment
+#ifndef CYGARC_P2ALIGNMENT
+# define CYGARC_P2ALIGNMENT 3
+#endif
+
+#endif /* CYGONCE_INFRA_CYG_TYPE_INC */
+
+// EOF cyg_type.inc
diff --git a/ecos/packages/infra/current/include/diag.h b/ecos/packages/infra/current/include/diag.h
new file mode 100644
index 0000000..633e4e3
--- /dev/null
+++ b/ecos/packages/infra/current/include/diag.h
@@ -0,0 +1,117 @@
+#ifndef CYGONCE_INFRA_DIAG_H
+#define CYGONCE_INFRA_DIAG_H
+
+/*=============================================================================
+//
+//      diag.h
+//
+//      Diagnostic Routines for Infra Development
+//
+//==========================================================================
+// ####ECOSGPLCOPYRIGHTBEGIN####                                            
+// -------------------------------------------                              
+// This file is part of eCos, the Embedded Configurable Operating System.   
+// Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+//
+// eCos 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 or (at your option) any later      
+// version.                                                                 
+//
+// eCos 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 eCos; if not, write to the Free Software Foundation, Inc.,    
+// 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.            
+//
+// As a special exception, if other files instantiate templates or use      
+// macros or inline functions from this file, or you compile this file      
+// and link it with other works to produce a work based on this file,       
+// this file does not by itself cause the resulting work to be covered by   
+// the GNU General Public License. However the source code for this file    
+// must still be made available in accordance with section (3) of the GNU   
+// General Public License v2.                                               
+//
+// This exception does not invalidate any other reasons why a work based    
+// on this file might be covered by the GNU General Public License.         
+// -------------------------------------------                              
+// ####ECOSGPLCOPYRIGHTEND####                                              
+//==========================================================================
+//#####DESCRIPTIONBEGIN####
+//
+// Author(s):   nickg
+// Contributors:        nickg, gthomas
+// Date:        1998-03-02
+// Purpose:     Diagnostic Routines for Infra Development
+// Description: Diagnostic routines for use during infra development.
+// Usage:       #include <cyg/infra/diag.h>
+//
+//####DESCRIPTIONEND####
+//
+//==========================================================================*/
+
+#include <pkgconf/infra.h>
+#include <cyg/infra/cyg_type.h>
+#include <stdarg.h>
+
+/*---------------------------------------------------------------------------*/
+/* Diagnostic routines                                                       */
+
+externC void diag_init(void);         /* Initialize, call before any others*/
+
+externC void diag_write_char(char c); /* Write single char to output       */
+
+externC void diag_write_string(const char *psz); /* Write zero terminated string */
+
+externC void diag_write_dec( cyg_int32 n);    /* Write decimal value       */
+
+externC void diag_write_hex( cyg_uint32 n);   /* Write hexadecimal value   */
+
+externC void diag_dump_buf(void *buf, CYG_ADDRWORD len);
+externC void diag_dump_buf_32bit(void *buf, CYG_ADDRWORD len);
+externC void diag_dump_buf_16bit(void *buf, CYG_ADDRWORD len);
+typedef int __printf_fun(const char *fmt, ...);
+externC void diag_vdump_buf_with_offset(__printf_fun *pf,
+                                        cyg_uint8     *p, 
+                                        CYG_ADDRWORD   s, 
+                                        cyg_uint8     *base);
+externC void diag_dump_buf_with_offset(cyg_uint8     *p, 
+                                       CYG_ADDRWORD   s, 
+                                       cyg_uint8     *base);
+
+externC void diag_dump_buf_with_offset_32bit(cyg_uint32 *p, 
+                                             CYG_ADDRWORD     s, 
+                                             cyg_uint32      *base);
+
+externC void diag_dump_buf_with_offset_16bit(cyg_uint16 *p, 
+                                             CYG_ADDRWORD     s, 
+                                             cyg_uint16      *base);
+
+/* Formatted print      */
+externC int  diag_printf( const char *fmt, ... ) CYGBLD_ATTRIB_PRINTF_FORMAT(1,2);  
+
+externC void diag_init_putc(void (*putc)(char c, void **param));
+externC int  diag_sprintf(char *buf, const char *fmt, ...) 
+     CYGBLD_ATTRIB_PRINTF_FORMAT(2,3);
+externC int  diag_snprintf(char *buf, size_t len, const char *fmt, ...)
+     CYGBLD_ATTRIB_PRINTF_FORMAT(3,4);
+externC int  diag_vsprintf(char *buf, const char *fmt, va_list ap)
+     CYGBLD_ATTRIB_PRINTF_FORMAT(2,0);
+externC int  diag_vsnprintf(char *buf, size_t len, const char *fmt, va_list ap)
+     CYGBLD_ATTRIB_PRINTF_FORMAT(3,0);
+externC int  diag_vprintf(const char *fmt, va_list ap)
+     CYGBLD_ATTRIB_PRINTF_FORMAT(1,0);
+
+
+/*---------------------------------------------------------------------------*/
+/* Internal Diagnostic MACROS                                                */
+
+#define DIAG_DEVICE_START_SYNC()
+#define DIAG_DEVICE_END_SYNC()
+
+/*---------------------------------------------------------------------------*/
+#endif /* CYGONCE_INFRA_DIAG_H */
+/* EOF diag.h */
diff --git a/ecos/packages/infra/current/include/testcase.h b/ecos/packages/infra/current/include/testcase.h
new file mode 100644
index 0000000..9d359b2
--- /dev/null
+++ b/ecos/packages/infra/current/include/testcase.h
@@ -0,0 +1,198 @@
+#ifndef CYGONCE_INFRA_TESTCASE_H
+#define CYGONCE_INFRA_TESTCASE_H
+//==========================================================================
+//
+//        testcase.h
+//
+//        Target side interface for tests
+//
+//==========================================================================
+// ####ECOSGPLCOPYRIGHTBEGIN####                                            
+// -------------------------------------------                              
+// This file is part of eCos, the Embedded Configurable Operating System.   
+// Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+//
+// eCos 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 or (at your option) any later      
+// version.                                                                 
+//
+// eCos 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 eCos; if not, write to the Free Software Foundation, Inc.,    
+// 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.            
+//
+// As a special exception, if other files instantiate templates or use      
+// macros or inline functions from this file, or you compile this file      
+// and link it with other works to produce a work based on this file,       
+// this file does not by itself cause the resulting work to be covered by   
+// the GNU General Public License. However the source code for this file    
+// must still be made available in accordance with section (3) of the GNU   
+// General Public License v2.                                               
+//
+// This exception does not invalidate any other reasons why a work based    
+// on this file might be covered by the GNU General Public License.         
+// -------------------------------------------                              
+// ####ECOSGPLCOPYRIGHTEND####                                              
+//==========================================================================
+//#####DESCRIPTIONBEGIN####
+//
+// Author(s):       ctarpy
+// Contributors:    ctarpy, jlarmour
+// Date:            1999-02-16
+//
+//
+//####DESCRIPTIONEND####
+
+#include <cyg/infra/cyg_type.h> // Common type definitions and support
+
+
+// CONSTANTS
+
+// Status codes
+
+typedef enum {
+    CYGNUM_TEST_FAIL,
+    CYGNUM_TEST_PASS,
+    CYGNUM_TEST_EXIT,
+    CYGNUM_TEST_INFO,
+    CYGNUM_TEST_GDBCMD,
+    CYGNUM_TEST_NA
+} Cyg_test_code;
+
+// FUNCTION PROTOTYPES
+
+externC void
+cyg_test_output(Cyg_test_code _status_, const char* _msg_, int _line_number_,
+                const char* _file_);
+
+// This should be called at the start of each test file
+externC void
+cyg_test_init(void);
+
+// This causes the test to exit
+externC void
+cyg_test_exit(void) CYGBLD_ATTRIB_NORET;
+
+// GLOBALS
+
+externC int cyg_test_is_simulator;    // infrastructure changes as necessary
+
+// MACROS
+
+// ----------- Info -----------
+//
+// Any macro with EXIT in it should only be used in a panic situation. It
+// is synonymous with assert. If the test behaves as expected, it
+// should call one of the FINISH macros.
+//
+// - Compound testcases
+// If a testcase is capable of being part of a compound, then the following
+// rules apply:
+// - The testcase must only ever call one of the EXIT macros if it decides
+//   the state of the system is such that further testing is meaningless;
+//   such a call would prevent subsequent tests in the compound from being
+//   run.
+// - In order to terminate the test, the testcase should call one of the
+//   FINISH macros. This must be done from within main().
+
+
+
+
+// The following is the testcase API to be used by testcases.
+
+#define CYG_TEST_INIT() cyg_test_init()
+
+#define CYG_TEST_INFO( _msg_ ) \
+ cyg_test_output(CYGNUM_TEST_INFO, _msg_, __LINE__, __FILE__)
+
+#define CYG_TEST_PASS( _msg_ ) \
+ cyg_test_output(CYGNUM_TEST_PASS, _msg_, __LINE__, __FILE__)
+
+#define CYG_TEST_FAIL( _msg_ ) \
+ cyg_test_output(CYGNUM_TEST_FAIL, _msg_, __LINE__, __FILE__)
+
+#define CYG_TEST_EXIT( _msg_ ) \
+ (cyg_test_output(CYGNUM_TEST_EXIT, _msg_, __LINE__, __FILE__), \
+  cyg_test_exit())
+
+// Use the following macro to instruct GDB to run a command when using
+// the automatic testing infrastructure. This must be used *before*
+// CYG_TEST_INIT() is called
+
+#define CYG_TEST_GDBCMD( _command_ )                                     \
+     CYG_MACRO_START                                                     \
+     cyg_test_output(CYGNUM_TEST_GDBCMD, _command_, __LINE__, __FILE__); \
+     CYG_MACRO_END
+
+// Use the following macro to declare that a test is not applicable for
+// some reason - perhaps not appropriate due to chosen hardware,
+// configuration options governing the presence of a tested feature, or
+// even configuration options governing the presence of a feature the
+// test relies on _in_order_ to test the feature (despite being
+// unrelated!)
+
+#define CYG_TEST_NA( _msg_ )                                         \
+     CYG_MACRO_START                                                 \
+     cyg_test_output(CYGNUM_TEST_NA, _msg_, __LINE__, __FILE__);     \
+     cyg_test_exit();                                                \
+     CYG_MACRO_END
+
+#ifdef CYG_COMPOUND_TEST
+#  define CYG_TEST_FINISH( _msg_ )                                  \
+     CYG_MACRO_START                                                \
+     cyg_test_output(CYGNUM_TEST_EXIT, _msg_, __LINE__, __FILE__);  \
+     return 0;                                                      \
+     CYG_MACRO_END
+#else
+#  define CYG_TEST_FINISH( _msg_ ) CYG_TEST_EXIT( _msg_ )
+#endif
+
+#define CYG_TEST_STILL_ALIVE( _ctr_ , _msg_ ) CYG_TEST_INFO( _msg_ )
+
+
+// ----- The following are convenience functions
+
+#define CYG_TEST_PASS_FINISH( _msg_ ) \
+    CYG_MACRO_START                   \
+    CYG_TEST_PASS( _msg_ );           \
+    CYG_TEST_FINISH("done");          \
+    CYG_MACRO_END
+ 
+#define CYG_TEST_FAIL_FINISH( _msg_ ) \
+    CYG_MACRO_START                   \
+    CYG_TEST_FAIL( _msg_ );           \
+    CYG_TEST_FINISH("done");          \
+    CYG_MACRO_END
+
+
+#define CYG_TEST_CHECK( _chk_ , _msg_)                                   \
+    CYG_MACRO_START                                                      \
+    (void)(( _chk_ ) || ( CYG_TEST_FAIL( _msg_ ) , cyg_test_exit(), 1)); \
+    CYG_MACRO_END
+
+#define CYG_TEST_PASS_FAIL( _cdn_, _msg_ )                            \
+    CYG_MACRO_START                                                   \
+    if ( _cdn_ ) CYG_TEST_PASS( _msg_ ); else CYG_TEST_FAIL( _msg_ ); \
+    CYG_MACRO_END
+
+
+// CYG_TEST_PASS_EXIT and CYG_TEST_FAIL_EXIT are now obscelete, 
+// but are here for now
+// to avoid breaking testcases which still use them. They will
+// soon go away.
+#define CYG_TEST_PASS_EXIT( _msg_ )                             \
+ (cyg_test_output(CYGNUM_TEST_PASS, _msg_, __LINE__, __FILE__), \
+ CYG_TEST_EXIT("done"))
+
+#define CYG_TEST_FAIL_EXIT( _msg_ )                             \
+ (cyg_test_output(CYGNUM_TEST_FAIL, _msg_, __LINE__, __FILE__), \
+ CYG_TEST_EXIT("done"))
+
+
+#endif // CYGONCE_INFRA_TESTCASE_H
+// EOF testcase.h