Doxygen
Loading...
Searching...
No Matches
message.cpp File Reference
#include <cstdio>
#include <cstdlib>
#include <mutex>
#include <atomic>
#include <unordered_set>
#include "config.h"
#include "debug.h"
#include "portable.h"
#include "message.h"
#include "doxygen.h"
#include "fileinfo.h"
#include "dir.h"
#include "md5.h"
Include dependency graph for message.cpp:

Go to the source code of this file.

Functions

static bool checkWarnMessage (QCString result)
static void format_warn (const QCString &file, int line, const QCString &text)
static void handle_warn_as_error ()
static void do_warn (const QCString &file, int line, const char *prefix, fmt::string_view fmt, fmt::format_args args)
void msg_ (fmt::string_view fmt, fmt::format_args args)
void warn_ (WarningType type, const QCString &file, int line, fmt::string_view fmt, fmt::format_args args)
void warn_uncond_ (fmt::string_view fmt, fmt::format_args args)
void err_ (fmt::string_view fmt, fmt::format_args args)
void err_full_ (const QCString &file, int line, fmt::string_view fmt, fmt::format_args args)
void term_ (fmt::string_view fmt, fmt::format_args args)
QCString warn_line (const QCString &file, int line)
void warn_flush ()
void initWarningFormat ()
void finishWarnExit ()

Variables

static QCString g_warnFormat
static QCString g_warnLineFormat
static const char * g_warningStr = "warning: "
static const char * g_errorStr = "error: "
static FILE * g_warnFile = stderr
static WARN_AS_ERROR_t g_warnBehavior = WARN_AS_ERROR_t::NO
static QCString g_warnlogFile
static bool g_warnlogTemp = false
static std::atomic_bool g_warnStat = false
static std::mutex g_mutex
static std::unordered_set< std::string > g_warnHash

Function Documentation

◆ checkWarnMessage()

bool checkWarnMessage ( QCString result)
static

Definition at line 46 of file message.cpp.

47{
48 uint8_t md5_sig[16];
49 char sigStr[33];
50 MD5Buffer(result.data(),result.length(),md5_sig);
51 MD5SigToString(md5_sig,sigStr);
52
53 return g_warnHash.insert(sigStr).second;
54}
size_t length() const
Returns the length of the string, not counting the 0-terminator.
Definition qcstring.h:166
const char * data() const
Returns a pointer to the contents of the string in the form of a 0-terminated C string.
Definition qcstring.h:172
static std::unordered_set< std::string > g_warnHash
Definition message.cpp:42

References QCString::data(), g_warnHash, and QCString::length().

Referenced by err_(), format_warn(), term_(), and warn_uncond_().

◆ do_warn()

void do_warn ( const QCString & file,
int line,
const char * prefix,
fmt::string_view fmt,
fmt::format_args args )
static

Definition at line 121 of file message.cpp.

122{
123 format_warn(file,line,prefix+fmt::vformat(fmt,args));
125}
constexpr auto prefix
Definition anchor.cpp:44
static void format_warn(const QCString &file, int line, const QCString &text)
Definition message.cpp:56
static void handle_warn_as_error()
Definition message.cpp:100
Definition message.h:144

References format_warn(), handle_warn_as_error(), and prefix.

Referenced by warn_().

◆ err_()

void err_ ( fmt::string_view fmt,
fmt::format_args args )

Definition at line 174 of file message.cpp.

175{
176 {
177 std::unique_lock<std::mutex> lock(g_mutex);
178 if (checkWarnMessage(g_errorStr+fmt::vformat(fmt,args))) fmt::print(g_warnFile,"{}{}",g_errorStr,fmt::vformat(fmt,args));
179 }
181}
static bool checkWarnMessage(QCString result)
Definition message.cpp:46
static const char * g_errorStr
Definition message.cpp:35
static std::mutex g_mutex
Definition message.cpp:41
static FILE * g_warnFile
Definition message.cpp:36

References checkWarnMessage(), g_errorStr, g_mutex, g_warnFile, and handle_warn_as_error().

Referenced by err_fmt().

◆ err_full_()

void err_full_ ( const QCString & file,
int line,
fmt::string_view fmt,
fmt::format_args args )

Definition at line 185 of file message.cpp.

186{
187 format_warn(file,line,g_errorStr+fmt::vformat(fmt,args));
188}

References format_warn(), and g_errorStr.

Referenced by err_full_fmt().

◆ finishWarnExit()

void finishWarnExit ( )

Definition at line 294 of file message.cpp.

