gwenhywfar  5.8.2
debug.h
Go to the documentation of this file.
1 /***************************************************************************
2  $RCSfile$
3  -------------------
4  cvs : $Id$
5  begin : Thu Nov 28 2002
6  copyright : (C) 2002 by Martin Preuss
7  email : martin@libchipcard.de
8 
9  ***************************************************************************
10  * *
11  * This library is free software; you can redistribute it and/or *
12  * modify it under the terms of the GNU Lesser General Public *
13  * License as published by the Free Software Foundation; either *
14  * version 2.1 of the License, or (at your option) any later version. *
15  * *
16  * This library is distributed in the hope that it will be useful, *
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of *
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
19  * Lesser General Public License for more details. *
20  * *
21  * You should have received a copy of the GNU Lesser General Public *
22  * License along with this library; if not, write to the Free Software *
23  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
24  * MA 02111-1307 USA *
25  * *
26  ***************************************************************************/
27 
28 
29 #ifndef GWEN_DEBUG_H
30 #define GWEN_DEBUG_H
31 
32 #include <stdio.h>
34 #include <gwenhywfar/logger.h>
35 #include <gwenhywfar/error.h>
36 #include <gwenhywfar/types.h>
37 
38 #ifdef __cplusplus
39 extern "C" {
40 #endif
41 
42 #if (defined HAVE_FUNC && (DEBUGMODE>10))
43 # define DBG_ENTER fprintf(stderr,"Enter \""__func__"\" \n")
44 # define DBG_LEAVE fprintf(stderr,"Leave \""__func__"\" \n")
45 #else
46 # define DBG_ENTER
47 # define DBG_LEAVE
48 #endif
49 
50 #define GWEN_MEMORY_DEBUG_MODE_ALL 0
51 #define GWEN_MEMORY_DEBUG_MODE_OPEN 1
52 #define GWEN_MEMORY_DEBUG_MODE_DETAILED 2
53 #define GWEN_MEMORY_DEBUG_MODE_SHORT 3
54 
56 
58 void GWEN_MemoryDebug_Increment(const char *name,
59  const char *wFile,
60  int wLine,
61  int attach);
63 void GWEN_MemoryDebug_Decrement(const char *name,
64  const char *wFile,
65  int wLine);
66 
68 void GWEN_MemoryDebug_Dump(uint32_t mode);
69 
71 void GWEN_MemoryDebug_DumpObject(const char *name,
72  uint32_t mode);
73 
75 long int GWEN_MemoryDebug_GetObjectCount(const char *name);
76 
78 void GWEN_MemoryDebug_CleanUp(void);
79 
80 
81 #ifdef GWEN_MEMORY_DEBUG
82 # define DBG_MEM_INC(o, attach)\
83  GWEN_MemoryDebug_Increment(o, __FILE__, __LINE__, attach)
84 # define DBG_MEM_DEC(o)\
85  GWEN_MemoryDebug_Decrement(o, __FILE__, __LINE__)
86 #else
87 # define DBG_MEM_INC(o, attach)
88 # define DBG_MEM_DEC(o)
89 #endif
90 
92 uint32_t GWEN_Debug_Snprintf(char *buffer,
93  uint32_t size,
94  const char *fmt, ...);
95 
96 #ifndef NO_VARIADIC_MACROS
97 # define DBG_ERROR(dbg_logger, format, args...) {\
98  if (GWEN_Logger_GetLevel(dbg_logger)>=GWEN_LoggerLevel_Error) {\
99  char dbg_buffer[300]; \
100  \
101  if (snprintf(dbg_buffer, sizeof(dbg_buffer)-1,\
102  __FILE__":%5d: " format , __LINE__ , ## args)>0) { \
103  dbg_buffer[sizeof(dbg_buffer)-1]=(char)0; \
104  GWEN_Logger_Log(dbg_logger, GWEN_LoggerLevel_Error, dbg_buffer);\
105  }\
106  }\
107  };
108 #else /* #ifndef NO_VARIADIC_MACROS */
110 void DBG_ERROR(const char *logdomain, const char *format, ...);
111 #endif /* #ifndef NO_VARIADIC_MACROS */
112 
113 #define DBG_ERROR_ERR(dbg_logger, dbg_err) {\
114  char dbg_buffer[300]; \
115  char dbg_errbuff[256]; \
116  \
117  GWEN_Error_ToString(dbg_err,dbg_errbuff, sizeof(dbg_errbuff)); \
118  snprintf(dbg_buffer, sizeof(dbg_buffer)-1,\
119  __FILE__":%5d: %s" , __LINE__ , dbg_errbuff); \
120  dbg_buffer[sizeof(dbg_buffer)-1]=0; \
121  GWEN_Logger_Log(dbg_logger, GWEN_LoggerLevel_Error, dbg_buffer);};
122 
123 #ifndef NO_VARIADIC_MACROS
124 # define DBG_WARN(dbg_logger, format, args...) {\
125  if (GWEN_Logger_GetLevel(dbg_logger)>=GWEN_LoggerLevel_Warning) {\
126  char dbg_buffer[300]; \
127  \
128  if (snprintf(dbg_buffer, sizeof(dbg_buffer)-1,\
129  __FILE__":%5d: " format , __LINE__ , ## args)>0) { \
130  dbg_buffer[sizeof(dbg_buffer)-1]=(char)0; \
131  GWEN_Logger_Log(dbg_logger, GWEN_LoggerLevel_Warning, dbg_buffer);\
132  }\
133  }\
134  };
135 #else /* #ifndef NO_VARIADIC_MACROS */
137 void DBG_WARN(const char *logdomain, const char *format, ...);
138 #endif /* #ifndef NO_VARIADIC_MACROS */
139 
140 #define DBG_WARN_ERR(dbg_logger, dbg_err) {\
141  char dbg_buffer[300]; \
142  char dbg_errbuff[256]; \
143  GWEN_Error_ToString(dbg_err,dbg_errbuff, sizeof(dbg_errbuff)); \
144  snprintf(dbg_buffer, sizeof(dbg_buffer)-1,\
145  __FILE__":%5d: %s" , __LINE__ , dbg_errbuff); \
146  dbg_buffer[sizeof(dbg_buffer)-1]=0; \
147  GWEN_Logger_Log(dbg_logger, GWEN_LoggerLevel_Warning, dbg_buffer);};
148 
149 
150 #ifndef NO_VARIADIC_MACROS
151 # define DBG_NOTICE(dbg_logger, format, args...) \
152  if (GWEN_Logger_GetLevel(dbg_logger)>=GWEN_LoggerLevel_Notice) {\
153  char dbg_buffer[300]; \
154  \
155  if (snprintf(dbg_buffer, sizeof(dbg_buffer)-1,\
156  __FILE__":%5d: " format , __LINE__ , ## args)>0) { \
157  dbg_buffer[sizeof(dbg_buffer)-1]=(char)0; \
158  GWEN_Logger_Log(dbg_logger, GWEN_LoggerLevel_Notice, dbg_buffer);\
159  }\
160  };
161 #else /* #ifndef NO_VARIADIC_MACROS */
163 void DBG_NOTICE(const char *logdomain, const char *format, ...);
164 #endif /* #ifndef NO_VARIADIC_MACROS */
165 
166 #define DBG_NOTICE_ERR(dbg_logger, dbg_err) \
167  if (GWEN_Logger_GetLevel(dbg_logger)>=GWEN_LoggerLevel_Notice) {\
168  char dbg_buffer[300]; \
169  char dbg_errbuff[256]; \
170  GWEN_Error_ToString(dbg_err,dbg_errbuff, sizeof(dbg_errbuff)); \
171  snprintf(dbg_buffer, sizeof(dbg_buffer)-1,\
172  __FILE__":%5d: %s" , __LINE__ , dbg_errbuff); \
173  dbg_buffer[sizeof(dbg_buffer)-1]=0; \
174  GWEN_Logger_Log(dbg_logger, GWEN_LoggerLevel_Notice, dbg_buffer);};
175 
176 
177 #ifndef NO_VARIADIC_MACROS
178 # define DBG_INFO(dbg_logger, format, args...) \
179  if (GWEN_Logger_GetLevel(dbg_logger)>=GWEN_LoggerLevel_Info) {\
180  char dbg_buffer[300]; \
181  \
182  if (snprintf(dbg_buffer, sizeof(dbg_buffer)-1,\
183  __FILE__":%5d: " format , __LINE__ , ## args)>0) { \
184  dbg_buffer[sizeof(dbg_buffer)-1]=(char)0; \
185  GWEN_Logger_Log(dbg_logger, GWEN_LoggerLevel_Info, dbg_buffer);\
186  }\
187  };
188 #else /* #ifndef NO_VARIADIC_MACROS */
190 void DBG_INFO(const char *logdomain, const char *format, ...);
191 #endif /* #ifndef NO_VARIADIC_MACROS */
192 
193 #define DBG_INFO_ERR(dbg_logger, dbg_err) \
194  if (GWEN_Logger_GetLevel(dbg_logger)>=GWEN_LoggerLevel_Info) {\
195  char dbg_buffer[300]; \
196  char dbg_errbuff[256]; \
197  GWEN_Error_ToString(dbg_err,dbg_errbuff, sizeof(dbg_errbuff)); \
198  snprintf(dbg_buffer, sizeof(dbg_buffer)-1,\
199  __FILE__":%5d: %s" , __LINE__ , dbg_errbuff); \
200  dbg_buffer[sizeof(dbg_buffer)-1]=0; \
201  GWEN_Logger_Log(dbg_logger, GWEN_LoggerLevel_Info, dbg_buffer);};
202 
203 
204 
205 
206 #ifndef DISABLE_DEBUGLOG
207 
208 # ifndef NO_VARIADIC_MACROS
209 # define DBG_DEBUG(dbg_logger, format, args...) \
210  if (GWEN_Logger_GetLevel(dbg_logger)>=GWEN_LoggerLevel_Debug) {\
211  char dbg_buffer[300]; \
212  snprintf(dbg_buffer, sizeof(dbg_buffer)-1,\
213  __FILE__":%5d: " format , __LINE__ , ## args); \
214  dbg_buffer[sizeof(dbg_buffer)-1]=0; \
215  GWEN_Logger_Log(dbg_logger, GWEN_LoggerLevel_Debug, dbg_buffer);};
216 
217 # define DBG_VERBOUS(dbg_logger, format, args...) \
218  if (GWEN_Logger_GetLevel(dbg_logger)>=GWEN_LoggerLevel_Verbous) {\
219  char dbg_buffer[300]; \
220  snprintf(dbg_buffer, sizeof(dbg_buffer)-1,\
221  __FILE__":%5d: " format , __LINE__ , ## args); \
222  dbg_buffer[sizeof(dbg_buffer)-1]=0; \
223  GWEN_Logger_Log(dbg_logger, GWEN_LoggerLevel_Verbous, dbg_buffer);};
224 # endif /* #ifndef NO_VARIADIC_MACROS */
225 
226 # define DBG_DEBUG_ERR(dbg_logger, dbg_err) \
227  if (GWEN_Logger_GetLevel(dbg_logger)>=GWEN_LoggerLevel_Debug) {\
228  char dbg_buffer[300]; \
229  char dbg_errbuff[256]; \
230  GWEN_Error_ToString(dbg_err,dbg_errbuff, sizeof(dbg_errbuff)); \
231  snprintf(dbg_buffer, sizeof(dbg_buffer)-1,\
232  __FILE__":%5d: %s" , __LINE__ , dbg_errbuff); \
233  dbg_buffer[sizeof(dbg_buffer)-1]=0; \
234  GWEN_Logger_Log(dbg_logger, GWEN_LoggerLevel_Debug, dbg_buffer);};
235 
236 # define DBG_VERBOUS_ERR(dbg_logger, dbg_err) \
237  if (GWEN_Logger_GetLevel(dbg_logger)>=GWEN_LoggerLevel_Verbous) {\
238  char dbg_buffer[300]; \
239  char dbg_errbuff[256]; \
240  GWEN_Error_ToString(dbg_err,dbg_errbuff, sizeof(dbg_errbuff)); \
241  snprintf(dbg_buffer, sizeof(dbg_buffer)-1,\
242  __FILE__":%5d: %s" , __LINE__ , dbg_errbuff); \
243  dbg_buffer[sizeof(dbg_buffer)-1]=0; \
244  GWEN_Logger_Log(dbg_logger, GWEN_LoggerLevel_Verbous, dbg_buffer);};
245 
246 
247 
248 #else
249 
250 # ifndef NO_VARIADIC_MACROS
251 # define DBG_DEBUG(dbg_logger, format, args...)
252 # define DBG_VERBOUS(dbg_logger, format, args...)
253 # endif /* ifndef NO_VARIADIC_MACROS */
254 
255 # define DBG_DEBUG_ERR(dbg_logger, dbg_err)
256 # define DBG_VERBOUS_ERR(dbg_logger, dbg_err)
257 
258 #endif /* DISABLE_DEBUGLOG */
259 
260 #ifdef NO_VARIADIC_MACROS
262 void DBG_DEBUG(const char *logdomain, const char *format, ...);
264 void DBG_VERBOUS(const char *logdomain, const char *format, ...);
265 #endif /* #ifdef NO_VARIADIC_MACROS */
266 
267 
268 #ifdef __cplusplus
269 }
270 #endif
271 
272 
273 #endif
274 
275 
DBG_WARN
#define DBG_WARN(dbg_logger, format, args...)
Definition: debug.h:124
GWEN_MemoryDebug_Decrement
GWENHYWFAR_API void GWEN_MemoryDebug_Decrement(const char *name, const char *wFile, int wLine)
types.h
logger.h
fmt
GWENHYWFAR_API const char * fmt
Definition: buffer.h:283
GWEN_Debug_Snprintf
GWENHYWFAR_API uint32_t GWEN_Debug_Snprintf(char *buffer, uint32_t size, const char *fmt,...)
GWEN_MemoryDebug_DumpObject
GWENHYWFAR_API void GWEN_MemoryDebug_DumpObject(const char *name, uint32_t mode)
DBG_NOTICE
#define DBG_NOTICE(dbg_logger, format, args...)
Definition: debug.h:151
DBG_INFO
#define DBG_INFO(dbg_logger, format, args...)
Definition: debug.h:178
GWEN_MEMORY_DEBUG_OBJECT
struct GWEN_MEMORY_DEBUG_OBJECT GWEN_MEMORY_DEBUG_OBJECT
Definition: debug.h:55
DBG_VERBOUS
#define DBG_VERBOUS(dbg_logger, format, args...)
Definition: debug.h:217
GWEN_MemoryDebug_GetObjectCount
GWENHYWFAR_API long int GWEN_MemoryDebug_GetObjectCount(const char *name)
error.h
GWEN_MemoryDebug_CleanUp
GWENHYWFAR_API void GWEN_MemoryDebug_CleanUp(void)
DBG_DEBUG
#define DBG_DEBUG(dbg_logger, format, args...)
Definition: debug.h:209
GWEN_MemoryDebug_Dump
GWENHYWFAR_API void GWEN_MemoryDebug_Dump(uint32_t mode)
gwenhywfarapi.h
GWEN_MemoryDebug_Increment
GWENHYWFAR_API void GWEN_MemoryDebug_Increment(const char *name, const char *wFile, int wLine, int attach)
GWENHYWFAR_API
#define GWENHYWFAR_API
Definition: gwenhywfarapi.h:67
DBG_ERROR
#define DBG_ERROR(dbg_logger, format, args...)
Definition: debug.h:97