stream.c 9.12 KB
Newer Older
1
2
3
4
5
6
/*
 * This file is part of the Micro Python project, http://micropython.org/
 *
 * The MIT License (MIT)
 *
 * Copyright (c) 2013, 2014 Damien P. George
7
 * Copyright (c) 2014 Paul Sokolovsky
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

28
#include <string.h>
29

30
#include "mpconfig.h"
31
32
#include "nlr.h"
#include "misc.h"
33
#include "qstr.h"
34
#include "obj.h"
35
#include "objstr.h"
36
#include "runtime.h"
37
#include "stream.h"
38
39
40
#if MICROPY_STREAMS_NON_BLOCK
#include <errno.h>
#endif
41
42
43
44

// This file defines generic Python stream read/write methods which
// dispatch to the underlying stream interface of an object.

45
46
47
// TODO: should be in mpconfig.h
#define DEFAULT_BUFFER_SIZE 256

48
STATIC mp_obj_t stream_readall(mp_obj_t self_in);
49

50
#if MICROPY_STREAMS_NON_BLOCK
51
52
53
// TODO: This is POSIX-specific (but then POSIX is the only real thing,
// and anything else just emulates it, right?)
#define is_nonblocking_error(errno) ((errno) == EAGAIN || (errno) == EWOULDBLOCK)
54
55
56
#else
#define is_nonblocking_error(errno) (0)
#endif
57

58
59
#define STREAM_CONTENT_TYPE(stream) (((stream)->is_bytes) ? &mp_type_bytes : &mp_type_str)

60
STATIC mp_obj_t stream_read(uint n_args, const mp_obj_t *args) {
61
    struct _mp_obj_base_t *o = (struct _mp_obj_base_t *)args[0];
62
    if (o->type->stream_p == NULL || o->type->stream_p->read == NULL) {
63
        // CPython: io.UnsupportedOperation, OSError subclass
64
        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, "Operation not supported"));
65
66
    }

67
68
69
70
    machine_int_t sz;
    if (n_args == 1 || ((sz = mp_obj_get_int(args[1])) == -1)) {
        return stream_readall(args[0]);
    }
71
72
73
74
75
76
77

    #if MICROPY_PY_BUILTINS_STR_UNICODE
    if (!o->type->stream_p->is_bytes) {
        mp_not_implemented("Reading from unicode text streams by character count");
    }
    #endif

78
    byte *buf = m_new(byte, sz);
79
    int error;
80
    machine_int_t out_sz = o->type->stream_p->read(o, buf, sz, &error);
81
    if (out_sz == -1) {
82
83
84
85
86
87
88
89
        if (is_nonblocking_error(error)) {
            // https://docs.python.org/3.4/library/io.html#io.RawIOBase.read
            // "If the object is in non-blocking mode and no bytes are available,
            // None is returned."
            // This is actually very weird, as naive truth check will treat
            // this as EOF.
            return mp_const_none;
        }
90
        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError, "[Errno %d]", error));
91
    } else {
92
        mp_obj_t s = mp_obj_new_str_of_type(STREAM_CONTENT_TYPE(o->type->stream_p), buf, out_sz); // will reallocate to use exact size
93
94
        m_free(buf, sz);
        return s;
95
96
97
    }
}

98
STATIC mp_obj_t stream_write(mp_obj_t self_in, mp_obj_t arg) {
99
    struct _mp_obj_base_t *o = (struct _mp_obj_base_t *)self_in;
100
    if (o->type->stream_p == NULL || o->type->stream_p->write == NULL) {
101
        // CPython: io.UnsupportedOperation, OSError subclass
102
        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, "Operation not supported"));
103
104
    }

105
106
107
    mp_buffer_info_t bufinfo;
    mp_get_buffer_raise(arg, &bufinfo, MP_BUFFER_READ);

108
    int error;
109
    machine_int_t out_sz = o->type->stream_p->write(self_in, bufinfo.buf, bufinfo.len, &error);
110
    if (out_sz == -1) {
111
112
113
114
115
116
117
118
        if (is_nonblocking_error(error)) {
            // http://docs.python.org/3/library/io.html#io.RawIOBase.write
            // "None is returned if the raw stream is set not to block and
            // no single byte could be readily written to it."
            // This is for consistency with read() behavior, still weird,
            // see abobe.
            return mp_const_none;
        }
119
        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError, "[Errno %d]", error));
120
121
122
123
124
    } else {
        return MP_OBJ_NEW_SMALL_INT(out_sz);
    }
}

125
STATIC mp_obj_t stream_readall(mp_obj_t self_in) {
126
    struct _mp_obj_base_t *o = (struct _mp_obj_base_t *)self_in;
127
    if (o->type->stream_p == NULL || o->type->stream_p->read == NULL) {
128
        // CPython: io.UnsupportedOperation, OSError subclass
129
        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, "Operation not supported"));
130
131
132
    }

    int total_size = 0;
133
    vstr_t *vstr = vstr_new_size(DEFAULT_BUFFER_SIZE);
134
135
136
    char *buf = vstr_str(vstr);
    char *p = buf;
    int error;
137
    int current_read = DEFAULT_BUFFER_SIZE;
138
    while (true) {
139
        machine_int_t out_sz = o->type->stream_p->read(self_in, p, current_read, &error);
140
        if (out_sz == -1) {
141
142
143
144
145
146
147
148
149
            if (is_nonblocking_error(error)) {
                // With non-blocking streams, we read as much as we can.
                // If we read nothing, return None, just like read().
                // Otherwise, return data read so far.
                if (total_size == 0) {
                    return mp_const_none;
                }
                break;
            }
150
            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError, "[Errno %d]", error));
151
152
153
154
155
156
157
158
159
        }
        if (out_sz == 0) {
            break;
        }
        total_size += out_sz;
        if (out_sz < current_read) {
            current_read -= out_sz;
            p += out_sz;
        } else {
160
            current_read = DEFAULT_BUFFER_SIZE;
161
162
163
            p = vstr_extend(vstr, current_read);
            if (p == NULL) {
                // TODO
164
                nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError/*&mp_type_RuntimeError*/, "Out of memory"));