295{
296 fflush(stdout);
297 if (g_warnBehavior == WARN_AS_ERROR_t::FAIL_ON_WARNINGS_PRINT && g_warnlogFile != "-")
298 {
300 g_warnFile = nullptr;
301 }
302 if (g_warnStat && g_warnBehavior == WARN_AS_ERROR_t::FAIL_ON_WARNINGS_PRINT && g_warnlogFile != "-")
303 {
304
305 std::ifstream warnFile = Portable::openInputStream(g_warnlogFile);
306 if (!warnFile.is_open())
307 {
308 g_warnFile = stderr;
309 err("Cannot open warnings file '{}' for reading\n",g_warnlogFile);
310 }
311 else
312 {
313 std::string line;
314 while (getline(warnFile,line))
315 {
316 fmt::print(stderr,"{}\n",line);
317 }
318 warnFile.close();
319 }
320 }
321
323
324 if (g_warnStat && (g_warnBehavior == WARN_AS_ERROR_t::FAIL_ON_WARNINGS ||
325 g_warnBehavior == WARN_AS_ERROR_t::FAIL_ON_WARNINGS_PRINT))
326 {
327 exit(1);
328 }
329}
static bool g_warnlogTemp
Definition message.cpp:39
static std::atomic_bool g_warnStat
Definition message.cpp:40
static WARN_AS_ERROR_t g_warnBehavior
Definition message.cpp:37
static QCString g_warnlogFile
Definition message.cpp:38
#define err(fmt,...)
Definition message.h:127
std::ifstream openInputStream(const QCString &name, bool binary=false, bool openAtEnd=false)
Definition portable.cpp:660
void unlink(const QCString &fileName)
Definition portable.cpp:545
int fclose(FILE *f)
Definition portable.cpp:370

References err, Portable::fclose(), g_warnBehavior, g_warnFile, g_warnlogFile, g_warnlogTemp, g_warnStat, Portable::openInputStream(), and Portable::unlink().

Referenced by generateOutput().

◆ format_warn()

void format_warn ( const QCString & file,
int line,
const QCString & text )
static

Definition at line 56 of file message.cpp.

57{
58 QCString fileSubst = file.isEmpty() ? "<unknown>" : file;
59 QCString lineSubst; lineSubst.setNum(line);
60 QCString versionSubst;
61 // substitute markers by actual values
62 QCString msgText =
68 "$file",fileSubst
69 ),
70 "$line",lineSubst
71 ),
72 "$version",versionSubst
73 ),
74 "$text",text
75 );
76 if (g_warnBehavior == WARN_AS_ERROR_t::YES)
77 {
78 msgText += " (warning treated as error, aborting now)";
79 }
80 msgText += '\n';
81
82 {
83 std::unique_lock<std::mutex> lock(g_mutex);
84 // print resulting message
85 if (checkWarnMessage(msgText)) fwrite(msgText.data(),1,msgText.length(),g_warnFile);
86 }
87 if (g_warnBehavior == WARN_AS_ERROR_t::YES)
88 {
89 if (g_warnFile != stderr && !Config_getBool(QUIET))
90 {
91 msg("See '{}' for the reason of termination.\n",g_warnlogFile);
92 }
93 exit(1);
94 }
95 g_warnStat = true;
96}
This is an alternative implementation of QCString.
Definition qcstring.h:101
bool isEmpty() const
Returns TRUE iff the string is empty.
Definition qcstring.h:163
QCString & setNum(short n)
Definition qcstring.h:459
#define Config_getBool(name)
Definition config.h:33
static QCString g_warnFormat
Definition message.cpp:32
#define msg(fmt,...)
Definition message.h:94
QCString substitute(const QCString &s, const QCString &src, const QCString &dst)
substitute all occurrences of src in s by dst
Definition qcstring.cpp:482

References checkWarnMessage(), Config_getBool, QCString::data(), g_mutex, g_warnBehavior, g_warnFile, g_warnFormat, g_warnlogFile, g_warnStat, QCString::isEmpty(), QCString::length(), msg, QCString::setNum(), and substitute().

Referenced by do_warn(), and err_full_().

◆ handle_warn_as_error()

void handle_warn_as_error ( )
static

Definition at line 100 of file message.cpp.

101{
102 if (g_warnBehavior == WARN_AS_ERROR_t::YES)
103 {
104 {
105 std::unique_lock<std::mutex> lock(g_mutex);
106 QCString msgText = " (warning treated as error, aborting now)\n";
107 fwrite(msgText.data(),1,msgText.length(),g_warnFile);
108 if (g_warnFile != stderr && !Config_getBool(QUIET))
109 {
110 // cannot use `msg` due to the mutex
111 fprintf(stdout,"See '%s' for the reason of termination.\n",qPrint(g_warnlogFile));
112 }
113 }
114 exit(1);
115 }
116 g_warnStat = true;
117}
const char * qPrint(const char *s)
Definition qcstring.h:687

References Config_getBool, QCString::data(), g_mutex, g_warnBehavior, g_warnFile, g_warnlogFile, g_warnStat, QCString::length(), and qPrint().

