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
|
/*
* (c) The GRASP/AQUA Project, Glasgow University, 1994-1998
*
* $Id: writeFile.c,v 1.3 1998/12/02 13:28:07 simonm Exp $
*
* hPutStr Runtime Support
*/
#include "Rts.h"
#include "stgio.h"
StgInt
writeFileObject(ptr, bytes)
StgForeignPtr ptr;
StgInt bytes;
{
int rc=0;
IOFileObject* fo = (IOFileObject*)ptr;
char *p = (char *) fo->buf;
/* If we've got a r/w file object in our hand, flush the
(input) buffer contents first.
*/
if ( FILEOBJ_READABLE(fo) && FILEOBJ_JUST_READ(fo) ) {
fo->flags = (fo->flags & ~FILEOBJ_RW_READ) | FILEOBJ_RW_WRITE;
rc = flushReadBuffer(ptr);
if (rc < 0) return rc;
}
return (writeBuffer(ptr, bytes));
}
StgInt
writeBuffer(ptr, bytes)
StgForeignPtr ptr;
StgInt bytes;
{
int count, rc=0;
IOFileObject* fo = (IOFileObject*)ptr;
char *p = (char *) fo->buf;
/* Disallow short writes */
if (bytes == 0 || fo->buf == NULL)
return 0;
if ( fo->flags & FILEOBJ_NONBLOCKING_IO && inputReady(ptr,0) != 1 )
return FILEOBJ_BLOCKED_WRITE;
while ((count = write(fo->fd, fo->buf, bytes)) < bytes) {
if (errno != EINTR) {
cvtErrno();
stdErrno();
return -1;
}
bytes -= count;
p += count;
}
/* Signal that we've emptied the buffer */
fo->bufWPtr=0;
return 0;
}
StgInt
writeBuf(ptr, buf, len)
StgForeignPtr ptr;
StgAddr buf;
StgInt len;
{
IOFileObject* fo = (IOFileObject*)ptr;
int count;
int rc = 0;
char *p = (char *) buf;
if (len == 0 )
return 0;
/* First of all, check if we do need to flush the buffer .. */
/* Note - in the case of line buffering, we do not currently check
whether we need to flush buffer due to line terminators in the
buffer we're outputting */
if ( fo->buf != NULL && /* buffered and */
(fo->bufWPtr + len < (fo->bufSize)) /* there's room */
) {
/* Block copying is likely to be cheaper than, flush, followed by write */
memcpy(((char*)fo->buf + fo->bufWPtr), buf, len);
fo->bufWPtr += len;
return 0;
}
/* If we do overflow, flush current contents of the buffer and
directly output the chunk.
(no attempt at splitting up the chunk is currently made)
*/
if ( fo->buf != NULL && /* buffered and */
(fo->bufWPtr + len >= (fo->bufSize)) /* there's not room */
) {
/* Flush buffer */
rc = writeFileObject(ptr, fo->bufWPtr);
/* ToDo: undo buffer fill if we're blocking.. */
}
if (rc != 0) {
return rc;
}
if ( fo->flags & FILEOBJ_NONBLOCKING_IO && inputReady(ptr,0) != 1 )
return FILEOBJ_BLOCKED_WRITE;
/* Disallow short writes */
while ((count = write(fo->fd, (char *)buf, (int)len)) < len) {
if (errno != EINTR) {
cvtErrno();
stdErrno();
return -1;
}
len -= count;
p += count;
}
return 0;
}
StgInt
writeBufBA(ptr, buf, len)
StgForeignPtr ptr;
StgByteArray buf;
StgInt len;
{ return (writeBuf(ptr,(StgAddr)buf, len)); }
|
