tmfat32debug.h

PNX1500上Fat32文件系统源代码

/* -------------------------------------------------------------------------- */
/* (C) Copyright 2000,2002, 2003 Koninklijke Philips Electronics N.V.,        */
/*     All rights reserved                                                    */
/*                                                                            */
/* This source code and any compilation or derivative thereof is the          */
/* proprietary information of Konlinklijke Philips Electronics N.V. and is    */
/* Confidential in nature.                                                    */
/* Under no circumstances is this software to be exposed to or placed under an*/
/* Open Source License of any type without the expressed written permission of*/
/* Koninklijke Philips Electronics N.V.                                       */
/* -------------------------------------------------------------------------- */
/* FILE NAME:    tmFat32Debug.h                                               */
/*                                                                            */
/* DESCRIPTION:  Debugging definitions for tmFat32.                           */
/*                                                                            */
/* DOCUMENT REF: tbd                                                          */
/* 																			  */
/* NOTES:        tbd                                                          */
/*                                                                            */
/* -------------------------------------------------------------------------- */

#ifndef _TMFAT32DEBUG_H_
#define _TMFAT32DEBUG_H_

/* -------------------------------------------------------------------------- */
/*                                                                            */
/*   Standard include files:                                                  */
/*                                                                            */
/* -------------------------------------------------------------------------- */

#if !USE_GENERIC_C
#include <tmbslCore.h>
#endif

#if USE_SIMULATOR || USE_GENERIC_C
#include <assert.h>
#endif

/* -------------------------------------------------------------------------- */
/* Define extern c for C++ prototypes                                         */
/* -------------------------------------------------------------------------- */