Referenced by do_warn(), err_(), and warn_uncond_().

◆ initWarningFormat()

void initWarningFormat ( )

Definition at line 236 of file message.cpp.

237{
238 g_warnFormat = Config_getString(WARN_FORMAT);
239 g_warnLineFormat = Config_getString(WARN_LINE_FORMAT);
240 g_warnBehavior = Config_getEnum(WARN_AS_ERROR);
241 g_warnlogFile = Config_getString(WARN_LOGFILE);
242 if (g_warnlogFile.isEmpty() && g_warnBehavior == WARN_AS_ERROR_t::FAIL_ON_WARNINGS_PRINT)
243 {
244 uint32_t pid = Portable::pid();
245 g_warnlogFile.sprintf("doxygen_warnings_temp_%d.tmp",pid);
246 g_warnlogTemp = true;
247 }
248
249 if (!g_warnlogFile.isEmpty())
250 {
251 if (g_warnlogFile == "-")
252 {
253 g_warnFile = stdout;
254 }
255 else
256 {
257 FileInfo fi(g_warnlogFile.str());
258 Dir d(fi.dirPath());
259 if (!d.exists() && !d.mkdir(fi.dirPath()))
260 {
261 // point it to something valid, because warn() relies on it
262 g_warnFile = stderr;
263 err("Cannot create directory for '{}', redirecting 'WARN_LOGFILE' output to 'stderr'\n",g_warnlogFile);
264 }
265 else if (!(g_warnFile = Portable::fopen(g_warnlogFile,"w")))
266 {
267 // point it to something valid, because warn() relies on it
268 g_warnFile = stderr;
269 err("Cannot open '{}' for writing, redirecting 'WARN_LOGFILE' output to 'stderr'\n",g_warnlogFile);
270 }
271 }
272 }
273 else
274 {
275 g_warnFile = stderr;
276 }
277 if (g_warnBehavior != WARN_AS_ERROR_t::NO)
278 {
280 }
281
282 // make sure the g_warnFile is closed in case we call exit and it is still open
283 std::atexit([](){
284 if (g_warnFile && g_warnFile!=stderr && g_warnFile!=stdout)
285 {
287 g_warnFile = nullptr;
288 }
289 });
290}
Class representing a directory in the file system.
Definition dir.h:75
Minimal replacement for QFileInfo.
Definition fileinfo.h:23
#define Config_getString(name)
Definition config.h:32
#define Config_getEnum(name)
Definition config.h:35
static QCString g_warnLineFormat
Definition message.cpp:33
static const char * g_warningStr
Definition message.cpp:34
FILE * fopen(const QCString &fileName, const QCString &mode)
Definition portable.cpp:350
uint32_t pid()
Definition portable.cpp:249

References Config_getEnum, Config_getString, FileInfo::dirPath(), err, Dir::exists(), Portable::fclose(), Portable::fopen(), g_errorStr, g_warnBehavior, g_warnFile, g_warnFormat, g_warningStr, g_warnLineFormat, g_warnlogFile, g_warnlogTemp, Dir::mkdir(), and Portable::pid().

Referenced by checkConfiguration().

◆ msg_()

void msg_ ( fmt::string_view fmt,
fmt::format_args args )

Definition at line 129 of file message.cpp.

130{
131 if (!Config_getBool(QUIET))
132 {
133 std::unique_lock<std::mutex> lock(g_mutex);
135 {
136 fmt::print("{:.3f} sec: ",(static_cast<double>(Debug::elapsedTime())));
137 }
138 fmt::print("{}",fmt::vformat(fmt,args));
139 }
140}
@ Time
Definition debug.h:35
static bool isFlagSet(const DebugMask mask)
Definition debug.cpp:132
static double elapsedTime()
Definition debug.cpp:200

References Config_getBool, Debug::elapsedTime(), g_mutex, Debug::isFlagSet(), and Debug::Time.

Referenced by msg_fmt().

◆ term_()

void term_ ( fmt::string_view fmt,
fmt::format_args args )

Definition at line 192 of file message.cpp.

193{
194 {
195 std::unique_lock<std::mutex> lock(g_mutex);
196 if (checkWarnMessage(g_errorStr+fmt::vformat(fmt,args))) fmt::print(g_warnFile, "{}{}", g_errorStr, fmt::vformat(fmt,args));
197 if (g_warnFile != stderr)
198 {
199 size_t l = strlen(g_errorStr);
200 for (size_t i=0; i<l; i++) fmt::print(g_warnFile, " ");
201 fmt::print(g_warnFile, "{}\n", "Exiting...");
202 if (!Config_getBool(QUIET))
203 {
204 // cannot use `msg` due to the mutex
205 fmt::print("See '{}' for the reason of termination.\n",g_warnlogFile);
206 }
207 }
208 }
209 exit(1);
210}

