gwenhywfar  5.10.1
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>
33 #include <gwenhywfar/gwenhywfarapi.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 
55 typedef struct GWEN_MEMORY_DEBUG_OBJECT GWEN_MEMORY_DEBUG_OBJECT;
56 
57 GWENHYWFAR_API
58 void GWEN_MemoryDebug_Increment(const char *name,
59  const char *wFile,
60  int wLine,
61  int attach);
62 GWENHYWFAR_API
63 void GWEN_MemoryDebug_Decrement(const char *name,
64  const char *wFile,
65  int wLine);
66 
67 GWENHYWFAR_API
68 void GWEN_MemoryDebug_Dump(uint32_t mode);
69 
70 GWENHYWFAR_API
71 void GWEN_MemoryDebug_DumpObject(const char *name,
72  uint32_t mode);
73 
74 GWENHYWFAR_API
75 long int GWEN_MemoryDebug_GetObjectCount(const char *name);
76 
77 GWENHYWFAR_API
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 
91 GWENHYWFAR_API
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 */
109 GWENHYWFAR_API
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  if (snprintf(dbg_buffer, sizeof(dbg_buffer)-1,\
119  __FILE__":%5d: %s" , __LINE__ , dbg_errbuff)>0) { \
120  dbg_buffer[sizeof(dbg_buffer)-1]=0; \
121  GWEN_Logger_Log(dbg_logger, GWEN_LoggerLevel_Error, dbg_buffer);}; \
122  };
123 
124 #ifndef NO_VARIADIC_MACROS
125 # define DBG_WARN(dbg_logger, format, args...) {\
126  if (GWEN_Logger_GetLevel(dbg_logger)>=GWEN_LoggerLevel_Warning) {\
127  char dbg_buffer[300]; \
128  \
129  if (snprintf(dbg_buffer, sizeof(dbg_buffer)-1,\
130  __FILE__":%5d: " format , __LINE__ , ## args)>0) { \
131  dbg_buffer[sizeof(dbg_buffer)-1]=(char)0; \
132  GWEN_Logger_Log(dbg_logger, GWEN_LoggerLevel_Warning, dbg_buffer);\
133  }\
134  }\
135  };
136 #else /* #ifndef NO_VARIADIC_MACROS */
137 GWENHYWFAR_API
138 void DBG_WARN(const char *logdomain, const char *format, ...);
139 #endif /* #ifndef NO_VARIADIC_MACROS */
140 
141 #define DBG_WARN_ERR(dbg_logger, dbg_err) {\
142  char dbg_buffer[300]; \
143  char dbg_errbuff[256]; \
144  GWEN_Error_ToString(dbg_err,dbg_errbuff, sizeof(dbg_errbuff)); \
145  if (snprintf(dbg_buffer, sizeof(dbg_buffer)-1,\
146  __FILE__":%5d: %s" , __LINE__ , dbg_errbuff)>0) { \
147  dbg_buffer[sizeof(dbg_buffer)-1]=0; \
148  GWEN_Logger_Log(dbg_logger, GWEN_LoggerLevel_Warning, dbg_buffer);}; \
149  };
150 
151 #ifndef NO_VARIADIC_MACROS
152 # define DBG_NOTICE(dbg_logger, format, args...) \
153  if (GWEN_Logger_GetLevel(dbg_logger)>=GWEN_LoggerLevel_Notice) {\
154  char dbg_buffer[300]; \
155  \
156  if (snprintf(dbg_buffer, sizeof(dbg_buffer)-1,\
157  __FILE__":%5d: " format , __LINE__ , ## args)>0) { \
158  dbg_buffer[sizeof(dbg_buffer)-1]=(char)0; \
159  GWEN_Logger_Log(dbg_logger, GWEN_LoggerLevel_Notice, dbg_buffer);\
160  }\
161  };
162 #else /* #ifndef NO_VARIADIC_MACROS */
163 GWENHYWFAR_API
164 void DBG_NOTICE(const char *logdomain, const char *format, ...);
165 #endif /* #ifndef NO_VARIADIC_MACROS */
166 
167 #define DBG_NOTICE_ERR(dbg_logger, dbg_err) \
168  if (GWEN_Logger_GetLevel(dbg_logger)>=GWEN_LoggerLevel_Notice) {\
169  char dbg_buffer[300]; \
170  char dbg_errbuff[256]; \
171  \
172  GWEN_Error_ToString(dbg_err,dbg_errbuff, sizeof(dbg_errbuff)); \
173  if (snprintf(dbg_buffer, sizeof(dbg_buffer)-1, __FILE__":%5d: %s" , __LINE__ , dbg_errbuff)>0) {\
174  dbg_buffer[sizeof(dbg_buffer)-1]=0; \
175  GWEN_Logger_Log(dbg_logger, GWEN_LoggerLevel_Notice, dbg_buffer);\
176  } \
177  };
178 
179 
180 #ifndef NO_VARIADIC_MACROS
181 # define DBG_INFO(dbg_logger, format, args...) \
182  if (GWEN_Logger_GetLevel(dbg_logger)>=GWEN_LoggerLevel_Info) {\
183  char dbg_buffer[300]; \
184  \
185  if (snprintf(dbg_buffer, sizeof(dbg_buffer)-1,\
186  __FILE__":%5d: " format , __LINE__ , ## args)>0) { \
187  dbg_buffer[sizeof(dbg_buffer)-1]=(char)0; \
188  GWEN_Logger_Log(dbg_logger, GWEN_LoggerLevel_Info, dbg_buffer);\
189  }\
190  };
191 #else /* #ifndef NO_VARIADIC_MACROS */
192 GWENHYWFAR_API
193 void DBG_INFO(const char *logdomain, const char *format, ...);
194 #endif /* #ifndef NO_VARIADIC_MACROS */
195 
196 #define DBG_INFO_ERR(dbg_logger, dbg_err) \
197  if (GWEN_Logger_GetLevel(dbg_logger)>=GWEN_LoggerLevel_Info) {\
198  char dbg_buffer[300]; \
199  char dbg_errbuff[256]; \
200  \
201  GWEN_Error_ToString(dbg_err,dbg_errbuff, sizeof(dbg_errbuff)); \
202  if (snprintf(dbg_buffer, sizeof(dbg_buffer)-1, __FILE__":%5d: %s" , __LINE__ , dbg_errbuff)>0) { \
203  dbg_buffer[sizeof(dbg_buffer)-1]=0; \
204  GWEN_Logger_Log(dbg_logger, GWEN_LoggerLevel_Info, dbg_buffer);\
205  }\
206  };
207 
208 
209 
210 
211 #ifndef DISABLE_DEBUGLOG
212 
213 # ifndef NO_VARIADIC_MACROS
214 # define DBG_DEBUG(dbg_logger, format, args...) \
215  if (GWEN_Logger_GetLevel(dbg_logger)>=GWEN_LoggerLevel_Debug) {\
216  char dbg_buffer[300]; \
217  \
218  if (snprintf(dbg_buffer, sizeof(dbg_buffer)-1, __FILE__":%5d: " format , __LINE__ , ## args)>0) { \
219  dbg_buffer[sizeof(dbg_buffer)-1]=0; \
220  GWEN_Logger_Log(dbg_logger, GWEN_LoggerLevel_Debug, dbg_buffer);\
221  }\
222  };
223 
224 # define DBG_VERBOUS(dbg_logger, format, args...) \
225  if (GWEN_Logger_GetLevel(dbg_logger)>=GWEN_LoggerLevel_Verbous) {\
226  char dbg_buffer[300]; \
227  \
228  if (snprintf(dbg_buffer, sizeof(dbg_buffer)-1, __FILE__":%5d: " format , __LINE__ , ## args)>0) { \
229  dbg_buffer[sizeof(dbg_buffer)-1]=0; \
230  GWEN_Logger_Log(dbg_logger, GWEN_LoggerLevel_Verbous, dbg_buffer);\
231  }\
232  };
233 # endif /* #ifndef NO_VARIADIC_MACROS */
234 
235 # define DBG_DEBUG_ERR(dbg_logger, dbg_err) \
236  if (GWEN_Logger_GetLevel(dbg_logger)>=GWEN_LoggerLevel_Debug) {\
237  char dbg_buffer[300]; \
238  char dbg_errbuff[256]; \
239  \
240  GWEN_Error_ToString(dbg_err,dbg_errbuff, sizeof(dbg_errbuff)); \
241  if (snprintf(dbg_buffer, sizeof(dbg_buffer)-1, __FILE__":%5d: %s" , __LINE__ , dbg_errbuff)>0) { \
242  dbg_buffer[sizeof(dbg_buffer)-1]=0; \
243  GWEN_Logger_Log(dbg_logger, GWEN_LoggerLevel_Debug, dbg_buffer);\
244  }\
245  };
246 
247 # define DBG_VERBOUS_ERR(dbg_logger, dbg_err) \
248  if (GWEN_Logger_GetLevel(dbg_logger)>=GWEN_LoggerLevel_Verbous) {\
249  char dbg_buffer[300]; \
250  char dbg_errbuff[256]; \
251  \
252  GWEN_Error_ToString(dbg_err,dbg_errbuff, sizeof(dbg_errbuff)); \
253  if (snprintf(dbg_buffer, sizeof(dbg_buffer)-1, __FILE__":%5d: %s" , __LINE__ , dbg_errbuff)>0) {\
254  dbg_buffer[sizeof(dbg_buffer)-1]=0; \
255  GWEN_Logger_Log(dbg_logger, GWEN_LoggerLevel_Verbous, dbg_buffer);\
256  }\
257  };
258 
259 
260 
261 #else
262 
263 # ifndef NO_VARIADIC_MACROS
264 # define DBG_DEBUG(dbg_logger, format, args...)
265 # define DBG_VERBOUS(dbg_logger, format, args...)
266 # endif /* ifndef NO_VARIADIC_MACROS */
267 
268 # define DBG_DEBUG_ERR(dbg_logger, dbg_err)
269 # define DBG_VERBOUS_ERR(dbg_logger, dbg_err)
270 
271 #endif /* DISABLE_DEBUGLOG */
272 
273 #ifdef NO_VARIADIC_MACROS
274 GWENHYWFAR_API
275 void DBG_DEBUG(const char *logdomain, const char *format, ...);
276 GWENHYWFAR_API
277 void DBG_VERBOUS(const char *logdomain, const char *format, ...);
278 #endif /* #ifdef NO_VARIADIC_MACROS */
279 
280 
281 #ifdef __cplusplus
282 }
283 #endif
284 
285 
286 #endif
287 
288 
fmt
GWENHYWFAR_API const char * fmt
Definition: buffer.h:283
DBG_NOTICE
#define DBG_NOTICE(dbg_logger, format, args...)
Definition: debug.h:152
DBG_VERBOUS
#define DBG_VERBOUS(dbg_logger, format, args...)
Definition: debug.h:224
GWEN_MemoryDebug_DumpObject
GWENHYWFAR_API void GWEN_MemoryDebug_DumpObject(const char *name, uint32_t mode)
Definition: debug.c:584
DBG_WARN
#define DBG_WARN(dbg_logger, format, args...)
Definition: debug.h:125
GWEN_MEMORY_DEBUG_OBJECT
struct GWEN_MEMORY_DEBUG_OBJECT GWEN_MEMORY_DEBUG_OBJECT
Definition: debug.h:55
DBG_DEBUG
#define DBG_DEBUG(dbg_logger, format, args...)
Definition: debug.h:214
GWEN_MemoryDebug_GetObjectCount
GWENHYWFAR_API long int GWEN_MemoryDebug_GetObjectCount(const char *name)
Definition: debug.c:600
GWENHYWFAR_API
#define GWENHYWFAR_API
Definition: gwenhywfarapi.h:67
GWEN_Debug_Snprintf
GWENHYWFAR_API uint32_t GWEN_Debug_Snprintf(char *buffer, uint32_t size, const char *fmt,...)
Definition: debug.c:186
GWEN_MemoryDebug_CleanUp
GWENHYWFAR_API void GWEN_MemoryDebug_CleanUp(void)
Definition: debug.c:632
DBG_ERROR
#define DBG_ERROR(dbg_logger, format, args...)
Definition: debug.h:97
DBG_INFO
#define DBG_INFO(dbg_logger, format, args...)
Definition: debug.h:181
GWEN_MemoryDebug_Decrement
GWENHYWFAR_API void GWEN_MemoryDebug_Decrement(const char *name, const char *wFile, int wLine)
Definition: debug.c:513
GWEN_MemoryDebug_Increment
GWENHYWFAR_API void GWEN_MemoryDebug_Increment(const char *name, const char *wFile, int wLine, int attach)
Definition: debug.c:481
GWEN_MemoryDebug_Dump
GWENHYWFAR_API void GWEN_MemoryDebug_Dump(uint32_t mode)
Definition: debug.c:616
Generated by   doxygen 1.8.14