coffdefs.h

TMS320F2808的完整驱动测试程序源码

/*------------------------------------------------------------------------*/
#define  TI_T_NULL     0x80       /* UNDEFINED OR ERROR TYPE (NO TYPE INFO)  */
#define  TI_T_VOID     0          /* VOID TYPE                               */
#define  TI_T_SCHAR    1          /* CHARACTER (EXPLICITLY "signed")         */
#define  TI_T_CHAR     2          /* CHARACTER (IMPLICITLY SIGNED)           */
#define  TI_T_SHORT    3          /* SHORT INTEGER                           */
#define  TI_T_INT      4          /* INTEGER                                 */
#define  TI_T_LONG     5          /* LONG INTEGER                            */
#define  TI_T_FLOAT    6          /* SINGLE PRECISION FLOATING POINT         */
#define  TI_T_DOUBLE   7          /* DOUBLE PRECISION FLOATING POINT         */
#define  TI_T_STRUCT   8          /* STRUCTURE                               */
#define  TI_T_UNION    9          /* UNION                                   */
#define  TI_T_ENUM     10         /* ENUMERATION                             */
#define  TI_T_LDOUBLE  11         /* LONG DOUBLE FLOATING POINT              */
#define  TI_T_UCHAR    12         /* UNSIGNED CHARACTER                      */
#define  TI_T_USHORT   13         /* UNSIGNED SHORT                          */
#define  TI_T_UINT     14         /* UNSIGNED INTEGER                        */
#define  TI_T_ULONG    15         /* UNSIGNED LONG                           */

/*------------------------------------------------------------------------*/
/* SIGNED AND UNSIGNED ARE NOT ACTUALLY STORED IN THE TYPE FIELD BUT      */
/* USED TO MODIFY THE BYTPE ACCORDINGLY.                                  */
/*------------------------------------------------------------------------*/
#define  TI_T_SIGNED   16         /* BECOMES CHAR, SHORT, INT, OR LONG       */
#define  TI_T_UNSIGNED 17         /* BECOMES UCHAR, USHORT, UINT, OR ULONG   */

/*------------------------------------------------------------------------*/
/* DERIVED TYPES: 2 BITS EACH                                             */
/*------------------------------------------------------------------------*/
#define  TI_DT_NON     0x0        /* NO DERIVED TYPE                         */
#define  TI_DT_PTR     0x1        /* POINTER                                 */
#define  TI_DT_FCN     0x2        /* FUNCTION                                */
#define  TI_DT_ARY     0x3        /* ARRAY                                   */

/*------------------------------------------------------------------------*/
/* TYPE QUALIFIERS - USES SAME ENCODING AS TYPE FIELDS                    */
/*------------------------------------------------------------------------*/
#define  TI_Q_CONST    0x1
#define  TI_Q_VOLATILE 0x2


/*------------------------------------------------------------------------*/
/* TYPE FIELD MASKS AND SIZES                                             */
/*------------------------------------------------------------------------*/
#define  TI_N_BTMASK     0xF      /* MASK FOR BASIC TYPE                     */
#define  TI_N_TMASK      0x30     /* MASK FOR FIRST DERIVED TYPE             */    
#define  TI_N_DTMAX      12       /* MAXIMUM DERIVED TYPES                   */
#define  TI_N_BTSHFT     4        /* SHIFT AMOUNT (WIDTH) FOR BASIC TYPE     */
#define  TI_N_TSHIFT     2        /* SHIFT AMOUNT (WIDTH) FOR DERIVED TYPES  */

/*------------------------------------------------------------------------*/
/* TYPE MANIPULATION MACROS                                               */
/*                                                                        */
/*    BTYPE(t)    - Return basic type from t                              */
/*    DTYPE(t)    - Return all derived types from t                       */
/*    DTYPE1(t)   - Return 1st derived type from t                        */
/*    TQUAL(t,q)  - Return qualification of type                          */
/*    UNQUAL(t,q) - Return unqualified version of type                    */
/*                                                                        */
/*    MKTYPE()    - Build a type from basic and several derived types     */
/*    DERIVE(d,t) - Build a type from basic and one derived type          */
/*    INCREF(t)   - Convert 't' into pointer to 't'                       */
/*    DECREF(t)   - Remove first derviation from t                        */
/*                                                                        */
/*    ISINT(t)    - TRUE if t is an integral type                         */
/*    ISSGN(t)    - TRUE if t is a signed type                            */
/*    ISUNS(t)    - TRUE if t is an unsigned type                         */
/*    ISFLT(t)    - TRUE if t is a floating point type                    */
/*    ISDBL(t)    - TRUE if t is a double or long double type             */
/*    ISPTR(t)    - TRUE if t is a pointer                                */
/*    ISFCN(t)    - TRUE if t is a function                               */
/*    ISARY(t)    - TRUE if t is an array                                 */
/*    ISSTR(t)    - TRUE if t is a struct, union, or enum type            */
/*    ISAGG(t)    - TRUE if t is an array, struct, or union               */
/*                                                                        */
/*    ITOU(t)     - convert signed type to unsigned equivalent            */
/*    UTOI(t)     - convert unsigned type to signed equivalent            */
/*    NOSIGN(t)   - convert signed or unsigned type to "plain" equivalent */
/*------------------------------------------------------------------------*/
#define  TI_BTYPE(t)    ((int)((t) & TI_N_BTMASK))  
#define  TI_DTYPE(t)    ((t) & ~TI_N_BTMASK)
#define  TI_DTYPE1(t)   (((t) & TI_N_TMASK) >> TI_N_BTSHFT)

