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
|
#include "fitz-internal.h"
/* Warning context */
void fz_var_imp(void *var)
{
UNUSED(var); /* Do nothing */
}
void fz_flush_warnings(fz_context *ctx)
{
if (ctx->warn->count > 1)
{
fprintf(stderr, "warning: ... repeated %d times ...\n", ctx->warn->count);
LOGE("warning: ... repeated %d times ...\n", ctx->warn->count);
}
ctx->warn->message[0] = 0;
ctx->warn->count = 0;
}
void fz_warn(fz_context *ctx, char *fmt, ...)
{
va_list ap;
char buf[sizeof ctx->warn->message];
va_start(ap, fmt);
vsnprintf(buf, sizeof buf, fmt, ap);
va_end(ap);
if (!strcmp(buf, ctx->warn->message))
{
ctx->warn->count++;
}
else
{
fz_flush_warnings(ctx);
fprintf(stderr, "warning: %s\n", buf);
LOGE("warning: %s\n", buf);
fz_strlcpy(ctx->warn->message, buf, sizeof ctx->warn->message);
ctx->warn->count = 1;
}
}
/* Error context */
/* When we first setjmp, code is set to 0. Whenever we throw, we add 2 to
* this code. Whenever we enter the always block, we add 1.
*
* fz_push_try sets code to 0.
* If (fz_throw called within fz_try)
* fz_throw makes code = 2.
* If (no always block present)
* enter catch region with code = 2. OK.
* else
* fz_always entered as code < 3; Makes code = 3;
* if (fz_throw called within fz_always)
* fz_throw makes code = 5
* fz_always is not reentered.
* catch region entered with code = 5. OK.
* else
* catch region entered with code = 3. OK
* else
* if (no always block present)
* catch region not entered as code = 0. OK.
* else
* fz_always entered as code < 3. makes code = 1
* if (fz_throw called within fz_always)
* fz_throw makes code = 3;
* fz_always NOT entered as code >= 3
* catch region entered with code = 3. OK.
* else
* catch region entered with code = 1.
*/
static void throw(fz_error_context *ex)
{
if (ex->top >= 0) {
fz_longjmp(ex->stack[ex->top].buffer, ex->stack[ex->top].code + 2);
} else {
fprintf(stderr, "uncaught exception: %s\n", ex->message);
LOGE("uncaught exception: %s\n", ex->message);
exit(EXIT_FAILURE);
}
}
int fz_push_try(fz_error_context *ex)
{
assert(ex);
ex->top++;
/* Normal case, get out of here quick */
if (ex->top < nelem(ex->stack)-1)
return 1; /* We exit here, and the setjmp sets the code to 0 */
/* We reserve the top slot on the exception stack purely to cope with
* the case when we overflow. If we DO hit this, then we 'throw'
* immediately - returning 0 stops the setjmp happening and takes us
* direct to the always/catch clauses. */
assert(ex->top == nelem(ex->stack)-1);
strcpy(ex->message, "exception stack overflow!\n");
ex->stack[ex->top].code = 2;
return 0;
}
char *fz_caught(fz_context *ctx)
{
assert(ctx);
assert(ctx->error);
return ctx->error->message;
}
void fz_throw(fz_context *ctx, char *fmt, ...)
{
va_list args;
va_start(args, fmt);
vsnprintf(ctx->error->message, sizeof ctx->error->message, fmt, args);
va_end(args);
fz_flush_warnings(ctx);
fprintf(stderr, "error: %s\n", ctx->error->message);
LOGE("error: %s\n", ctx->error->message);
throw(ctx->error);
}
void fz_rethrow(fz_context *ctx)
{
throw(ctx->error);
}
|