165
166
167
            }
        }
    }
168

169
    mp_obj_t s = mp_obj_new_str_of_type(STREAM_CONTENT_TYPE(o->type->stream_p), (byte*)vstr->buf, total_size);
170
171
    vstr_free(vstr);
    return s;
172
173
}

174
// Unbuffered, inefficient implementation of readline() for raw I/O files.
175
STATIC mp_obj_t stream_unbuffered_readline(uint n_args, const mp_obj_t *args) {
176
    struct _mp_obj_base_t *o = (struct _mp_obj_base_t *)args[0];
177
    if (o->type->stream_p == NULL || o->type->stream_p->read == NULL) {
178
        // CPython: io.UnsupportedOperation, OSError subclass
179
        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, "Operation not supported"));
180
181
182
183
184
185
186
187
188
    }

    machine_int_t max_size = -1;
    if (n_args > 1) {
        max_size = MP_OBJ_SMALL_INT_VALUE(args[1]);
    }

    vstr_t *vstr;
    if (max_size != -1) {
189
        vstr = vstr_new_size(max_size);
190
191
192
193
194
195
196
197
    } else {
        vstr = vstr_new();
    }

    int error;
    while (max_size == -1 || max_size-- != 0) {
        char *p = vstr_add_len(vstr, 1);
        if (p == NULL) {
198
            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_MemoryError, "out of memory"));
199
200
        }

201
        machine_int_t out_sz = o->type->stream_p->read(o, p, 1, &error);
202
        if (out_sz == -1) {
203
            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError, "[Errno %d]", error));
204
        }
205
206
207
208
209
210
211
212
213
        if (out_sz == 0) {
            // Back out previously added byte
            // TODO: This is a bit hacky, does it supported by vstr API contract?
            // Consider, what's better - read a char and get OutOfMemory (so read
            // char is lost), or allocate first as we do.
            vstr_add_len(vstr, -1);
            break;
        }
        if (*p == '\n') {
214
215
216
            break;
        }
    }
217
    // TODO need a string creation API that doesn't copy the given data
218
    mp_obj_t ret = mp_obj_new_str_of_type(STREAM_CONTENT_TYPE(o->type->stream_p), (byte*)vstr->buf, vstr->len);
219
220
221
222
223
224
225
226
227
    vstr_free(vstr);
    return ret;
}

// TODO take an optional extra argument (what does it do exactly?)
STATIC mp_obj_t stream_unbuffered_readlines(mp_obj_t self) {
    mp_obj_t lines = mp_obj_new_list(0, NULL);
    for (;;) {
        mp_obj_t line = stream_unbuffered_readline(1, &self);
228
        if (!mp_obj_is_true(line)) {
229
230
231
232
233
            break;
        }
        mp_obj_list_append(lines, line);
    }
    return lines;
234
}
235
MP_DEFINE_CONST_FUN_OBJ_1(mp_stream_unbuffered_readlines_obj, stream_unbuffered_readlines);
236

237
238
mp_obj_t mp_stream_unbuffered_iter(mp_obj_t self) {
    mp_obj_t l_in = stream_unbuffered_readline(1, &self);
239
    if (mp_obj_is_true(l_in)) {
240
241
        return l_in;
    }
242
    return MP_OBJ_STOP_ITERATION;
243
}
244

245
MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_stream_read_obj, 1, 2, stream_read);
246
MP_DEFINE_CONST_FUN_OBJ_1(mp_stream_readall_obj, stream_readall);
247
MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_stream_unbuffered_readline_obj, 1, 2, stream_unbuffered_readline);
248
MP_DEFINE_CONST_FUN_OBJ_2(mp_stream_write_obj, stream_write);