gwenhywfar  4.13.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>
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...) if (1){\
98  char dbg_buffer[256]; \
99  snprintf(dbg_buffer, sizeof(dbg_buffer)-1,\
100  __FILE__":%5d: " format , __LINE__ , ## args); \
101  dbg_buffer[sizeof(dbg_buffer)-1]=0; \
102  GWEN_Logger_Log(dbg_logger, GWEN_LoggerLevel_Error, dbg_buffer);};
103 #else /* #ifndef NO_VARIADIC_MACROS */
105 void DBG_ERROR(const char *logdomain, const char *format, ...);
106 #endif /* #ifndef NO_VARIADIC_MACROS */
107 
108 #define DBG_ERROR_ERR(dbg_logger, dbg_err) {\
109  char dbg_buffer[256]; \
110  char dbg_errbuff[256]; \
111  GWEN_Error_ToString(dbg_err,dbg_errbuff, sizeof(dbg_errbuff)); \
112  snprintf(dbg_buffer, sizeof(dbg_buffer)-1,\
113  __FILE__":%5d: %s" , __LINE__ , dbg_errbuff); \
114  dbg_buffer[sizeof(dbg_buffer)-1]=0; \
115  GWEN_Logger_Log(dbg_logger, GWEN_LoggerLevel_Error, dbg_buffer);};
116 
117 #ifndef NO_VARIADIC_MACROS
118 # define DBG_WARN(dbg_logger, format, args...) {\
119  char dbg_buffer[256]; \
120  snprintf(dbg_buffer, sizeof(dbg_buffer)-1,\
121  __FILE__":%5d: " format , __LINE__ , ## args); \
122  dbg_buffer[sizeof(dbg_buffer)-1]=0; \
123  GWEN_Logger_Log(dbg_logger, GWEN_LoggerLevel_Warning, dbg_buffer);};
124 #else /* #ifndef NO_VARIADIC_MACROS */
126 void DBG_WARN(const char *logdomain, const char *format, ...);
127 #endif /* #ifndef NO_VARIADIC_MACROS */
128 
129 #define DBG_WARN_ERR(dbg_logger, dbg_err) {\
130  char dbg_buffer[256]; \
131  char dbg_errbuff[256]; \
132  GWEN_Error_ToString(dbg_err,dbg_errbuff, sizeof(dbg_errbuff)); \
133  snprintf(dbg_buffer, sizeof(dbg_buffer)-1,\
134  __FILE__":%5d: %s" , __LINE__ , dbg_errbuff); \
135  dbg_buffer[sizeof(dbg_buffer)-1]=0; \
136  GWEN_Logger_Log(dbg_logger, GWEN_LoggerLevel_Warning, dbg_buffer);};
137 
138 
139 #ifndef NO_VARIADIC_MACROS
140 # define DBG_NOTICE(dbg_logger, format, args...) \
141  if (GWEN_Logger_GetLevel(dbg_logger)>=GWEN_LoggerLevel_Notice) {\
142  char dbg_buffer[256]; \
143  snprintf(dbg_buffer, sizeof(dbg_buffer)-1,\
144  __FILE__":%5d: " format , __LINE__ , ## args); \
145  dbg_buffer[sizeof(dbg_buffer)-1]=0; \
146  GWEN_Logger_Log(dbg_logger, GWEN_LoggerLevel_Notice, dbg_buffer);};
147 #else /* #ifndef NO_VARIADIC_MACROS */
149 void DBG_NOTICE(const char *logdomain, const char *format, ...);
150 #endif /* #ifndef NO_VARIADIC_MACROS */
151 
152 #define DBG_NOTICE_ERR(dbg_logger, dbg_err) \
153  if (GWEN_Logger_GetLevel(dbg_logger)>=GWEN_LoggerLevel_Notice) {\
154  char dbg_buffer[256]; \
155  char dbg_errbuff[256]; \
156  GWEN_Error_ToString(dbg_err,dbg_errbuff, sizeof(dbg_errbuff)); \
157  snprintf(dbg_buffer, sizeof(dbg_buffer)-1,\
158  __FILE__":%5d: %s" , __LINE__ , dbg_errbuff); \
159  dbg_buffer[sizeof(dbg_buffer)-1]=0; \
160  GWEN_Logger_Log(dbg_logger, GWEN_LoggerLevel_Notice, dbg_buffer);};
161 
162 
163 #ifndef NO_VARIADIC_MACROS
164 # define DBG_INFO(dbg_logger, format, args...) \
165  if (GWEN_Logger_GetLevel(dbg_logger)>=GWEN_LoggerLevel_Info) {\
166  char dbg_buffer[256]; \
167  snprintf(dbg_buffer, sizeof(dbg_buffer)-1,\
168  __FILE__":%5d: " format , __LINE__ , ## args); \
169  dbg_buffer[sizeof(dbg_buffer)-1]=0; \
170  GWEN_Logger_Log(dbg_logger, GWEN_LoggerLevel_Info, dbg_buffer);};
171 #else /* #ifndef NO_VARIADIC_MACROS */
173 void DBG_INFO(const char *logdomain, const char *format, ...);
174 #endif /* #ifndef NO_VARIADIC_MACROS */
175 
176 #define DBG_INFO_ERR(dbg_logger, dbg_err) \
177  if (GWEN_Logger_GetLevel(dbg_logger)>=GWEN_LoggerLevel_Info) {\
178  char dbg_buffer[256]; \
179  char dbg_errbuff[256]; \
180  GWEN_Error_ToString(dbg_err,dbg_errbuff, sizeof(dbg_errbuff)); \
181  snprintf(dbg_buffer, sizeof(dbg_buffer)-1,\
182  __FILE__":%5d: %s" , __LINE__ , dbg_errbuff); \
183  dbg_buffer[sizeof(dbg_buffer)-1]=0; \
184  GWEN_Logger_Log(dbg_logger, GWEN_LoggerLevel_Info, dbg_buffer);};
185 
186 
187 
188 
189 #ifndef DISABLE_DEBUGLOG
190 
191 # ifndef NO_VARIADIC_MACROS
192 # define DBG_DEBUG(dbg_logger, format, args...) \
193  if (GWEN_Logger_GetLevel(dbg_logger)>=GWEN_LoggerLevel_Debug) {\
194  char dbg_buffer[256]; \
195  snprintf(dbg_buffer, sizeof(dbg_buffer)-1,\
196  __FILE__":%5d: " format , __LINE__ , ## args); \
197  dbg_buffer[sizeof(dbg_buffer)-1]=0; \
198  GWEN_Logger_Log(dbg_logger, GWEN_LoggerLevel_Debug, dbg_buffer);};
199 
200 # define DBG_VERBOUS(dbg_logger, format, args...) \
201  if (GWEN_Logger_GetLevel(dbg_logger)>=GWEN_LoggerLevel_Verbous) {\
202  char dbg_buffer[256]; \
203  snprintf(dbg_buffer, sizeof(dbg_buffer)-1,\
204  __FILE__":%5d: " format , __LINE__ , ## args); \
205  dbg_buffer[sizeof(dbg_buffer)-1]=0; \
206  GWEN_Logger_Log(dbg_logger, GWEN_LoggerLevel_Verbous, dbg_buffer);};
207 # endif /* #ifndef NO_VARIADIC_MACROS */
208 
209 # define DBG_DEBUG_ERR(dbg_logger, dbg_err) \
210  if (GWEN_Logger_GetLevel(dbg_logger)>=GWEN_LoggerLevel_Debug) {\
211  char dbg_buffer[256]; \
212  char dbg_errbuff[256]; \
213  GWEN_Error_ToString(dbg_err,dbg_errbuff, sizeof(dbg_errbuff)); \
214  snprintf(dbg_buffer, sizeof(dbg_buffer)-1,\
215  __FILE__":%5d: %s" , __LINE__ , dbg_errbuff); \
216  dbg_buffer[sizeof(dbg_buffer)-1]=0; \
217  GWEN_Logger_Log(dbg_logger, GWEN_LoggerLevel_Debug, dbg_buffer);};
218 
219 # define DBG_VERBOUS_ERR(dbg_logger, dbg_err) \
220  if (GWEN_Logger_GetLevel(dbg_logger)>=GWEN_LoggerLevel_Verbous) {\
221  char dbg_buffer[256]; \
222  char dbg_errbuff[256]; \
223  GWEN_Error_ToString(dbg_err,dbg_errbuff, sizeof(dbg_errbuff)); \
224  snprintf(dbg_buffer, sizeof(dbg_buffer)-1,\
225  __FILE__":%5d: %s" , __LINE__ , dbg_errbuff); \
226  dbg_buffer[sizeof(dbg_buffer)-1]=0; \
227  GWEN_Logger_Log(dbg_logger, GWEN_LoggerLevel_Verbous, dbg_buffer);};
228 
229 
230 
231 #else
232 
233 # ifndef NO_VARIADIC_MACROS
234 # define DBG_DEBUG(dbg_logger, format, args...)
235 # define DBG_VERBOUS(dbg_logger, format, args...)
236 # endif /* ifndef NO_VARIADIC_MACROS */
237 
238 # define DBG_DEBUG_ERR(dbg_logger, dbg_err)
239 # define DBG_VERBOUS_ERR(dbg_logger, dbg_err)
240 
241 #endif /* DISABLE_DEBUGLOG */
242 
243 #ifdef NO_VARIADIC_MACROS
245 void DBG_DEBUG(const char *logdomain, const char *format, ...);
247 void DBG_VERBOUS(const char *logdomain, const char *format, ...);
248 #endif /* #ifdef NO_VARIADIC_MACROS */
249 
250 
251 #ifdef __cplusplus
252 }
253 #endif
254 
255 
256 #endif
257 
258 
#define DBG_NOTICE(dbg_logger, format, args...)
Definition: debug.h:140
#define DBG_VERBOUS(dbg_logger, format, args...)
Definition: debug.h:200
GWENHYWFAR_API void GWEN_MemoryDebug_DumpObject(const char *name, uint32_t mode)
#define DBG_WARN(dbg_logger, format, args...)
Definition: debug.h:118
struct GWEN_MEMORY_DEBUG_OBJECT GWEN_MEMORY_DEBUG_OBJECT
Definition: debug.h:55
#define DBG_DEBUG(dbg_logger, format, args...)
Definition: debug.h:192
GWENHYWFAR_API long int GWEN_MemoryDebug_GetObjectCount(const char *name)
#define GWENHYWFAR_API
Definition: gwenhywfarapi.h:67
GWENHYWFAR_API uint32_t GWEN_Debug_Snprintf(char *buffer, uint32_t size, const char *fmt,...)
GWENHYWFAR_API void GWEN_MemoryDebug_CleanUp(void)
#define DBG_ERROR(dbg_logger, format, args...)
Definition: debug.h:97
#define DBG_INFO(dbg_logger, format, args...)
Definition: debug.h:164
GWENHYWFAR_API void GWEN_MemoryDebug_Decrement(const char *name, const char *wFile, int wLine)
GWENHYWFAR_API void GWEN_MemoryDebug_Increment(const char *name, const char *wFile, int wLine, int attach)
GWENHYWFAR_API void GWEN_MemoryDebug_Dump(uint32_t mode)