#define  TI_TQUAL(t,q)  ((int)(TI_DTYPE(t) ? TI_DTYPE1(q) : TI_BTYPE(q)))
#define  TI_UNQUAL(t,q) (TI_ISPTR(t) ? ((q) & ~TI_N_TMASK) : ((q) & ~TI_N_BTMASK))

#define  TI_MKTYPE(basic, d1,d2,d3,d4,d5,d6) \
                     ((basic) | ((d1) <<  4) | ((d2) <<  6) | ((d3) <<  8) |\
                                ((d4) << 10) | ((d5) << 12) | ((d6) << 14))
#define  TI_DERIVE(d,t) ((TI_DTYPE(t) << TI_N_TSHIFT) | ((d)    << TI_N_BTSHFT) | TI_BTYPE(t))
#define  TI_INCREF(t)   ((TI_DTYPE(t) << TI_N_TSHIFT) | (TI_DT_PTR << TI_N_BTSHFT) | TI_BTYPE(t))
#define  TI_DECREF(t)   (TI_DTYPE((t) >> TI_N_TSHIFT) | TI_BTYPE(t))

#define  TI_ISSGN(t)    (((t) >= TI_T_SCHAR && (t) <= TI_T_LONG)  || (t) == TI_T_ENUM)
#define  TI_ISUNS(t)    ((t) >= TI_T_UCHAR  && (t) <= TI_T_ULONG)
#define  TI_ISINT(t)    (((t) >= TI_T_SCHAR && (t) <= TI_T_LONG)  || (t) == TI_T_ENUM || \
                      ((t) >= TI_T_UCHAR  && (t) <= TI_T_ULONG))
#define  TI_ISFLT(t)    ((t) == TI_T_FLOAT || (t) == TI_T_DOUBLE || (t) == TI_T_LDOUBLE)
#define	 TI_ISDBL(t)    ((t) == TI_T_DOUBLE || (t) == TI_T_LDOUBLE)
#define  TI_ISPTR(t)    (((t) & TI_N_TMASK) == (TI_DT_PTR << TI_N_BTSHFT)) 
#define  TI_ISFCN(t)    (((t) & TI_N_TMASK) == (TI_DT_FCN << TI_N_BTSHFT))
#define  TI_ISARY(t)    (((t) & TI_N_TMASK) == (TI_DT_ARY << TI_N_BTSHFT))
#define  TI_ISSTR(t)    ((t) == TI_T_STRUCT || (t) == TI_T_UNION || (t) == TI_T_ENUM)
#define  TI_ISAGG(t)    (TI_ISARY(t) || (t) == TI_T_STRUCT || (t) == TI_T_UNION)
#define  TI_ISCHAR(t)   ((t) == TI_T_CHAR || (t) == TI_T_SCHAR || (t) == TI_T_UCHAR)
#define  TI_ISSHORT(t)  ((t) == TI_T_SHORT || (t) == TI_T_USHORT)
#define  TI_ISLONG(t)   ((t) == TI_T_LONG || (t) == TI_T_ULONG)

#define  TI_ITOU(t)     ((t) + (TI_T_UCHAR - ((t) == TI_T_SCHAR ? TI_T_SCHAR : TI_T_CHAR)))
#define  TI_UTOI(t)     ((t) - (TI_T_UCHAR - TI_T_CHAR))
#define  TI_NOSIGN(t)   (TI_ISUNS(t) ? TI_UTOI(t) : (t) == TI_T_SCHAR ? TI_T_CHAR : (t))

/*------------------------------------------------------------------------*/
/* ILLEGAL TYPES USED TO MARK SPECIAL OBJECTS.                            */
/*                                                                        */
/* TI_T_VENEER  - DENOTES A VENEER OF A FUNCTION.                            */
/*------------------------------------------------------------------------*/
#define TI_T_VENEER     (MKTYPE(TI_T_VOID, TI_DT_FCN, TI_DT_FCN, 0, 0, 0, 0))
#define TI_ISVENEER(t)  ((t) == TI_T_VENEER)