1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
|
/*
* error.cpp
* by pts@fazekas.hu at Fri Mar 1 11:46:27 CET 2002
* added policies at Sat Sep 7 18:28:30 CEST 2002
*/
#ifdef __GNUC__
#ifndef __clang__
#pragma implementation
#endif
#endif
#include "error.hpp"
#include "gensio.hpp"
#include <stdio.h>
#include <stdlib.h> /* exit() */
#include <string.h> /* strlen() */
#if _MSC_VER > 1000
# include "windows.h" /* ExitThread() */
#endif
char const* Error::argv0=(char const*)NULLP;
char const* Error::long_argv0=(char const*)NULLP;
char const* Error::banner0=(char const*)NULLP;
char const* Error::tmpargv0=(char const*)"pRg_tMp";
static Filter::NullE devNull;
Files::FILEW serr_default(stderr);
GenBuffer::Writable * Error::serr = &serr_default;
static Error::Policy defaultPolicy={
(SimBuffer::B*)NULLP, /* record */
(Error::level_t)-9999, /* topSecret */
(Error::level_t)-9999, /* topRecorded */
(Error::level_t)0, /* killer (level>=0) */
(Error::level_t)-99, /* printed */
(Error::level_t)-199, /* recorded */
Error::serr, /* err */
(Error::Policy*)NULLP, /* prev */
(Error::Policy*)NULLP, /* next */
(Error::level_t)-9999, /* curlev */
};
Error::Policy *Error::policy_top=&defaultPolicy, *Error::policy_bottom=&defaultPolicy;
char const*Error::level2str(level_t level) {
return level==ASSERT ? "failed_assertion" : /* Imp: make assert() produce this */
level==FATAL ? "Fatal Error" :
level==ERROR_CONT ? "Error" :
level==EERROR ? "Error" :
level==WARNING_DEFER ? "Warning" :
level==WARNING ? "Warning" :
level==NOTICE ? "Notice" :
level==NOTICE_DEFER ? "Notice" :
level==INFO ? "Info" :
level==DEBUG ? "DEBUG" :
"??level" ;
}
GenBuffer::Writable& Error::sev(level_t level) {
/* So they are trying to make an error? Let's see whether they can. */
GenBuffer::Writable *err=policy_top->err;
// printf("curlev=%d\n", policy_top->curlev);
assert(policy_top->curlev==-9999 && "nested error/ unfinished prev err");
policy_top->curlev=level;
/* printf("level=%d\n", level); */
if (level>=policy_top->printed) { /* printed or killer */
#if 0 /* Disables printing of "using template: " */
/* vvv Delay printing this message after all recorded messages */
if (policy_top->record!=NULLP) err=policy_top->record;
#endif
} else if (level>=policy_top->recorded) { /* recorded */
if (NULLP==(err=policy_top->record)) err=policy_top->record=new SimBuffer::B();
if (level>policy_top->topRecorded) policy_top->topRecorded=level;
} else { /* secret */
if (level>policy_top->topSecret) policy_top->topSecret=level;
return devNull;
}
return *err << (argv0==(char const*)NULLP?"??argv0":argv0) << ": " << level2str(level) << ": ";
/* Processing will continue soon by GenBuffer::Writable& operator <<(GenBuffer::Writable& gb,Error*) */
}
GenBuffer::Writable& operator <<(GenBuffer::Writable& err,Error*) {
err << '\n';
Error::level_t level=Error::policy_top->curlev;
if (level>=Error::policy_top->killer) { /* killer */
/* Also print recorded messages throughout the the policy stack */
Error::Policy *p=Error::policy_bottom;
while (p!=NULLP) {
if (NULLP!=p->record) Error::policy_top->err->vi_write(p->record->begin_(), p->record->getLength());
p=p->next;
}
// if (level>=Error::policy_top->killer)
Error::cexit(level);
}
/* Note that the order of error messages might be scrambled, i.e `printed'
* is printed before `recorded'.
*/
Error::policy_top->curlev=(Error::level_t)-9999; /* pedantic but useless because of nesting */
return err;
}
void Error::pushPolicy(level_t killer_, level_t printed_, level_t recorded_, GenBuffer::Writable *err) {
Policy *p=new Policy();
p->record=(SimBuffer::B*)NULLP;
p->topSecret=p->topRecorded=(Error::level_t)-9999;
p->killer=killer_;
p->printed=printed_;
p->recorded=recorded_;
p->err=(err==NULLP) ? policy_top->err : err;
p->prev=policy_top;
p->next=(Policy*)NULLP;
policy_top=p->prev->next=p;
p->curlev=(Error::level_t)-9999; /* pedantic but useless because of nesting */
}
SimBuffer::B *Error::getRecorded() {
SimBuffer::B *ret=policy_top->record;
policy_top->record=(SimBuffer::B*)NULLP;
return ret;
}
void Error::setTopPrinted(level_t printed_) {
policy_top->printed=printed_;
}
Error::level_t Error::getTopPrinted() { return policy_top->printed; }
void Error::popPolicy() {
if (policy_top==policy_bottom) {
Error::sev(Error::ASSERT) << "popPolicy: underflow" << (Error*)0;
} else {
if (NULLP!=policy_top->record) {
(*Error::policy_top->err) << "-- recorded messages:\n";
Error::policy_top->err->vi_write(policy_top->record->begin_(), policy_top->record->getLength());
delete policy_top->record;
}
policy_top=policy_top->prev;
delete policy_top->next;
policy_top->next=(Policy*)NULLP;
}
}
/* --- */
Error::Cleanup *Error::first_cleanup=(Error::Cleanup*)NULLP;
int Error::runCleanups(int exitCode) {
/* Flush buffered messages and revert to the default policy so subsequent
* errors can be logged.
*/
while (policy_top != policy_bottom)
popPolicy();
Cleanup *next;
int exit2;
while (first_cleanup!=NULLP) {
// fprintf(stderr, "hand %p\n", first_cleanup);
if (exitCode<(exit2=first_cleanup->handler(first_cleanup))) exitCode=exit2;
next=first_cleanup->next;
/* Allocated from as an array of char (to make space for
* first_cleanup->getBuf()), but has no destructors.
*/
delete [] (char*)first_cleanup;
first_cleanup=next;
}
return exitCode;
}
void Error::cexit(int exitCode) {
#if _MSC_VER > 1000
ExitThread(exitCode);
#else
exit(exitCode); /* <stdlib.h> */
#endif
}
Error::Cleanup* Error::newCleanup(Error::Cleanup::handler_t handler, void *data, slen_t bufSize) {
param_assert(handler!=0);
// slen_t num_packets=(bufSize+sizeof(Cleanup)-1)/sizeof(Cleanup);
Cleanup *new_=(Cleanup*)new char[bufSize+sizeof(Cleanup)]; /* new Cleanup[1+num_packets]; */
/* ^^^ should be a new Cleanup + new char[bufSize]; now we can avoid alignment
* problems
*/
new_->handler=handler;
new_->bufSize=bufSize;
new_->data=data;
new_->next=first_cleanup;
first_cleanup=new_;
return new_;
}
Error::Cleanup* Error::newCleanup(Error::Cleanup::handler_t handler, void *data, char const*bufCstr) {
const slen_t bufSize=strlen(bufCstr)+1;
Cleanup *new_=newCleanup(handler, data, bufSize);
memcpy(new_->getBuf(), bufCstr, bufSize);
return new_;
}
/* __END__ */
|
