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
|
/* $Id: sfexcept.c,v 1.1.1.1 2004/12/23 04:04:06 ellson Exp $ $Revision: 1.1.1.1 $ */
/* vim:set shiftwidth=4 ts=8: */
/**********************************************************
* This software is part of the graphviz package *
* http://www.graphviz.org/ *
* *
* Copyright (c) 1994-2004 AT&T Corp. *
* and is licensed under the *
* Common Public License, Version 1.0 *
* by AT&T Corp. *
* *
* Information and Software Systems Research *
* AT&T Research, Florham Park NJ *
**********************************************************/
#include "sfhdr.h"
/* Function to handle io exceptions.
** Written by Kiem-Phong Vo
*/
#if __STD_C
int _sfexcept(Sfio_t * f, int type, ssize_t io, Sfdisc_t * disc)
#else
int _sfexcept(f, type, io, disc)
Sfio_t *f; /* stream where the exception happened */
int type; /* io type that was performed */
ssize_t io; /* the io return value that indicated exception */
Sfdisc_t *disc; /* discipline in use */
#endif
{
reg int ev, local, lock;
reg ssize_t size;
reg uchar *data;
SFMTXSTART(f, -1);
GETLOCAL(f, local);
lock = f->mode & SF_LOCK;
if (local && io <= 0)
f->flags |= io < 0 ? SF_ERROR : SF_EOF;
if (disc && disc->exceptf) { /* let the stream be generally accessible for this duration */
if (local && lock)
SFOPEN(f, 0);
/* so that exception handler knows what we are asking for */
_Sfi = f->val = io;
ev = (*(disc->exceptf)) (f, type, &io, disc);
/* relock if necessary */
if (local && lock)
SFLOCK(f, 0);
if (io > 0 && !(f->flags & SF_STRING))
SFMTXRETURN(f, ev);
if (ev < 0)
SFMTXRETURN(f, SF_EDONE);
if (ev > 0)
SFMTXRETURN(f, SF_EDISC);
}
if (f->flags & SF_STRING) {
if (type == SF_READ)
goto chk_stack;
else if (type != SF_WRITE && type != SF_SEEK)
SFMTXRETURN(f, SF_EDONE);
if (local && io >= 0) {
if (f->size >= 0 && !(f->flags & SF_MALLOC))
goto chk_stack;
/* extend buffer */
if ((size = f->size) < 0)
size = 0;
if ((io -= size) <= 0)
io = SF_GRAIN;
size = ((size + io + SF_GRAIN - 1) / SF_GRAIN) * SF_GRAIN;
if (f->size > 0)
data = (uchar *) realloc((char *) f->data, size);
else
data = (uchar *) malloc(size);
if (!data)
goto chk_stack;
f->endb = data + size;
f->next = data + (f->next - f->data);
f->endr = f->endw = f->data = data;
f->size = size;
}
SFMTXRETURN(f, SF_EDISC);
}
if (errno == EINTR) {
if (_Sfexiting || (f->bits & SF_ENDING)) /* stop being a hero */
SFMTXRETURN(f, SF_EDONE);
/* a normal interrupt, we can continue */
errno = 0;
f->flags &= ~(SF_EOF | SF_ERROR);
SFMTXRETURN(f, SF_ECONT);
}
chk_stack:
if (local && f->push && ((type == SF_READ && f->next >= f->endb) || (type == SF_WRITE && f->next <= f->data))) { /* pop the stack */
reg Sfio_t *pf;
if (lock)
SFOPEN(f, 0);
/* pop and close */
pf = (*_Sfstack) (f, NIL(Sfio_t *));
if ((ev = sfclose(pf)) < 0) /* can't close, restack */
(*_Sfstack) (f, pf);
if (lock)
SFLOCK(f, 0);
ev = ev < 0 ? SF_EDONE : SF_ESTACK;
} else
ev = SF_EDONE;
SFMTXRETURN(f, ev);
}
|
