source: svn/trunk/zas_dstar/hal/os/src/v2lin/v2ldebug.h

/****************************************************************************
 * This file is part of the v2lin Library.
 * VxWorks is a registered trademark of Wind River Systems, Inc.
 *
 * Copyright (C) 2006 Constantine Shulyupin, conan.sh@gmail.com
 *
 * The v2lin library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * The v2lin Library 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
 * Lesser General Public License for more details.
 *
 ****************************************************************************/

#ifndef __V2LIN_DEBUG__
#define __V2LIN_DEBUG__

#include <time.h>
#include <string.h>
#include <stdio.h>
#include <sys/time.h>
#include <errno.h>

#include <sys/types.h>
#ifdef USE_CYGWIN
#include <unistd.h>
#else
#include <linux/unistd.h>
#endif
pid_t gettid(void);

#include "internal.h"

extern int trace;
extern int trace_cnt;
extern int tid;
extern char trace_fn[100];

extern struct timeval prev_tv;
extern struct timeval start_tv;

//#define DEBUG

void trace_time();
#ifdef DEBUG

// TRACEV is for printing variable name and value
#define TRACEV(F,V) do { if (trace)  { \
        if ( tid != gettid() ) { \
                tid = gettid();\
                fprintf(stderr,"thread=%i\n",tid);}; \
        fprintf(stderr,#V"="F"\n",V);   \
} } while (0)

#define TRACEF(args ... ) do { if (trace)  { \
        trace_time(); \
        fprintf(stderr,"%s:%i", __FILE__, __LINE__);    \
        if ( strcmp(trace_fn,__FUNCTION__) ) \
                strcpy(trace_fn,__FUNCTION__) && fprintf(stderr," %s()",trace_fn); \
        fprintf(stderr," "args);        \
        fprintf(stderr,"\n");   \
} } while (0)

//      if ( tid != gettid() ) { 
//              tid = gettid();
//              fprintf(stderr,"\nthread=%i task=%x %s\n",(int)tid,(int)my_task(),my_task()?my_task()->taskname:NULL);}; 
//

#else
#define TRACEV(F,V)
#define TRACEF(args ... )
#endif

#define FNSTART int status = OK;
#define FNFINISH exit: return status;

#ifdef TRACE_IN_OUT
#define FN_IN(s) TRACEF("%s {",s)
#define FN_OUT(s) TRACEF("%s }",s)
#else
#define FN_IN(s)
#define FN_OUT(s)
#endif

// ON_ERR defines common error processing behaveur:
// a) ignore error and continue code exection
// b) goto to finalization sections of a functions

#define ON_ERR // ignore
//#define ON_ERR goto exit

// CHK and CHK0 - common macros for error processing
// and optional code tracing. This marcos prints error messages and
// optionally processes errors in case of subfunction failures.
#define TRACE_errno() fprintf(stderr,"\t|%s:%d| errno=%i(%x) %s \n",__FUNCTION__, __LINE__, errno, errno, VxWorksError(errno))

// CHK supposes !0 is success, suitable for checking pointers
// and functions in form: CHK(0<read(fd,buff,count));
#define CHK(command)    \
        do {    int ret;\
                FN_IN(#command); \
                if ( ! (ret=(int) (command)) ) {    \
                        TRACEF("ERROR: %s \n\treturned 0",#command);   \
                        TRACE_errno(); \
                        ON_ERR ;\
                }   \
                FN_OUT(#command); \
        } while (0)

// CHK0 supposes 0 is success, sutable for checking most of libc functions
#define CHK0(command)   \
        do { \
                int status;  \
                FN_IN(#command); \
                if ((status = (command)) != 0 ) {    \
                        TRACEF("ERROR: %s \n\treturned status: #%i (%x):\"%s\"",\
                                #command,status,status, VxWorksError(status));   \
                        TRACE_errno(); \
                        ON_ERR;\
                }   \
                FN_OUT(#command); \
        } while (0)

//#define TRACE_PTHREAD
#ifdef TRACE_PTHREAD

#define pthread_mutex_lock(m)   \
do { \
        if ( EBUSY == pthread_mutex_trylock(m)) { TRACEF("pthread_mutex_lock %s %x EBUSY",#m,m); \
        pthread_mutex_lock(m); } \
        TRACEF("pthread_mutex_lock %s %x OK",#m,m); \
} while ( 0 )

#define pthread_mutex_unlock(m) \
do { \
        TRACEF("pthread_mutex_unlock %s %x OK",#m,m); \
        pthread_mutex_unlock(m); \
} while ( 0 )

#define pthread_cond_timedwait(args ... ) \
        ( fprintf(stderr,"%s:%i %s", __FILE__, __LINE__, __FUNCTION__), \
        fprintf(stderr,"pthread_cond_timedwait %x\n",#args), pthread_cond_timedwait(args))

#define thread_cleanup_pop(i) do { \
        TRACEF("thread_cleanup_pop %s OK",#i); \
        thread_cleanup_pop(m); \
} while ( 0 
#endif

#endif