References checkWarnMessage(), Config_getBool, g_errorStr, g_mutex, g_warnFile, and g_warnlogFile.

Referenced by term_fmt().

◆ warn_()

void warn_ ( WarningType type,
const QCString & file,
int line,
fmt::string_view fmt,
fmt::format_args args )

Definition at line 144 of file message.cpp.

145{
146 bool enabled = false;
147 switch (type)
148 {
149 case WarningType::Generic: enabled = Config_getBool(WARNINGS); break;
150 case WarningType::Undocumented: enabled = Config_getBool(WARN_IF_UNDOCUMENTED); break;
151 case WarningType::IncompleteDoc: enabled = Config_getBool(WARN_IF_INCOMPLETE_DOC); break;
152 case WarningType::DocError: enabled = Config_getBool(WARN_IF_DOC_ERROR); break;
153 case WarningType::Layout: enabled = Config_getBool(WARN_LAYOUT_FILE); break;
154 }
155 if (enabled)
156 {
157 do_warn(file, line, g_warningStr, fmt, args);
158 }
159}
static void do_warn(const QCString &file, int line, const char *prefix, fmt::string_view fmt, fmt::format_args args)
Definition message.cpp:121
@ IncompleteDoc
Definition message.h:29
@ Undocumented
Definition message.h:28

References Config_getBool, do_warn(), DocError, g_warningStr, Generic, IncompleteDoc, Layout, and Undocumented.

Referenced by warn_fmt().

◆ warn_flush()

void warn_flush ( )

Definition at line 229 of file message.cpp.

230{
231 fflush(g_warnFile);
232}

References g_warnFile.

Referenced by Statistics::end().

◆ warn_line()

QCString warn_line ( const QCString & file,
int line )

Definition at line 214 of file message.cpp.

215{
216 QCString fileSubst = file.isEmpty() ? "<unknown>" : file;
217 QCString lineSubst; lineSubst.setNum(line);
218 return substitute(
221 "$file",fileSubst
222 ),
223 "$line",lineSubst
224 );
225}

References g_warnLineFormat, QCString::isEmpty(), QCString::setNum(), and substitute().

Referenced by addMemberFunction(), checkPageRelations(), computePageRelations(), and findGlobalMember().

◆ warn_uncond_()

void warn_uncond_ ( fmt::string_view fmt,
fmt::format_args args )

Definition at line 163 of file message.cpp.

164{
165 {
166 std::unique_lock<std::mutex> lock(g_mutex);
167 if (checkWarnMessage(g_errorStr+fmt::vformat(fmt,args))) fmt::print(g_warnFile,"{}{}",g_warningStr,vformat(fmt,args));
168 }
170}

References checkWarnMessage(), g_errorStr, g_mutex, g_warnFile, g_warningStr, and handle_warn_as_error().

Referenced by warn_uncond_fmt().

Variable Documentation

◆ g_errorStr

const char* g_errorStr = "error: "
static

Definition at line 35 of file message.cpp.

Referenced by err_(), err_full_(), initWarningFormat(), term_(), and warn_uncond_().

◆ g_mutex

std::mutex g_mutex
static

Definition at line 41 of file message.cpp.

Referenced by err_(), format_warn(), handle_warn_as_error(), msg_(), term_(), and warn_uncond_().

◆ g_warnBehavior

WARN_AS_ERROR_t g_warnBehavior = WARN_AS_ERROR_t::NO
static

Definition at line 37 of file message.cpp.

Referenced by finishWarnExit(), format_warn(), handle_warn_as_error(), and initWarningFormat().

◆ g_warnFile

FILE* g_warnFile = stderr
static

◆ g_warnFormat

QCString g_warnFormat
static

Definition at line 32 of file message.cpp.

Referenced by format_warn(), and initWarningFormat().

◆ g_warnHash

std::unordered_set<std::string> g_warnHash
static

Definition at line 42 of file message.cpp.

Referenced by checkWarnMessage().

◆ g_warningStr

const char* g_warningStr = "warning: "
static

Definition at line 34 of file message.cpp.

Referenced by initWarningFormat(), warn_(), and warn_uncond_().

◆ g_warnLineFormat

QCString g_warnLineFormat
static

Definition at line 33 of file message.cpp.

Referenced by initWarningFormat(), and warn_line().

◆ g_warnlogFile

QCString g_warnlogFile
static

◆ g_warnlogTemp

bool g_warnlogTemp = false
static

Definition at line 39 of file message.cpp.

Referenced by finishWarnExit(), and initWarningFormat().

◆ g_warnStat

std::atomic_bool g_warnStat = false
static

Definition at line 40 of file message.cpp.

Referenced by finishWarnExit(), format_warn(), and handle_warn_as_error().