gwenhywfar  4.99.15beta
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[256]; \
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[256]; \
115  char dbg_errbuff[256]; \
116  GWEN_Error_ToString(dbg_err,dbg_errbuff, sizeof(dbg_errbuff)); \
117  snprintf(dbg_buffer, sizeof(dbg_buffer)-1,\
118  __FILE__":%5d: %s" , __LINE__ , dbg_errbuff); \
119  dbg_buffer[sizeof(dbg_buffer)-1]=0; \
120  GWEN_Logger_Log(dbg_logger, GWEN_LoggerLevel_Error, dbg_buffer);};
121 
122 #ifndef NO_VARIADIC_MACROS
123 # define DBG_WARN(dbg_logger, format, args...) {\
124  if (GWEN_Logger_GetLevel(dbg_logger)>=GWEN_LoggerLevel_Warning) {\
125  char dbg_buffer[256]; \
126  \
127  if (snprintf(dbg_buffer, sizeof(dbg_buffer)-1,\
128  __FILE__":%5d: " format , __LINE__ , ## args)>0) { \
129  dbg_buffer[sizeof(dbg_buffer)-1]=(char)0; \
130  GWEN_Logger_Log(dbg_logger, GWEN_LoggerLevel_Warning, dbg_buffer);\
131  }\
132  }\
133  };
134 #else /* #ifndef NO_VARIADIC_MACROS */
135 GWENHYWFAR_API
136 void DBG_WARN(const char *logdomain, const char *format, ...);
137 #endif /* #ifndef NO_VARIADIC_MACROS */
138 
139 #define DBG_WARN_ERR(dbg_logger, dbg_err) {\
140  char dbg_buffer[256]; \
141  char dbg_errbuff[256]; \
142  GWEN_Error_ToString(dbg_err,dbg_errbuff, sizeof(dbg_errbuff)); \
143  snprintf(dbg_buffer, sizeof(dbg_buffer)-1,\
144  __FILE__":%5d: %s" , __LINE__ , dbg_errbuff); \
145  dbg_buffer[sizeof(dbg_buffer)-1]=0; \
146  GWEN_Logger_Log(dbg_logger, GWEN_LoggerLevel_Warning, dbg_buffer);};
147 
148 
149 #ifndef NO_VARIADIC_MACROS
150 # define DBG_NOTICE(dbg_logger, format, args...) \
151  if (GWEN_Logger_GetLevel(dbg_logger)>=GWEN_LoggerLevel_Notice) {\
152  char dbg_buffer[256]; \
153  \
154  if (snprintf(dbg_buffer, sizeof(dbg_buffer)-1,\
155  __FILE__":%5d: " format , __LINE__ , ## args)>0) { \
156  dbg_buffer[sizeof(dbg_buffer)-1]=(char)0; \
157  GWEN_Logger_Log(dbg_logger, GWEN_LoggerLevel_Notice, dbg_buffer);\
158  }\
159  };
160 #else /* #ifndef NO_VARIADIC_MACROS */
161 GWENHYWFAR_API
162 void DBG_NOTICE(const char *logdomain, const char *format, ...);
163 #endif /* #ifndef NO_VARIADIC_MACROS */
164 
165 #define DBG_NOTICE_ERR(dbg_logger, dbg_err) \
166  if (GWEN_Logger_GetLevel(dbg_logger)>=GWEN_LoggerLevel_Notice) {\
167  char dbg_buffer[256]; \
168  char dbg_errbuff[256]; \
169  GWEN_Error_ToString(dbg_err,dbg_errbuff, sizeof(dbg_errbuff)); \
170  snprintf(dbg_buffer, sizeof(dbg_buffer)-1,\
171  __FILE__":%5d: %s" , __LINE__ , dbg_errbuff); \
172  dbg_buffer[sizeof(dbg_buffer)-1]=0; \
173  GWEN_Logger_Log(dbg_logger, GWEN_LoggerLevel_Notice, dbg_buffer);};
174 
175 
176 #ifndef NO_VARIADIC_MACROS
177 # define DBG_INFO(dbg_logger, format, args...) \
178  if (GWEN_Logger_GetLevel(dbg_logger)>=GWEN_LoggerLevel_Info) {\
179  char dbg_buffer[256]; \
180  \
181  if (snprintf(dbg_buffer, sizeof(dbg_buffer)-1,\
182  __FILE__":%5d: " format , __LINE__ , ## args)>0) { \
183  dbg_buffer[sizeof(dbg_buffer)-1]=(char)0; \
184  GWEN_Logger_Log(dbg_logger, GWEN_LoggerLevel_Info, dbg_buffer);\
185  }\
186  };
187 #else /* #ifndef NO_VARIADIC_MACROS */
188 GWENHYWFAR_API
189 void DBG_INFO(const char *logdomain, const char *format, ...);
190 #endif /* #ifndef NO_VARIADIC_MACROS */
191 
192 #define DBG_INFO_ERR(dbg_logger, dbg_err) \
193  if (GWEN_Logger_GetLevel(dbg_logger)>=GWEN_LoggerLevel_Info) {\
194  char dbg_buffer[256]; \
195  char dbg_errbuff[256]; \
196  GWEN_Error_ToString(dbg_err,dbg_errbuff, sizeof(dbg_errbuff)); \
197  snprintf(dbg_buffer, sizeof(dbg_buffer)-1,\
198  __FILE__":%5d: %s" , __LINE__ , dbg_errbuff); \
199  dbg_buffer[sizeof(dbg_buffer)-1]=0; \
200  GWEN_Logger_Log(dbg_logger, GWEN_LoggerLevel_Info, dbg_buffer);};
201 
202 
203 
204 
205 #ifndef DISABLE_DEBUGLOG
206 
207 # ifndef NO_VARIADIC_MACROS
208 # define DBG_DEBUG(dbg_logger, format, args...) \
209  if (GWEN_Logger_GetLevel(dbg_logger)>=GWEN_LoggerLevel_Debug) {\
210  char dbg_buffer[256]; \
211  snprintf(dbg_buffer, sizeof(dbg_buffer)-1,\
212  __FILE__":%5d: " format , __LINE__ , ## args); \
213  dbg_buffer[sizeof(dbg_buffer)-1]=0; \
214  GWEN_Logger_Log(dbg_logger, GWEN_LoggerLevel_Debug, dbg_buffer);};
215 
216 # define DBG_VERBOUS(dbg_logger, format, args...) \
217  if (GWEN_Logger_GetLevel(dbg_logger)>=GWEN_LoggerLevel_Verbous) {\
218  char dbg_buffer[256]; \
219  snprintf(dbg_buffer, sizeof(dbg_buffer)-1,\
220  __FILE__":%5d: " format , __LINE__ , ## args); \
221  dbg_buffer[sizeof(dbg_buffer)-1]=0; \
222  GWEN_Logger_Log(dbg_logger, GWEN_LoggerLevel_Verbous, dbg_buffer);};
223 # endif /* #ifndef NO_VARIADIC_MACROS */
224 
225 # define DBG_DEBUG_ERR(dbg_logger, dbg_err) \
226  if (GWEN_Logger_GetLevel(dbg_logger)>=GWEN_LoggerLevel_Debug) {\
227  char dbg_buffer[256]; \
228  char dbg_errbuff[256]; \
229  GWEN_Error_ToString(dbg_err,dbg_errbuff, sizeof(dbg_errbuff)); \
230  snprintf(dbg_buffer, sizeof(dbg_buffer)-1,\
231  __FILE__":%5d: %s" , __LINE__ , dbg_errbuff); \
232  dbg_buffer[sizeof(dbg_buffer)-1]=0; \
233  GWEN_Logger_Log(dbg_logger, GWEN_LoggerLevel_Debug, dbg_buffer);};
234 
235 # define DBG_VERBOUS_ERR(dbg_logger, dbg_err) \
236  if (GWEN_Logger_GetLevel(dbg_logger)>=GWEN_LoggerLevel_Verbous) {\
237  char dbg_buffer[256]; \
238  char dbg_errbuff[256]; \
239  GWEN_Error_ToString(dbg_err,dbg_errbuff, sizeof(dbg_errbuff)); \
240  snprintf(dbg_buffer, sizeof(dbg_buffer)-1,\
241  __FILE__":%5d: %s" , __LINE__ , dbg_errbuff); \
242  dbg_buffer[sizeof(dbg_buffer)-1]=0; \
243  GWEN_Logger_Log(dbg_logger, GWEN_LoggerLevel_Verbous, dbg_buffer);};
244 
245 
246 
247 #else
248 
249 # ifndef NO_VARIADIC_MACROS
250 # define DBG_DEBUG(dbg_logger, format, args...)
251 # define DBG_VERBOUS(dbg_logger, format, args...)
252 # endif /* ifndef NO_VARIADIC_MACROS */
253 
254 # define DBG_DEBUG_ERR(dbg_logger, dbg_err)
255 # define DBG_VERBOUS_ERR(dbg_logger, dbg_err)
256 
257 #endif /* DISABLE_DEBUGLOG */
258 
259 #ifdef NO_VARIADIC_MACROS
260 GWENHYWFAR_API
261 void DBG_DEBUG(const char *logdomain, const char *format, ...);
262 GWENHYWFAR_API
263 void DBG_VERBOUS(const char *logdomain, const char *format, ...);
264 #endif /* #ifdef NO_VARIADIC_MACROS */
265 
266 
267 #ifdef __cplusplus
268 }
269 #endif
270 
271 
272 #endif
273 
274 
DBG_NOTICE
#define DBG_NOTICE(dbg_logger, format, args...)
Definition: debug.h:150
DBG_VERBOUS
#define DBG_VERBOUS(dbg_logger, format, args...)
Definition: debug.h:216
GWEN_MemoryDebug_DumpObject
GWENHYWFAR_API void GWEN_MemoryDebug_DumpObject(const char *name, uint32_t mode)
Definition: debug.c:583
DBG_WARN
#define DBG_WARN(dbg_logger, format, args...)
Definition: debug.h:123
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:208
GWEN_MemoryDebug_GetObjectCount
GWENHYWFAR_API long int GWEN_MemoryDebug_GetObjectCount(const char *name)
Definition: debug.c:599
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:631
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:177
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:615
Generated by   doxygen 1.8.15