#if defined(__cplusplus)
extern "C"{
#endif

/* -------------------------------------------------------------------------- */
/*    Types and defines:                                                      */
/* -------------------------------------------------------------------------- */

// Debugging macros

// Set what we mean by "debug"

#if USE_GENERIC_C
#define TMFAT_DEBUG     defined(NDEBUG)
#else
#define TMFAT_DEBUG     0
//#define TMFAT_DEBUG     ((TMFL_REL == TMFL_REL_DEBUG) || (TMFL_REL == TMFL_REL_TRACE))
#endif

#if     !TMFAT_DEBUG

#define TMFAT_DEBUG7(pFmt, p1, p2, p3, p4, p5, p6, p7)
#define TMFAT_DEBUG6(pFmt, p1, p2, p3, p4, p5, p6)
#define TMFAT_DEBUG5(pFmt, p1, p2, p3, p4, p5)
#define TMFAT_DEBUG4(pFmt, p1, p2, p3, p4)
#define TMFAT_DEBUG3(pFmt, p1, p2, p3)
#define TMFAT_DEBUG2(pFmt, p1, p2)
#define TMFAT_DEBUG1(pFmt, p1)
#define TMFAT_DEBUG0(pFmt)

#define DUMP_STR(desc,p,len)
#define DUMP_8(desc,p)
#define DUMP_16(desc,p)
#define DUMP_32(desc,p)

#else   // !TMFAT_DEBUG

#define DUMP_STR(desc,p,len) \
                {UInt8 tempstr[(len) + 1]; GETSTRING(tempstr, p, len); \
                 TMFAT_DEBUG2("%s: '%s'\n", desc, tempstr);}

#define DUMP_8(desc,p) TMFAT_DEBUG2("%s: %u\n", desc, ((UInt8 *)(p))[0])
                 
#define DUMP_16(desc,p) \
                {UInt16 temp16; temp16 = GET16(p); \
                 TMFAT_DEBUG2("%s: %u\n", desc, temp16);}

#define DUMP_32(desc,p) \
                {UInt32 temp32; temp32 = GET32(p); \
                 TMFAT_DEBUG2("%s: %u\n", desc, temp32);}

#if USE_SIMULATOR || USE_GENERIC_C

#define TMFAT_DEBUG7(pFmt, p1, p2, p3, p4, p5, p6, p7) printf(pFmt, p1, p2, p3, p4, p5, p6, p7)
#define TMFAT_DEBUG6(pFmt, p1, p2, p3, p4, p5, p6)     printf(pFmt, p1, p2, p3, p4, p5, p6)
#define TMFAT_DEBUG5(pFmt, p1, p2, p3, p4, p5)         printf(pFmt, p1, p2, p3, p4, p5)
#define TMFAT_DEBUG4(pFmt, p1, p2, p3, p4)             printf(pFmt, p1, p2, p3, p4)
#define TMFAT_DEBUG3(pFmt, p1, p2, p3)                 printf(pFmt, p1, p2, p3)
#define TMFAT_DEBUG2(pFmt, p1, p2)                     printf(pFmt, p1, p2)
#define TMFAT_DEBUG1(pFmt, p1)                         printf(pFmt, p1)
#define TMFAT_DEBUG0(pFmt)                             printf(pFmt)

#else

#define TMFAT_DEBUG0(t)                                                       \
    DBG_PRINT0(                                                               \
        DBG_MEM,                                                              \
        DBG_DEFAULT,                                                          \
        (t)                                                                   \
    )
#define TMFAT_DEBUG1(t, u)                                                    \
    DBG_PRINT1(                                                               \
        DBG_MEM,                                                              \
        DBG_DEFAULT,                                                          \
        (t),                                                                  \
        (u)                                                                   \
    )
#define TMFAT_DEBUG2(t, u, v)                                                 \
    DBG_PRINT2(                                                               \
        DBG_MEM,                                                              \
        DBG_DEFAULT,                                                          \
        (t),                                                                  \
        (u),                                                                  \
        (v)                                                                   \
    )
#define TMFAT_DEBUG3(t, u, v, w)                                              \
    DBG_PRINT3(                                                               \
        DBG_MEM,                                                              \
        DBG_DEFAULT,                                                          \
        (t),                                                                  \
        (u),                                                                  \
        (v),                                                                  \
        (w)                                                                   \
    )
#define TMFAT_DEBUG4(t, u, v, w, x)                                           \
    DBG_PRINT4(                                                               \
        DBG_MEM,                                                              \
        DBG_DEFAULT,                                                          \
        (t),                                                                  \
        (u),                                                                  \
        (v),                                                                  \
        (w),                                                                  \
        (x)                                                                   \
    )
#define TMFAT_DEBUG5(t, u, v, w, x, y)                                        \
    DBG_PRINT5(                                                               \
        DBG_MEM,                                                              \
        DBG_DEFAULT,                                                          \
        (t),                                                                  \
        (u),                                                                  \
        (v),                                                                  \
        (w),                                                                  \
        (x),                                                                  \
        (y)                                                                   \
    )
#define TMFAT_DEBUG6(t, u, v, w, x, y, z)                                     \
    DBG_PRINT6(                                                               \
        DBG_MEM,                                                              \
        DBG_DEFAULT,                                                          \
        (t),                                                                  \
        (u),                                                                  \
        (v),                                                                  \
        (w),                                                                  \
        (x),                                                                  \
        (y),                                                                  \
        (z)                                                                   \
    )
    
#define TMFAT_DEBUG7(t, u, v, w, x, y, z, a)                                  \
    DBG_PRINT7(                                                               \
        DBG_MEM,                                                              \
        DBG_DEFAULT,                                                          \
        (t),                                                                  \
        (u),                                                                  \
        (v),                                                                  \
        (w),                                                                  \
        (x),                                                                  \
        (y),                                                                  \
        (z),                                                                  \
        (a)                                                                   \
    )

#endif
#endif  // !TMFAT_DEBUG

#define CHECK(x, code) if (code != TM_OK) \
					   { TMFAT_DEBUG2 ("%s failed, status = 0x%X\n",#x, code); \
					   	return code; }

#if     TMFAT_DEBUG

#if 0
#define TMFAT_PANIC(s)      { printf("PANIC tmFat32: "); printf(s); exit(1); }
#define TMFAT_PANIC1(s,x)   { printf("PANIC tmFat32: "); printf(s,x); exit(1); }
#else
#define TMFAT_PANIC(s)      { printf("PANIC tmFat32: "); printf(s);}
#define TMFAT_PANIC1(s,x)   { printf("PANIC tmFat32: "); printf(s,x);}
#endif

#define TM_FAT32_ASSERT_ERROR  (TM_FAT32_ERR_BASE | TM_ERR_ASSERT_START | \
                                    TM_ERR_ASSERTION)
#if USE_SIMULATOR || USE_GENERIC_C
#define TMFAT_ASSERT(exp)      assert((exp))
#else
#define TMFAT_ASSERT(exp)      tmbslCoreAssert((exp), TM_FAT32_ASSERT_ERROR,\
                               tmbslCoreDbgDevMem)
#endif

#else

#define TMFAT_PANIC(s)
#define TMFAT_PANIC1(s,x)
#define TMFAT_ASSERT(exp)

#endif  // TMFAT_DEBUG


/* -------------------------------------------------------------------------- */
/*    Exported functions:                                                     */
/* -------------------------------------------------------------------------- */

    
//-----------------------------------------------------------------------------
// FUNCTION:    UTIL_dump_buffer
//
// DESCRIPTION: For debugging.
//
// RETURN:      
//
// NOTES:       
//-----------------------------------------------------------------------------
//

void UTIL_dump_buffer (
    UInt8  *buf,     // I: Pointer to buffer to dump
    UInt    size     // I: Number of bytes to dump (should be a multiple of 16).
    );

/* -------------------------------------------------------------------------- */
/* End of extern c for C++ prototypes                                         */
/* -------------------------------------------------------------------------- */

#if defined(__cplusplus)
}
#endif

#endif	/* !defined(_TMFAT32DEBUG_H_) */